X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=ec34fbf67035dbdd6f48828cee66f26bb8aed2ca;hb=1a2ceb635b38ebe136f806bd391ff600863e1691;hp=1480546a544f0e22df44f81931e919de3c33d187;hpb=51b5991eead370ec64ad5336d1e6126ba6b2cc10;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 1480546a..ec34fbf6 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -1,5 +1,5 @@ /* This file is part of the Linux Trace Toolkit viewer - * Copyright (C) 2003-2004 Xiangxiu Yang + * Copyright (C) 2003-2004 Xiangxiu Yang, Mathieu Desnoyers * * 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 @@ -24,6 +24,7 @@ #include #include #include +#include // For realpath #include @@ -37,18 +38,29 @@ #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 */ void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace *t); /* get the size of the field type according to the archtecture's size and endian type(info of the archecture) */ -int getFieldtypeSize(LttTracefile * tf, LttEventType * evT, int offsetRoot, - int offsetParent, LttField *fld, void *evD, LttTrace* t); +static inline gint getFieldtypeSize(LttTracefile * tf, + LttEventType * evT, gint offsetRoot, + 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); @@ -493,8 +505,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"); @@ -507,8 +519,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 = true; + } else if(sys_description->endian == LTT_BIG_ENDIAN + && G_BYTE_ORDER != G_BIG_ENDIAN) { + t->reverse_byte_order = true; + } else t->reverse_byte_order = false; //get facilities info if(getFacilityInfo(t,eventdefs)) { @@ -671,34 +690,54 @@ 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; } return count; } +/* FIXME : performances could be improved with a better design for this + * function : sequential search through a container has never been the + * best on the critical path. */ LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id) { - LttFacility * facility; + 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) + unsigned int num = trace->facility_number; + GPtrArray *facilities = trace->facilities; + + for(i=0;unlikely(ibase_id; + + if(likely(id >= base_id && + id < base_id + iter_facility->event_number)) { + facility = iter_facility; break; + } else { + i++; + } } - if(i==trace->facility_number) return NULL; - else return facility; + + return facility; } LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) { + LttEventType *event_type; + LttFacility * f; f = ltt_trace_facility_by_id(t,evId); - if(!f) return NULL; - return f->events[evId - f->base_id]; + + if(unlikely(!f)) event_type = NULL; + else event_type = f->events[evId - f->base_id]; + + return event_type; } /***************************************************************************** @@ -983,13 +1022,13 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) 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(ep->old_position){ + if(likely(ep->old_position)){ int err; t->which_event = ep->event_num; @@ -1005,11 +1044,13 @@ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) t->prev_event_time = ep->prev_event_time; 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 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"); return; } @@ -1019,7 +1060,7 @@ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) g_warning("using slow O(n) tracefile seek position"); LttEvent event; - while(t->which_event < ep->event_num) ltt_tracefile_read(t, &event); + while(likely(t->which_event < ep->event_num)) ltt_tracefile_read(t, &event); return; } @@ -1037,27 +1078,27 @@ LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *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"); } - event->event_id = (int)(*(guint16 *)(t->cur_event_pos)); - if(event->event_id == TRACE_TIME_HEARTBEAT) + event->event_id = ltt_get_uint16(t, 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, 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; @@ -1067,13 +1108,16 @@ LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) event->prev_event_time = t->prev_event_time; 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 */ //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"); return event; } @@ -1106,6 +1150,7 @@ int readFile(int fd, void * buf, size_t size, char * mesg) return 0; } + /**************************************************************************** *Function name * readBlock : read a block from the file @@ -1123,7 +1168,10 @@ int readBlock(LttTracefile * tf, int whichBlock) off_t nbBytes; guint32 lostSize; - if(whichBlock - tf->which_block == 1 && tf->which_block != 0){ + /* same block already opened requested */ + 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; }else{ @@ -1134,24 +1182,37 @@ 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 = *(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 = ltt_get_uint32(tf, tf->cur_event_pos + EVENT_ID_SIZE); getCyclePerNsec(tf); + tf->overflow_nsec = + (-((double) + (ltt_get_uint32(tf, tf->a_block_start->cycle_count)&0xFFFFFFFF)) + * tf->nsec_per_cycle); + tf->current_event_time = getEventTime(tf); return 0; @@ -1174,6 +1235,12 @@ void updateTracefile(LttTracefile * tf) tf->prev_event_time.tv_sec = 0; tf->prev_event_time.tv_nsec = 0; + tf->count = 0; + + tf->overflow_nsec = + (-((double)ltt_get_uint32(tf, tf->a_block_start->cycle_count)) + * tf->nsec_per_cycle); + } /***************************************************************************** @@ -1193,18 +1260,18 @@ int skipEvent(LttTracefile * t) LttEventType * evT; LttField * rootFld; - evId = (int)(*(guint16 *)(t->cur_event_pos)); + evId = ltt_get_uint16(t, 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; @@ -1214,9 +1281,10 @@ 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->cur_cycle_count = ltt_get_uint32(t, t->cur_event_pos + EVENT_ID_SIZE); t->which_event++; t->current_event_time = getEventTime(t); } @@ -1228,6 +1296,8 @@ int skipEvent(LttTracefile * t) /***************************************************************************** *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 ****************************************************************************/ @@ -1235,78 +1305,86 @@ int skipEvent(LttTracefile * t) void getCyclePerNsec(LttTracefile * t) { LttTime lBufTotalTime; /* Total time for this buffer */ - LttCycleCount lBufTotalNSec; /* Total time for this buffer in nsecs */ + double lBufTotalNSec; /* Total time for this buffer in nsecs */ 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); /* Calculate the total cycles for this bufffer */ - lBufTotalCycle = t->a_block_end->cycle_count; - lBufTotalCycle -= t->a_block_start->cycle_count; + lBufTotalCycle = ltt_get_uint32(t, t->a_block_end->cycle_count); + lBufTotalCycle -= ltt_get_uint32(t, t->a_block_start->cycle_count); - /* Convert the total time to nsecs */ - lBufTotalNSec = lBufTotalTime.tv_sec; - lBufTotalNSec *= NANOSECONDS_PER_SECOND; - lBufTotalNSec += lBufTotalTime.tv_nsec; + /* Convert the total time to double */ + lBufTotalNSec = ltt_time_to_double(lBufTotalTime); - t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec; + 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; + } /**************************************************************************** *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 - LttCycleCount lEventNSec; // Total usecs from start for event + //LttCycleCount lEventTotalCycle; // Total cycles from start for event + gint64 lEventNSec; // Total nsecs from start for event LttTime lTimeOffset; // Time offset in struct LttTime guint16 evId; - LttCycleCount tmpCycleCount = (((LttCycleCount)1)<<32); - - evId = *(guint16 *)tf->cur_event_pos; - if(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){ - 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)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); - - if(cycle_count < tf->pre_cycle_count)tf->count++; - tf->pre_cycle_count = cycle_count; - cycle_count += tmpCycleCount * tf->count; - - // if(tf->cur_heart_beat_number > tf->count) - // cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count); - tf->cur_cycle_count = cycle_count; + evId = ltt_get_uint16(tf, tf->cur_event_pos); + + cycle_count = ltt_get_uint32(tf, tf->cur_event_pos + EVENT_ID_SIZE); - lEventTotalCycle = cycle_count; - lEventTotalCycle -= tf->a_block_start->cycle_count; + gboolean comp_count = cycle_count < tf->pre_cycle_count; - // Convert it to nsecs - lEventNSec = (double)lEventTotalCycle / (double)tf->cycle_per_nsec; + tf->pre_cycle_count = cycle_count; + + if(unlikely(comp_count)) { + /* Overflow */ + tf->overflow_nsec += tf->one_overflow_nsec; + tf->count++; //increment overflow count + } - // Determine offset in struct LttTime - lTimeOffset.tv_nsec = lEventNSec % NANOSECONDS_PER_SECOND; - lTimeOffset.tv_sec = lEventNSec / NANOSECONDS_PER_SECOND; + if(unlikely(evId == TRACE_BLOCK_START)) { + lEventNSec = 0; + } else if(unlikely(evId == TRACE_BLOCK_END)) { + lEventNSec = ((double) + (ltt_get_uint32(tf, tf->a_block_end->cycle_count) + - ltt_get_uint32(tf, tf->a_block_start->cycle_count)) + * tf->nsec_per_cycle); + } +#if 0 + /* 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)) { + + 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 + 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); return time; @@ -1326,7 +1404,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); } @@ -1344,119 +1422,159 @@ void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t) * int : size of the field ****************************************************************************/ -int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, - int offsetParent, LttField * fld, void *evD, LttTrace *trace) +static inline gint getFieldtypeSize(LttTracefile * t, + LttEventType * evT, gint offsetRoot, + gint offsetParent, LttField * fld, void *evD, LttTrace *trace) { - int size, size1, element_number, i, offset1, offset2; + gint 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){ - return fld->field_size; - } - } - - if(fld->field_fixed == 1){ - if(fld == evT->root_field) return fld->field_size; - } - - 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){ - size = (int) ltt_type_size(trace, type); - fld->field_fixed = 1; - }else size = fld->field_size; - - }else if(type->type_class == 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; + if(unlikely(t && evT->latest_block==t->which_block && + evT->latest_event==t->which_event)){ + 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; } - }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; - - }else if(type->type_class == 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; } - }else if(type->type_class == LTT_STRING){ - size = 0; - if(fld->field_fixed == -1){ - fld->field_fixed = 0; - }else{//0: string - size = strlen((char*)evD) + 1; //include end : '\0' + /* 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; + + 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(t,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; + } + + 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; + /* 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' + } + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; + + 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[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; + } + break; } - - }else if(type->type_class == 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; } fld->offset_root = offsetRoot; fld->offset_parent = offsetParent; - if(!evD){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } fld->field_size = size; +end_getFieldtypeSize: + return size; } @@ -1468,18 +1586,24 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, * 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(LttTracefile * t, int size, void *evD) { gint64 i; - 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; - - return (int) i; + + switch(size) { + case 1: i = *((gint8*)evD); break; + case 2: i = ltt_get_int16(t, evD); break; + case 4: i = ltt_get_int32(t, evD); break; + case 8: i = ltt_get_int64(t, evD); break; + default: i = ltt_get_int64(t, evD); + g_critical("getIntNumber : integer size %d unknown", size); + break; + } + + return i; } /*****************************************************************************