X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=5c30d9a18fa1e5df08c59034585ad6dcc573fe75;hb=a1062ddd65b968c3ba077bc68b88887888b5057a;hp=5c45d56623a3b53db1b374610413c02da1b018d2;hpb=e4eced0fb7cd23ba2b16eff08f2185bed49ab5e5;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 5c45d566..5c30d9a1 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -1,15 +1,54 @@ +/* This file is part of the Linux Trace Toolkit viewer + * Copyright (C) 2003-2004 Xiangxiu Yang + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License Version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + */ + #include #include +#include +#include #include #include -#include -#include +#include +#include + +// For realpath +#include +#include + -#include #include "parser.h" +#include +#include "ltt-private.h" #include +#include +#include +#include #define DIR_NAME_SIZE 256 +#define __UNUSED__ __attribute__((__unused__)) + +#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) + + +/* obtain the time of an event */ + +static inline LttTime getEventTime(LttTracefile * tf); + /* set the offset of the fields belonging to the event, need the information of the archecture */ @@ -33,9 +72,81 @@ void updateTracefile(LttTracefile * tf); /* go to the next event */ int skipEvent(LttTracefile * t); -/* compare two time (LttTime), 0:t1=t2, -1:t1t2 */ -int timecmp(LttTime * t1, LttTime * t2); +/* Functions to parse system.xml file (using glib xml parser) */ +static void parser_start_element (GMarkupParseContext __UNUSED__ *context, + const gchar *element_name, + const gchar **attribute_names, + const gchar **attribute_values, + gpointer user_data, + GError **error) +{ + int i=0; + LttSystemDescription* des = (LttSystemDescription* )user_data; + if(strcmp("system", element_name)){ + *error = g_error_new(G_MARKUP_ERROR, + G_LOG_LEVEL_WARNING, + "This is not system.xml file"); + return; + } + + while(attribute_names[i]){ + if(strcmp("node_name", attribute_names[i])==0){ + des->node_name = g_strdup(attribute_values[i]); + }else if(strcmp("domainname", attribute_names[i])==0){ + des->domain_name = g_strdup(attribute_values[i]); + }else if(strcmp("cpu", attribute_names[i])==0){ + des->nb_cpu = atoi(attribute_values[i]); + }else if(strcmp("arch_size", attribute_names[i])==0){ + if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32; + else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32; + else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64; + else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64; + else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN; + }else if(strcmp("endian", attribute_names[i])==0){ + if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0) + des->endian = LTT_LITTLE_ENDIAN; + else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0) + des->endian = LTT_BIG_ENDIAN; + }else if(strcmp("kernel_name", attribute_names[i])==0){ + des->kernel_name = g_strdup(attribute_values[i]); + }else if(strcmp("kernel_release", attribute_names[i])==0){ + des->kernel_release = g_strdup(attribute_values[i]); + }else if(strcmp("kernel_version", attribute_names[i])==0){ + des->kernel_version = g_strdup(attribute_values[i]); + }else if(strcmp("machine", attribute_names[i])==0){ + des->machine = g_strdup(attribute_values[i]); + }else if(strcmp("processor", attribute_names[i])==0){ + des->processor = g_strdup(attribute_values[i]); + }else if(strcmp("hardware_platform", attribute_names[i])==0){ + des->hardware_platform = g_strdup(attribute_values[i]); + }else if(strcmp("operating_system", attribute_names[i])==0){ + des->operating_system = g_strdup(attribute_values[i]); + }else if(strcmp("ltt_major_version", attribute_names[i])==0){ + des->ltt_major_version = atoi(attribute_values[i]); + }else if(strcmp("ltt_minor_version", attribute_names[i])==0){ + des->ltt_minor_version = atoi(attribute_values[i]); + }else if(strcmp("ltt_block_size", attribute_names[i])==0){ + des->ltt_block_size = atoi(attribute_values[i]); + }else{ + *error = g_error_new(G_MARKUP_ERROR, + G_LOG_LEVEL_WARNING, + "Not a valid attribute"); + return; + } + i++; + } +} + +static void parser_characters (GMarkupParseContext __UNUSED__ *context, + const gchar *text, + gsize __UNUSED__ text_len, + gpointer user_data, + GError __UNUSED__ **error) +{ + LttSystemDescription* des = (LttSystemDescription* )user_data; + des->description = g_strdup(text); +} /***************************************************************************** @@ -52,7 +163,6 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) { LttTracefile * tf; struct stat lTDFStat; /* Trace data file status */ - BlockStart a_block_start; tf = g_new(LttTracefile, 1); @@ -61,16 +171,23 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) tf->trace = t; tf->fd = open(fileName, O_RDONLY, 0); if(tf->fd < 0){ - g_error("Unable to open input data file %s\n", fileName); + g_warning("Unable to open input data file %s\n", fileName); + g_free(tf->name); + g_free(tf); + return NULL; } // Get the file's status if(fstat(tf->fd, &lTDFStat) < 0){ - g_error("Unable to get the status of the input data file %s\n", fileName); + g_warning("Unable to get the status of the input data file %s\n", fileName); + g_free(tf->name); + close(tf->fd); + g_free(tf); + return NULL; } // Is the file large enough to contain a trace - if(lTDFStat.st_size < sizeof(BlockStart) + EVENT_HEADER_SIZE){ + 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); @@ -107,32 +224,33 @@ void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name) g_ptr_array_add(t->per_cpu_tracefiles, tf); } -void ltt_tracefile_open_control(LttTrace *t, char * control_name) +gint ltt_tracefile_open_control(LttTrace *t, char * control_name) { LttTracefile * tf; - LttEvent * ev; + LttEvent ev; LttFacility * f; - uint16_t evId; void * pos; FacilityLoad fLoad; - int i; + unsigned int i; tf = ltt_tracefile_open(t,control_name); - if(!tf) return; + if(!tf) { + g_warning("ltt_tracefile_open_control : bad file descriptor"); + return -1; + } t->control_tracefile_number++; g_ptr_array_add(t->control_tracefiles,tf); //parse facilities tracefile to get base_id if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){ while(1){ - ev = ltt_tracefile_read(tf); - if(!ev)return; // end of file + if(!ltt_tracefile_read(tf,&ev)) return 0; // end of file - if(ev->event_id == TRACE_FACILITY_LOAD){ - pos = ev->data; + if(ev.event_id == TRACE_FACILITY_LOAD){ + pos = ev.data; fLoad.name = (char*)pos; fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name)); - fLoad.base_code = *(uint32_t*)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); + fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities,i); @@ -141,16 +259,22 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name) break; } } - if(i==t->facility_number) - g_error("Facility: %s, checksum: %d is not founded\n", - fLoad.name,fLoad.checksum); - }else if(ev->event_id == TRACE_BLOCK_START){ + if(i==t->facility_number) { + g_warning("Facility: %s, checksum: %u is not found", + fLoad.name,(unsigned int)fLoad.checksum); + return -1; + } + }else if(ev.event_id == TRACE_BLOCK_START){ continue; - }else if(ev->event_id == TRACE_BLOCK_END){ + }else if(ev.event_id == TRACE_BLOCK_END){ break; - }else g_error("Not valid facilities trace file\n"); + }else { + g_warning("Not valid facilities trace file"); + return -1; + } } } + return 0; } /***************************************************************************** @@ -172,169 +296,65 @@ void ltt_tracefile_close(LttTracefile *t) /***************************************************************************** *Get system information ****************************************************************************/ -void getSystemInfo(LttSystemDescription* des, char * pathname) +gint getSystemInfo(LttSystemDescription* des, char * pathname) { FILE * fp; - int i; - int entry_number = 15; char buf[DIR_NAME_SIZE]; - char description[4*DIR_NAME_SIZE]; - char * ptr; + + GMarkupParseContext * context; + GError * error = NULL; + GMarkupParser markup_parser = + { + parser_start_element, + NULL, + parser_characters, + NULL, /* passthrough */ + NULL /* error */ + }; fp = fopen(pathname,"r"); if(!fp){ - g_error("Can not open file : %s\n", pathname); + g_warning("Can not open file : %s\n", pathname); + return -1; } - while(fgets(buf,DIR_NAME_SIZE, fp)!= NULL){ - ptr = buf; - while(isspace(*ptr)) ptr++; - if(strlen(ptr) == 0) continue; - break; - } + context = g_markup_parse_context_new(&markup_parser, 0, des,NULL); - if(strlen(ptr) == 0) g_error("Not a valid file: %s\n", pathname); - if(strncmp("node_name = g_strdup(ptr+10); - break; - case 1: - if(strncmp("domainname=",ptr,11)!=0) - g_error("Not a valid file: %s\n", pathname); - des->domain_name = g_strdup(ptr+11); - break; - case 2: - if(strncmp("cpu=",ptr,4)!=0) - g_error("Not a valid file: %s\n", pathname); - des->nb_cpu = (unsigned)atoi(ptr+4); - break; - case 3: - if(strncmp("arch_size=",ptr,10)!=0) - g_error("Not a valid file: %s\n", pathname); - if(strcmp(ptr+10,"\"LP32\"") == 0) des->size = LTT_LP32; - else if(strcmp(ptr+10,"\"ILP32\"") == 0) des->size = LTT_ILP32; - else if(strcmp(ptr+10,"\"LP64\"") == 0) des->size = LTT_LP64; - else if(strcmp(ptr+10,"\"ILP64\"") == 0) des->size = LTT_ILP64; - else if(strcmp(ptr+10,"\"UNKNOWN\"") == 0) des->size = LTT_UNKNOWN; - break; - case 4: - if(strncmp("endian=",ptr,7)!=0) - g_error("Not a valid file: %s\n", pathname); - if(strcmp(ptr+7,"\"LITTLE_ENDIAN\"") == 0) - des->endian = LTT_LITTLE_ENDIAN; - else if(strcmp(ptr+7,"\"BIG_ENDIAN\"") == 0) - des->endian = LTT_BIG_ENDIAN; - break; - case 5: - if(strncmp("kernel_name=",ptr,12)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_name = g_strdup(ptr+12); - break; - case 6: - if(strncmp("kernel_release=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_release = g_strdup(ptr+15); - break; - case 7: - if(strncmp("kernel_version=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_version = g_strdup(ptr+15); - break; - case 8: - if(strncmp("machine=",ptr,8)!=0) - g_error("Not a valid file: %s\n", pathname); - des->machine = g_strdup(ptr+8); - break; - case 9: - if(strncmp("processor=",ptr,10)!=0) - g_error("Not a valid file: %s\n", pathname); - des->processor = g_strdup(ptr+10); - break; - case 10: - if(strncmp("hardware_platform=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - des->hardware_platform = g_strdup(ptr+18); - break; - case 11: - if(strncmp("operating_system=",ptr,17)!=0) - g_error("Not a valid file: %s\n", pathname); - des->operating_system = g_strdup(ptr+17); - break; - case 12: - if(strncmp("ltt_major_version=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 18; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_major_version = (unsigned)atoi(ptr); - break; - case 13: - if(strncmp("ltt_minor_version=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 18; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_minor_version = (unsigned)atoi(ptr); - break; - case 14: - if(strncmp("ltt_block_size=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 15; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_block_size = (unsigned)atoi(ptr); - break; - default: - g_error("Not a valid file: %s\n", pathname); - } - } - - //get description - description[0] = '\0'; - if(fgets(buf,DIR_NAME_SIZE, fp)== NULL) - g_error("Not a valid file: %s\n", pathname); - ptr = buf; - while(isspace(*ptr)) ptr++; - if(*ptr != '>') g_error("Not a valid file: %s\n", pathname); - while((ptr=fgets(buf,DIR_NAME_SIZE, fp))!= NULL){ - ptr = buf; - while(isspace(*ptr)) ptr++; - if(strncmp("",ptr,9) == 0 )break; - strcat(description, buf); + while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){ + if(!g_markup_parse_context_parse(context, buf, DIR_NAME_SIZE, &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); + return -1; + } } - if(!ptr)g_error("Not a valid file: %s\n", pathname); - if(description[0] = '\0')des->description = NULL; - des->description = g_strdup(description); - + g_markup_parse_context_free(context); fclose(fp); + return 0; } /***************************************************************************** *The following functions get facility/tracefile information ****************************************************************************/ -void getFacilityInfo(LttTrace *t, char* eventdefs) +gint getFacilityInfo(LttTrace *t, char* eventdefs) { DIR * dir; struct dirent *entry; char * ptr; - int i,j; + unsigned int i,j; LttFacility * f; LttEventType * et; char name[DIR_NAME_SIZE]; dir = opendir(eventdefs); - if(!dir) g_error("Can not open directory: %s\n", eventdefs); + if(!dir) { + g_warning("Can not open directory: %s\n", eventdefs); + return -1; + } while((entry = readdir(dir)) != NULL){ ptr = &entry->d_name[strlen(entry->d_name)-4]; @@ -352,16 +372,20 @@ void getFacilityInfo(LttTrace *t, char* eventdefs) setFieldsOffset(NULL, et, NULL, t); } } + return 0; } -void getControlFileInfo(LttTrace *t, char* control) +gint getControlFileInfo(LttTrace *t, char* control) { DIR * dir; struct dirent *entry; char name[DIR_NAME_SIZE]; dir = opendir(control); - if(!dir) g_error("Can not open directory: %s\n", control); + if(!dir) { + g_warning("Can not open directory: %s\n", control); + return -1; + } while((entry = readdir(dir)) != NULL){ if(strcmp(entry->d_name,"facilities") != 0 && @@ -370,29 +394,36 @@ void getControlFileInfo(LttTrace *t, char* control) strcpy(name,control); strcat(name,entry->d_name); - ltt_tracefile_open_control(t,name); + if(ltt_tracefile_open_control(t,name)) + return -1; } closedir(dir); + return 0; } -void getCpuFileInfo(LttTrace *t, char* cpu) +gint getCpuFileInfo(LttTrace *t, char* cpu) { DIR * dir; struct dirent *entry; char name[DIR_NAME_SIZE]; dir = opendir(cpu); - if(!dir) g_error("Can not open directory: %s\n", cpu); + if(!dir) { + g_warning("Can not open directory: %s\n", cpu); + return -1; + } while((entry = readdir(dir)) != NULL){ if(strcmp(entry->d_name,".") != 0 && - 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); }else continue; } closedir(dir); + return 0; } /***************************************************************************** @@ -402,9 +433,34 @@ void getCpuFileInfo(LttTrace *t, char* cpu) * *When a trace is closed, all the associated facilities, types and fields *are released as well. + */ + + +/**************************************************************************** + * get_absolute_pathname + * + * return the unique pathname in the system + * + * MD : Fixed this function so it uses realpath, dealing well with + * forgotten cases (.. were not used correctly before). + * ****************************************************************************/ +void get_absolute_pathname(const char *pathname, char * abs_pathname) +{ + abs_pathname[0] = '\0'; + + if ( realpath (pathname, abs_pathname) != NULL) + return; + else + { + /* error, return the original path unmodified */ + strcpy(abs_pathname, pathname); + return; + } + return; +} -LttTrace *ltt_trace_open(char *pathname) +LttTrace *ltt_trace_open(const char *pathname) { LttTrace * t; LttSystemDescription * sys_description; @@ -413,30 +469,32 @@ LttTrace *ltt_trace_open(char *pathname) char control[DIR_NAME_SIZE]; char cpu[DIR_NAME_SIZE]; char tmp[DIR_NAME_SIZE]; + char abs_path[DIR_NAME_SIZE]; gboolean has_slash = FALSE; + get_absolute_pathname(pathname, abs_path); //establish the pathname to different directories - if(pathname[strlen(pathname)-1] == '/')has_slash = TRUE; - strcpy(eventdefs,pathname); + if(abs_path[strlen(abs_path)-1] == '/')has_slash = TRUE; + strcpy(eventdefs,abs_path); if(!has_slash)strcat(eventdefs,"/"); strcat(eventdefs,"eventdefs/"); - strcpy(info,pathname); + strcpy(info,abs_path); if(!has_slash)strcat(info,"/"); strcat(info,"info/"); - strcpy(control,pathname); + strcpy(control,abs_path); if(!has_slash)strcat(control,"/"); strcat(control,"control/"); - strcpy(cpu,pathname); + strcpy(cpu,abs_path); if(!has_slash)strcat(cpu,"/"); strcat(cpu,"cpu/"); //new trace - t = g_new(LttTrace, 1); sys_description = g_new(LttSystemDescription, 1); - t->pathname = g_strdup(pathname); + t = g_new(LttTrace, 1); + t->pathname = g_strdup(abs_path); t->facility_number = 0; t->control_tracefile_number = 0; t->per_cpu_tracefile_number = 0; @@ -449,23 +507,75 @@ LttTrace *ltt_trace_open(char *pathname) //get system description strcpy(tmp,info); strcat(tmp,"system.xml"); - getSystemInfo(sys_description, tmp); + if(getSystemInfo(sys_description, tmp)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } + + //get facilities info - getFacilityInfo(t,eventdefs); + if(getFacilityInfo(t,eventdefs)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } //get control tracefile info getControlFileInfo(t,control); + /* + if(getControlFileInfo(t,control)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + }*/ // With fatal error //get cpu tracefile info - getCpuFileInfo(t,cpu); + if(getCpuFileInfo(t,cpu)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } return t; } +char * ltt_trace_name(LttTrace *t) +{ + return t->pathname; +} + + +/****************************************************************************** + * When we copy a trace, we want all the opening actions to happen again : + * the trace will be reopened and totally independant from the original. + * That's why we call ltt_trace_open. + *****************************************************************************/ +LttTrace *ltt_trace_copy(LttTrace *self) +{ + return ltt_trace_open(self->pathname); +} + void ltt_trace_close(LttTrace *t) { - int i; + unsigned int i; LttTracefile * tf; LttFacility * f; @@ -548,7 +658,7 @@ LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i) unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) { - int i, count=0; + unsigned int i, count=0; LttFacility * f; for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities, i); @@ -568,28 +678,34 @@ unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) unsigned ltt_trace_eventtype_number(LttTrace *t) { - int i; + unsigned int i; unsigned count = 0; LttFacility * f; - for(i=0;i=t->facility_number;i++){ + for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities, i); count += f->event_number; } return count; } +/* FIXME : performances could be improved with a better design for this + * function */ LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id) { - LttFacility * facility; - int i; + LttFacility * facility = NULL; + unsigned int i; + for(i=0;ifacility_number;i++){ - facility = (LttFacility*) g_ptr_array_index(trace->facilities,i); - if(id >= facility->base_id && - id < facility->base_id + facility->event_number) + LttFacility *iter_facility = + (LttFacility*) g_ptr_array_index(trace->facilities,i); + if(unlikely(id >= iter_facility->base_id && + id < iter_facility->base_id + iter_facility->event_number)) { + facility = iter_facility; break; + } } - if(i==trace->facility_number) return NULL; - else return facility; + + return facility; } LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) @@ -622,10 +738,10 @@ unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t) *and a negative value otherwise. ****************************************************************************/ -int ltt_trace_control_tracefile_find(LttTrace *t, char *name) +int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name) { LttTracefile * tracefile; - int i; + unsigned int i; for(i=0;icontrol_tracefile_number;i++){ tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i); if(strcmp(tracefile->name, name)==0)break; @@ -634,17 +750,19 @@ int ltt_trace_control_tracefile_find(LttTrace *t, char *name) return i; } -int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i) +/* not really useful. We just have to know that cpu tracefiles + * comes before control tracefiles. + */ +int ltt_trace_per_cpu_tracefile_find(LttTrace *t, const gchar *name) { LttTracefile * tracefile; - int j, name; - for(j=0;jper_cpu_tracefile_number;j++){ - tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, j); - name = atoi(tracefile->name); - if(name == (int)i)break; + unsigned int i; + for(i=0;iper_cpu_tracefile_number;i++){ + tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i); + if(strcmp(tracefile->name, name)==0)break; } - if(j == t->per_cpu_tracefile_number) return -1; - return j; + if(i == t->per_cpu_tracefile_number) return -1; + return i; } /***************************************************************************** @@ -668,7 +786,7 @@ LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i) void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) { LttTime startSmall, startTmp, endBig, endTmp; - int i, j=0; + unsigned int i, j=0; LttTracefile * tf; for(i=0;icontrol_tracefile_number;i++){ @@ -683,8 +801,8 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) j = 1; continue; } - if(timecmp(&startSmall,&startTmp) > 0) startSmall = startTmp; - if(timecmp(&endBig,&endTmp) < 0) endBig = endTmp; + if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp; + if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; } for(i=0;iper_cpu_tracefile_number;i++){ @@ -698,12 +816,12 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) endBig = endTmp; continue; } - if(timecmp(&startSmall,&startTmp) > 0) startSmall = startTmp; - if(timecmp(&endBig,&endTmp) < 0) endBig = endTmp; + if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp; + if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; } - *start = startSmall; - *end = endBig; + if(start != NULL) *start = startSmall; + if(end != NULL) *end = endBig; } @@ -733,62 +851,135 @@ unsigned ltt_tracefile_block_number(LttTracefile *tf) * t : tracefile * time : criteria of the time ****************************************************************************/ +void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time, + int start_block, int end_block) +{ + int err, tmp_block, s, e; + int headTime; + int tailTime; + + err=readBlock(t,start_block); + 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); + 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); + 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); + if(headTime <= 0 && tailTime >= 0) return; + + if(headTime > 0){ + s = start_block + 1; + e = tmp_block - 1; + if(s <= e) + ltt_tracefile_find_time_block(t, time, s, e); + else return; + } + + if(tailTime < 0){ + s = tmp_block + 1; + e = end_block - 1; + if(s <= e) + ltt_tracefile_find_time_block(t, time, s, e); + else return; + } +} + +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); + 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); + 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); + }else if(h_time > 0){ + ltt_tracefile_find_time_block(t, time, 1, t->which_block); + return ltt_tracefile_seek_time(t, time) ; + }else{ + if(t_time >= 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); + } +} void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) { int err; LttTime lttTime; - int headTime = timecmp(&(t->a_block_start->time), &time); - int tailTime = timecmp(&(t->a_block_end->time), &time); - LttEvent * ev; + int headTime = ltt_time_compare(t->a_block_start->time, time); + int tailTime = ltt_time_compare(t->a_block_end->time, time); + LttEvent ev; if(headTime < 0 && tailTime > 0){ - lttTime = getEventTime(t); - err = timecmp(<tTime, &time); - if(err > 0){ - if(t->which_event==2 || timecmp(&t->prev_event_time,&time)<0){ - return; - }else{ - updateTracefile(t); - return ltt_tracefile_seek_time(t, time); - } - }else if(err < 0){ - while(1){ - ev = ltt_tracefile_read(t); - if(ev == NULL){ - g_print("End of file\n"); + if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) { + lttTime = getEventTime(t); + err = ltt_time_compare(lttTime, time); + if(err > 0){ + if(t->which_event==2 || ltt_time_compare(t->prev_event_time,time)<0){ return; + }else{ + updateTracefile(t); + return ltt_tracefile_seek_time(t, time); } - lttTime = getEventTime(t); - err = timecmp(<tTime, &time); - if(err >= 0)return; - } - }else return; - }else if(headTime > 0){ + }else if(err < 0){ + while(1){ + if(ltt_tracefile_read(t,&ev) == NULL) { + g_print("End of file\n"); + return; + } + lttTime = getEventTime(t); + err = ltt_time_compare(lttTime, time); + if(err >= 0)return; + } + }else return; + }else{//we are at the end of the block + updateTracefile(t); + return ltt_tracefile_seek_time(t, time); + } + }else if(headTime >= 0){ if(t->which_block == 1){ updateTracefile(t); }else{ - if(timecmp(&(t->prev_block_end_time),&time) >= 0 ){ - err=readBlock(t,t->which_block-1); - if(err) g_error("Can not read tracefile: %s\n", t->name); - return ltt_tracefile_seek_time(t, time) ; + if(ltt_time_compare(t->prev_block_end_time, time) >= 0 || + (t->prev_block_end_time.tv_sec == 0 && + t->prev_block_end_time.tv_nsec == 0 )){ + ltt_tracefile_backward_find_time_block(t, time); }else{ updateTracefile(t); } } }else if(tailTime < 0){ if(t->which_block != t->block_number){ - err=readBlock(t,t->which_block+1); - if(err) g_error("Can not read tracefile: %s\n", t->name); + ltt_tracefile_find_time_block(t, time, t->which_block+1, t->block_number); + return ltt_tracefile_seek_time(t, time); }else { - g_print("End of file\n"); + t->cur_event_pos = t->buffer + t->block_size; + g_print("End of file\n"); return; } - if(tailTime < 0) return ltt_tracefile_seek_time(t, time); - }else if(headTime == 0){ - updateTracefile(t); }else if(tailTime == 0){ - t->cur_event_pos = t->a_block_end - EVENT_HEADER_SIZE; + t->cur_event_pos = t->last_event_pos; t->current_event_time = time; t->cur_heart_beat_number = 0; t->prev_event_time.tv_sec = 0; @@ -799,26 +990,51 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) /***************************************************************************** * Seek to the first event with position equal or larger to ep + * + * Modified by Mathieu Desnoyers to used faster offset position instead of + * re-reading the whole buffer. ****************************************************************************/ -void ltt_tracefile_seek_position(LttTracefile *t, LttEventPosition *ep) +void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) { //if we are at the right place, just return - if(t->which_block == ep->block_num && t->which_event == ep->event_num) + if(likely(t->which_block == ep->block_num && t->which_event == ep->event_num)) return; - if(t->which_block == ep->block_num) updateTracefile(t); + if(likely(t->which_block == ep->block_num)) updateTracefile(t); else readBlock(t,ep->block_num); + //event offset is available + if(likely(ep->old_position)){ + int err; - //event offset is availiable - if(ep->old_position){ - t->cur_heart_beat_number = ep->heart_beat_number; + t->which_event = ep->event_num; t->cur_event_pos = t->buffer + ep->event_offset; + t->prev_event_time = ep->event_time; + t->current_event_time = ep->event_time; + t->cur_heart_beat_number = ep->heart_beat_number; + t->cur_cycle_count = ep->event_cycle_count; + + /* This is a workaround for fast position seek */ + t->last_event_pos = ep->last_event_pos; + t->prev_block_end_time = ep->prev_block_end_time; + t->prev_event_time = ep->prev_event_time; + t->pre_cycle_count = ep->pre_cycle_count; + t->count = ep->count; + /* end of workaround */ + + //update the fields of the current event and go to the next event + err = skipEvent(t); + if(unlikely(err == ERANGE)) g_error("event id is out of range\n"); + return; } - //only block number and event index are availiable - while(t->which_event < ep->event_num) ltt_tracefile_read(t); + //only block number and event index are available + //MD: warning : this is slow! + g_warning("using slow O(n) tracefile seek position"); + + LttEvent event; + while(likely(t->which_event < ep->event_num)) ltt_tracefile_read(t, &event); return; } @@ -832,41 +1048,49 @@ void ltt_tracefile_seek_position(LttTracefile *t, LttEventPosition *ep) * LttEvent * : an event to be processed ****************************************************************************/ -LttEvent *ltt_tracefile_read(LttTracefile *t) +LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) { - LttEvent * lttEvent = &t->an_event; int err; - if(t->cur_event_pos == t->buffer + t->block_size){ - if(t->which_block == t->block_number){ + if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){ + if(unlikely(t->which_block == t->block_number)){ return NULL; } err = readBlock(t, t->which_block + 1); - if(err)g_error("Can not read tracefile"); + if(unlikely(err))g_error("Can not read tracefile"); } - lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos)); - if(lttEvent->event_id == TRACE_TIME_HEARTBEAT) + 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); - lttEvent->time_delta = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE); - lttEvent->event_time = t->current_event_time; + 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 */ + - lttEvent->tracefile = t; - lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE; - lttEvent->which_block = t->which_block; - lttEvent->which_event = t->which_event; //update the fields of the current event and go to the next event err = skipEvent(t); - if(err == ERANGE) g_error("event id is out of range\n"); + if(unlikely(err == ERANGE)) g_error("event id is out of range\n"); - lttEvent->event_cycle_count = t->cur_cycle_count; - - return lttEvent; + return event; } /**************************************************************************** @@ -884,15 +1108,179 @@ LttEvent *ltt_tracefile_read(LttTracefile *t) int readFile(int fd, void * buf, size_t size, char * mesg) { - ssize_t nbBytes; - nbBytes = read(fd, buf, size); - if(nbBytes != size){ - printf("%s\n",mesg); + ssize_t nbBytes = read(fd, buf, size); + + if((size_t)nbBytes != size) { + if(nbBytes < 0) { + perror("Error in readFile : "); + } else { + g_warning("%s",mesg); + } return EIO; } 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; + tf->pre_cycle_count = cycle_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; + 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 * readBlock : read a block from the file @@ -908,9 +1296,9 @@ int readFile(int fd, void * buf, size_t size, char * mesg) int readBlock(LttTracefile * tf, int whichBlock) { off_t nbBytes; - uint32_t lostSize; + guint32 lostSize; - if(whichBlock - tf->which_block == 1 && tf->which_block != 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; }else{ @@ -921,20 +1309,32 @@ int readBlock(LttTracefile * tf, int whichBlock) } nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET); - if(nbBytes == -1) return EINVAL; + if(unlikely(nbBytes == -1)) return EINVAL; - if(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block")) + if(unlikely(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block"))) return EIO; tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE); - lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t)); + 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->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; + + /* read the whole block to precalculate total of cycles in it */ + tf->count = 0; + tf->pre_cycle_count = 0; + tf->cur_cycle_count = tf->a_block_start->cycle_count; + while(likely(ltt_tracefile_pre_read_cycles(tf))); + + /* put back pointer at the beginning */ + tf->which_event = 1; + tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev + tf->cur_heart_beat_number = 0; getCyclePerNsec(tf); @@ -974,23 +1374,23 @@ void updateTracefile(LttTracefile * tf) int skipEvent(LttTracefile * t) { - int evId, err; + int evId; void * evData; LttEventType * evT; LttField * rootFld; - evId = (int)(*(uint16_t *)(t->cur_event_pos)); + 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(evT) rootFld = evT->root_field; + if(likely(evT)) rootFld = evT->root_field; else return ERANGE; - if(rootFld){ + if(likely(rootFld)){ //event has string/sequence or the last event is not the same event - if((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event) - && rootFld->field_fixed == 0){ + 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; @@ -1000,7 +1400,7 @@ int skipEvent(LttTracefile * t) evT->latest_event = t->which_event; //the next event is in the next block - if(evId == TRACE_BLOCK_END){ + if(unlikely(evId == TRACE_BLOCK_END)){ t->cur_event_pos = t->buffer + t->block_size; }else{ t->which_event++; @@ -1010,9 +1410,12 @@ int skipEvent(LttTracefile * t) return 0; } + /***************************************************************************** *Function name * getCyclePerNsec : calculate cycles per nsec for current block + * MD: should have tracefile_read the whole block, so we know the + * total of cycles in it before being called. *Input Params * t : tracefile ****************************************************************************/ @@ -1020,67 +1423,73 @@ int skipEvent(LttTracefile * t) void getCyclePerNsec(LttTracefile * t) { LttTime lBufTotalTime; /* Total time for this buffer */ - LttCycleCount lBufTotalNSec; /* Total time for this buffer in nsecs */ - LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */ + double lBufTotalNSec; /* Total time for this buffer in nsecs */ + double lBufTotalCycle;/* Total cycles for this buffer */ /* Calculate the total time for this buffer */ - TimeSub(lBufTotalTime,t->a_block_end->time, t->a_block_start->time); + lBufTotalTime = ltt_time_sub(t->a_block_end->time, 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; /* Convert the total time to nsecs */ - lBufTotalNSec = lBufTotalTime.tv_sec; - lBufTotalNSec *= NANSECOND_CONST; - lBufTotalNSec += lBufTotalTime.tv_nsec; + lBufTotalNSec = ltt_time_to_double(lBufTotalTime); - t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec; + t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle; + /* 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); + //} + } /**************************************************************************** *Function name * getEventTime : obtain the time of an event + * NOTE : this function _really_ is on critical path. *Input params * tf : tracefile *Return value * LttTime : the time of the event ****************************************************************************/ -LttTime getEventTime(LttTracefile * tf) +static inline LttTime getEventTime(LttTracefile * tf) { LttTime time; LttCycleCount cycle_count; // cycle count for the current event LttCycleCount lEventTotalCycle; // Total cycles from start for event - double lEventNSec; // Total usecs from start for event + LttCycleCount lEventNSec; // Total nsecs from start for event LttTime lTimeOffset; // Time offset in struct LttTime - uint16_t evId; - int64_t nanoSec, tmpCycleCount = (((uint64_t)1)<<32); - static LttCycleCount preCycleCount = 0; - static int count = 0; - - evId = *(uint16_t*)tf->cur_event_pos; - if(evId == TRACE_BLOCK_START){ - count = 0; - preCycleCount = 0; + 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(evId == TRACE_BLOCK_END){ - count = 0; - preCycleCount = 0; + }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; } // Calculate total time in cycles from start of buffer for this event - cycle_count = (LttCycleCount)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE); + cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); - if(cycle_count < preCycleCount)count++; - preCycleCount = cycle_count; - cycle_count += tmpCycleCount * count; + if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++; + tf->pre_cycle_count = cycle_count; + cycle_count += (LttCycleCount)tf->count << 32; - if(tf->cur_heart_beat_number > count) - cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - count); + //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; @@ -1088,14 +1497,13 @@ LttTime getEventTime(LttTracefile * tf) lEventTotalCycle -= tf->a_block_start->cycle_count; // Convert it to nsecs - lEventNSec = lEventTotalCycle / tf->cycle_per_nsec; - nanoSec = lEventNSec; - + lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle; + //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16; + // Determine offset in struct LttTime - lTimeOffset.tv_nsec = nanoSec % NANSECOND_CONST; - lTimeOffset.tv_sec = nanoSec / NANSECOND_CONST; + lTimeOffset = ltt_time_from_double(lEventNSec); - TimeAdd(time, tf->a_block_start->time, lTimeOffset); + time = ltt_time_add(tf->a_block_start->time, lTimeOffset); return time; } @@ -1114,7 +1522,7 @@ void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t) LttField * rootFld = evT->root_field; // rootFld->base_address = evD; - if(rootFld) + if(likely(rootFld)) rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t); } @@ -1138,16 +1546,117 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, int size, size1, element_number, i, offset1, offset2; LttType * type = fld->field_type; - if(t){ - if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){ + if(likely(t)){ + if(unlikely(evT->latest_block==t->which_block && evT->latest_event==t->which_event)){ return fld->field_size; } } - if(fld->field_fixed == 1){ + if(likely(fld->field_fixed == 1)){ if(fld == evT->root_field) return fld->field_size; } + 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; + break; + + 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; + 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 + size = strlen((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; + } + } + 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; + } + + + +#if 0 if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY && type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){ if(fld->field_fixed == -1){ @@ -1236,6 +1745,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, size = offset2; }else size = fld->field_size; } +#endif //0 fld->offset_root = offsetRoot; fld->offset_parent = offsetParent; @@ -1248,24 +1758,6 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, return size; } -/***************************************************************************** - *Function name - * timecmp : compare two time - *Input params - * t1 : first time - * t2 : second time - *Return value - * int : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2 - ****************************************************************************/ - -int timecmp(LttTime * t1, LttTime * t2) -{ - if(t1->tv_sec < t2->tv_sec) return -1; - if(t1->tv_sec > t2->tv_sec) return 1; - if(t1->tv_nsec < t2->tv_nsec) return -1; - if(t1->tv_nsec > t2->tv_nsec) return 1; - return 0; -} /***************************************************************************** *Function name @@ -1274,18 +1766,31 @@ int timecmp(LttTime * t1, LttTime * t2) * size : the size of the integer * evD : the event data *Return value - * int : an integer + * gint64 : a 64 bits integer ****************************************************************************/ -int getIntNumber(int size, void *evD) +gint64 getIntNumber(int size, void *evD) { - int64_t i; - if(size == 1) i = *(int8_t *)evD; - else if(size == 2) i = *(int16_t *)evD; - else if(size == 4) i = *(int32_t *)evD; - else if(size == 8) i = *(int64_t *)evD; - - return (int) i; + 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; + 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; } /***************************************************************************** @@ -1317,3 +1822,50 @@ void getDataEndianType(LttArchSize * size, LttArchEndian * endian) else *size = LTT_UNKNOWN; } +/* get the node name of the system */ + +char * ltt_trace_system_description_node_name (LttSystemDescription * s) +{ + return s->node_name; +} + + +/* get the domain name of the system */ + +char * ltt_trace_system_description_domain_name (LttSystemDescription * s) +{ + return s->domain_name; +} + + +/* get the description of the system */ + +char * ltt_trace_system_description_description (LttSystemDescription * s) +{ + return s->description; +} + + +/* get the start time of the trace */ + +LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s) +{ + return s->trace_start; +} + + +LttTracefile *ltt_tracefile_new() +{ + return g_new(LttTracefile, 1); +} + +void ltt_tracefile_destroy(LttTracefile *tf) +{ + g_free(tf); +} + +void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) +{ + *dest = *src; +} +