1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Xiangxiu Yang
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
24 #include <sys/types.h>
35 #include "ltt-private.h"
36 #include <ltt/trace.h>
37 #include <ltt/facility.h>
38 #include <ltt/event.h>
41 #define DIR_NAME_SIZE 256
42 #define __UNUSED__ __attribute__((__unused__))
45 /* obtain the time of an event */
47 static inline LttTime
getEventTime(LttTracefile
* tf
);
50 /* set the offset of the fields belonging to the event,
51 need the information of the archecture */
52 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
*t
);
54 /* get the size of the field type according to the archtecture's
55 size and endian type(info of the archecture) */
56 int getFieldtypeSize(LttTracefile
* tf
, LttEventType
* evT
, int offsetRoot
,
57 int offsetParent
, LttField
*fld
, void *evD
, LttTrace
* t
);
59 /* read a fixed size or a block information from the file (fd) */
60 int readFile(int fd
, void * buf
, size_t size
, char * mesg
);
61 int readBlock(LttTracefile
* tf
, int whichBlock
);
63 /* calculate cycles per nsec for current block */
64 void getCyclePerNsec(LttTracefile
* t
);
66 /* reinitialize the info of the block which is already in the buffer */
67 void updateTracefile(LttTracefile
* tf
);
69 /* go to the next event */
70 int skipEvent(LttTracefile
* t
);
73 /* Functions to parse system.xml file (using glib xml parser) */
74 static void parser_start_element (GMarkupParseContext __UNUSED__
*context
,
75 const gchar
*element_name
,
76 const gchar
**attribute_names
,
77 const gchar
**attribute_values
,
82 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
83 if(strcmp("system", element_name
)){
84 *error
= g_error_new(G_MARKUP_ERROR
,
86 "This is not system.xml file");
90 while(attribute_names
[i
]){
91 if(strcmp("node_name", attribute_names
[i
])==0){
92 des
->node_name
= g_strdup(attribute_values
[i
]);
93 }else if(strcmp("domainname", attribute_names
[i
])==0){
94 des
->domain_name
= g_strdup(attribute_values
[i
]);
95 }else if(strcmp("cpu", attribute_names
[i
])==0){
96 des
->nb_cpu
= atoi(attribute_values
[i
]);
97 }else if(strcmp("arch_size", attribute_names
[i
])==0){
98 if(strcmp(attribute_values
[i
],"LP32") == 0) des
->size
= LTT_LP32
;
99 else if(strcmp(attribute_values
[i
],"ILP32") == 0) des
->size
= LTT_ILP32
;
100 else if(strcmp(attribute_values
[i
],"LP64") == 0) des
->size
= LTT_LP64
;
101 else if(strcmp(attribute_values
[i
],"ILP64") == 0) des
->size
= LTT_ILP64
;
102 else if(strcmp(attribute_values
[i
],"UNKNOWN") == 0) des
->size
= LTT_UNKNOWN
;
103 }else if(strcmp("endian", attribute_names
[i
])==0){
104 if(strcmp(attribute_values
[i
],"LITTLE_ENDIAN") == 0)
105 des
->endian
= LTT_LITTLE_ENDIAN
;
106 else if(strcmp(attribute_values
[i
],"BIG_ENDIAN") == 0)
107 des
->endian
= LTT_BIG_ENDIAN
;
108 }else if(strcmp("kernel_name", attribute_names
[i
])==0){
109 des
->kernel_name
= g_strdup(attribute_values
[i
]);
110 }else if(strcmp("kernel_release", attribute_names
[i
])==0){
111 des
->kernel_release
= g_strdup(attribute_values
[i
]);
112 }else if(strcmp("kernel_version", attribute_names
[i
])==0){
113 des
->kernel_version
= g_strdup(attribute_values
[i
]);
114 }else if(strcmp("machine", attribute_names
[i
])==0){
115 des
->machine
= g_strdup(attribute_values
[i
]);
116 }else if(strcmp("processor", attribute_names
[i
])==0){
117 des
->processor
= g_strdup(attribute_values
[i
]);
118 }else if(strcmp("hardware_platform", attribute_names
[i
])==0){
119 des
->hardware_platform
= g_strdup(attribute_values
[i
]);
120 }else if(strcmp("operating_system", attribute_names
[i
])==0){
121 des
->operating_system
= g_strdup(attribute_values
[i
]);
122 }else if(strcmp("ltt_major_version", attribute_names
[i
])==0){
123 des
->ltt_major_version
= atoi(attribute_values
[i
]);
124 }else if(strcmp("ltt_minor_version", attribute_names
[i
])==0){
125 des
->ltt_minor_version
= atoi(attribute_values
[i
]);
126 }else if(strcmp("ltt_block_size", attribute_names
[i
])==0){
127 des
->ltt_block_size
= atoi(attribute_values
[i
]);
129 *error
= g_error_new(G_MARKUP_ERROR
,
131 "Not a valid attribute");
138 static void parser_characters (GMarkupParseContext __UNUSED__
*context
,
140 gsize __UNUSED__ text_len
,
142 GError __UNUSED__
**error
)
144 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
145 des
->description
= g_strdup(text
);
149 /*****************************************************************************
151 * ltt_tracefile_open : open a trace file, construct a LttTracefile
153 * t : the trace containing the tracefile
154 * fileName : path name of the trace file
156 * : a pointer to a tracefile
157 ****************************************************************************/
159 LttTracefile
* ltt_tracefile_open(LttTrace
* t
, char * fileName
)
162 struct stat lTDFStat
; /* Trace data file status */
164 tf
= g_new(LttTracefile
, 1);
167 tf
->name
= g_strdup(fileName
);
169 tf
->fd
= open(fileName
, O_RDONLY
, 0);
171 g_warning("Unable to open input data file %s\n", fileName
);
177 // Get the file's status
178 if(fstat(tf
->fd
, &lTDFStat
) < 0){
179 g_warning("Unable to get the status of the input data file %s\n", fileName
);
186 // Is the file large enough to contain a trace
187 if(lTDFStat
.st_size
< (off_t
)(sizeof(BlockStart
) + EVENT_HEADER_SIZE
)){
188 g_print("The input data file %s does not contain a trace\n", fileName
);
195 //store the size of the file
196 tf
->file_size
= lTDFStat
.st_size
;
197 tf
->block_size
= t
->system_description
->ltt_block_size
;
198 tf
->block_number
= tf
->file_size
/ tf
->block_size
;
201 //allocate memory to contain the info of a block
202 tf
->buffer
= (void *) g_new(char, t
->system_description
->ltt_block_size
);
204 //read the first block
205 if(readBlock(tf
,1)) exit(1);
211 /*****************************************************************************
212 *Open control and per cpu tracefiles
213 ****************************************************************************/
215 void ltt_tracefile_open_cpu(LttTrace
*t
, char * tracefile_name
)
218 tf
= ltt_tracefile_open(t
,tracefile_name
);
220 t
->per_cpu_tracefile_number
++;
221 g_ptr_array_add(t
->per_cpu_tracefiles
, tf
);
224 gint
ltt_tracefile_open_control(LttTrace
*t
, char * control_name
)
233 tf
= ltt_tracefile_open(t
,control_name
);
235 g_warning("ltt_tracefile_open_control : bad file descriptor");
238 t
->control_tracefile_number
++;
239 g_ptr_array_add(t
->control_tracefiles
,tf
);
241 //parse facilities tracefile to get base_id
242 if(strcmp(&control_name
[strlen(control_name
)-10],"facilities") ==0){
244 if(!ltt_tracefile_read(tf
,&ev
)) return 0; // end of file
246 if(ev
.event_id
== TRACE_FACILITY_LOAD
){
248 fLoad
.name
= (char*)pos
;
249 fLoad
.checksum
= *(LttChecksum
*)(pos
+ strlen(fLoad
.name
));
250 fLoad
.base_code
= *(guint32
*)(pos
+ strlen(fLoad
.name
) + sizeof(LttChecksum
));
252 for(i
=0;i
<t
->facility_number
;i
++){
253 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
254 if(strcmp(f
->name
,fLoad
.name
)==0 && fLoad
.checksum
==f
->checksum
){
255 f
->base_id
= fLoad
.base_code
;
259 if(i
==t
->facility_number
) {
260 g_warning("Facility: %s, checksum: %u is not found",
261 fLoad
.name
,(unsigned int)fLoad
.checksum
);
264 }else if(ev
.event_id
== TRACE_BLOCK_START
){
266 }else if(ev
.event_id
== TRACE_BLOCK_END
){
269 g_warning("Not valid facilities trace file");
277 /*****************************************************************************
279 * ltt_tracefile_close: close a trace file,
281 * t : tracefile which will be closed
282 ****************************************************************************/
284 void ltt_tracefile_close(LttTracefile
*t
)
293 /*****************************************************************************
294 *Get system information
295 ****************************************************************************/
296 gint
getSystemInfo(LttSystemDescription
* des
, char * pathname
)
299 char buf
[DIR_NAME_SIZE
];
301 GMarkupParseContext
* context
;
302 GError
* error
= NULL
;
303 GMarkupParser markup_parser
=
305 parser_start_element
,
308 NULL
, /* passthrough */
312 fp
= fopen(pathname
,"r");
314 g_warning("Can not open file : %s\n", pathname
);
318 context
= g_markup_parse_context_new(&markup_parser
, 0, des
,NULL
);
320 while(fgets(buf
,DIR_NAME_SIZE
, fp
) != NULL
){
321 if(!g_markup_parse_context_parse(context
, buf
, DIR_NAME_SIZE
, &error
)){
323 g_warning("Can not parse xml file: \n%s\n", error
->message
);
326 g_markup_parse_context_free(context
);
331 g_markup_parse_context_free(context
);
336 /*****************************************************************************
337 *The following functions get facility/tracefile information
338 ****************************************************************************/
340 gint
getFacilityInfo(LttTrace
*t
, char* eventdefs
)
343 struct dirent
*entry
;
348 char name
[DIR_NAME_SIZE
];
350 dir
= opendir(eventdefs
);
352 g_warning("Can not open directory: %s\n", eventdefs
);
356 while((entry
= readdir(dir
)) != NULL
){
357 ptr
= &entry
->d_name
[strlen(entry
->d_name
)-4];
358 if(strcmp(ptr
,".xml") != 0) continue;
359 strcpy(name
,eventdefs
);
360 strcat(name
,entry
->d_name
);
361 ltt_facility_open(t
,name
);
365 for(j
=0;j
<t
->facility_number
;j
++){
366 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, j
);
367 for(i
=0; i
<f
->event_number
; i
++){
369 setFieldsOffset(NULL
, et
, NULL
, t
);
375 gint
getControlFileInfo(LttTrace
*t
, char* control
)
378 struct dirent
*entry
;
379 char name
[DIR_NAME_SIZE
];
381 dir
= opendir(control
);
383 g_warning("Can not open directory: %s\n", control
);
387 while((entry
= readdir(dir
)) != NULL
){
388 if(strcmp(entry
->d_name
,"facilities") != 0 &&
389 strcmp(entry
->d_name
,"interrupts") != 0 &&
390 strcmp(entry
->d_name
,"processes") != 0) continue;
392 strcpy(name
,control
);
393 strcat(name
,entry
->d_name
);
394 if(ltt_tracefile_open_control(t
,name
))
401 gint
getCpuFileInfo(LttTrace
*t
, char* cpu
)
404 struct dirent
*entry
;
405 char name
[DIR_NAME_SIZE
];
409 g_warning("Can not open directory: %s\n", cpu
);
413 while((entry
= readdir(dir
)) != NULL
){
414 if(strcmp(entry
->d_name
,".") != 0 &&
415 strcmp(entry
->d_name
,"..") != 0 &&
416 strcmp(entry
->d_name
,".svn") != 0){
418 strcat(name
,entry
->d_name
);
419 ltt_tracefile_open_cpu(t
,name
);
426 /*****************************************************************************
427 *A trace is specified as a pathname to the directory containing all the
428 *associated data (control tracefiles, per cpu tracefiles, event
431 *When a trace is closed, all the associated facilities, types and fields
432 *are released as well.
436 /****************************************************************************
437 * get_absolute_pathname
439 * return the unique pathname in the system
441 * MD : Fixed this function so it uses realpath, dealing well with
442 * forgotten cases (.. were not used correctly before).
444 ****************************************************************************/
445 void get_absolute_pathname(const char *pathname
, char * abs_pathname
)
447 abs_pathname
[0] = '\0';
449 if ( realpath (pathname
, abs_pathname
) != NULL
)
453 /* error, return the original path unmodified */
454 strcpy(abs_pathname
, pathname
);
460 LttTrace
*ltt_trace_open(const char *pathname
)
463 LttSystemDescription
* sys_description
;
464 char eventdefs
[DIR_NAME_SIZE
];
465 char info
[DIR_NAME_SIZE
];
466 char control
[DIR_NAME_SIZE
];
467 char cpu
[DIR_NAME_SIZE
];
468 char tmp
[DIR_NAME_SIZE
];
469 char abs_path
[DIR_NAME_SIZE
];
470 gboolean has_slash
= FALSE
;
472 get_absolute_pathname(pathname
, abs_path
);
473 //establish the pathname to different directories
474 if(abs_path
[strlen(abs_path
)-1] == '/')has_slash
= TRUE
;
475 strcpy(eventdefs
,abs_path
);
476 if(!has_slash
)strcat(eventdefs
,"/");
477 strcat(eventdefs
,"eventdefs/");
479 strcpy(info
,abs_path
);
480 if(!has_slash
)strcat(info
,"/");
481 strcat(info
,"info/");
483 strcpy(control
,abs_path
);
484 if(!has_slash
)strcat(control
,"/");
485 strcat(control
,"control/");
487 strcpy(cpu
,abs_path
);
488 if(!has_slash
)strcat(cpu
,"/");
492 sys_description
= g_new(LttSystemDescription
, 1);
493 t
= g_new(LttTrace
, 1);
494 t
->pathname
= g_strdup(abs_path
);
495 t
->facility_number
= 0;
496 t
->control_tracefile_number
= 0;
497 t
->per_cpu_tracefile_number
= 0;
498 t
->system_description
= sys_description
;
499 t
->control_tracefiles
= g_ptr_array_new();
500 t
->per_cpu_tracefiles
= g_ptr_array_new();
501 t
->facilities
= g_ptr_array_new();
502 getDataEndianType(&(t
->my_arch_size
), &(t
->my_arch_endian
));
504 //get system description
506 strcat(tmp
,"system.xml");
507 if(getSystemInfo(sys_description
, tmp
)) {
508 g_ptr_array_free(t
->facilities
, TRUE
);
509 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
510 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
511 g_free(sys_description
);
519 //get facilities info
520 if(getFacilityInfo(t
,eventdefs
)) {
521 g_ptr_array_free(t
->facilities
, TRUE
);
522 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
523 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
524 g_free(sys_description
);
530 //get control tracefile info
531 getControlFileInfo(t
,control
);
533 if(getControlFileInfo(t,control)) {
534 g_ptr_array_free(t->facilities, TRUE);
535 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
536 g_ptr_array_free(t->control_tracefiles, TRUE);
537 g_free(sys_description);
541 }*/ // With fatal error
543 //get cpu tracefile info
544 if(getCpuFileInfo(t
,cpu
)) {
545 g_ptr_array_free(t
->facilities
, TRUE
);
546 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
547 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
548 g_free(sys_description
);
557 char * ltt_trace_name(LttTrace
*t
)
563 /******************************************************************************
564 * When we copy a trace, we want all the opening actions to happen again :
565 * the trace will be reopened and totally independant from the original.
566 * That's why we call ltt_trace_open.
567 *****************************************************************************/
568 LttTrace
*ltt_trace_copy(LttTrace
*self
)
570 return ltt_trace_open(self
->pathname
);
573 void ltt_trace_close(LttTrace
*t
)
581 //free system_description
582 g_free(t
->system_description
->description
);
583 g_free(t
->system_description
->node_name
);
584 g_free(t
->system_description
->domain_name
);
585 g_free(t
->system_description
->kernel_name
);
586 g_free(t
->system_description
->kernel_release
);
587 g_free(t
->system_description
->kernel_version
);
588 g_free(t
->system_description
->machine
);
589 g_free(t
->system_description
->processor
);
590 g_free(t
->system_description
->hardware_platform
);
591 g_free(t
->system_description
->operating_system
);
592 g_free(t
->system_description
);
594 //free control_tracefiles
595 for(i
=0;i
<t
->control_tracefile_number
;i
++){
596 tf
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
,i
);
597 ltt_tracefile_close(tf
);
599 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
601 //free per_cpu_tracefiles
602 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
603 tf
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
,i
);
604 ltt_tracefile_close(tf
);
606 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
609 for(i
=0;i
<t
->facility_number
;i
++){
610 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
611 ltt_facility_close(f
);
613 g_ptr_array_free(t
->facilities
, TRUE
);
621 /*****************************************************************************
622 *Get the system description of the trace
623 ****************************************************************************/
625 LttSystemDescription
*ltt_trace_system_description(LttTrace
*t
)
627 return t
->system_description
;
630 /*****************************************************************************
631 * The following functions discover the facilities of the trace
632 ****************************************************************************/
634 unsigned ltt_trace_facility_number(LttTrace
*t
)
636 return (unsigned)(t
->facility_number
);
639 LttFacility
*ltt_trace_facility_get(LttTrace
*t
, unsigned i
)
641 return (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
644 /*****************************************************************************
646 * ltt_trace_facility_find : find facilities in the trace
649 * name : facility name
651 * position : position of the facility in the trace
653 * : the number of facilities
654 ****************************************************************************/
656 unsigned ltt_trace_facility_find(LttTrace
*t
, char *name
, unsigned *position
)
658 unsigned int i
, count
=0;
660 for(i
=0;i
<t
->facility_number
;i
++){
661 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
662 if(strcmp(f
->name
,name
)==0){
664 if(count
==1) *position
= i
;
672 /*****************************************************************************
673 * Functions to discover all the event types in the trace
674 ****************************************************************************/
676 unsigned ltt_trace_eventtype_number(LttTrace
*t
)
681 for(i
=0;i
<t
->facility_number
;i
++){
682 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
683 count
+= f
->event_number
;
688 /* FIXME : performances could be improved with a better design for this
690 LttFacility
* ltt_trace_facility_by_id(LttTrace
* trace
, unsigned id
)
692 LttFacility
* facility
= NULL
;
695 for(i
=0;i
<trace
->facility_number
;i
++){
696 LttFacility
*iter_facility
=
697 (LttFacility
*) g_ptr_array_index(trace
->facilities
,i
);
698 if(unlikely(id
>= iter_facility
->base_id
&&
699 id
< iter_facility
->base_id
+ iter_facility
->event_number
)) {
700 facility
= iter_facility
;
708 LttEventType
*ltt_trace_eventtype_get(LttTrace
*t
, unsigned evId
)
711 f
= ltt_trace_facility_by_id(t
,evId
);
713 return f
->events
[evId
- f
->base_id
];
716 /*****************************************************************************
717 *There is one "per cpu" tracefile for each CPU, numbered from 0 to
718 *the maximum number of CPU in the system. When the number of CPU installed
719 *is less than the maximum, some positions are unused. There are also a
720 *number of "control" tracefiles (facilities, interrupts...).
721 ****************************************************************************/
722 unsigned ltt_trace_control_tracefile_number(LttTrace
*t
)
724 return t
->control_tracefile_number
;
727 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace
*t
)
729 return t
->per_cpu_tracefile_number
;
732 /*****************************************************************************
733 *It is possible to search for the tracefiles by name or by CPU position.
734 *The index within the tracefiles of the same type is returned if found
735 *and a negative value otherwise.
736 ****************************************************************************/
738 int ltt_trace_control_tracefile_find(LttTrace
*t
, const gchar
*name
)
740 LttTracefile
* tracefile
;
742 for(i
=0;i
<t
->control_tracefile_number
;i
++){
743 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
744 if(strcmp(tracefile
->name
, name
)==0)break;
746 if(i
== t
->control_tracefile_number
) return -1;
750 /* not really useful. We just have to know that cpu tracefiles
751 * comes before control tracefiles.
753 int ltt_trace_per_cpu_tracefile_find(LttTrace
*t
, const gchar
*name
)
755 LttTracefile
* tracefile
;
757 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
758 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
759 if(strcmp(tracefile
->name
, name
)==0)break;
761 if(i
== t
->per_cpu_tracefile_number
) return -1;
765 /*****************************************************************************
766 *Get a specific tracefile
767 ****************************************************************************/
769 LttTracefile
*ltt_trace_control_tracefile_get(LttTrace
*t
, unsigned i
)
771 return (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
774 LttTracefile
*ltt_trace_per_cpu_tracefile_get(LttTrace
*t
, unsigned i
)
776 return (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
779 /*****************************************************************************
780 * Get the start time and end time of the trace
781 ****************************************************************************/
783 void ltt_trace_time_span_get(LttTrace
*t
, LttTime
*start
, LttTime
*end
)
785 LttTime startSmall
, startTmp
, endBig
, endTmp
;
789 for(i
=0;i
<t
->control_tracefile_number
;i
++){
790 tf
= g_ptr_array_index(t
->control_tracefiles
, i
);
792 startTmp
= tf
->a_block_start
->time
;
793 readBlock(tf
,tf
->block_number
);
794 endTmp
= tf
->a_block_end
->time
;
796 startSmall
= startTmp
;
801 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
802 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
805 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
806 tf
= g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
808 startTmp
= tf
->a_block_start
->time
;
809 readBlock(tf
,tf
->block_number
);
810 endTmp
= tf
->a_block_end
->time
;
812 startSmall
= startTmp
;
816 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
817 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
820 if(start
!= NULL
) *start
= startSmall
;
821 if(end
!= NULL
) *end
= endBig
;
825 /*****************************************************************************
826 *Get the name of a tracefile
827 ****************************************************************************/
829 char *ltt_tracefile_name(LttTracefile
*tf
)
834 /*****************************************************************************
835 * Get the number of blocks in the tracefile
836 ****************************************************************************/
838 unsigned ltt_tracefile_block_number(LttTracefile
*tf
)
840 return tf
->block_number
;
843 /*****************************************************************************
845 * ltt_tracefile_seek_time: seek to the first event of the trace with time
846 * larger or equal to time
849 * time : criteria of the time
850 ****************************************************************************/
851 void ltt_tracefile_find_time_block(LttTracefile
*t
, LttTime time
,
852 int start_block
, int end_block
)
854 int err
, tmp_block
, s
, e
;
858 err
=readBlock(t
,start_block
);
859 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
860 if(start_block
== end_block
)return;
862 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
863 if(tailTime
>= 0) return;
865 err
=readBlock(t
,end_block
);
866 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
867 if(start_block
+1 == end_block
)return;
869 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
870 if(headTime
<= 0 ) return;
872 tmp_block
= (end_block
+ start_block
)/2;
873 err
=readBlock(t
,tmp_block
);
874 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
876 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
877 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
878 if(headTime
<= 0 && tailTime
>= 0) return;
884 ltt_tracefile_find_time_block(t
, time
, s
, e
);
892 ltt_tracefile_find_time_block(t
, time
, s
, e
);
897 void ltt_tracefile_backward_find_time_block(LttTracefile
*t
, LttTime time
)
899 int t_time
, h_time
, err
;
900 err
=readBlock(t
,t
->which_block
-1);
901 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
902 h_time
= ltt_time_compare(t
->a_block_start
->time
, time
);
903 t_time
= ltt_time_compare(t
->a_block_end
->time
, time
);
906 if(t
->which_block
== 1) return;
907 err
=readBlock(t
,t
->which_block
-1);
908 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
909 tmp
= ltt_time_compare(t
->a_block_end
->time
, time
);
910 if(tmp
== 0) return ltt_tracefile_seek_time(t
, time
);
911 err
=readBlock(t
,t
->which_block
+1);
912 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
913 }else if(h_time
> 0){
914 ltt_tracefile_find_time_block(t
, time
, 1, t
->which_block
);
915 return ltt_tracefile_seek_time(t
, time
) ;
917 if(t_time
>= 0) return ltt_tracefile_seek_time(t
, time
);
918 err
=readBlock(t
,t
->which_block
+1);
919 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
923 void ltt_tracefile_seek_time(LttTracefile
*t
, LttTime time
)
927 int headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
928 int tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
931 if(headTime
< 0 && tailTime
> 0){
932 if(ltt_time_compare(t
->a_block_end
->time
, t
->current_event_time
) !=0) {
933 lttTime
= getEventTime(t
);
934 err
= ltt_time_compare(lttTime
, time
);
936 if(t
->which_event
==2 || ltt_time_compare(t
->prev_event_time
,time
)<0){
940 return ltt_tracefile_seek_time(t
, time
);
944 if(ltt_tracefile_read(t
,&ev
) == NULL
) {
945 g_print("End of file\n");
948 lttTime
= getEventTime(t
);
949 err
= ltt_time_compare(lttTime
, time
);
953 }else{//we are at the end of the block
955 return ltt_tracefile_seek_time(t
, time
);
957 }else if(headTime
>= 0){
958 if(t
->which_block
== 1){
961 if(ltt_time_compare(t
->prev_block_end_time
, time
) >= 0 ||
962 (t
->prev_block_end_time
.tv_sec
== 0 &&
963 t
->prev_block_end_time
.tv_nsec
== 0 )){
964 ltt_tracefile_backward_find_time_block(t
, time
);
969 }else if(tailTime
< 0){
970 if(t
->which_block
!= t
->block_number
){
971 ltt_tracefile_find_time_block(t
, time
, t
->which_block
+1, t
->block_number
);
972 return ltt_tracefile_seek_time(t
, time
);
974 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
975 g_print("End of file\n");
978 }else if(tailTime
== 0){
979 t
->cur_event_pos
= t
->last_event_pos
;
980 t
->current_event_time
= time
;
981 t
->cur_heart_beat_number
= 0;
982 t
->prev_event_time
.tv_sec
= 0;
983 t
->prev_event_time
.tv_nsec
= 0;
988 /*****************************************************************************
989 * Seek to the first event with position equal or larger to ep
991 * Modified by Mathieu Desnoyers to used faster offset position instead of
992 * re-reading the whole buffer.
993 ****************************************************************************/
995 void ltt_tracefile_seek_position(LttTracefile
*t
, const LttEventPosition
*ep
)
997 //if we are at the right place, just return
998 if(likely(t
->which_block
== ep
->block_num
&& t
->which_event
== ep
->event_num
))
1001 if(likely(t
->which_block
== ep
->block_num
)) updateTracefile(t
);
1002 else readBlock(t
,ep
->block_num
);
1003 //event offset is available
1004 if(likely(ep
->old_position
)){
1007 t
->which_event
= ep
->event_num
;
1008 t
->cur_event_pos
= t
->buffer
+ ep
->event_offset
;
1009 t
->prev_event_time
= ep
->event_time
;
1010 t
->current_event_time
= ep
->event_time
;
1011 t
->cur_heart_beat_number
= ep
->heart_beat_number
;
1012 t
->cur_cycle_count
= ep
->event_cycle_count
;
1014 /* This is a workaround for fast position seek */
1015 t
->last_event_pos
= ep
->last_event_pos
;
1016 t
->prev_block_end_time
= ep
->prev_block_end_time
;
1017 t
->prev_event_time
= ep
->prev_event_time
;
1018 t
->pre_cycle_count
= ep
->pre_cycle_count
;
1019 t
->count
= ep
->count
;
1020 /* end of workaround */
1022 //update the fields of the current event and go to the next event
1024 if(unlikely(err
== ERANGE
)) g_error("event id is out of range\n");
1029 //only block number and event index are available
1030 //MD: warning : this is slow!
1031 g_warning("using slow O(n) tracefile seek position");
1034 while(likely(t
->which_event
< ep
->event_num
)) ltt_tracefile_read(t
, &event
);
1039 /*****************************************************************************
1041 * ltt_tracefile_read : read the current event, set the pointer to the next
1045 * LttEvent * : an event to be processed
1046 ****************************************************************************/
1048 LttEvent
*ltt_tracefile_read(LttTracefile
*t
, LttEvent
*event
)
1052 if(unlikely(t
->cur_event_pos
== t
->buffer
+ t
->block_size
)){
1053 if(unlikely(t
->which_block
== t
->block_number
)){
1056 err
= readBlock(t
, t
->which_block
+ 1);
1057 if(unlikely(err
))g_error("Can not read tracefile");
1060 event
->event_id
= (int)(*(guint16
*)(t
->cur_event_pos
));
1061 if(unlikely(event
->event_id
== TRACE_TIME_HEARTBEAT
))
1062 t
->cur_heart_beat_number
++;
1064 t
->prev_event_time
= t
->current_event_time
;
1065 // t->current_event_time = getEventTime(t);
1067 event
->time_delta
= *(guint32
*)(t
->cur_event_pos
+ EVENT_ID_SIZE
);
1068 event
->event_time
= t
->current_event_time
;
1069 event
->event_cycle_count
= t
->cur_cycle_count
;
1071 event
->tracefile
= t
;
1072 event
->data
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
1073 event
->which_block
= t
->which_block
;
1074 event
->which_event
= t
->which_event
;
1076 /* This is a workaround for fast position seek */
1077 event
->last_event_pos
= t
->last_event_pos
;
1078 event
->prev_block_end_time
= t
->prev_block_end_time
;
1079 event
->prev_event_time
= t
->prev_event_time
;
1080 event
->pre_cycle_count
= t
->pre_cycle_count
;
1081 event
->count
= t
->count
;
1082 /* end of workaround */
1086 //update the fields of the current event and go to the next event
1088 if(unlikely(err
== ERANGE
)) g_error("event id is out of range\n");
1093 /****************************************************************************
1095 * readFile : wrap function to read from a file
1097 * fd : file descriptor
1098 * buf : buf to contain the content
1099 * size : number of bytes to be read
1100 * mesg : message to be printed if some thing goes wrong
1103 * EIO : can not read from the file
1104 ****************************************************************************/
1106 int readFile(int fd
, void * buf
, size_t size
, char * mesg
)
1108 ssize_t nbBytes
= read(fd
, buf
, size
);
1110 if((size_t)nbBytes
!= size
) {
1112 perror("Error in readFile : ");
1114 g_warning("%s",mesg
);
1121 /****************************************************************************
1123 * readBlock : read a block from the file
1125 * lttdes : ltt trace file
1126 * whichBlock : the block which will be read
1129 * EINVAL : lseek fail
1130 * EIO : can not read from the file
1131 ****************************************************************************/
1133 int readBlock(LttTracefile
* tf
, int whichBlock
)
1138 if(likely(whichBlock
- tf
->which_block
== 1 && tf
->which_block
!= 0)){
1139 tf
->prev_block_end_time
= tf
->a_block_end
->time
;
1140 tf
->prev_event_time
= tf
->a_block_end
->time
;
1142 tf
->prev_block_end_time
.tv_sec
= 0;
1143 tf
->prev_block_end_time
.tv_nsec
= 0;
1144 tf
->prev_event_time
.tv_sec
= 0;
1145 tf
->prev_event_time
.tv_nsec
= 0;
1148 nbBytes
=lseek(tf
->fd
,(off_t
)((whichBlock
-1)*tf
->block_size
), SEEK_SET
);
1149 if(unlikely(nbBytes
== -1)) return EINVAL
;
1151 if(unlikely(readFile(tf
->fd
,tf
->buffer
,tf
->block_size
,"Unable to read a block")))
1154 tf
->a_block_start
=(BlockStart
*) (tf
->buffer
+ EVENT_HEADER_SIZE
);
1155 lostSize
= *(guint32
*)(tf
->buffer
+ tf
->block_size
- sizeof(guint32
));
1156 tf
->a_block_end
=(BlockEnd
*)(tf
->buffer
+ tf
->block_size
-
1157 lostSize
+ EVENT_HEADER_SIZE
);
1158 tf
->last_event_pos
= tf
->buffer
+ tf
->block_size
- lostSize
;
1160 tf
->which_block
= whichBlock
;
1161 tf
->which_event
= 1;
1162 tf
->cur_event_pos
= tf
->buffer
;//the beginning of the block, block start ev
1163 tf
->cur_heart_beat_number
= 0;
1165 getCyclePerNsec(tf
);
1167 tf
->current_event_time
= getEventTime(tf
);
1172 /*****************************************************************************
1174 * updateTracefile : reinitialize the info of the block which is already
1178 ****************************************************************************/
1180 void updateTracefile(LttTracefile
* tf
)
1182 tf
->which_event
= 1;
1183 tf
->cur_event_pos
= tf
->buffer
;
1184 tf
->current_event_time
= getEventTime(tf
);
1185 tf
->cur_heart_beat_number
= 0;
1187 tf
->prev_event_time
.tv_sec
= 0;
1188 tf
->prev_event_time
.tv_nsec
= 0;
1191 /*****************************************************************************
1193 * skipEvent : go to the next event, update the fields of the current event
1198 * ERANGE : event id is out of range
1199 ****************************************************************************/
1201 int skipEvent(LttTracefile
* t
)
1208 evId
= (int)(*(guint16
*)(t
->cur_event_pos
));
1209 evData
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
1211 evT
= ltt_trace_eventtype_get(t
->trace
,(unsigned)evId
);
1213 if(likely(evT
)) rootFld
= evT
->root_field
;
1216 if(likely(rootFld
)){
1217 //event has string/sequence or the last event is not the same event
1218 if(likely((evT
->latest_block
!=t
->which_block
|| evT
->latest_event
!=t
->which_event
)
1219 && rootFld
->field_fixed
== 0)){
1220 setFieldsOffset(t
, evT
, evData
, t
->trace
);
1222 t
->cur_event_pos
+= EVENT_HEADER_SIZE
+ rootFld
->field_size
;
1223 }else t
->cur_event_pos
+= EVENT_HEADER_SIZE
;
1225 evT
->latest_block
= t
->which_block
;
1226 evT
->latest_event
= t
->which_event
;
1228 //the next event is in the next block
1229 if(unlikely(evId
== TRACE_BLOCK_END
)){
1230 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
1233 t
->current_event_time
= getEventTime(t
);
1240 /*****************************************************************************
1242 * getCyclePerNsec : calculate cycles per nsec for current block
1245 ****************************************************************************/
1247 void getCyclePerNsec(LttTracefile
* t
)
1249 LttTime lBufTotalTime
; /* Total time for this buffer */
1250 double lBufTotalNSec
; /* Total time for this buffer in nsecs */
1251 double lBufTotalCycle
;/* Total cycles for this buffer */
1253 /* Calculate the total time for this buffer */
1254 lBufTotalTime
= ltt_time_sub(t
->a_block_end
->time
, t
->a_block_start
->time
);
1256 /* Calculate the total cycles for this bufffer */
1257 lBufTotalCycle
= t
->a_block_end
->cycle_count
;
1258 lBufTotalCycle
-= t
->a_block_start
->cycle_count
;
1260 /* Convert the total time to nsecs */
1261 lBufTotalNSec
= ltt_time_to_double(lBufTotalTime
);
1263 t
->nsec_per_cycle
= (double)lBufTotalNSec
/ (double)lBufTotalCycle
;
1264 /* See : http://www.azillionmonkeys.com/qed/adiv.html */
1265 // precalculate the reciprocal, so divisions will be really fast.
1266 // 2^32-1 == 0xFFFFFFFFULL
1268 // double int_res = lBufTotalCycle/lBufTotalNSec;
1269 // t->cycles_per_nsec_reciprocal =
1270 // ((0xFFFF+int_res)/int_res);
1275 /****************************************************************************
1277 * getEventTime : obtain the time of an event
1278 * NOTE : this function _really_ is on critical path.
1282 * LttTime : the time of the event
1283 ****************************************************************************/
1285 static inline LttTime
getEventTime(LttTracefile
* tf
)
1288 LttCycleCount cycle_count
; // cycle count for the current event
1289 LttCycleCount lEventTotalCycle
; // Total cycles from start for event
1290 LttCycleCount lEventNSec
; // Total nsecs from start for event
1291 LttTime lTimeOffset
; // Time offset in struct LttTime
1294 evId
= *(guint16
*)tf
->cur_event_pos
;
1295 if(unlikely(evId
== TRACE_BLOCK_START
)){
1297 tf
->pre_cycle_count
= 0;
1298 tf
->cur_cycle_count
= tf
->a_block_start
->cycle_count
;
1299 return tf
->a_block_start
->time
;
1300 }else if(unlikely(evId
== TRACE_BLOCK_END
)){
1302 tf
->pre_cycle_count
= 0;
1303 tf
->cur_cycle_count
= tf
->a_block_end
->cycle_count
;
1304 return tf
->a_block_end
->time
;
1307 // Calculate total time in cycles from start of buffer for this event
1308 cycle_count
= (LttCycleCount
)*(guint32
*)(tf
->cur_event_pos
+ EVENT_ID_SIZE
);
1310 if(unlikely(cycle_count
< tf
->pre_cycle_count
)) tf
->count
++;
1311 tf
->pre_cycle_count
= cycle_count
;
1312 cycle_count
+= (LttCycleCount
)tf
->count
<< 32;
1314 // if(tf->cur_heart_beat_number > tf->count)
1315 // cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count);
1317 tf
->cur_cycle_count
= cycle_count
;
1319 lEventTotalCycle
= cycle_count
;
1320 lEventTotalCycle
-= tf
->a_block_start
->cycle_count
;
1322 // Convert it to nsecs
1323 lEventNSec
= (double)lEventTotalCycle
* (double)tf
->nsec_per_cycle
;
1324 //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16;
1326 // Determine offset in struct LttTime
1327 lTimeOffset
= ltt_time_from_double(lEventNSec
);
1329 time
= ltt_time_add(tf
->a_block_start
->time
, lTimeOffset
);
1334 /*****************************************************************************
1336 * setFieldsOffset : set offset of the fields
1338 * tracefile : opened trace file
1339 * evT : the event type
1340 * evD : event data, it may be NULL
1341 ****************************************************************************/
1343 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
* t
)
1345 LttField
* rootFld
= evT
->root_field
;
1346 // rootFld->base_address = evD;
1349 rootFld
->field_size
= getFieldtypeSize(tf
, evT
, 0,0,rootFld
, evD
,t
);
1352 /*****************************************************************************
1354 * getFieldtypeSize: get the size of the field type (primitive type)
1356 * tracefile : opened trace file
1358 * offsetRoot : offset from the root
1359 * offsetParent : offset from the parrent
1361 * evD : event data, it may be NULL
1363 * int : size of the field
1364 ****************************************************************************/
1366 int getFieldtypeSize(LttTracefile
* t
, LttEventType
* evT
, int offsetRoot
,
1367 int offsetParent
, LttField
* fld
, void *evD
, LttTrace
*trace
)
1369 int size
, size1
, element_number
, i
, offset1
, offset2
;
1370 LttType
* type
= fld
->field_type
;
1373 if(unlikely(evT
->latest_block
==t
->which_block
&& evT
->latest_event
==t
->which_event
)){
1374 return fld
->field_size
;
1378 if(likely(fld
->field_fixed
== 1)){
1379 if(fld
== evT
->root_field
) return fld
->field_size
;
1382 switch(type
->type_class
) {
1384 element_number
= (int) type
->element_number
;
1385 if(fld
->field_fixed
== -1){
1386 size
= getFieldtypeSize(t
, evT
, offsetRoot
,
1387 0,fld
->child
[0], NULL
, trace
);
1388 if(size
== 0){ //has string or sequence
1389 fld
->field_fixed
= 0;
1391 fld
->field_fixed
= 1;
1392 size
*= element_number
;
1394 }else if(fld
->field_fixed
== 0){// has string or sequence
1396 for(i
=0;i
<element_number
;i
++){
1397 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
,size
,
1398 fld
->child
[0], evD
+size
, trace
);
1400 }else size
= fld
->field_size
;
1404 size1
= (int) ltt_type_size(trace
, type
);
1405 if(fld
->field_fixed
== -1){
1406 fld
->sequ_number_size
= size1
;
1407 fld
->field_fixed
= 0;
1408 size
= getFieldtypeSize(t
, evT
, offsetRoot
,
1409 0,fld
->child
[0], NULL
, trace
);
1410 fld
->element_size
= size
;
1412 element_number
= getIntNumber(size1
,evD
);
1413 type
->element_number
= element_number
;
1414 if(fld
->element_size
> 0){
1415 size
= element_number
* fld
->element_size
;
1416 }else{//sequence has string or sequence
1418 for(i
=0;i
<element_number
;i
++){
1419 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
+size1
,size
+size1
,
1420 fld
->child
[0], evD
+size
+size1
, trace
);
1429 if(fld
->field_fixed
== -1){
1430 fld
->field_fixed
= 0;
1432 size
= strlen((char*)evD
) + 1; //include end : '\0'
1437 element_number
= (int) type
->element_number
;
1439 if(fld
->field_fixed
== -1){
1440 offset1
= offsetRoot
;
1442 for(i
=0;i
<element_number
;i
++){
1443 size1
=getFieldtypeSize(t
, evT
,offset1
,offset2
,
1444 fld
->child
[i
], NULL
, trace
);
1445 if(size1
> 0 && size
>= 0){
1447 if(offset1
>= 0) offset1
+= size1
;
1456 fld
->field_fixed
= 0;
1458 }else fld
->field_fixed
= 1;
1459 }else if(fld
->field_fixed
== 0){
1460 offset1
= offsetRoot
;
1462 for(i
=0;i
<element_number
;i
++){
1463 size
=getFieldtypeSize(t
,evT
,offset1
,offset2
,
1464 fld
->child
[i
],evD
+offset2
, trace
);
1469 }else size
= fld
->field_size
;
1473 if(fld
->field_fixed
== -1){
1474 size
= (int) ltt_type_size(trace
, type
);
1475 fld
->field_fixed
= 1;
1476 }else size
= fld
->field_size
;
1483 if(type
->type_class
!= LTT_STRUCT
&& type
->type_class
!= LTT_ARRAY
&&
1484 type
->type_class
!= LTT_SEQUENCE
&& type
->type_class
!= LTT_STRING
){
1485 if(fld
->field_fixed
== -1){
1486 size
= (int) ltt_type_size(trace
, type
);
1487 fld
->field_fixed
= 1;
1488 }else size
= fld
->field_size
;
1490 }else if(type
->type_class
== LTT_ARRAY
){
1491 element_number
= (int) type
->element_number
;
1492 if(fld
->field_fixed
== -1){
1493 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1494 if(size
== 0){ //has string or sequence
1495 fld
->field_fixed
= 0;
1497 fld
->field_fixed
= 1;
1498 size
*= element_number
;
1500 }else if(fld
->field_fixed
== 0){// has string or sequence
1502 for(i
=0;i
<element_number
;i
++){
1503 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
,size
,
1504 fld
->child
[0], evD
+size
, trace
);
1506 }else size
= fld
->field_size
;
1508 }else if(type
->type_class
== LTT_SEQUENCE
){
1509 size1
= (int) ltt_type_size(trace
, type
);
1510 if(fld
->field_fixed
== -1){
1511 fld
->sequ_number_size
= size1
;
1512 fld
->field_fixed
= 0;
1513 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1514 fld
->element_size
= size
;
1516 element_number
= getIntNumber(size1
,evD
);
1517 type
->element_number
= element_number
;
1518 if(fld
->element_size
> 0){
1519 size
= element_number
* fld
->element_size
;
1520 }else{//sequence has string or sequence
1522 for(i
=0;i
<element_number
;i
++){
1523 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
+size1
,size
+size1
,
1524 fld
->child
[0], evD
+size
+size1
, trace
);
1530 }else if(type
->type_class
== LTT_STRING
){
1532 if(fld
->field_fixed
== -1){
1533 fld
->field_fixed
= 0;
1535 size
= strlen((char*)evD
) + 1; //include end : '\0'
1538 }else if(type
->type_class
== LTT_STRUCT
){
1539 element_number
= (int) type
->element_number
;
1541 if(fld
->field_fixed
== -1){
1542 offset1
= offsetRoot
;
1544 for(i
=0;i
<element_number
;i
++){
1545 size1
=getFieldtypeSize(t
, evT
,offset1
,offset2
, fld
->child
[i
], NULL
, trace
);
1546 if(size1
> 0 && size
>= 0){
1548 if(offset1
>= 0) offset1
+= size1
;
1557 fld
->field_fixed
= 0;
1559 }else fld
->field_fixed
= 1;
1560 }else if(fld
->field_fixed
== 0){
1561 offset1
= offsetRoot
;
1563 for(i
=0;i
<element_number
;i
++){
1564 size
=getFieldtypeSize(t
,evT
,offset1
,offset2
,fld
->child
[i
],evD
+offset2
, trace
);
1569 }else size
= fld
->field_size
;
1573 fld
->offset_root
= offsetRoot
;
1574 fld
->offset_parent
= offsetParent
;
1576 fld
->fixed_root
= (offsetRoot
==-1) ? 0 : 1;
1577 fld
->fixed_parent
= (offsetParent
==-1) ? 0 : 1;
1579 fld
->field_size
= size
;
1585 /*****************************************************************************
1587 * getIntNumber : get an integer number
1589 * size : the size of the integer
1590 * evD : the event data
1592 * gint64 : a 64 bits integer
1593 ****************************************************************************/
1595 gint64
getIntNumber(int size
, void *evD
)
1600 case 1: i
= *(gint8
*)evD
; break;
1601 case 2: i
= *(gint16
*)evD
; break;
1602 case 4: i
= *(gint32
*)evD
; break;
1603 case 8: i
= *(gint64
*)evD
; break;
1604 default: i
= *(gint64
*)evD
;
1605 g_critical("getIntNumber : integer size %d unknown", size
);
1610 if(size
== 1) i
= *(gint8
*)evD
;
1611 else if(size
== 2) i
= *(gint16
*)evD
;
1612 else if(size
== 4) i
= *(gint32
*)evD
;
1613 else if(size
== 8) i
= *(gint64
*)evD
;
1619 /*****************************************************************************
1621 * getDataEndianType : get the data type size and endian type of the local
1624 * size : size of data type
1625 * endian : endian type, little or big
1626 ****************************************************************************/
1628 void getDataEndianType(LttArchSize
* size
, LttArchEndian
* endian
)
1632 int sizeInt
=sizeof(int), sizeLong
=sizeof(long), sizePointer
=sizeof(void *);
1634 if(c
== 1) *endian
= LTT_LITTLE_ENDIAN
;
1635 else *endian
= LTT_BIG_ENDIAN
;
1637 if(sizeInt
== 2 && sizeLong
== 4 && sizePointer
== 4)
1639 else if(sizeInt
== 4 && sizeLong
== 4 && sizePointer
== 4)
1641 else if(sizeInt
== 4 && sizeLong
== 8 && sizePointer
== 8)
1643 else if(sizeInt
== 8 && sizeLong
== 8 && sizePointer
== 8)
1645 else *size
= LTT_UNKNOWN
;
1648 /* get the node name of the system */
1650 char * ltt_trace_system_description_node_name (LttSystemDescription
* s
)
1652 return s
->node_name
;
1656 /* get the domain name of the system */
1658 char * ltt_trace_system_description_domain_name (LttSystemDescription
* s
)
1660 return s
->domain_name
;
1664 /* get the description of the system */
1666 char * ltt_trace_system_description_description (LttSystemDescription
* s
)
1668 return s
->description
;
1672 /* get the start time of the trace */
1674 LttTime
ltt_trace_system_description_trace_start_time(LttSystemDescription
*s
)
1676 return s
->trace_start
;
1680 LttTracefile
*ltt_tracefile_new()
1682 return g_new(LttTracefile
, 1);
1685 void ltt_tracefile_destroy(LttTracefile
*tf
)
1690 void ltt_tracefile_copy(LttTracefile
*dest
, const LttTracefile
*src
)