X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=a111e41fd3a706c323636ed24e366f833f2c6fb1;hb=4e4d11b3b1db254446f6cad04b3c3fa9b574851f;hp=f535877edea8129fa7f6e1ce37440c0e96a5e333;hpb=57df94dd8dd13258d6a5a83406f2f76a045a7cc3;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index f535877e..a111e41f 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -16,6 +16,10 @@ * MA 02111-1307, USA. */ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include @@ -24,6 +28,8 @@ #include #include #include +#include +#include // For realpath #include @@ -37,6 +43,12 @@ #include #include #include +#include + +#ifndef g_open +#define g_open open +#endif + #define DIR_NAME_SIZE 256 #define __UNUSED__ __attribute__((__unused__)) @@ -44,6 +56,7 @@ #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format) #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format) +#define g_close close /* obtain the time of an event */ @@ -61,7 +74,7 @@ static inline gint getFieldtypeSize(LttTracefile * tf, gint offsetParent, LttField *fld, void *evD, LttTrace* t); /* read a fixed size or a block information from the file (fd) */ -int readFile(int fd, void * buf, size_t size, char * mesg); +int readFile(int fd, void * buf, size_t size, gchar * mesg); int readBlock(LttTracefile * tf, int whichBlock); /* calculate cycles per nsec for current block */ @@ -160,7 +173,7 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, * : a pointer to a tracefile ****************************************************************************/ -LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) +LttTracefile* ltt_tracefile_open(LttTrace * t, gchar * fileName) { LttTracefile * tf; struct stat lTDFStat; /* Trace data file status */ @@ -170,7 +183,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) //open the file tf->name = g_strdup(fileName); tf->trace = t; - tf->fd = open(fileName, O_RDONLY, 0); + tf->fd = g_open(fileName, O_RDONLY, 0); if(tf->fd < 0){ g_warning("Unable to open input data file %s\n", fileName); g_free(tf->name); @@ -182,7 +195,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) if(fstat(tf->fd, &lTDFStat) < 0){ g_warning("Unable to get the status of the input data file %s\n", fileName); g_free(tf->name); - close(tf->fd); + g_close(tf->fd); g_free(tf); return NULL; } @@ -191,7 +204,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) if(lTDFStat.st_size < (off_t)(sizeof(BlockStart) + EVENT_HEADER_SIZE)){ g_print("The input data file %s does not contain a trace\n", fileName); g_free(tf->name); - close(tf->fd); + g_close(tf->fd); g_free(tf); return NULL; } @@ -203,7 +216,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) tf->which_block = 0; //allocate memory to contain the info of a block - tf->buffer = (void *) g_new(char, t->system_description->ltt_block_size); + tf->buffer = (void *) g_new(gchar, t->system_description->ltt_block_size); //read the first block if(readBlock(tf,1)) exit(1); @@ -216,7 +229,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) *Open control and per cpu tracefiles ****************************************************************************/ -void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name) +void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name) { LttTracefile * tf; tf = ltt_tracefile_open(t,tracefile_name); @@ -225,7 +238,7 @@ void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name) g_ptr_array_add(t->per_cpu_tracefiles, tf); } -gint ltt_tracefile_open_control(LttTrace *t, char * control_name) +gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name) { LttTracefile * tf; LttEvent ev; @@ -249,7 +262,7 @@ gint ltt_tracefile_open_control(LttTrace *t, char * control_name) if(ev.event_id == TRACE_FACILITY_LOAD){ pos = ev.data; - fLoad.name = (char*)pos; + fLoad.name = (gchar*)pos; fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name)); fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); @@ -297,10 +310,12 @@ void ltt_tracefile_close(LttTracefile *t) /***************************************************************************** *Get system information ****************************************************************************/ -gint getSystemInfo(LttSystemDescription* des, char * pathname) +gint getSystemInfo(LttSystemDescription* des, gchar * pathname) { - FILE * fp; - char buf[DIR_NAME_SIZE]; + int fd; + GIOChannel *iochan; + gchar *buf = NULL; + gsize length; GMarkupParseContext * context; GError * error = NULL; @@ -313,27 +328,52 @@ gint getSystemInfo(LttSystemDescription* des, char * pathname) NULL /* error */ }; - fp = fopen(pathname,"r"); - if(!fp){ + fd = g_open(pathname, O_RDONLY, 0); + if(fd == -1){ g_warning("Can not open file : %s\n", pathname); return -1; } + iochan = g_io_channel_unix_new(fd); + context = g_markup_parse_context_new(&markup_parser, 0, des,NULL); - while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){ - if(!g_markup_parse_context_parse(context, buf, DIR_NAME_SIZE, &error)){ + //while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){ + while(g_io_channel_read_line(iochan, &buf, &length, NULL, &error) + != G_IO_STATUS_EOF) { + + if(error != NULL) { + g_warning("Can not read xml file: \n%s\n", error->message); + g_error_free(error); + } + if(!g_markup_parse_context_parse(context, buf, length, &error)){ if(error != NULL) { g_warning("Can not parse xml file: \n%s\n", error->message); g_error_free(error); } g_markup_parse_context_free(context); - fclose(fp); + + g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */ + if(error != NULL) { + g_warning("Can not close file: \n%s\n", error->message); + g_error_free(error); + } + + close(fd); return -1; } } g_markup_parse_context_free(context); - fclose(fp); + + g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */ + if(error != NULL) { + g_warning("Can not close file: \n%s\n", error->message); + g_error_free(error); + } + + g_close(fd); + + g_free(buf); return 0; } @@ -341,30 +381,31 @@ gint getSystemInfo(LttSystemDescription* des, char * pathname) *The following functions get facility/tracefile information ****************************************************************************/ -gint getFacilityInfo(LttTrace *t, char* eventdefs) +gint getFacilityInfo(LttTrace *t, gchar* eventdefs) { - DIR * dir; - struct dirent *entry; - char * ptr; + GDir * dir; + const gchar * name; unsigned int i,j; LttFacility * f; LttEventType * et; - char name[DIR_NAME_SIZE]; + gchar fullname[DIR_NAME_SIZE]; + GError * error = NULL; - dir = opendir(eventdefs); - if(!dir) { - g_warning("Can not open directory: %s\n", eventdefs); + dir = g_dir_open(eventdefs, 0, &error); + + if(error != NULL) { + g_warning("Can not open directory: %s, %s\n", eventdefs, error->message); + g_error_free(error); return -1; } - while((entry = readdir(dir)) != NULL){ - ptr = &entry->d_name[strlen(entry->d_name)-4]; - if(strcmp(ptr,".xml") != 0) continue; - strcpy(name,eventdefs); - strcat(name,entry->d_name); - ltt_facility_open(t,name); - } - closedir(dir); + while((name = g_dir_read_name(dir)) != NULL){ + if(!g_pattern_match_simple("*.xml", name)) continue; + strcpy(fullname,eventdefs); + strcat(fullname,name); + ltt_facility_open(t,fullname); + } + g_dir_close(dir); for(j=0;jfacility_number;j++){ f = (LttFacility*)g_ptr_array_index(t->facilities, j); @@ -376,54 +417,60 @@ gint getFacilityInfo(LttTrace *t, char* eventdefs) return 0; } -gint getControlFileInfo(LttTrace *t, char* control) +gint getControlFileInfo(LttTrace *t, gchar* control) { - DIR * dir; - struct dirent *entry; - char name[DIR_NAME_SIZE]; + GDir * dir; + const gchar *name; + gchar fullname[DIR_NAME_SIZE]; + GError * error = NULL; + + dir = g_dir_open(control, 0, &error); - dir = opendir(control); - if(!dir) { - g_warning("Can not open directory: %s\n", control); + if(error != NULL) { + g_warning("Can not open directory: %s, %s\n", control, error->message); + g_error_free(error); return -1; } - while((entry = readdir(dir)) != NULL){ - if(strcmp(entry->d_name,"facilities") != 0 && - strcmp(entry->d_name,"interrupts") != 0 && - strcmp(entry->d_name,"processes") != 0) continue; + while((name = g_dir_read_name(dir)) != NULL){ + if(strcmp(name,"facilities") != 0 && + strcmp(name,"interrupts") != 0 && + strcmp(name,"processes") != 0) continue; - strcpy(name,control); - strcat(name,entry->d_name); - if(ltt_tracefile_open_control(t,name)) + strcpy(fullname,control); + strcat(fullname,name); + if(ltt_tracefile_open_control(t,fullname)) { + g_dir_close(dir); return -1; + } } - closedir(dir); + g_dir_close(dir); return 0; } gint getCpuFileInfo(LttTrace *t, char* cpu) { - DIR * dir; - struct dirent *entry; - char name[DIR_NAME_SIZE]; + GDir * dir; + const gchar * name; + gchar fullname[DIR_NAME_SIZE]; + GError * error = NULL; + + dir = g_dir_open(cpu, 0, &error); - dir = opendir(cpu); - if(!dir) { - g_warning("Can not open directory: %s\n", cpu); + if(error != NULL) { + g_warning("Can not open directory: %s, %s\n", cpu, error->message); + g_error_free(error); return -1; } - while((entry = readdir(dir)) != NULL){ - if(strcmp(entry->d_name,".") != 0 && - strcmp(entry->d_name,"..") != 0 && - strcmp(entry->d_name,".svn") != 0){ - strcpy(name,cpu); - strcat(name,entry->d_name); - ltt_tracefile_open_cpu(t,name); + while((name = g_dir_read_name(dir)) != NULL){ + if(strcmp(name,".svn") != 0){ /* . and .. already excluded */ + strcpy(fullname,cpu); + strcat(fullname,name); + ltt_tracefile_open_cpu(t,fullname); }else continue; } - closedir(dir); + g_dir_close(dir); return 0; } @@ -446,7 +493,7 @@ gint getCpuFileInfo(LttTrace *t, char* cpu) * forgotten cases (.. were not used correctly before). * ****************************************************************************/ -void get_absolute_pathname(const char *pathname, char * abs_pathname) +void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname) { abs_pathname[0] = '\0'; @@ -461,16 +508,16 @@ void get_absolute_pathname(const char *pathname, char * abs_pathname) return; } -LttTrace *ltt_trace_open(const char *pathname) +LttTrace *ltt_trace_open(const gchar *pathname) { LttTrace * t; LttSystemDescription * sys_description; - char eventdefs[DIR_NAME_SIZE]; - char info[DIR_NAME_SIZE]; - char control[DIR_NAME_SIZE]; - char cpu[DIR_NAME_SIZE]; - char tmp[DIR_NAME_SIZE]; - char abs_path[DIR_NAME_SIZE]; + gchar eventdefs[DIR_NAME_SIZE]; + gchar info[DIR_NAME_SIZE]; + gchar control[DIR_NAME_SIZE]; + gchar cpu[DIR_NAME_SIZE]; + gchar tmp[DIR_NAME_SIZE]; + gchar abs_path[DIR_NAME_SIZE]; gboolean has_slash = FALSE; get_absolute_pathname(pathname, abs_path); @@ -503,8 +550,8 @@ LttTrace *ltt_trace_open(const char *pathname) t->control_tracefiles = g_ptr_array_new(); t->per_cpu_tracefiles = g_ptr_array_new(); t->facilities = g_ptr_array_new(); - getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian)); - + //getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian)); + //get system description strcpy(tmp,info); strcat(tmp,"system.xml"); @@ -517,8 +564,15 @@ LttTrace *ltt_trace_open(const char *pathname) g_free(t); return NULL; } - - + + /* Set the reverse byte order between trace and reader */ + if(sys_description->endian == LTT_LITTLE_ENDIAN + && G_BYTE_ORDER != G_LITTLE_ENDIAN) { + t->reverse_byte_order = 1; + } else if(sys_description->endian == LTT_BIG_ENDIAN + && G_BYTE_ORDER != G_BIG_ENDIAN) { + t->reverse_byte_order = 1; + } else t->reverse_byte_order = 0; //get facilities info if(getFacilityInfo(t,eventdefs)) { @@ -681,8 +735,10 @@ unsigned ltt_trace_eventtype_number(LttTrace *t) { unsigned int i; unsigned count = 0; + unsigned int num = t->facility_number; LttFacility * f; - for(i=0;ifacility_number;i++){ + + for(i=0;ifacilities, i); count += f->event_number; } @@ -696,17 +752,23 @@ LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id) { LttFacility * facility = NULL; unsigned int i; + unsigned int num = trace->facility_number; + GPtrArray *facilities = trace->facilities; - for(i=0;ifacility_number;i++){ + for(i=0;unlikely(ifacilities,i); - if(unlikely(id >= iter_facility->base_id && - id < iter_facility->base_id + iter_facility->event_number)) { + (LttFacility*) g_ptr_array_index(facilities,i); + unsigned base_id = iter_facility->base_id; + + if(likely(id >= base_id && + id < base_id + iter_facility->event_number)) { facility = iter_facility; break; + } else { + i++; } } - + return facility; } @@ -799,9 +861,9 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) for(i=0;icontrol_tracefile_number;i++){ tf = g_ptr_array_index(t->control_tracefiles, i); readBlock(tf,1); - startTmp = tf->a_block_start->time; + startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time); readBlock(tf,tf->block_number); - endTmp = tf->a_block_end->time; + endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time); if(i==0){ startSmall = startTmp; endBig = endTmp; @@ -815,9 +877,9 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) for(i=0;iper_cpu_tracefile_number;i++){ tf = g_ptr_array_index(t->per_cpu_tracefiles, i); readBlock(tf,1); - startTmp = tf->a_block_start->time; + startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time); readBlock(tf,tf->block_number); - endTmp = tf->a_block_end->time; + endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time); if(j == 0 && i==0){ startSmall = startTmp; endBig = endTmp; @@ -869,22 +931,26 @@ void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time, if(err) g_error("Can not read tracefile: %s\n", t->name); if(start_block == end_block)return; - tailTime = ltt_time_compare(t->a_block_end->time, time); + tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), time); if(tailTime >= 0) return; err=readBlock(t,end_block); if(err) g_error("Can not read tracefile: %s\n", t->name); if(start_block+1 == end_block)return; - headTime = ltt_time_compare(t->a_block_start->time, time); + headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_start->time), time); if(headTime <= 0 ) return; tmp_block = (end_block + start_block)/2; err=readBlock(t,tmp_block); if(err) g_error("Can not read tracefile: %s\n", t->name); - headTime = ltt_time_compare(t->a_block_start->time, time); - tailTime = ltt_time_compare(t->a_block_end->time, time); + headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_start->time), time); + tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), time); if(headTime <= 0 && tailTime >= 0) return; if(headTime > 0){ @@ -909,14 +975,17 @@ void ltt_tracefile_backward_find_time_block(LttTracefile *t, LttTime time) int t_time, h_time, err; err=readBlock(t,t->which_block-1); if(err) g_error("Can not read tracefile: %s\n", t->name); - h_time = ltt_time_compare(t->a_block_start->time, time); - t_time = ltt_time_compare(t->a_block_end->time, time); + h_time = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_start->time), time); + t_time = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), time); if(h_time == 0){ int tmp; if(t->which_block == 1) return; err=readBlock(t,t->which_block-1); if(err) g_error("Can not read tracefile: %s\n", t->name); - tmp = ltt_time_compare(t->a_block_end->time, time); + tmp = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), time); if(tmp == 0) return ltt_tracefile_seek_time(t, time); err=readBlock(t,t->which_block+1); if(err) g_error("Can not read tracefile: %s\n", t->name); @@ -934,12 +1003,16 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) { int err; LttTime lttTime; - int headTime = ltt_time_compare(t->a_block_start->time, time); - int tailTime = ltt_time_compare(t->a_block_end->time, time); + int headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_start->time), time); + int tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), time); LttEvent ev; if(headTime < 0 && tailTime > 0){ - if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) { + if(ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, + &t->a_block_end->time), + t->current_event_time) !=0) { lttTime = getEventTime(t); err = ltt_time_compare(lttTime, time); if(err > 0){ @@ -1028,6 +1101,7 @@ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) t->pre_cycle_count = ep->pre_cycle_count; t->count = ep->count; t->overflow_nsec = ep->overflow_nsec; + t->last_heartbeat = ep->last_heartbeat; /* end of workaround */ //update the fields of the current event and go to the next event @@ -1068,19 +1142,19 @@ LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) if(unlikely(err))g_error("Can not read tracefile"); } - event->event_id = (int)(*(guint16 *)(t->cur_event_pos)); + event->event_id = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos); if(unlikely(event->event_id == TRACE_TIME_HEARTBEAT)) t->cur_heart_beat_number++; t->prev_event_time = t->current_event_time; // t->current_event_time = getEventTime(t); - event->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE); + event->time_delta = ltt_get_uint32(t->trace->reverse_byte_order, t->cur_event_pos + EVENT_ID_SIZE); event->event_time = t->current_event_time; event->event_cycle_count = t->cur_cycle_count; event->tracefile = t; - event->data = t->cur_event_pos + EVENT_HEADER_SIZE; + event->data = t->cur_event_pos + EVENT_HEADER_SIZE; event->which_block = t->which_block; event->which_event = t->which_event; @@ -1091,6 +1165,7 @@ LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) event->pre_cycle_count = t->pre_cycle_count; event->count = t->count; event->overflow_nsec = t->overflow_nsec; + event->last_heartbeat = t->last_heartbeat; /* end of workaround */ @@ -1131,174 +1206,6 @@ int readFile(int fd, void * buf, size_t size, char * mesg) return 0; } -/***************************************************************************** - *Function name - * skipEvent_pre_read_cycles : go to the next event, - * update the necessary fields of the current event - * increment the cycle counter, save it at the end. - *Input params - * t : tracefile - *return value - * 0 : success - * ERANGE : event id is out of range - ****************************************************************************/ - -int skipEvent_pre_read_cycles(LttTracefile * t) -{ - int evId; - void * evData; - LttEventType * evT; - LttField * rootFld; - - evId = (int)(*(guint16 *)(t->cur_event_pos)); - evData = t->cur_event_pos + EVENT_HEADER_SIZE; - - evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId); - - if(likely(evT)) rootFld = evT->root_field; - else return ERANGE; - - if(likely(rootFld)){ - //event has string/sequence or the last event is not the same event - if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event) - && rootFld->field_fixed == 0)){ - setFieldsOffset(t, evT, evData, t->trace); - } - t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size; - }else t->cur_event_pos += EVENT_HEADER_SIZE; - - //evT->latest_block = t->which_block; - //evT->latest_event = t->which_event; - - //the next event is in the next block - //if(unlikely(evId == TRACE_BLOCK_END)){ - // Specify end of buffer reached. - // t->cur_event_pos = t->buffer + t->block_size; - //}else{ - //g_critical("COUNT : %lu", t->cur_cycle_count); - //t->which_event++; - // t->current_event_time = getEventTime(t); - //} - - return 0; -} - - - - -/***************************************************************************** - *Function name - * ltt_tracefile_pre_read_cycles : - * read the current event, increment the cycle counter - *Input params - * t : tracefile - *Return value - * False : end of bloc reached - ****************************************************************************/ - -gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) -{ - int err; - //LttEvent event; - - // if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){ - //if(unlikely(t->which_block == t->block_number)){ - // return FALSE; - //} - // return FALSE; // end of bloc reached - //err = readBlock(t, t->which_block + 1); - //if(unlikely(err))g_error("Can not read tracefile"); - //} - - //event.event_id = (int)(*(guint16 *)(t->cur_event_pos)); - //if(unlikely(event.event_id == TRACE_TIME_HEARTBEAT)) - // t->cur_heart_beat_number++; - - //t->prev_event_time = t->current_event_time; - // t->current_event_time = getEventTime(t); - - //event.time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE); - //event.event_time = t->current_event_time; - //event.event_cycle_count = t->cur_cycle_count; - - //event.tracefile = t; - //event.data = t->cur_event_pos + EVENT_HEADER_SIZE; - //event.which_block = t->which_block; - //event.which_event = t->which_event; - - /* This is a workaround for fast position seek */ - //event.last_event_pos = t->last_event_pos; - //event.prev_block_end_time = t->prev_block_end_time; - //event.prev_event_time = t->prev_event_time; - //event.pre_cycle_count = t->pre_cycle_count; - //event.count = t->count; - /* end of workaround */ - - - /* Increment the cycle counter for the bloc */ - LttTime time; - LttCycleCount cycle_count; // cycle count for the current event - LttCycleCount lEventTotalCycle; // Total cycles from start for event - LttCycleCount lEventNSec; // Total nsecs from start for event - LttTime lTimeOffset; // Time offset in struct LttTime - guint16 evId; - - evId = *(guint16 *)tf->cur_event_pos; - - // Calculate total time in cycles from start of buffer for this event - cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); - //g_debug("event cycle count %llu", cycle_count); - // - //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count); - //LttCycleCount res_delta_count; - gboolean comp_count = cycle_count < tf->pre_cycle_count; - tf->pre_cycle_count = cycle_count; - - if(unlikely(comp_count)) { - /* Wrapped */ - tf->count++; //increment wrap count - } - - //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++; - //if(unlikely(delta_count < 0)) { - // tf->count++; //increment wrap count - // keep in mind that delta_count is negative here. - // res_delta_count = delta_count + 0x100000000ULL ; - //} else - // res_delta_count = (LttCycleCount)delta_count; - - //cycle_count += (LttCycleCount)tf->count << 32; - - //FIXME (MD) - // if(tf->cur_heart_beat_number > tf->count) - // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32; - - //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count; - tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32); - //g_debug("cur cycle count %llu", tf->cur_cycle_count); - - - - - if(unlikely(evId == TRACE_BLOCK_START)){ - //g_debug("BLOCK START"); - }else if(unlikely(evId == TRACE_BLOCK_END)){ - //g_debug("BLOCK END"); - - /* The goal of all this pre reading */ - tf->a_block_end->cycle_count = tf->cur_cycle_count; - //g_debug("end of block cycle count : %llu", tf->cur_cycle_count); - - return FALSE; - } - - //update the fields of the current event and go to the next event - err = skipEvent_pre_read_cycles(tf); - if(unlikely(err == ERANGE)) g_error("event id is out of range\n"); - - - return TRUE; -} /**************************************************************************** *Function name @@ -1321,8 +1228,10 @@ int readBlock(LttTracefile * tf, int whichBlock) if((guint)whichBlock == tf->which_block) return 0; if(likely(whichBlock - tf->which_block == 1 && tf->which_block != 0)){ - tf->prev_block_end_time = tf->a_block_end->time; - tf->prev_event_time = tf->a_block_end->time; + tf->prev_block_end_time = ltt_get_time(tf->trace->reverse_byte_order, + &tf->a_block_end->time); + tf->prev_event_time = ltt_get_time(tf->trace->reverse_byte_order, + &tf->a_block_end->time); }else{ tf->prev_block_end_time.tv_sec = 0; tf->prev_block_end_time.tv_nsec = 0; @@ -1338,61 +1247,30 @@ int readBlock(LttTracefile * tf, int whichBlock) tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE); lostSize = *(guint32 *)(tf->buffer + tf->block_size - sizeof(guint32)); - tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size - - lostSize + EVENT_HEADER_SIZE); - tf->last_event_pos = tf->buffer + tf->block_size - lostSize; + tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size + - sizeof(guint32) - lostSize - sizeof(BlockEnd)); + tf->last_event_pos = tf->buffer + tf->block_size - + sizeof(guint32) - lostSize + - sizeof(BlockEnd) - EVENT_HEADER_SIZE; tf->which_block = whichBlock; tf->which_event = 1; tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev tf->cur_heart_beat_number = 0; + tf->last_heartbeat = NULL; /* read the whole block to precalculate total of cycles in it */ tf->count = 0; tf->pre_cycle_count = 0; - tf->cur_cycle_count = 0; - //g_debug("precalculating cycles begin for block %i", whichBlock); - while(likely(ltt_tracefile_pre_read_cycles(tf))); - /* Rough approximation of cycles per usec to calculate - * the real block start and end time. - */ - getCyclePerNsec(tf); - /* we are at end position, make end time more precise */ - /* Start overflow_nsec to a negative value : takes account of the - * start of block cycle counter */ - tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count) - * tf->nsec_per_cycle); - /* put back the numbers corresponding to end time */ - tf->overflow_nsec += tf->one_overflow_nsec * tf->count; - - tf->a_block_end->time = getEventTime(tf); - - //g_debug("precalculating cycles end for block %i", whichBlock); - - /* put back pointer at the beginning */ - tf->count = 0; - tf->pre_cycle_count = 0; - tf->cur_cycle_count = 0; - tf->which_event = 1; - tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev - tf->cur_heart_beat_number = 0; - - /* Make start time more precise */ - /* Start overflow_nsec to a negative value : takes account of the - * start of block cycle counter */ - tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count) - * tf->nsec_per_cycle); - - - tf->a_block_start->time = getEventTime(tf); + tf->cur_cycle_count = ltt_get_uint32(tf->trace->reverse_byte_order, tf->cur_event_pos + EVENT_ID_SIZE); - /* recalculate the cycles per nsec, with now more precise start and end time - */ getCyclePerNsec(tf); - tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count) - * tf->nsec_per_cycle); - + tf->overflow_nsec = + (-((double) + (ltt_get_uint64(tf->trace->reverse_byte_order, + &tf->a_block_start->cycle_count)&0xFFFFFFFF)) + * tf->nsec_per_cycle); tf->current_event_time = getEventTime(tf); @@ -1418,7 +1296,9 @@ void updateTracefile(LttTracefile * tf) tf->prev_event_time.tv_nsec = 0; tf->count = 0; - tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count) + tf->overflow_nsec = + (-((double)ltt_get_uint64(tf->trace->reverse_byte_order, + &tf->a_block_start->cycle_count)) * tf->nsec_per_cycle); } @@ -1440,7 +1320,7 @@ int skipEvent(LttTracefile * t) LttEventType * evT; LttField * rootFld; - evId = (int)(*(guint16 *)(t->cur_event_pos)); + evId = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos); evData = t->cur_event_pos + EVENT_HEADER_SIZE; evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId); @@ -1464,6 +1344,8 @@ int skipEvent(LttTracefile * t) if(unlikely(evId == TRACE_BLOCK_END)){ t->cur_event_pos = t->buffer + t->block_size; }else{ + t->cur_cycle_count = ltt_get_uint32(t->trace->reverse_byte_order, + t->cur_event_pos + EVENT_ID_SIZE); t->which_event++; t->current_event_time = getEventTime(t); } @@ -1485,31 +1367,27 @@ void getCyclePerNsec(LttTracefile * t) { LttTime lBufTotalTime; /* Total time for this buffer */ double lBufTotalNSec; /* Total time for this buffer in nsecs */ - double lBufTotalCycle;/* Total cycles for this buffer */ + LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */ /* Calculate the total time for this buffer */ - lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time); + lBufTotalTime = ltt_time_sub( + ltt_get_time(t->trace->reverse_byte_order, &t->a_block_end->time), + ltt_get_time(t->trace->reverse_byte_order, &t->a_block_start->time)); /* Calculate the total cycles for this bufffer */ - lBufTotalCycle = t->a_block_end->cycle_count; - lBufTotalCycle -= t->a_block_start->cycle_count; + lBufTotalCycle = ltt_get_uint64(t->trace->reverse_byte_order, + &t->a_block_end->cycle_count); + lBufTotalCycle -= ltt_get_uint64(t->trace->reverse_byte_order, + &t->a_block_start->cycle_count); - /* Convert the total time to nsecs */ + /* Convert the total time to double */ lBufTotalNSec = ltt_time_to_double(lBufTotalTime); t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle; + /* Pre-multiply one overflow (2^32 cycles) by nsec_per_cycle */ t->one_overflow_nsec = t->nsec_per_cycle * (double)0x100000000ULL; - /* See : http://www.azillionmonkeys.com/qed/adiv.html */ - // precalculate the reciprocal, so divisions will be really fast. - // 2^32-1 == 0xFFFFFFFFULL - //{ - // double int_res = lBufTotalCycle/lBufTotalNSec; - // t->cycles_per_nsec_reciprocal = - // ((0xFFFF+int_res)/int_res); - //} - } /**************************************************************************** @@ -1531,96 +1409,53 @@ static inline LttTime getEventTime(LttTracefile * tf) LttTime lTimeOffset; // Time offset in struct LttTime guint16 evId; - evId = *(guint16 *)tf->cur_event_pos; - //if(unlikely(evId == TRACE_BLOCK_START)){ - // tf->count = 0; - // tf->pre_cycle_count = 0; - // tf->cur_cycle_count = tf->a_block_start->cycle_count; - // return tf->a_block_start->time; - //}//else if(unlikely(evId == TRACE_BLOCK_END)){ - //tf->count = 0; - //tf->pre_cycle_count = 0; - //tf->cur_cycle_count = tf->a_block_end->cycle_count; - //return tf->a_block_end->time; - //} + evId = ltt_get_uint16(tf->trace->reverse_byte_order, + tf->cur_event_pos); - // Calculate total time in cycles from start of buffer for this event - cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); - //g_debug("event cycle count %llu", cycle_count); - // - //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count); - //LttCycleCount res_delta_count; + cycle_count = ltt_get_uint32(tf->trace->reverse_byte_order, + tf->cur_event_pos + EVENT_ID_SIZE); + gboolean comp_count = cycle_count < tf->pre_cycle_count; + tf->pre_cycle_count = cycle_count; if(unlikely(comp_count)) { - /* Wrapped */ + /* Overflow */ tf->overflow_nsec += tf->one_overflow_nsec; tf->count++; //increment overflow count } - - //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++; - //if(unlikely(delta_count < 0)) { - // tf->count++; //increment wrap count - // keep in mind that delta_count is negative here. - // res_delta_count = delta_count + 0x100000000ULL ; - //} else - // res_delta_count = (LttCycleCount)delta_count; - - //cycle_count += (LttCycleCount)tf->count << 32; - - //FIXME (MD) - // if(tf->cur_heart_beat_number > tf->count) - // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32; - - //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count; - // - // - // Total cycle counter of the event. - //tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32); - - //g_debug("cur cycle count %llu", tf->cur_cycle_count); - - // Total number of cycles since the beginning of the block - //lEventTotalCycle = tf->cur_cycle_count - // - tf->a_block_start->cycle_count; - - + if(unlikely(evId == TRACE_BLOCK_START)) { + lEventNSec = 0; + } else if(unlikely(evId == TRACE_BLOCK_END)) { + lEventNSec = ((double) + (ltt_get_uint64(tf->trace->reverse_byte_order, + &tf->a_block_end->cycle_count) + - ltt_get_uint64(tf->trace->reverse_byte_order, + &tf->a_block_start->cycle_count)) + * tf->nsec_per_cycle); + } #if 0 - // Calculate total time in cycles from start of buffer for this event - cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); - - if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++; - tf->pre_cycle_count = cycle_count; - cycle_count += (LttCycleCount)tf->count << 32; - - //FIXME (MD) - // if(tf->cur_heart_beat_number > tf->count) - // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32; - - tf->cur_cycle_count = cycle_count; + /* If you want to make heart beat a special case and use their own 64 bits + * TSC, activate this. + */ + else if(unlikely(evId == TRACE_TIME_HEARTBEAT)) { - lEventTotalCycle = cycle_count; - lEventTotalCycle -= tf->a_block_start->cycle_count; + tf->last_heartbeat = (TimeHeartbeat*)(tf->cur_event_pos+EVENT_HEADER_SIZE); + lEventNSec = ((double)(tf->last_heartbeat->cycle_count + - tf->a_block_start->cycle_count) + * tf->nsec_per_cycle); + } #endif //0 - // Convert it to nsecs - //lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle; - //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16; - - // Determine offset in struct LttTime - //lTimeOffset = ltt_time_from_double(lEventNSec); - // - // We do not substract block start cycle count here, it has already been done - // on the overflow_nsec - // The result should never be negative, because the cycle count of - // the event following the block start should be >= the previous one. - lEventNSec = (gint64)((double)cycle_count * tf->nsec_per_cycle) - +tf->overflow_nsec; - //g_assert(lEventNSec >= 0); + else { + lEventNSec = (gint64)((double)cycle_count * tf->nsec_per_cycle) + +tf->overflow_nsec; + } + lTimeOffset = ltt_time_from_uint64(lEventNSec); - time = ltt_time_add(tf->a_block_start->time, lTimeOffset); + time = ltt_time_add(ltt_get_time(tf->trace->reverse_byte_order, + &tf->a_block_start->time), lTimeOffset); return time; } @@ -1668,124 +1503,144 @@ static inline gint getFieldtypeSize(LttTracefile * t, evT->latest_event==t->which_event)){ size = fld->field_size; goto end_getFieldtypeSize; - } - - if(unlikely(fld->field_fixed == 1)){ - if(likely(fld == evT->root_field)) { - size = fld->field_size; - goto end_getFieldtypeSize; + } else { + /* This likely has been tested with gcov : half of them.. */ + if(unlikely(fld->field_fixed == 1)){ + /* tested : none */ + if(unlikely(fld == evT->root_field)) { + size = fld->field_size; + goto end_getFieldtypeSize; + } } - } + /* From gcov profiling : half string, half struct, can we gain something + * from that ? (Mathieu) */ + switch(type->type_class) { + case LTT_ARRAY: + element_number = (int) type->element_number; + if(fld->field_fixed == -1){ + size = getFieldtypeSize(t, evT, offsetRoot, + 0,fld->child[0], NULL, trace); + if(size == 0){ //has string or sequence + fld->field_fixed = 0; + }else{ + fld->field_fixed = 1; + size *= element_number; + } + }else if(fld->field_fixed == 0){// has string or sequence + size = 0; + for(i=0;ichild[0], evD+size, trace); + } + }else size = fld->field_size; + if(unlikely(!evD)){ + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; + } + + break; - switch(type->type_class) { - case LTT_ARRAY: - element_number = (int) type->element_number; - if(fld->field_fixed == -1){ - size = getFieldtypeSize(t, evT, offsetRoot, - 0,fld->child[0], NULL, trace); - if(size == 0){ //has string or sequence + case LTT_SEQUENCE: + size1 = (int) ltt_type_size(trace, type); + if(fld->field_fixed == -1){ + fld->sequ_number_size = size1; fld->field_fixed = 0; - }else{ - fld->field_fixed = 1; - size *= element_number; + size = getFieldtypeSize(t, evT, offsetRoot, + 0,fld->child[0], NULL, trace); + fld->element_size = size; + }else{//0: sequence + element_number = getIntNumber(t->trace->reverse_byte_order,size1,evD); + type->element_number = element_number; + if(fld->element_size > 0){ + size = element_number * fld->element_size; + }else{//sequence has string or sequence + size = 0; + for(i=0;ichild[0], evD+size+size1, trace); + } + } + size += size1; + } + if(unlikely(!evD)){ + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; } - }else if(fld->field_fixed == 0){// has string or sequence + + break; + + case LTT_STRING: size = 0; - for(i=0;ichild[0], evD+size, trace); + if(fld->field_fixed == -1){ + fld->field_fixed = 0; + }else{//0: string + /* Hope my implementation is faster than strlen (Mathieu) */ + char *ptr=(char*)evD; + size = 1; + /* from gcov : many many strings are empty, make it the common case.*/ + while(unlikely(*ptr != '\0')) { size++; ptr++; } + //size = ptr - (char*)evD + 1; //include end : '\0' } - }else size = fld->field_size; - break; + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - case LTT_SEQUENCE: - size1 = (int) ltt_type_size(trace, type); - if(fld->field_fixed == -1){ - fld->sequ_number_size = size1; - fld->field_fixed = 0; - size = getFieldtypeSize(t, evT, offsetRoot, - 0,fld->child[0], NULL, trace); - fld->element_size = size; - }else{//0: sequence - element_number = getIntNumber(size1,evD); - type->element_number = element_number; - if(fld->element_size > 0){ - size = element_number * fld->element_size; - }else{//sequence has string or sequence - size = 0; + break; + + case LTT_STRUCT: + element_number = (int) type->element_number; + size = 0; + /* tested with gcov */ + if(unlikely(fld->field_fixed == -1)){ + offset1 = offsetRoot; + offset2 = 0; for(i=0;ichild[0], evD+size+size1, trace); - } - } - size += size1; - } - break; - - case LTT_STRING: - size = 0; - if(fld->field_fixed == -1){ - fld->field_fixed = 0; - }else{//0: string - /* Hope my implementation is faster than strlen (Mathieu) */ - char *ptr=(char*)evD; - size = 1; - while(*ptr != '\0') { size++; ptr++; } - //size = ptr - (char*)evD + 1; //include end : '\0' - } - break; - - case LTT_STRUCT: - element_number = (int) type->element_number; - size = 0; - if(fld->field_fixed == -1){ - offset1 = offsetRoot; - offset2 = 0; - for(i=0;ichild[i], NULL, trace); - if(size1 > 0 && size >= 0){ - size += size1; - if(offset1 >= 0) offset1 += size1; - offset2 += size1; - }else{ - size = -1; - offset1 = -1; - offset2 = -1; + size1=getFieldtypeSize(t, evT,offset1,offset2, + fld->child[i], NULL, trace); + if(likely(size1 > 0 && size >= 0)){ + size += size1; + if(likely(offset1 >= 0)) offset1 += size1; + offset2 += size1; + }else{ + size = -1; + offset1 = -1; + offset2 = -1; + } } + if(unlikely(size == -1)){ + fld->field_fixed = 0; + size = 0; + }else fld->field_fixed = 1; + }else if(likely(fld->field_fixed == 0)){ + offset1 = offsetRoot; + offset2 = 0; + for(i=0;unlikely(ichild[i],evD+offset2, trace); + offset1 += size; + offset2 += size; + } + size = offset2; + }else size = fld->field_size; + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; + break; + + default: + if(unlikely(fld->field_fixed == -1)){ + size = (int) ltt_type_size(trace, type); + fld->field_fixed = 1; + }else size = fld->field_size; + if(unlikely(!evD)){ + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; } - if(size == -1){ - fld->field_fixed = 0; - size = 0; - }else fld->field_fixed = 1; - }else if(fld->field_fixed == 0){ - offset1 = offsetRoot; - offset2 = 0; - for(i=0;ichild[i],evD+offset2, trace); - offset1 += size; - offset2 += size; - } - size = offset2; - }else size = fld->field_size; - break; - - default: - if(fld->field_fixed == -1){ - size = (int) ltt_type_size(trace, type); - fld->field_fixed = 1; - }else size = fld->field_size; - break; + break; + } } fld->offset_root = offsetRoot; fld->offset_parent = offsetParent; - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } fld->field_size = size; end_getFieldtypeSize: @@ -1804,30 +1659,23 @@ end_getFieldtypeSize: * gint64 : a 64 bits integer ****************************************************************************/ -gint64 getIntNumber(int size, void *evD) +gint64 getIntNumber(gboolean reverse_byte_order, int size, void *evD) { gint64 i; switch(size) { - case 1: i = *(gint8 *)evD; break; - case 2: i = *(gint16 *)evD; break; - case 4: i = *(gint32 *)evD; break; - case 8: i = *(gint64 *)evD; break; - default: i = *(gint64 *)evD; + case 1: i = *((gint8*)evD); break; + case 2: i = ltt_get_int16(reverse_byte_order, evD); break; + case 4: i = ltt_get_int32(reverse_byte_order, evD); break; + case 8: i = ltt_get_int64(reverse_byte_order, evD); break; + default: i = ltt_get_int64(reverse_byte_order, evD); g_critical("getIntNumber : integer size %d unknown", size); break; } -#if 0 - if(size == 1) i = *(gint8 *)evD; - else if(size == 2) i = *(gint16 *)evD; - else if(size == 4) i = *(gint32 *)evD; - else if(size == 8) i = *(gint64 *)evD; -#endif //0 - - return (gint64)i; + return i; } - +#if 0 /***************************************************************************** *Function name * getDataEndianType : get the data type size and endian type of the local @@ -1856,7 +1704,7 @@ void getDataEndianType(LttArchSize * size, LttArchEndian * endian) *size = LTT_ILP64; else *size = LTT_UNKNOWN; } - +#endif //0 /* get the node name of the system */ char * ltt_trace_system_description_node_name (LttSystemDescription * s)