X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=acd9954b872010b8cab1807afd9955f35737ab74;hb=63c35f6c3a742bb0bcd558c4899221231bcb05d7;hp=5c30d9a18fa1e5df08c59034585ad6dcc573fe75;hpb=a1062ddd65b968c3ba077bc68b88887888b5057a;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 5c30d9a1..acd9954b 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 @@ -56,8 +56,9 @@ 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); @@ -680,8 +681,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; } @@ -689,31 +692,43 @@ unsigned ltt_trace_eventtype_number(LttTrace *t) } /* FIXME : performances could be improved with a better design for this - * function */ + * 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 = 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; } 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; } /***************************************************************************** @@ -1020,6 +1035,8 @@ 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 @@ -1082,6 +1099,9 @@ 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 */ @@ -1132,7 +1152,7 @@ int readFile(int fd, void * buf, size_t size, char * mesg) * 0 : success * ERANGE : event id is out of range ****************************************************************************/ - +#if 0 int skipEvent_pre_read_cycles(LttTracefile * t) { int evId; @@ -1172,7 +1192,7 @@ int skipEvent_pre_read_cycles(LttTracefile * t) return 0; } - +#endif //0 @@ -1185,7 +1205,7 @@ int skipEvent_pre_read_cycles(LttTracefile * t) *Return value * False : end of bloc reached ****************************************************************************/ - +#if 0 gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) { int err; @@ -1222,6 +1242,7 @@ gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) //event.prev_event_time = t->prev_event_time; //event.pre_cycle_count = t->pre_cycle_count; //event.count = t->count; + //event.last_heartbeat = t->last_heartbeat; /* end of workaround */ @@ -1238,17 +1259,24 @@ gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) // 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; + // + //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)) { + //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; + // res_delta_count = delta_count + 0x100000000ULL ; + //} else + // res_delta_count = (LttCycleCount)delta_count; //cycle_count += (LttCycleCount)tf->count << 32; @@ -1256,20 +1284,22 @@ gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) // 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); + //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"); + //g_debug("BLOCK START"); }else if(unlikely(evId == TRACE_BLOCK_END)){ - g_debug("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); + //g_debug("end of block cycle count : %llu", tf->cur_cycle_count); + return FALSE; } @@ -1280,6 +1310,7 @@ gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf) return TRUE; } +#endif //0 /**************************************************************************** *Function name @@ -1298,6 +1329,9 @@ int readBlock(LttTracefile * tf, int whichBlock) off_t nbBytes; guint32 lostSize; + /* 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; @@ -1316,27 +1350,81 @@ 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 = tf->a_block_start->cycle_count; - while(likely(ltt_tracefile_pre_read_cycles(tf))); + tf->cur_cycle_count = 0; + //g_debug("precalculating cycles begin for block %i", whichBlock); + /* End of block event already has 64 bits cycle counter! */ + //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); + + /* 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); + + + { + guint64 lEventNSec; + LttTime lTimeOffset; + /* End time more precise */ + lEventNSec = ((double) + (tf->a_block_end->cycle_count - tf->a_block_start->cycle_count) + * tf->nsec_per_cycle); + //g_assert(lEventNSec >= 0); + lTimeOffset = ltt_time_from_uint64(lEventNSec); + tf->a_block_end->time = ltt_time_add(tf->a_block_start->time, lTimeOffset); + } + + + //g_debug("precalculating cycles end for block %i", whichBlock); + +#if 0 /* 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; + tf->last_heartbeat = NULL; +#endif //0 + /* 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->current_event_time = getEventTime(tf); @@ -1360,6 +1448,11 @@ 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)tf->a_block_start->cycle_count) + * tf->nsec_per_cycle); + } /***************************************************************************** @@ -1437,6 +1530,9 @@ void getCyclePerNsec(LttTracefile * t) 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 @@ -1462,25 +1558,58 @@ 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 nsecs 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; 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; - } + //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; + //} // Calculate total time in cycles from start of buffer for this event + + + + //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 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++; @@ -1495,14 +1624,69 @@ static inline LttTime getEventTime(LttTracefile * tf) lEventTotalCycle = cycle_count; lEventTotalCycle -= tf->a_block_start->cycle_count; - +#endif //0 // Convert it to nsecs - lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle; + //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); + //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. + + /* keep the overflow count correct. The heartbeat event makes sure + * that we do not miss an overflow.*/ + + 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->overflow_nsec += tf->one_overflow_nsec; + tf->count++; //increment overflow count + } + + if(unlikely(evId == TRACE_BLOCK_START)) { + lEventNSec = 0; + } else if(unlikely(evId == TRACE_BLOCK_END)) { + lEventNSec = ((double) + (tf->a_block_end->cycle_count - tf->a_block_start->cycle_count) + * tf->nsec_per_cycle); + g_printf("CYCLES COUNTED : %llu", + (gint64)((double)cycle_count * tf->nsec_per_cycle) + +tf->overflow_nsec + +tf->a_block_start->cycle_count); + + + } + /* heartbeat cycle counter is only numheartbeat<<32, not meaningful + */ +#if 0 + 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; + } + //g_assert(lEventNSec >= 0); + lTimeOffset = ltt_time_from_uint64(lEventNSec); + time = ltt_time_add(tf->a_block_start->time, lTimeOffset); return time; @@ -1540,221 +1724,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(likely(t)){ - if(unlikely(evT->latest_block==t->which_block && evT->latest_event==t->which_event)){ - return fld->field_size; - } - } - - 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; + 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; + } + } - 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 + /* 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+size1, trace); + size += getFieldtypeSize(t, evT, offsetRoot+size,size, + fld->child[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; } - 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; - } + 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; + } + if(unlikely(!evD)){ + fld->fixed_root = (offsetRoot==-1) ? 0 : 1; + fld->fixed_parent = (offsetParent==-1) ? 0 : 1; + } -#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){ - 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; - } - }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; - } + 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; - }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' + 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; } -#endif //0 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; }