From 3aee1200b100fe8063661fd2d8eaa5fbbfc1977f Mon Sep 17 00:00:00 2001 From: compudj Date: Sat, 13 Aug 2005 18:54:27 +0000 Subject: [PATCH] ltt newlib commit it, it compiles, not tested git-svn-id: http://ltt.polymtl.ca/svn@1011 04897980-b3bd-0310-b5e0-8ef037075253 --- ltt/branches/poly/ltt/event.c | 224 +-- ltt/branches/poly/ltt/event.h | 3 +- ltt/branches/poly/ltt/facility.c | 325 ++-- ltt/branches/poly/ltt/facility.h | 18 +- ltt/branches/poly/ltt/ltt-private.h | 348 ++-- ltt/branches/poly/ltt/ltt.h | 5 +- ltt/branches/poly/ltt/trace.h | 62 +- ltt/branches/poly/ltt/tracefile.c | 2484 ++++++++++++++++----------- ltt/branches/poly/ltt/type.c | 105 +- ltt/branches/poly/ltt/type.h | 10 +- 10 files changed, 2070 insertions(+), 1514 deletions(-) diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c index 02ecf271..fe299b5d 100644 --- a/ltt/branches/poly/ltt/event.c +++ b/ltt/branches/poly/ltt/event.c @@ -23,6 +23,7 @@ #include #include #include +#include #include #include @@ -46,6 +47,8 @@ void ltt_event_destroy(LttEvent *event) } +#if 0 +/* Use get_field_type_size instead */ /***************************************************************************** *Function name * ltt_event_refresh_fields : refresh fields of an event @@ -172,6 +175,8 @@ int ltt_event_refresh_fields(int offsetRoot,int offsetParent, return size; } +#endif //0 + /***************************************************************************** *Function name @@ -217,7 +222,7 @@ LttEventType *ltt_event_eventtype(LttEvent *e) { LttFacility* facility = ltt_event_facility(e); if(!facility) return NULL; - return facility->events[e->event_id - facility->base_id]; + return &g_array_index(facility->events, LttEventType, e->event_id); } /***************************************************************************** @@ -237,17 +242,9 @@ LttField *ltt_event_field(LttEvent *e) field = event_type->root_field; if(unlikely(!field)) return NULL; - //check if the field need refresh - if(likely(e->which_block != event_type->latest_block || - e->which_event != event_type->latest_event)){ - - event_type->latest_block = e->which_block; - event_type->latest_event = e->which_event; - - if(unlikely(field->field_fixed != 1)) - ltt_event_refresh_fields(0, 0, field, e->data, - e->tracefile->trace->reverse_byte_order); - } + get_field_type_size(e->tracefile, event_type, 0, 0, + field, e->data); + return field; } @@ -276,7 +273,7 @@ LttTime ltt_event_time(LttEvent *e) LttCycleCount ltt_event_cycle_count(LttEvent *e) { - return e->event_cycle_count; + return e->tsc; } /***************************************************************************** @@ -289,24 +286,10 @@ LttCycleCount ltt_event_cycle_count(LttEvent *e) void ltt_event_position(LttEvent *e, LttEventPosition *ep) { - ep->block_num = e->which_block; - ep->event_num = e->which_event; - ep->event_time = e->event_time; - ep->event_cycle_count = e->event_cycle_count; - ep->heart_beat_number = e->tracefile->cur_heart_beat_number; - ep->old_position = TRUE; - ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ; - ep->tf = e->tracefile; - ep->overflow_nsec = e->overflow_nsec; - /* This is a workaround for fast position seek */ - ep->last_event_pos = e->last_event_pos; - ep->prev_block_end_time = e->prev_block_end_time; - ep->prev_event_time = e->prev_event_time; - ep->pre_cycle_count = e->pre_cycle_count; - ep->count = e->count; - ep->last_heartbeat = e->last_heartbeat; - - /* end of workaround */ + ep->tracefile = e->tracefile; + ep->block = e->block; + ep->offset = e->offset; + ep->tsc = e->tsc; } LttEventPosition * ltt_event_position_new() @@ -314,44 +297,6 @@ LttEventPosition * ltt_event_position_new() return g_new(LttEventPosition, 1); } -/***************************************************************************** - *Function name - * ltt_event_position_get : get the block number and index of the event - *Input params - * ep : a pointer to event's position structure - * block_number : the block number of the event - * index_in_block : the index of the event within the block - ****************************************************************************/ - -void ltt_event_position_get(LttEventPosition *ep, - unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf) -{ - *block_number = ep->block_num; - *index_in_block = ep->event_num; - *tf = ep->tf; -} - -/***************************************************************************** - *Function name - * ltt_event_position_set : set the block number and index of the event - * It does put the old_position gboolean to FALSE, as it is impossible - * to know the quick position to seek in the tracefile. - *Input params - * ep : a pointer to event's position structure - * block_number : the block number of the event - * index_in_block : the index of the event within the block - ****************************************************************************/ - -void ltt_event_position_set(LttEventPosition *ep, - unsigned block_number, unsigned index_in_block) -{ - if(ep->block_num != block_number || ep->event_num != index_in_block) - ep->old_position = FALSE; - - ep->block_num = block_number; - ep->event_num = index_in_block; - -} /***************************************************************************** * Function name @@ -370,58 +315,23 @@ void ltt_event_position_set(LttEventPosition *ep, gint ltt_event_position_compare(const LttEventPosition *ep1, const LttEventPosition *ep2) { - if(ep1->tf != ep2->tf) - g_error("ltt_event_position_compare on different tracefiles makes no sense"); if(ep1 == NULL && ep2 == NULL) return 0; if(ep1 != NULL && ep2 == NULL) return -1; if(ep1 == NULL && ep2 != NULL) return 1; - - if(ep1->block_num < ep2->block_num) - return -1; - if(ep1->block_num > ep2->block_num) - return 1; - if(ep1->event_num < ep2->event_num) - return -1; - if(ep1->event_num > ep2->event_num) - return 1; - return 0; -} -/***************************************************************************** - * Function name - * ltt_event_event_position_compare : compare two positions, one in event, - * other in position opaque structure. - * Input params - * event : a pointer to event structure - * ep : a pointer to event's position structure - * Return - * -1 is event < ep - * 1 if event > ep - * 0 if event == ep - ****************************************************************************/ - -gint ltt_event_event_position_compare(const LttEvent *event, - const LttEventPosition *ep) -{ - if(event == NULL && ep == NULL) - return 0; - if(event != NULL && ep == NULL) - return -1; - if(event == NULL && ep != NULL) - return 1; - - g_assert(event->tracefile == ep->tf); - - if(event->which_block < ep->block_num) + if(ep1->tracefile != ep2->tracefile) + g_error("ltt_event_position_compare on different tracefiles makes no sense"); + + if(ep1->block < ep2->block) return -1; - if(event->which_block > ep->block_num) + if(ep1->block > ep2->block) return 1; - if(event->which_event < ep->event_num) + if(ep1->offset < ep2->offset) return -1; - if(event->which_event > ep->event_num) + if(ep1->offset > ep2->offset) return 1; return 0; } @@ -455,23 +365,8 @@ void ltt_event_position_copy(LttEventPosition *dest, ****************************************************************************/ unsigned ltt_event_cpu_id(LttEvent *e) -{ - gchar * c1, * c2, * c3; - c1 = strrchr(e->tracefile->name,'\\'); - c2 = strrchr(e->tracefile->name,'/'); - if(c1 == NULL && c2 == NULL){ - return (unsigned)atoi(e->tracefile->name); - }else if(c1 == NULL){ - c2++; - return (unsigned)atoi(c2); - }else if(c2 == NULL){ - c1++; - return (unsigned)atoi(c1); - }else{ - c3 = (c1 > c2) ? c1 : c2; - c3++; - return (unsigned)atoi(c3); - } +{ + return e->tracefile->cpu_num; } /***************************************************************************** @@ -500,8 +395,7 @@ void *ltt_event_data(LttEvent *e) *Return value * unsigned : the number of elements for an array/sequence field ****************************************************************************/ - -unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) +guint64 ltt_event_field_element_number(LttEvent *e, LttField *f) { if(f->field_type->type_class != LTT_ARRAY && f->field_type->type_class != LTT_SEQUENCE) @@ -509,8 +403,8 @@ unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) if(f->field_type->type_class == LTT_ARRAY) return f->field_type->element_number; - return (unsigned) getIntNumber(e->tracefile->trace->reverse_byte_order, - f->sequ_number_size, e + f->offset_root); + return get_unsigned(LTT_GET_BO(e->tracefile), f->sequ_number_size, + e + f->offset_root); } /***************************************************************************** @@ -518,50 +412,60 @@ unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) * ltt_event_field_element_select * : Set the currently selected element for a sequence or * array field + * O(1) if fields are of fixed size, else O(n) if fields are + * of variable size. *Input params * e : an instance of an event type * f : a field of the instance - * i : the ith element + * i : the ith element (0, ...) ****************************************************************************/ - void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) { unsigned element_number; - LttField *fld; + LttField *field; unsigned int k; - int size; - void *evD; + size_t size; + LttEventType *event_type; if(f->field_type->type_class != LTT_ARRAY && f->field_type->type_class != LTT_SEQUENCE) return ; element_number = ltt_event_field_element_number(e,f); - /* Sanity check for i : 1..n only, and must be lower or equal element_number + event_type = ltt_event_eventtype(e); + /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number */ - if(element_number < i || i == 0) return; + if(i >= element_number) return; - fld = f->child[0]; + field = f->child[0]; + + if(f->field_type->type_class == LTT_SEQUENCE) + size = f->sequ_number_size; + else + size = 0; - evD = e->data + f->offset_root; - size = 0; - for(k=0;koffset_root+size,size, fld, evD+size, - e->tracefile->trace->reverse_byte_order); + if(field->fixed_size == FIELD_FIXED) { + size += field->field_size * i; + + get_field_type_size(e->tracefile, event_type, + f->offset_root+size, size, field, e->data); + + } else { + for(k=0;k<=i;k++){ + size += get_field_type_size(e->tracefile, event_type, + f->offset_root+size, size, field, e->data); + } } - f->current_element = i - 1; + f->current_element = i; } /***************************************************************************** * These functions extract data from an event after architecture specific * conversions ****************************************************************************/ - guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f) { - //int revFlag = e->tracefile->trace->my_arch_endian == - // e->tracefile->trace->system_description->endian ? 0:1; - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); LttTypeEnum t = f->field_type->type_class; @@ -590,9 +494,7 @@ guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f) gint32 ltt_event_get_int(LttEvent *e, LttField *f) { - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; - //int revFlag = e->tracefile->trace->my_arch_endian == - // e->tracefile->trace->system_description->endian ? 0:1; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); g_assert(f->field_type->type_class == LTT_INT); @@ -619,9 +521,8 @@ gint32 ltt_event_get_int(LttEvent *e, LttField *f) guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f) { - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; - //int revFlag = e->tracefile->trace->my_arch_endian == - // e->tracefile->trace->system_description->endian ? 0:1; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); + LttTypeEnum t = f->field_type->type_class; g_assert(t == LTT_UINT || t == LTT_ENUM); @@ -644,7 +545,7 @@ gint64 ltt_event_get_long_int(LttEvent *e, LttField *f) { //int revFlag = e->tracefile->trace->my_arch_endian == // e->tracefile->trace->system_description->endian ? 0:1; - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); g_assert( f->field_type->type_class == LTT_INT); @@ -664,9 +565,7 @@ gint64 ltt_event_get_long_int(LttEvent *e, LttField *f) float ltt_event_get_float(LttEvent *e, LttField *f) { - //int revFlag = e->tracefile->trace->my_arch_endian == - // e->tracefile->trace->system_description->endian ? 0:1; - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4); @@ -681,9 +580,7 @@ float ltt_event_get_float(LttEvent *e, LttField *f) double ltt_event_get_double(LttEvent *e, LttField *f) { - gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; - //int revFlag = e->tracefile->trace->my_arch_endian == - // e->tracefile->trace->system_description->endian ? 0:1; + gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8); @@ -700,7 +597,6 @@ double ltt_event_get_double(LttEvent *e, LttField *f) * The string obtained is only valid until the next read from * the same tracefile. ****************************************************************************/ - char *ltt_event_get_string(LttEvent *e, LttField *f) { g_assert(f->field_type->type_class == LTT_STRING); diff --git a/ltt/branches/poly/ltt/event.h b/ltt/branches/poly/ltt/event.h index 3f1f8972..fc50fee9 100644 --- a/ltt/branches/poly/ltt/event.h +++ b/ltt/branches/poly/ltt/event.h @@ -19,6 +19,7 @@ #ifndef EVENT_H #define EVENT_H +#include #include LttEvent *ltt_event_new(); @@ -96,7 +97,7 @@ void *ltt_event_data(LttEvent *e); instance. This function returns the number of elements for an array or sequence field in an event. */ -unsigned ltt_event_field_element_number(LttEvent *e, LttField *f); +guint64 ltt_event_field_element_number(LttEvent *e, LttField *f); /* Set the currently selected element for a sequence or array field. */ diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c index 84baac98..1d9ed5f6 100644 --- a/ltt/branches/poly/ltt/facility.c +++ b/ltt/branches/poly/ltt/facility.c @@ -1,5 +1,6 @@ /* This file is part of the Linux Trace Toolkit viewer * Copyright (C) 2003-2004 Xiangxiu Yang + * 2005 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 @@ -46,12 +47,12 @@ LttType * lookup_named_type(LttFacility *fac, type_descriptor * td); /* construct directed acyclic graph for types, and tree for fields */ -void constructTypeAndFields(LttFacility * fac,type_descriptor * td, +void construct_types_and_fields(LttFacility * fac,type_descriptor * td, LttField * fld); /* generate the facility according to the events belongin to it */ void generateFacility(LttFacility * f, facility_t * fac, - LttChecksum checksum); + guint32 checksum); /* functions to release the memory occupied by a facility */ void freeFacility(LttFacility * facility); @@ -67,16 +68,17 @@ void freeLttNamedType(LttType * type); *Input params * t : the trace containing the facilities * pathname : the path name of the facility + * + *returns 0 on success, 1 on error. ****************************************************************************/ -void ltt_facility_open(LttTrace * t, gchar * pathname) +int ltt_facility_open(LttFacility *f, LttTrace * t, gchar * pathname) { gchar *token; parse_file in; gsize length; facility_t * fac; - LttFacility * f; - LttChecksum checksum; + guint32 checksum; GError * error = NULL; gchar buffer[BUFFER_SIZE]; @@ -86,7 +88,11 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) in.name = pathname; in.fd = g_open(in.name, O_RDONLY, 0); - if(in.fd < 0 ) in.error(&in,"cannot open input file"); + if(in.fd < 0 ) { + g_warning("cannot open facility description file %s", + in.name); + return 1; + } in.channel = g_io_channel_unix_new(in.fd); in.pos = 0; @@ -113,13 +119,8 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) g_assert(generateChecksum(fac->name, &checksum, &fac->events) == 0); - f = g_new(LttFacility,1); - f->base_id = 0; generateFacility(f, fac, checksum); - t->facility_number++; - g_ptr_array_add(t->facilities,f); - g_free(fac->name); g_free(fac->description); freeEvents(&fac->events); @@ -130,9 +131,13 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) sequence_dispose(&fac->unnamed_types); g_free(fac); } - else in.error(&in,"facility token was expected"); + else { + g_warning("facility token was expected in file %s", in.name); + goto parse_error; + } } + parse_error: g_io_channel_shutdown(in.channel, FALSE, &error); /* No flush */ if(error != NULL) { g_warning("Can not close file: \n%s\n", error->message); @@ -152,57 +157,76 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) * checksum : checksum of the facility ****************************************************************************/ -void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) +void generateFacility(LttFacility *f, facility_t *fac, guint32 checksum) { char * facilityName = fac->name; sequence * events = &fac->events; int i; - LttEventType * evType; + //LttEventType * evType; + LttEventType * event_type; LttField * field; LttType * type; - f->name = g_strdup(facilityName); - f->event_number = events->position; - f->checksum = checksum; + g_assert(f->name == g_quark_from_string(facilityName)); + g_assert(f->checksum == checksum); + + //f->event_number = events->position; //initialize inner structures - f->events = g_new(LttEventType*,f->event_number); - f->named_types_number = fac->named_types.keys.position; - f->named_types = g_new(LttType*, fac->named_types.keys.position); - for(i=0;inamed_types.keys.position;i++) f->named_types[i] = NULL; + f->events = g_array_sized_new (FALSE, TRUE, sizeof(LttEventType), + events->position); + //f->events = g_new(LttEventType*,f->event_number); + f->events = g_array_set_size(f->events, events->position); + + g_datalist_init(&f->events_by_name); + g_datalist_init(&f->named_types); + + //f->named_types_number = fac->named_types.keys.position; + //f->named_types = g_array_sized_new (FALSE, TRUE, sizeof(LttType), + // fac->named_types.keys.position); + //f->named_types = g_new(LttType*, fac->named_types.keys.position); + //f->named_types = g_array_set_size(f->named_types, + // fac->named_types.keys.position); //for each event, construct field tree and type graph for(i=0;iposition;i++){ - evType = g_new(LttEventType,1); - f->events[i] = evType; + event_type = &g_array_index(f->events, LttEventType, i); + //evType = g_new(LttEventType,1); + //f->events[i] = evType; - evType->name = g_strdup(((event_t*)(events->array[i]))->name); - evType->description=g_strdup(((event_t*)(events->array[i]))->description); + event_type->name = + g_quark_from_string(((event_t*)(events->array[i]))->name); + + g_datalist_id_set_data(&f->events_by_name, event_type->name, + event_type); + + event_type->description = + g_strdup(((event_t*)(events->array[i]))->description); field = g_new(LttField, 1); - evType->root_field = field; - evType->facility = f; - evType->index = i; + event_type->root_field = field; + event_type->facility = f; + event_type->index = i; if(((event_t*)(events->array[i]))->type != NULL){ - field->field_pos = 0; + // field->field_pos = 0; type = lookup_named_type(f,((event_t*)(events->array[i]))->type); field->field_type = type; field->offset_root = 0; - field->fixed_root = 1; + field->fixed_root = FIELD_UNKNOWN; field->offset_parent = 0; - field->fixed_parent = 1; + field->fixed_parent = FIELD_UNKNOWN; // field->base_address = NULL; field->field_size = 0; - field->field_fixed = -1; + field->fixed_size = FIELD_UNKNOWN; field->parent = NULL; field->child = NULL; field->current_element = 0; //construct field tree and type graph - constructTypeAndFields(f,((event_t*)(events->array[i]))->type,field); + construct_types_and_fields(f,((event_t*)(events->array[i]))->type,field); }else{ - evType->root_field = NULL; + event_type->root_field = NULL; g_free(field); } } @@ -211,7 +235,7 @@ void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) /***************************************************************************** *Function name - * constructTypeAndFields : construct field tree and type graph, + * construct_types_and_fields : construct field tree and type graph, * internal recursion function *Input params * fac : facility struct @@ -219,7 +243,87 @@ void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) * root_field : root field of the event ****************************************************************************/ -void constructTypeAndFields(LttFacility * fac,type_descriptor * td, + +void construct_types_and_fields(LttFacility * fac, type_descriptor * td, + LttField * fld) +{ + int i, flag; + type_descriptor * tmpTd; + + switch(td->type) { + case LTT_ENUM: + fld->field_type->element_number = td->labels.position; + fld->field_type->enum_strings = g_new(GQuark,td->labels.position); + for(i=0;ilabels.position;i++){ + fld->field_type->enum_strings[i] + = g_quark_from_string(((char*)(td->labels.array[i]))); + } + break; + case LTT_ARRAY: + fld->field_type->element_number = (unsigned)td->size; + case LTT_SEQUENCE: + fld->field_type->element_type = g_new(LttType*,1); + tmpTd = td->nested_type; + fld->field_type->element_type[0] = lookup_named_type(fac, tmpTd); + fld->child = g_new(LttField*, 1); + fld->child[0] = g_new(LttField, 1); + + fld->child[0]->field_type = fld->field_type->element_type[0]; + fld->child[0]->offset_root = 0; + fld->child[0]->fixed_root = FIELD_UNKNOWN; + fld->child[0]->offset_parent = 0; + fld->child[0]->fixed_parent = FIELD_UNKNOWN; + fld->child[0]->field_size = 0; + fld->child[0]->fixed_size = FIELD_UNKNOWN; + fld->child[0]->parent = fld; + fld->child[0]->child = NULL; + fld->child[0]->current_element = 0; + construct_types_and_fields(fac, tmpTd, fld->child[0]); + break; + case LTT_STRUCT: + case LTT_UNION: + fld->field_type->element_number = td->fields.position; + + g_assert(fld->field_type->element_type == NULL); + fld->field_type->element_type = g_new(LttType*, td->fields.position); + + fld->child = g_new(LttField*, td->fields.position); + for(i=0;ifields.position;i++){ + tmpTd = ((type_fields*)(td->fields.array[i]))->type; + + fld->field_type->element_type[i] = lookup_named_type(fac, tmpTd); + fld->child[i] = g_new(LttField,1); + + // fld->child[i]->field_pos = i; + fld->child[i]->field_type = fld->field_type->element_type[i]; + + fld->child[i]->field_type->element_name + = g_quark_from_string(((type_fields*)(td->fields.array[i]))->name); + + fld->child[i]->offset_root = 0; + fld->child[i]->fixed_root = FIELD_UNKNOWN; + fld->child[i]->offset_parent = 0; + fld->child[i]->fixed_parent = FIELD_UNKNOWN; + fld->child[i]->field_size = 0; + fld->child[i]->fixed_size = FIELD_UNKNOWN; + fld->child[i]->parent = fld; + fld->child[i]->child = NULL; + fld->child[i]->current_element = 0; + construct_types_and_fields(fac, tmpTd, fld->child[i]); + } + + break; + default: + g_error("construct_types_and_fields : unknown type"); + } + + +} + + + +#if 0 +void construct_types_and_fields(LttFacility * fac, type_descriptor * td, LttField * fld) { int i, flag; @@ -231,10 +335,10 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, if(td->type == LTT_ENUM){ fld->field_type->element_number = td->labels.position; - fld->field_type->enum_strings = g_new(char*,td->labels.position); + fld->field_type->enum_strings = g_new(GQuark,td->labels.position); for(i=0;ilabels.position;i++){ fld->field_type->enum_strings[i] - = g_strdup(((char*)(td->labels.array[i]))); + = g_quark_from_string(((char*)(td->labels.array[i]))); } }else if(td->type == LTT_ARRAY || td->type == LTT_SEQUENCE){ if(td->type == LTT_ARRAY) @@ -245,7 +349,7 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child = g_new(LttField*, 1); fld->child[0] = g_new(LttField, 1); - fld->child[0]->field_pos = 0; +// fld->child[0]->field_pos = 0; fld->child[0]->field_type = fld->field_type->element_type[0]; fld->child[0]->offset_root = fld->offset_root; fld->child[0]->fixed_root = fld->fixed_root; @@ -257,7 +361,7 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[0]->parent = fld; fld->child[0]->child = NULL; fld->child[0]->current_element = 0; - constructTypeAndFields(fac, tmpTd, fld->child[0]); + construct_types_and_fields(fac, tmpTd, fld->child[0]); }else if(td->type == LTT_STRUCT){ fld->field_type->element_number = td->fields.position; @@ -280,8 +384,8 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[i]->field_type = fld->field_type->element_type[i]; if(flag){ - fld->child[i]->field_type->element_name - = g_strdup(((type_fields*)(td->fields.array[i]))->name); + fld->child[i]->field_type->element_name + = g_quark_from_string(((type_fields*)(td->fields.array[i]))->name); } fld->child[i]->offset_root = -1; @@ -294,11 +398,11 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[i]->parent = fld; fld->child[i]->child = NULL; fld->child[i]->current_element = 0; - constructTypeAndFields(fac, tmpTd, fld->child[i]); + construct_types_and_fields(fac, tmpTd, fld->child[i]); } } } - +#endif //0 /***************************************************************************** *Function name @@ -313,43 +417,25 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) { - LttType * lttType = NULL; - unsigned int i=0; - gchar * name; - - if(td->type_name){ - for(i=0;inamed_types_number; i++){ - if(fac->named_types[i] == NULL) break; - name = fac->named_types[i]->type_name; - if(g_ascii_strcasecmp(name, td->type_name)==0){ - lttType = fac->named_types[i]; - // if(lttType->element_name) g_free(lttType->element_name); - // lttType->element_name = NULL; - break; - } - } - } + GQuark name = g_quark_from_string(td->type_name); - if(!lttType){ - lttType = g_new(LttType,1); - lttType->type_class = td->type; - if(td->fmt) lttType->fmt = g_strdup(td->fmt); - else lttType->fmt = NULL; - lttType->size = td->size; - lttType->enum_strings = NULL; - lttType->element_type = NULL; - lttType->element_number = 0; - lttType->element_name = NULL; - if(td->type_name){ - lttType->type_name = g_strdup(td->type_name); - fac->named_types[i] = lttType; /* i is initialized, checked. */ - } - else{ - lttType->type_name = NULL; - } + LttType *type = g_datalist_id_get_data(&fac->named_types, name); + + if(type == NULL){ + type = g_new(LttType,1); + type->type_name = name; + g_datalist_id_set_data_full(&fac->named_types, name, + type, (GDestroyNotify)freeLttNamedType); + type->type_class = td->type; + if(td->fmt) type->fmt = g_strdup(td->fmt); + else type->fmt = NULL; + type->size = td->size; + type->enum_strings = NULL; + type->element_type = NULL; + type->element_number = 0; } - return lttType; + return type; } @@ -359,16 +445,12 @@ LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) * if usage count = 0, release the memory *Input params * f : facility that will be closed - *Return value - * int : usage count ?? status ****************************************************************************/ -int ltt_facility_close(LttFacility *f) +void ltt_facility_close(LttFacility *f) { //release the memory it occupied freeFacility(f); - - return 0; } /***************************************************************************** @@ -377,30 +459,22 @@ int ltt_facility_close(LttFacility *f) void freeFacility(LttFacility * fac) { - unsigned int i; - g_free(fac->name); //free facility name + guint i; + LttEventType *et; - //free event types - for(i=0;ievent_number;i++){ - freeEventtype(fac->events[i]); + for(i=0; ievents->len; i++) { + et = &g_array_index (fac->events, LttEventType, i); + freeEventtype(et); } - g_free(fac->events); + g_array_free(fac->events, TRUE); - //free all named types - for(i=0;inamed_types_number;i++){ - freeLttNamedType(fac->named_types[i]); - fac->named_types[i] = NULL; - } - g_free(fac->named_types); + g_datalist_clear(&fac->named_types); - //free the facility itself - g_free(fac); } void freeEventtype(LttEventType * evType) { LttType * root_type; - g_free(evType->name); if(evType->description) g_free(evType->description); if(evType->root_field){ @@ -408,14 +482,10 @@ void freeEventtype(LttEventType * evType) freeLttField(evType->root_field); freeLttType(&root_type); } - - g_free(evType); } void freeLttNamedType(LttType * type) { - g_free(type->type_name); - type->type_name = NULL; freeLttType(&type); } @@ -423,16 +493,12 @@ void freeLttType(LttType ** type) { unsigned int i; if(*type == NULL) return; - if((*type)->type_name){ - return; //this is a named type - } - if((*type)->element_name) - g_free((*type)->element_name); + //if((*type)->type_name){ + // return; //this is a named type + //} if((*type)->fmt) g_free((*type)->fmt); if((*type)->enum_strings){ - for(i=0;i<(*type)->element_number;i++) - g_free((*type)->enum_strings[i]); g_free((*type)->enum_strings); } @@ -472,12 +538,12 @@ void freeLttField(LttField * fld) *Function name * ltt_facility_name : obtain the facility's name *Input params - * f : the facility that will be closed + * f : the facility *Return value - * char * : the facility's name + * GQuark : the facility's name ****************************************************************************/ -gchar *ltt_facility_name(LttFacility *f) +GQuark ltt_facility_name(LttFacility *f) { return f->name; } @@ -486,12 +552,12 @@ gchar *ltt_facility_name(LttFacility *f) *Function name * ltt_facility_checksum : obtain the facility's checksum *Input params - * f : the facility that will be closed + * f : the facility *Return value - * LttChecksum : the checksum of the facility + * : the checksum of the facility ****************************************************************************/ -LttChecksum ltt_facility_checksum(LttFacility *f) +guint32 ltt_facility_checksum(LttFacility *f) { return f->checksum; } @@ -505,9 +571,9 @@ LttChecksum ltt_facility_checksum(LttFacility *f) * : the base id of the facility ****************************************************************************/ -unsigned ltt_facility_base_id(LttFacility *f) +guint ltt_facility_id(LttFacility *f) { - return f->base_id; + return f->id; } /***************************************************************************** @@ -516,12 +582,12 @@ unsigned ltt_facility_base_id(LttFacility *f) *Input params * f : the facility that will be closed *Return value - * unsigned : the number of the event types + * : the number of the event types ****************************************************************************/ -unsigned ltt_facility_eventtype_number(LttFacility *f) +guint8 ltt_facility_eventtype_number(LttFacility *f) { - return (f->event_number); + return (f->events->len); } /***************************************************************************** @@ -534,9 +600,10 @@ unsigned ltt_facility_eventtype_number(LttFacility *f) * LttEventType * : the event type required ****************************************************************************/ -LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i) +LttEventType *ltt_facility_eventtype_get(LttFacility *f, guint8 i) { - return f->events[i]; + g_assert(i < f->events->len); + return &g_array_index(f->events, LttEventType, i); } /***************************************************************************** @@ -551,18 +618,8 @@ LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i) * LttEventType * : the event type required ****************************************************************************/ -LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, gchar *name) +LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, GQuark name) { - unsigned int i; - LttEventType * ev = NULL; - - for(i=0;ievent_number;i++){ - LttEventType *iter_ev = f->events[i]; - if(g_ascii_strcasecmp(iter_ev->name, name) == 0) { - ev = iter_ev; - break; - } - } - return ev; + LttEventType *et = g_datalist_get_data(f->events_by_name, name); } diff --git a/ltt/branches/poly/ltt/facility.h b/ltt/branches/poly/ltt/facility.h index 290dca7b..091d8af2 100644 --- a/ltt/branches/poly/ltt/facility.h +++ b/ltt/branches/poly/ltt/facility.h @@ -25,12 +25,12 @@ with a facility are released when the trace is closed. Each facility is characterized by its name and checksum. */ -gchar *ltt_facility_name(LttFacility *f); +GQuark ltt_facility_name(LttFacility *f); -LttChecksum ltt_facility_checksum(LttFacility *f); +guint32 ltt_facility_checksum(LttFacility *f); /* open facility */ -void ltt_facility_open(LttTrace * t, gchar * facility_name); +int ltt_facility_open(LttFacility *f, LttTrace * t, gchar * pathname); /* Discover the event types within the facility. The event type integer id relative to the trace is from 0 to nb_event_types - 1. The event @@ -39,13 +39,17 @@ void ltt_facility_open(LttTrace * t, gchar * facility_name); unsigned ltt_facility_base_id(LttFacility *f); -unsigned ltt_facility_eventtype_number(LttFacility *f); +guint8 ltt_facility_eventtype_number(LttFacility *f); -LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i); +LttEventType *ltt_facility_eventtype_get(LttFacility *f, guint8 i); -LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, gchar *name); +LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, GQuark name); -int ltt_facility_close(LttFacility *f); +void ltt_facility_close(LttFacility *f); + +/* Reserved facility names */ + +static const char *ltt_facility_name_core = "core"; #endif // FACILITY_H diff --git a/ltt/branches/poly/ltt/ltt-private.h b/ltt/branches/poly/ltt/ltt-private.h index 05c18c0f..25692fae 100644 --- a/ltt/branches/poly/ltt/ltt-private.h +++ b/ltt/branches/poly/ltt/ltt-private.h @@ -23,8 +23,28 @@ #include #include +#define LTT_MAGIC_NUMBER 0x00D6B7ED +#define LTT_REV_MAGIC_NUMBER 0xEDB7D600 + +#define NSEC_PER_USEC 1000 + #define LTT_PACKED_STRUCT __attribute__ ((packed)) +#define NUM_FACILITIES 256 + +/* Hardcoded facilities */ +#define LTT_FACILITY_CORE 0 + +/* Hardcoded core events */ +enum ltt_core_events { + LTT_EVENT_FACILITY_LOAD, + LTT_EVENT_FACILITY_UNLOAD, + LTT_EVENT_STATE_DUMP_FACILITY_LOAD, + LTT_EVENT_HEARTBEAT +}; + + +#if 0 /* enumeration definition */ typedef enum _BuildinEvent{ @@ -44,177 +64,290 @@ typedef struct _FacilityLoad{ } LTT_PACKED_STRUCT FacilityLoad; typedef struct _BlockStart { - LttTime time; //Time stamp of this block + LttTime time; //Time stamp of this block LttCycleCount cycle_count; //cycle count of the event guint32 block_id; //block id } LTT_PACKED_STRUCT BlockStart; typedef struct _BlockEnd { - LttTime time; //Time stamp of this block + LttTime time; //Time stamp of this block LttCycleCount cycle_count; //cycle count of the event guint32 block_id; //block id } LTT_PACKED_STRUCT BlockEnd; +#endif //0 + + +typedef guint8 uint8_t; +typedef guint16 uint16_t; +typedef guint32 uint32_t; +typedef guint64 uint64_t; + +/* Hardcoded facility load event : this plus an following "name" string */ +struct LttFacilityLoad { + guint32 checksum; + guint32 id; + guint32 long_size; + guint32 pointer_size; + guint32 size_t_size; + guint32 alignment; +}; + +struct LttFacilityUnload { + guint32 id; +}; + +struct LttStateDumpFacilityLoad { + guint32 checksum; + guint32 id; + guint32 long_size; + guint32 pointer_size; + guint32 size_t_size; + guint32 alignment; +}; + + typedef struct _TimeHeartbeat { - LttTime time; //Time stamp of this block - LttCycleCount cycle_count; //cycle count of the event + LttTime time; //Time stamp of this block + uint64_t cycle_count; //cycle count of the event } LTT_PACKED_STRUCT TimeHeartbeat; +struct ltt_event_header_hb { + uint32_t timestamp; + unsigned char facility_id; + unsigned char event_id; + uint16_t event_size; +} __attribute((aligned(8))); + +struct ltt_event_header_nohb { + uint64_t timestamp; + unsigned char facility_id; + unsigned char event_id; + uint16_t event_size; +} __attribute((aligned(8))); + +struct ltt_trace_header { + uint32_t magic_number; + uint32_t arch_type; + uint32_t arch_variant; + uint8_t arch_size; + //uint32_t system_type; + uint8_t major_version; + uint8_t minor_version; + uint8_t flight_recorder; + uint8_t has_heartbeat; + uint8_t has_alignment; /* Event header alignment */ + uint8_t has_tsc; +} __attribute((aligned(8))); + + +struct ltt_block_start_header { + struct { + struct timeval timestamp; + uint64_t cycle_count; + } begin; + struct { + struct timeval timestamp; + uint64_t cycle_count; + } end; + uint32_t lost_size; /* Size unused at the end of the buffer */ + uint32_t buf_size; /* The size of this sub-buffer */ + struct ltt_trace_header trace; +} __attribute((aligned(8))); + struct _LttType{ - gchar * type_name; //type name if it is a named type - gchar * element_name; //elements name of the struct + GQuark type_name; //type name if it is a named type + GQuark element_name; //elements name of the struct gchar * fmt; unsigned int size; LttTypeEnum type_class; //which type - gchar ** enum_strings; //for enum labels + GQuark * enum_strings; //for enum labels struct _LttType ** element_type; //for array, sequence and struct unsigned element_number; //the number of elements //for enum, array, sequence and structure }; struct _LttEventType{ - gchar * name; + GQuark name; gchar * description; - int index; //id of the event type within the facility + guint index; //id of the event type within the facility LttFacility * facility; //the facility that contains the event type LttField * root_field; //root field - unsigned int latest_block; //the latest block using the event type - unsigned int latest_event; //the latest event using the event type }; +/* Structure LttEvent and LttEventPosition must begin with the _exact_ same + * fields in the exact same order. LttEventPosition is a parent of LttEvent. */ struct _LttEvent{ - guint16 event_id; - guint32 time_delta; + + /* Begin of LttEventPosition fields */ + LttTracefile *tracefile; + unsigned int block; + void *offset; + + /* Timekeeping */ + uint64_t tsc; /* Current timestamp counter */ + + /* End of LttEventPosition fields */ + + union { /* choice by trace has_tsc */ + guint32 timestamp; /* truncated timestamp */ + LttTime delta; + } time; + + unsigned char facility_id; /* facility ID are never reused. */ + unsigned char event_id; + LttTime event_time; - LttCycleCount event_cycle_count; - LttTracefile * tracefile; + void * data; //event data - unsigned int which_block; //the current block of the event - unsigned int which_event; //the position of the event - /* This is a workaround for fast position seek */ - void * last_event_pos; - - LttTime prev_block_end_time; //the end time of previous block - LttTime prev_event_time; //the time of the previous event - LttCycleCount pre_cycle_count; //previous cycle count of the event + int count; //the number of overflow of cycle count gint64 overflow_nsec; //precalculated nsec for overflows - TimeHeartbeat * last_heartbeat; //last heartbeat +}; - /* end of workaround */ +struct _LttEventPosition{ + LttTracefile *tracefile; + unsigned int block; + void *offset; + + /* Timekeeping */ + uint64_t tsc; /* Current timestamp counter */ }; +enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED }; + struct _LttField{ - unsigned field_pos; //field position within its parent + //guint field_pos; //field position within its parent LttType * field_type; //field type, if it is root field //then it must be struct type off_t offset_root; //offset from the root, -1:uninitialized - short fixed_root; //offset fixed according to the root + enum field_status fixed_root; //offset fixed according to the root //-1:uninitialized, 0:unfixed, 1:fixed off_t offset_parent; //offset from the parent,-1:uninitialized - short fixed_parent; //offset fixed according to its parent + enum field_status fixed_parent; //offset fixed according to its parent //-1:uninitialized, 0:unfixed, 1:fixed // void * base_address; //base address of the field ???? - int field_size; //>0: size of the field, - //0 : uncertain - //-1: uninitialize - int sequ_number_size; //the size of unsigned used to save the + guint field_size; // //>0: size of the field, + // //0 : uncertain + // //-1: uninitialize + enum field_status fixed_size; + + /* for sequence */ + gint sequ_number_size; //the size of unsigned used to save the //number of elements in the sequence - int element_size; //the element size of the sequence - int field_fixed; //0: field has string or sequence + gint element_size; //the element size of the sequence + //int field_fixed; //0: field has string or sequence //1: field has no string or sequenc //-1: uninitialize struct _LttField * parent; - struct _LttField ** child; //for array, sequence and struct: + struct _LttField ** child; //for array, sequence, struct and union: //list of fields, it may have only one - //field if the element is not a struct + //field if the element is not a struct or + //union unsigned current_element; //which element is currently processed + // Used for sequences and arrays. }; struct _LttFacility{ - gchar * name; //facility name - unsigned int event_number; //number of events in the facility - LttChecksum checksum; //checksum of the facility - guint32 base_id; //base id of the facility - LttEventType ** events; //array of event types - LttType ** named_types; - unsigned int named_types_number; + LttTrace *trace; + //gchar * name; //facility name + GQuark name; + guint32 checksum; //checksum of the facility + guint32 id; //id of the facility + + guint32 pointer_size; + guint32 size_t_size; + guint32 alignment; + + + //LttEventType ** events; //array of event types + //unsigned int event_number; //number of events in the facility + //LttType ** named_types; + //unsigned int named_types_number; + + GArray *events; + GData *events_by_name; + // GArray *named_types; + //GData *named_types_by_name; + GData *named_types; + + unsigned char exists; /* 0 does not exist, 1 exists */ }; +typedef struct _LttBuffer { + void * head; + unsigned int index; + + struct { + LttTime timestamp; + uint64_t cycle_count; + } begin; + struct { + LttTime timestamp; + uint64_t cycle_count; + } end; + uint32_t lost_size; /* Size unused at the end of the buffer */ + + /* Timekeeping */ + uint64_t tsc; /* Current timestamp counter */ + double nsecs_per_cycle; +} LttBuffer; + struct _LttTracefile{ - gchar * name; //tracefile name + gboolean cpu_online; //is the cpu online ? + GQuark name; //tracefile name + guint cpu_num; //cpu number of the tracefile LttTrace * trace; //trace containing the tracefile int fd; //file descriptor off_t file_size; //file size unsigned block_size; //block_size - unsigned int block_number; //number of blocks in the file - unsigned int which_block; //which block the current block is - unsigned int which_event; //which event of the current block - //is currently processed - LttTime current_event_time; //time of the current event - BlockStart * a_block_start; //block start of the block- trace endian - BlockEnd * a_block_end; //block end of the block - trace endian - TimeHeartbeat * last_heartbeat; //last heartbeat - void * cur_event_pos; //the position of the current event - void * buffer; //the buffer containing the block - double nsec_per_cycle; //Nsec per cycle - guint64 one_overflow_nsec; //nsec for one overflow - gint64 overflow_nsec; //precalculated nsec for overflows - //can be negative to include value - //of block start cycle count. - //incremented at each overflow while - //reading. + unsigned int num_blocks; //number of blocks in the file + gboolean reverse_bo; //must we reverse byte order ? + + /* Current event */ + LttEvent event; //Event currently accessible in the trace + + /* Current block */ + LttBuffer buffer; //current buffer + guint32 buf_size; /* The size of blocks */ + + /* Time flow */ + //unsigned int count; //the number of overflow of cycle count + //double nsec_per_cycle; //Nsec per cycle + //TimeHeartbeat * last_heartbeat; //last heartbeat + //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed - unsigned cur_heart_beat_number; //current number of heart beat in the buf - LttCycleCount cur_cycle_count; //current cycle count of the event - void * last_event_pos; - - LttTime prev_block_end_time; //the end time of previous block - LttTime prev_event_time; //the time of the previous event - LttCycleCount pre_cycle_count; //previous cycle count of the event - unsigned int count; //the number of overflow of cycle count -}; + //void * last_event_pos; -struct _LttTrace{ - gchar * pathname; //the pathname of the trace - guint facility_number; //the number of facilities - guint control_tracefile_number; //the number of control files - guint per_cpu_tracefile_number; //the number of per cpu files - LttSystemDescription * system_description;//system description - - GPtrArray *control_tracefiles; //array of control tracefiles - GPtrArray *per_cpu_tracefiles; //array of per cpu tracefiles - GPtrArray *facilities; //array of facilities - gboolean reverse_byte_order; //must we reverse BO ? + //LttTime prev_block_end_time; //the end time of previous block + //LttTime prev_event_time; //the time of the previous event + //LttCycleCount pre_cycle_count; //previous cycle count of the event }; -struct _LttEventPosition{ - unsigned block_num; //block which contains the event - unsigned event_num; //event index in the block - unsigned event_offset; //event position in the block - LttTime event_time; //the time of the event - LttCycleCount event_cycle_count; //the cycle count of the event - unsigned heart_beat_number; //current number of heart beats - LttTracefile *tf; //tracefile containing the event - gboolean old_position; //flag to show if it is the position - //being remembered - /* This is a workaround for fast position seek */ - void * last_event_pos; - - LttTime prev_block_end_time; //the end time of previous block - LttTime prev_event_time; //the time of the previous event - LttCycleCount pre_cycle_count; //previous cycle count of the event - int count; //the number of overflow of cycle count - gint64 overflow_nsec; //precalculated nsec for overflows - TimeHeartbeat * last_heartbeat; //last heartbeat - /* end of workaround */ +struct _LttTrace{ + GQuark pathname; //the pathname of the trace + //LttSystemDescription * system_description;//system description + + GArray *facilities_by_num; /* fac_id as index in array */ + GData *facilities_by_name; /* fac name (GQuark) as index */ + /* Points to array of fac_id of all the + * facilities that has this name. */ + + guint8 ltt_major_version; + guint8 ltt_minor_version; + guint8 flight_recorder; + guint8 has_heartbeat; + // guint8 alignment; + guint8 has_tsc; + + GData *tracefiles; //tracefiles groups }; /* The characteristics of the system on which the trace was obtained @@ -234,9 +367,6 @@ struct _LttSystemDescription { gchar *processor; gchar *hardware_platform; gchar *operating_system; - unsigned ltt_major_version; - unsigned ltt_minor_version; - unsigned ltt_block_size; LttTime trace_start; LttTime trace_end; }; @@ -244,9 +374,13 @@ struct _LttSystemDescription { /***************************************************************************** macro for size of some data types *****************************************************************************/ -#define EVENT_ID_SIZE sizeof(guint16) -#define TIME_DELTA_SIZE sizeof(guint32) -#define EVENT_HEADER_SIZE (EVENT_ID_SIZE + TIME_DELTA_SIZE) +// alignment -> dynamic! + +//#define TIMESTAMP_SIZE sizeof(guint32) +//#define EVENT_ID_SIZE sizeof(guint16) +//#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE) + +#define LTT_GET_BO(t) ((t)->reverse_bo) #endif /* LTT_PRIVATE_H */ diff --git a/ltt/branches/poly/ltt/ltt.h b/ltt/branches/poly/ltt/ltt.h index 5651702c..4434f8cf 100644 --- a/ltt/branches/poly/ltt/ltt.h +++ b/ltt/branches/poly/ltt/ltt.h @@ -87,7 +87,7 @@ typedef struct _LttSystemDescription LttSystemDescription; /* Checksums are used to differentiate facilities which have the same name but differ. */ -typedef guint32 LttChecksum; +//typedef guint32 LttChecksum; /* Events are usually stored with the easily obtained CPU clock cycle count, @@ -127,7 +127,8 @@ typedef enum _LttArchEndian } LttArchEndian; typedef enum _LttTypeEnum -{ LTT_INT, LTT_UINT, LTT_FLOAT, LTT_STRING, LTT_ENUM, LTT_ARRAY, +{ LTT_INT, LTT_UINT, LTT_POINTER, LTT_LONG, LTT_ULONG, LTT_SIZE_T, + LTT_SSIZE_T, LTT_OFF_T, LTT_FLOAT, LTT_STRING, LTT_ENUM, LTT_ARRAY, LTT_SEQUENCE, LTT_STRUCT, LTT_UNION } LttTypeEnum; diff --git a/ltt/branches/poly/ltt/trace.h b/ltt/branches/poly/ltt/trace.h index a2360bb5..80258a78 100644 --- a/ltt/branches/poly/ltt/trace.h +++ b/ltt/branches/poly/ltt/trace.h @@ -21,6 +21,10 @@ #include + +extern GQuark LTT_FACILITY_NAME_HEARTBEAT, + LTT_EVENT_NAME_HEARTBEAT; + /* A trace is specified as a pathname to the directory containing all the associated data (control tracefiles, per cpu tracefiles, event descriptions...). @@ -40,7 +44,7 @@ LttTrace *ltt_trace_open(const gchar *pathname); */ LttTrace *ltt_trace_copy(LttTrace *self); -gchar * ltt_trace_name(LttTrace *t); +GQuark ltt_trace_name(LttTrace *t); void ltt_trace_close(LttTrace *t); @@ -57,7 +61,7 @@ unsigned ltt_trace_facility_number(LttTrace *t); LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i); -LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id); +LttFacility * ltt_trace_facility_by_id(LttTrace * trace, guint8 id); /* Look for a facility by name. It returns the number of facilities found and sets the position argument to the first found. Returning 0, the named @@ -75,34 +79,6 @@ unsigned ltt_trace_eventtype_number(LttTrace *t); LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i); -/* There is one "per cpu" tracefile for each CPU, numbered from 0 to - the maximum number of CPU in the system. When the number of CPU installed - is less than the maximum, some positions are unused. There are also a - number of "control" tracefiles (facilities, interrupts...). */ - -unsigned ltt_trace_control_tracefile_number(LttTrace *t); - -unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t); - - -/* It is possible to search for the tracefiles by name or by CPU tracefile - * name. - * The index within the tracefiles of the same type is returned if found - * and a negative value otherwise. - */ - -int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name); - -int ltt_trace_per_cpu_tracefile_find(LttTrace *t, const gchar *name); - - -/* Get a specific tracefile */ - -LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i); - -LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i); - - /* Get the start time and end time of the trace */ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end); @@ -110,7 +86,7 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end); /* Get the name of a tracefile */ -char *ltt_tracefile_name(LttTracefile *tf); +GQuark ltt_tracefile_name(LttTracefile *tf); /* Get the number of blocks in the tracefile */ @@ -120,34 +96,32 @@ unsigned ltt_tracefile_block_number(LttTracefile *tf); /* Seek to the first event of the trace with time larger or equal to time */ -void ltt_tracefile_seek_time(LttTracefile *t, LttTime time); +int ltt_tracefile_seek_time(LttTracefile *t, LttTime time); /* Seek to the first event with position equal or larger to ep */ -void ltt_tracefile_seek_position(LttTracefile *t, +int ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep); /* Read the next event */ -LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event); - -/* open tracefile */ - -LttTracefile * ltt_tracefile_open(LttTrace *t, gchar * tracefile_name); +int ltt_tracefile_read(LttTracefile *t); -void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name); +/* ltt_tracefile_read cut down in pieces */ +int ltt_tracefile_read_seek(LttTracefile *t); +int ltt_tracefile_read_update_event(LttTracefile *t); +int ltt_tracefile_read_op(LttTracefile *t); -gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name); +/* open tracefile */ +gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf); /* get the data type size and endian type of the local machine */ void getDataEndianType(LttArchSize * size, LttArchEndian * endian); /* get an integer number */ - -gint64 getIntNumber(gboolean reverse_byte_order, int size1, void *evD); - +gint64 get_int(gboolean reverse_byte_order, gint size, void *data); /* get the node name of the system */ @@ -175,4 +149,6 @@ void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src); void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname); + + #endif // TRACE_H diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index a111e41f..b78f4834 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -1,6 +1,8 @@ /* This file is part of the Linux Trace Toolkit viewer - * Copyright (C) 2003-2004 Xiangxiu Yang, Mathieu Desnoyers + * Copyright (C) 2005 Mathieu Desnoyers * + * Complete rewrite from the original version made by XangXiu 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; @@ -30,6 +32,8 @@ #include #include #include +#include +#include // For realpath #include @@ -45,16 +49,25 @@ #include #include + +/* Facility names used in this file */ + +GQuark LTT_FACILITY_NAME_HEARTBEAT, + LTT_EVENT_NAME_HEARTBEAT; +GQuark LTT_TRACEFILE_NAME_FACILITIES; + #ifndef g_open #define g_open open #endif -#define DIR_NAME_SIZE 256 #define __UNUSED__ __attribute__((__unused__)) #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format) + +#ifndef g_debug #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format) +#endif #define g_close close @@ -65,28 +78,34 @@ 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); +void set_fields_offsets(LttTracefile *tf, LttEventType *event_type); +size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data); -/* get the size of the field type according to the archtecture's - size and endian type(info of the archecture) */ -static inline gint getFieldtypeSize(LttTracefile * tf, - LttEventType * evT, gint offsetRoot, - gint offsetParent, LttField *fld, void *evD, LttTrace* t); +/* get the size of the field type according to + * The facility size information. */ +static inline void preset_field_type_size(LttTracefile *tf, + LttEventType *event_type, + off_t offset_root, off_t offset_parent, + enum field_status *fixed_root, enum field_status *fixed_parent, + LttField *field); -/* read a fixed size or a block information from the file (fd) */ -int readFile(int fd, void * buf, size_t size, gchar * mesg); -int readBlock(LttTracefile * tf, int whichBlock); -/* calculate cycles per nsec for current block */ -void getCyclePerNsec(LttTracefile * t); +static inline size_t get_field_type_size(LttTracefile *tf, + LttEventType *event_type, + off_t offset_root, off_t offset_parent, + LttField *field, void *data); -/* reinitialize the info of the block which is already in the buffer */ -void updateTracefile(LttTracefile * tf); -/* go to the next event */ -int skipEvent(LttTracefile * t); +/* map a fixed size or a block information from the file (fd) */ +static gint map_block(LttTracefile * tf, guint block_num); + +/* calculate nsec per cycles for current block */ +static double calc_nsecs_per_cycle(LttTracefile * t); +/* go to the next event */ +static int ltt_seek_next_event(LttTracefile *tf); +#if 0 /* Functions to parse system.xml file (using glib xml parser) */ static void parser_start_element (GMarkupParseContext __UNUSED__ *context, const gchar *element_name, @@ -161,6 +180,15 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, LttSystemDescription* des = (LttSystemDescription* )user_data; des->description = g_strdup(text); } +#endif //0 +static inline LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, + guint num) +{ + g_assert(num < t->facilities_by_num->len); + + return &g_array_index(t->facilities_by_num, LttFacility, num); + +} /***************************************************************************** @@ -169,62 +197,82 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, *Input params * t : the trace containing the tracefile * fileName : path name of the trace file + * tf : the tracefile structure *Return value - * : a pointer to a tracefile + * : 0 for success, -1 otherwise. ****************************************************************************/ -LttTracefile* ltt_tracefile_open(LttTrace * t, gchar * fileName) +gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf) { - LttTracefile * tf; struct stat lTDFStat; /* Trace data file status */ - - tf = g_new(LttTracefile, 1); + struct ltt_block_start_header *header; //open the file - tf->name = g_strdup(fileName); + tf->name = g_quark_from_string(fileName); tf->trace = t; tf->fd = g_open(fileName, O_RDONLY, 0); if(tf->fd < 0){ g_warning("Unable to open input data file %s\n", fileName); - g_free(tf->name); - g_free(tf); - return NULL; + goto end; } // Get the file's status if(fstat(tf->fd, &lTDFStat) < 0){ g_warning("Unable to get the status of the input data file %s\n", fileName); - g_free(tf->name); - g_close(tf->fd); - g_free(tf); - return NULL; + goto close_file; } // Is the file large enough to contain a trace - if(lTDFStat.st_size < (off_t)(sizeof(BlockStart) + EVENT_HEADER_SIZE)){ + if(lTDFStat.st_size < (off_t)(sizeof(struct ltt_block_start_header))){ g_print("The input data file %s does not contain a trace\n", fileName); - g_free(tf->name); - g_close(tf->fd); - g_free(tf); - return NULL; + goto close_file; + } + + /* Temporarily map the buffer start header to get trace information */ + /* Multiple of pages aligned head */ + tf->buffer.head = mmap(0, sizeof(struct ltt_block_start_header), PROT_READ, + MAP_PRIVATE, tf->fd, 0); + if(tf->buffer.head == NULL) { + perror("Error in allocating memory for buffer of tracefile"); + goto close_file; } + g_assert(((guint)tf->buffer.head & (8-1)) == 0); // make sure it's aligned. + + header = (struct ltt_block_start_header*)tf->buffer.head; + if(header->trace.magic_number == LTT_MAGIC_NUMBER) + tf->reverse_bo = 0; + else if(header->trace.magic_number == LTT_REV_MAGIC_NUMBER) + tf->reverse_bo = 1; + else /* invalid magic number, bad tracefile ! */ + goto unmap_file; + //store the size of the file tf->file_size = lTDFStat.st_size; - tf->block_size = t->system_description->ltt_block_size; - tf->block_number = tf->file_size / tf->block_size; - tf->which_block = 0; + tf->block_size = header->buf_size; + tf->num_blocks = tf->file_size / tf->block_size; - //allocate memory to contain the info of a block - tf->buffer = (void *) g_new(gchar, t->system_description->ltt_block_size); + vfree(tf->buffer.head); + tf->buffer.head = NULL; //read the first block - if(readBlock(tf,1)) exit(1); + if(map_block(tf,0)) { + perror("Cannot map block for tracefile"); + goto close_file; + } + + return 0; - return tf; + /* Error */ +unmap_file: + munmap(tf->buffer.head, sizeof(struct ltt_block_start_header)); +close_file: + g_close(tf->fd); +end: + return -1; } - +#if 0 /***************************************************************************** *Open control and per cpu tracefiles ****************************************************************************/ @@ -290,6 +338,7 @@ gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name) } return 0; } +#endif //0 /***************************************************************************** *Function name @@ -300,16 +349,16 @@ gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name) void ltt_tracefile_close(LttTracefile *t) { - g_free(t->name); - g_free(t->buffer); - close(t->fd); - g_free(t); + if(t->buffer.head != NULL) + munmap(t->buffer.head, t->buf_size); + g_close(t->fd); } /***************************************************************************** *Get system information ****************************************************************************/ +#if 0 gint getSystemInfo(LttSystemDescription* des, gchar * pathname) { int fd; @@ -376,11 +425,12 @@ gint getSystemInfo(LttSystemDescription* des, gchar * pathname) g_free(buf); return 0; } +#endif //0 /***************************************************************************** *The following functions get facility/tracefile information ****************************************************************************/ - +#if 0 gint getFacilityInfo(LttTrace *t, gchar* eventdefs) { GDir * dir; @@ -416,63 +466,7 @@ gint getFacilityInfo(LttTrace *t, gchar* eventdefs) } return 0; } - -gint getControlFileInfo(LttTrace *t, gchar* control) -{ - GDir * dir; - const gchar *name; - gchar fullname[DIR_NAME_SIZE]; - GError * error = NULL; - - dir = g_dir_open(control, 0, &error); - - if(error != NULL) { - g_warning("Can not open directory: %s, %s\n", control, error->message); - g_error_free(error); - return -1; - } - - while((name = g_dir_read_name(dir)) != NULL){ - if(strcmp(name,"facilities") != 0 && - strcmp(name,"interrupts") != 0 && - strcmp(name,"processes") != 0) continue; - - strcpy(fullname,control); - strcat(fullname,name); - if(ltt_tracefile_open_control(t,fullname)) { - g_dir_close(dir); - return -1; - } - } - g_dir_close(dir); - return 0; -} - -gint getCpuFileInfo(LttTrace *t, char* cpu) -{ - GDir * dir; - const gchar * name; - gchar fullname[DIR_NAME_SIZE]; - GError * error = NULL; - - dir = g_dir_open(cpu, 0, &error); - - if(error != NULL) { - g_warning("Can not open directory: %s, %s\n", cpu, error->message); - g_error_free(error); - return -1; - } - - while((name = g_dir_read_name(dir)) != NULL){ - if(strcmp(name,".svn") != 0){ /* . and .. already excluded */ - strcpy(fullname,cpu); - strcat(fullname,name); - ltt_tracefile_open_cpu(t,fullname); - }else continue; - } - g_dir_close(dir); - return 0; -} +#endif //0 /***************************************************************************** *A trace is specified as a pathname to the directory containing all the @@ -508,229 +502,507 @@ void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname) return; } -LttTrace *ltt_trace_open(const gchar *pathname) +/* Search for something like : .*_.* + * + * The left side is the name, the right side is the number. + */ + +int get_tracefile_name_number(const gchar *raw_name, + GQuark *name, + guint *num) { - LttTrace * t; - LttSystemDescription * sys_description; - gchar eventdefs[DIR_NAME_SIZE]; - gchar info[DIR_NAME_SIZE]; - gchar control[DIR_NAME_SIZE]; - gchar cpu[DIR_NAME_SIZE]; - gchar tmp[DIR_NAME_SIZE]; - gchar abs_path[DIR_NAME_SIZE]; - gboolean has_slash = FALSE; + guint raw_name_len = strlen(raw_name); + gchar char_name[PATH_MAX]; + gchar *digit_begin; + int i; + int underscore_pos; + long int cpu_num; + gchar *endptr; + + for(i=raw_name_len-1;i>=0;i--) { + if(raw_name[i] == '_') break; + } + if(i==0) /* Either not found or name length is 0 */ + return -1; + underscore_pos = i; - get_absolute_pathname(pathname, abs_path); - //establish the pathname to different directories - if(abs_path[strlen(abs_path)-1] == '/')has_slash = TRUE; - strcpy(eventdefs,abs_path); - if(!has_slash)strcat(eventdefs,"/"); - strcat(eventdefs,"eventdefs/"); - - strcpy(info,abs_path); - if(!has_slash)strcat(info,"/"); - strcat(info,"info/"); - - strcpy(control,abs_path); - if(!has_slash)strcat(control,"/"); - strcat(control,"control/"); - - strcpy(cpu,abs_path); - if(!has_slash)strcat(cpu,"/"); - strcat(cpu,"cpu/"); - - //new trace - sys_description = g_new(LttSystemDescription, 1); - 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; - t->system_description = sys_description; - 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)); + cpu_num = strtol(raw_name+underscore_pos+1, &endptr, 10); + + if(endptr == raw_name+underscore_pos+1) + return -1; /* No digit */ + if(cpu_num == LONG_MIN || cpu_num == LONG_MAX) + return -1; /* underflow / overflow */ - //get system description - strcpy(tmp,info); - strcat(tmp,"system.xml"); - 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; - } + strncpy(char_name, raw_name, underscore_pos); - /* Set the reverse byte order between trace and reader */ - if(sys_description->endian == LTT_LITTLE_ENDIAN - && G_BYTE_ORDER != G_LITTLE_ENDIAN) { - t->reverse_byte_order = 1; - } else if(sys_description->endian == LTT_BIG_ENDIAN - && G_BYTE_ORDER != G_BIG_ENDIAN) { - t->reverse_byte_order = 1; - } else t->reverse_byte_order = 0; - - //get facilities info - if(getFacilityInfo(t,eventdefs)) { - 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; - } + *name = g_quark_from_string(char_name); + *num = cpu_num; - //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 - 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 0; +} - return t; + +void ltt_tracefile_group_destroy(gpointer data) +{ + GArray *group = (GArray *)data; + int i; + LttTracefile *tf; + + for(i=0; ilen; i++) { + tf = &g_array_index (group, LttTracefile, i); + if(tf->cpu_online) + ltt_tracefile_close(tf); + } + g_array_free(group, TRUE); } -char * ltt_trace_name(LttTrace *t) +gboolean ltt_tracefile_group_has_cpu_online(gpointer data) { - return t->pathname; + GArray *group = (GArray *)data; + int i; + LttTracefile *tf; + + for(i=0; ilen; i++) { + tf = &g_array_index (group, LttTracefile, i); + if(tf->cpu_online) return 1; + } + return 0; } -/****************************************************************************** - * 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) +/* Open each tracefile under a specific directory. Put them in a + * GData : permits to access them using their tracefile group pathname. + * i.e. access control/modules tracefile group by index : + * "control/module". + * + * A tracefile group is simply an array where all the per cpu tracefiles sits. + */ + +static int open_tracefiles(LttTrace *trace, char *root_path, GData *tracefiles) { - return ltt_trace_open(self->pathname); + DIR *dir = opendir(root_path); + struct dirent *entry; + struct stat stat_buf; + int ret; + char path[PATH_MAX]; + int path_len; + char *path_ptr; + + if(dir == NULL) { + perror(root_path); + return ENOENT; + } + + strncpy(path, root_path, PATH_MAX-1); + path_len = strlen(path); + path[path_len] = '/'; + path_len++; + path_ptr = path + path_len; + + while((entry = readdir(dir)) != NULL) { + + if(entry->d_name[0] == '.') continue; + + strncpy(path_ptr, entry->d_name, PATH_MAX - path_len); + + ret = stat(path, &stat_buf); + if(ret == -1) { + perror(path); + continue; + } + + g_debug("Tracefile file or directory : %s\n", path); + + if(S_ISDIR(stat_buf.st_mode)) { + + g_debug("Entering subdirectory...\n"); + ret = open_tracefiles(trace, path, tracefiles); + if(ret < 0) continue; + } else if(S_ISREG(stat_buf.st_mode)) { + g_debug("Opening file.\n"); + + GQuark name; + guint num; + GArray *group; + LttTracefile *tf; + guint len; + + if(get_tracefile_name_number(path, &name, &num)) + continue; /* invalid name */ + + group = g_datalist_id_get_data(&tracefiles, name); + if(group == NULL) { + /* Elements are automatically cleared when the array is allocated. + * It makes the cpu_online variable set to 0 : cpu offline, by default. + */ + group = g_array_sized_new (FALSE, TRUE, sizeof(LttTracefile), 10); + g_datalist_id_set_data_full(&tracefiles, name, + group, ltt_tracefile_group_destroy); + } + /* Add the per cpu tracefile to the named group */ + unsigned int old_len = group->len; + if(num+1 > old_len) + group = g_array_set_size(group, num+1); + tf = &g_array_index (group, LttTracefile, num); + + if(ltt_tracefile_open(trace, path, tf)) { + g_info("Error opening tracefile %s", path); + g_array_set_size(group, old_len); + + if(!ltt_tracefile_group_has_cpu_online(group)) + g_datalist_id_remove_data(&tracefiles, name); + + continue; /* error opening the tracefile : bad magic number ? */ + } + tf->cpu_online = 1; + tf->cpu_num = num; + } + } + + closedir(dir); + + return 0; } -void ltt_trace_close(LttTrace *t) +/* ltt_get_facility_description + * + * Opens the trace corresponding to the requested facility (identified by fac_id + * and checksum). + * + * The name searched is : %trace root%/eventdefs/facname_checksum.xml + * + * Returns 0 on success, or 1 on failure. + */ + +static int ltt_get_facility_description(LttFacility *f, + LttTrace *t, + LttTracefile *fac_tf) { - unsigned int i; - LttTracefile * tf; - LttFacility * f; + char desc_file_name[PATH_MAX]; + const gchar *text; + guint textlen; + gint err; + int i, j; + LttEventType *et; + + text = g_quark_to_string(t->pathname); + textlen = strlen(text); + + if(textlen >= PATH_MAX) goto name_error; + strcpy(desc_file_name, text); + + text = "/eventdefs/"; + textlen+=strlen(text); + if(textlen >= PATH_MAX) goto name_error; + strcat(desc_file_name, text); + + text = g_quark_to_string(f->name); + textlen+=strlen(text); + if(textlen >= PATH_MAX) goto name_error; + strcat(desc_file_name, text); + + text = "_"; + textlen+=strlen(text); + if(textlen >= PATH_MAX) goto name_error; + strcat(desc_file_name, text); - g_free(t->pathname); + err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1, + "%u", f->checksum); + if(err) goto name_error; + + textlen=strlen(desc_file_name); + + text = ".xml"; + textlen+=strlen(text); + if(textlen >= PATH_MAX) goto name_error; + strcat(desc_file_name, text); - //free system_description - g_free(t->system_description->description); - g_free(t->system_description->node_name); - g_free(t->system_description->domain_name); - g_free(t->system_description->kernel_name); - g_free(t->system_description->kernel_release); - g_free(t->system_description->kernel_version); - g_free(t->system_description->machine); - g_free(t->system_description->processor); - g_free(t->system_description->hardware_platform); - g_free(t->system_description->operating_system); - g_free(t->system_description); - - //free control_tracefiles - for(i=0;icontrol_tracefile_number;i++){ - tf = (LttTracefile*)g_ptr_array_index(t->control_tracefiles,i); - ltt_tracefile_close(tf); + err = ltt_facility_open(f, t, desc_file_name); + if(err) goto facility_error; + + for(i=0;ifacilities_by_num->len;i++){ + f = &g_array_index(t->facilities_by_num, LttFacility, i); + if(f->exists) { + for(j=0; jevents->len; j++){ + et = &g_array_index(f->events, LttEventType, j); + set_fields_offsets(fac_tf, et); + } + } } - g_ptr_array_free(t->control_tracefiles, TRUE); - //free per_cpu_tracefiles - for(i=0;iper_cpu_tracefile_number;i++){ - tf = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,i); - ltt_tracefile_close(tf); + + return 0; + +facility_error: +name_error: + return 1; +} + +static void ltt_fac_ids_destroy(gpointer data) +{ + GArray *fac_ids = (GArray *)data; + int i; + LttFacility *fac; + + for(i=0; ilen; i++) { + fac = &g_array_index (fac_ids, LttFacility, i); + ltt_facility_close(fac); } - g_ptr_array_free(t->per_cpu_tracefiles, TRUE); - //free facilities - for(i=0;ifacility_number;i++){ - f = (LttFacility*)g_ptr_array_index(t->facilities,i); - ltt_facility_close(f); + g_array_free(fac_ids, TRUE); +} + + +/* Presumes the tracefile is already seeked at the beginning. It makes sense, + * because it must be done just after the opening */ +static int ltt_process_facility_tracefile(LttTracefile *tf) +{ + int err; + LttFacility *fac; + GArray *fac_ids; + + while(1) { + err = ltt_tracefile_read_seek(tf); + if(err == EPERM) goto seek_error; + else if(err == ERANGE) break; /* End of tracefile */ + + err = ltt_tracefile_read_update_event(tf); + if(err) goto update_error; + + /* We are on a facility load/or facility unload/ or heartbeat event */ + /* The rules are : + * * facility 0 is hardcoded : this is the core facility. It will be shown + * in the facility array though, and is shown as "loaded builtin" in the + * trace. + * It contains event : + * 0 : facility load + * 1 : facility unload + * 2 : state dump facility load + * Facility 1 : (heartbeat) + * 0 : heartbeat + */ + if(tf->event.facility_id > 1) { /* Should only contain core and heartbeat + facilities */ + g_warning("Error in processing facility file %s, " + "should not contain facility id %u.", g_quark_to_string(tf->name), + tf->event.facility_id); + err = EPERM; + goto fac_id_error; + } else if(tf->event.facility_id == LTT_FACILITY_CORE) { + + struct LttFacilityLoad *fac_load_data; + char *fac_name; + + // FIXME align + switch((enum ltt_core_events)tf->event.event_id) { + case LTT_EVENT_FACILITY_LOAD: + fac_load_data = + (struct LttFacilityLoad *)tf->event.data; + fac_name = + (char*)(tf->event.data + sizeof(struct LttFacilityLoad)); + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, + ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id)); + g_assert(fac->exists == 0); + fac->name = g_quark_from_string(fac_name); + fac->checksum = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->checksum); + fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id); + fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->pointer_size); + fac->size_t_size = ltt_get_uin32(LTT_GET_BO(tf), + &fac_load_data->size_t_size); + fac->alignment = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->alignment); + + if(ltt_get_facility_description(fac, tf->trace, tf)) + goto facility_error; + + fac->trace = tf->trace; + fac->exists = 1; + + fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, fac->name); + if(fac_ids == NULL) { + fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1); + g_datalist_id_set_data_full(&tf->trace->facilities_by_name, + fac->name, + fac_ids, ltt_fac_ids_destroy); + } + g_array_append_val(fac_ids, fac->id); + + break; + case LTT_EVENT_FACILITY_UNLOAD: + /* We don't care about unload : facilities ID are valid for the whole + * trace. They simply won't be used after the unload. */ + break; + case LTT_EVENT_STATE_DUMP_FACILITY_LOAD: + fac_load_data = + (struct LttFacilityLoad *)tf->event.data; + fac_name = + (char*)(tf->event.data + sizeof(struct LttFacilityLoad)); + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, + ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id)); + g_assert(fac->exists == 0); + fac->name = g_quark_from_string(fac_name); + fac->checksum = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->checksum); + fac->id = ltt_get_uint8(LTT_GET_BO(tf), &fac_load_data->id); + fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->pointer_size); + fac->size_t_size = ltt_get_uin32(LTT_GET_BO(tf), + &fac_load_data->size_t_size); + fac->alignment = ltt_get_uint32(LTT_GET_BO(tf), + &fac_load_data->alignment); + if(ltt_get_facility_description(fac, tf->trace, tf)) + goto facility_error; + + fac->trace = tf->trace; + + fac->exists = 1; + + fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, + fac->name); + if(fac_ids == NULL) { + fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1); + g_datalist_id_set_data_full(&tf->trace->facilities_by_name, + fac->name, + fac_ids, ltt_fac_ids_destroy); + } + g_array_append_val(fac_ids, fac->id); + + break; + case LTT_EVENT_HEARTBEAT: + break; + default: + g_warning("Error in processing facility file %s, " + "unknown event id %hhu in core facility.", + g_quark_to_string(tf->name), + tf->event.event_id); + err = EPERM; + goto event_id_error; + } + } } - g_ptr_array_free(t->facilities, TRUE); + return 0; - g_free(t); - - g_blow_chunks(); + /* Error handling */ +facility_error: +event_id_error: +fac_id_error: +update_error: +seek_error: + return err; } -/***************************************************************************** - *Get the system description of the trace - ****************************************************************************/ +LttTrace *ltt_trace_open(const gchar *pathname) +{ + gchar abs_path[PATH_MAX]; + LttTrace * t; + LttTracefile *tf; + GArray *group; + int i; + + t = g_new(LttTrace, 1); + if(!t) goto alloc_error; + + get_absolute_pathname(pathname, abs_path); + t->pathname = g_quark_from_string(abs_path); + + /* Open all the tracefiles */ + g_datalist_init(&t->tracefiles); + if(open_tracefiles(t, abs_path, t->tracefiles)) + goto open_error; + + /* Prepare the facilities containers : array and mapping */ + /* Array is zeroed : the "exists" field is set to false by default */ + t->facilities_by_num = g_array_sized_new (FALSE, + TRUE, sizeof(LttFacility), + NUM_FACILITIES); + t->facilities_by_num = g_array_set_size(t->facilities_by_num, NUM_FACILITIES); + + g_datalist_init(&t->facilities_by_name); + + /* Parse each trace control/facilitiesN files : get runtime fac. info */ + group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES); + if(group == NULL) { + g_error("Trace %s has no facility tracefile", abs_path); + goto facilities_error; + } + + for(i=0; ilen; i++) { + tf = &g_array_index (group, LttTracefile, i); + if(ltt_process_facility_tracefile(tf)) + goto facilities_error; + } + + + + return t; + + /* Error handling */ +facilities_error: + g_datalist_clear(&t->facilities_by_name); + g_array_free(t->facilities_by_num, TRUE); +open_error: + g_datalist_clear(&t->tracefiles); + g_free(t); +alloc_error: + return NULL; + +} -LttSystemDescription *ltt_trace_system_description(LttTrace *t) +GQuark ltt_trace_name(LttTrace *t) { - return t->system_description; + return t->pathname; } -/***************************************************************************** - * The following functions discover the facilities of the trace - ****************************************************************************/ -unsigned ltt_trace_facility_number(LttTrace *t) +/****************************************************************************** + * 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 (unsigned)(t->facility_number); + return ltt_trace_open(g_quark_to_string(self->pathname)); } -LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i) +void ltt_trace_close(LttTrace *t) { - return (LttFacility*)g_ptr_array_index(t->facilities, i); + g_datalist_clear(&t->facilities_by_name); + g_array_free(t->facilities_by_num, TRUE); + g_datalist_clear(&t->tracefiles); + g_free(t); } + /***************************************************************************** - *Function name - * ltt_trace_facility_find : find facilities in the trace - *Input params - * t : the trace - * name : facility name - *Output params - * position : position of the facility in the trace - *Return value - * : the number of facilities + *Get the system description of the trace ****************************************************************************/ -unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) +LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id) { - unsigned int i, count=0; - LttFacility * f; - for(i=0;ifacility_number;i++){ - f = (LttFacility*)g_ptr_array_index(t->facilities, i); - if(strcmp(f->name,name)==0){ - count++; - if(count==1) *position = i; - }else{ - if(count) break; - } - } - return count; + g_assert(id < t->facilities_by_num->len); + return &g_array_index(t->facilities_by_num, LttFacility, id); +} + +/* ltt_trace_facility_get_by_name + * + * Returns the GArray of facility indexes. All the fac_ids that matches the + * requested facility name. + * + * If name is not found, returns NULL. + */ +GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name) +{ + return g_datalist_id_get_data(&t->facilities_by_name, name); } /***************************************************************************** * Functions to discover all the event types in the trace ****************************************************************************/ +#if 0 unsigned ltt_trace_eventtype_number(LttTrace *t) { unsigned int i; @@ -744,34 +1016,11 @@ unsigned ltt_trace_eventtype_number(LttTrace *t) } return count; } +#endif //0 -/* 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 = NULL; - unsigned int i; - 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++; - } - } - - return facility; -} - +#if 0 +//use an iteration on all the trace facilities, and inside iteration on all the +//event types in each facilities instead. LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) { LttEventType *event_type; @@ -784,113 +1033,85 @@ LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) return event_type; } +#endif //0 +#if 0 /***************************************************************************** - *There is one "per cpu" tracefile for each CPU, numbered from 0 to - *the maximum number of CPU in the system. When the number of CPU installed - *is less than the maximum, some positions are unused. There are also a - *number of "control" tracefiles (facilities, interrupts...). + * ltt_trace_find_tracefile + * + * Find a tracefile by name and index in the group. + * + * Returns a pointer to the tracefiles, else NULL. ****************************************************************************/ -unsigned ltt_trace_control_tracefile_number(LttTrace *t) -{ - return t->control_tracefile_number; -} -unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t) +LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name) { - return t->per_cpu_tracefile_number; } +#endif //0 /***************************************************************************** - *It is possible to search for the tracefiles by name or by CPU position. - *The index within the tracefiles of the same type is returned if found - *and a negative value otherwise. + * Get the start time and end time of the trace ****************************************************************************/ -int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name) +static void ltt_tracefile_time_span_get(LttTracefile *tf, + LttTime *start, LttTime *end) { - LttTracefile * tracefile; - 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; - } - if(i == t->control_tracefile_number) return -1; - return i; -} + struct ltt_block_start_header * header; + int err; -/* 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; - 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(i == t->per_cpu_tracefile_number) return -1; - return i; + err = map_block(tf, 0); + if(unlikely(err)) { + g_error("Can not map block"); + *start = ltt_time_infinite; + } else + *start = tf->buffer.begin.timestamp; + + err = map_block(tf, tf->num_blocks - 1); /* Last block */ + if(unlikely(err)) { + g_error("Can not map block"); + *end = ltt_time_zero; + } else + *end = tf->buffer.end.timestamp; } -/***************************************************************************** - *Get a specific tracefile - ****************************************************************************/ - -LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i) -{ - return (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i); -} +struct tracefile_time_span_get_args { + LttTrace *t; + LttTime *start; + LttTime *end; +}; -LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i) +static void group_time_span_get(GQuark name, gpointer data, gpointer user_data) { - return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i); + struct tracefile_time_span_get_args *args = + (struct tracefile_time_span_get_args*)user_data; + + GArray *group = (GArray *)data; + int i; + LttTracefile *tf; + LttTime tmp_start; + LttTime tmp_end; + + for(i=0; ilen; i++) { + tf = &g_array_index (group, LttTracefile, i); + if(tf->cpu_online) { + ltt_tracefile_time_span_get(tf, &tmp_start, &tmp_end); + if(ltt_time_compare(*args->start, tmp_start)>0) *args->start = tmp_start; + if(ltt_time_compare(*args->end, tmp_end)<0) *args->end = tmp_end; + } + } } -/***************************************************************************** - * Get the start time and end time of the trace - ****************************************************************************/ - void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) { - LttTime startSmall, startTmp, endBig, endTmp; - unsigned int i, j=0; - LttTracefile * tf; - - for(i=0;icontrol_tracefile_number;i++){ - tf = g_ptr_array_index(t->control_tracefiles, i); - readBlock(tf,1); - startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time); - readBlock(tf,tf->block_number); - endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time); - if(i==0){ - startSmall = startTmp; - endBig = endTmp; - j = 1; - continue; - } - 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++){ - tf = g_ptr_array_index(t->per_cpu_tracefiles, i); - readBlock(tf,1); - startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time); - readBlock(tf,tf->block_number); - endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time); - if(j == 0 && i==0){ - startSmall = startTmp; - endBig = endTmp; - continue; - } - if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp; - if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; - } + LttTime min_start = ltt_time_infinite; + LttTime max_end = ltt_time_zero; + struct tracefile_time_span_get_args args = { t, &min_start, &max_end }; - if(start != NULL) *start = startSmall; - if(end != NULL) *end = endBig; + g_datalist_foreach(&t->tracefiles, &group_time_span_get, &args); + + if(start != NULL) *start = min_start; + if(end != NULL) *end = max_end; + } @@ -898,7 +1119,7 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) *Get the name of a tracefile ****************************************************************************/ -char *ltt_tracefile_name(LttTracefile *tf) +GQuark ltt_tracefile_name(LttTracefile *tf) { return tf->name; } @@ -907,309 +1128,331 @@ char *ltt_tracefile_name(LttTracefile *tf) * Get the number of blocks in the tracefile ****************************************************************************/ -unsigned ltt_tracefile_block_number(LttTracefile *tf) +guint ltt_tracefile_block_number(LttTracefile *tf) { - return tf->block_number; + return tf->num_blocks; } -/***************************************************************************** - *Function name - * ltt_tracefile_seek_time: seek to the first event of the trace with time - * larger or equal to time - *Input params - * 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(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), time); - if(tailTime >= 0) return; - - err=readBlock(t,end_block); - if(err) g_error("Can not read tracefile: %s\n", t->name); - if(start_block+1 == end_block)return; - - headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_start->time), time); - if(headTime <= 0 ) return; - - tmp_block = (end_block + start_block)/2; - err=readBlock(t,tmp_block); - if(err) g_error("Can not read tracefile: %s\n", t->name); - - headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_start->time), time); - tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), time); - if(headTime <= 0 && tailTime >= 0) return; - - if(headTime > 0){ - s = start_block + 1; - e = tmp_block - 1; - if(s <= e) - ltt_tracefile_find_time_block(t, time, s, e); - else return; +/* Seek to the first event in a tracefile that has a time equal or greater than + * the time passed in parameter. + * + * If the time parameter is outside the tracefile time span, seek to the first + * or the last event of the tracefile. + * + * If the time parameter is before the first event, we have to seek specially to + * there. + * + * If the time is after the end of the trace, get the last event. + * + * Do a binary search to find the right block, then a sequential search in the + * block to find the event. + * + * In the special case where the time requested fits inside a block that has no + * event corresponding to the requested time, the first event of the next block + * will be seeked. + * + * IMPORTANT NOTE : // FIXME everywhere... + * + * You MUST NOT do a ltt_tracefile_read right after a ltt_tracefile_seek_time : + * you will jump over an event if you do. + * + * Return value : 0 : no error, the tf->event can be used + * otherwise : this is an error. + * + * */ + +int ltt_tracefile_seek_time(LttTracefile *tf, LttTime time) +{ + int ret = 0; + int err; + unsigned int block_num, high, low; + + /* seek at the beginning of trace */ + err = map_block(tf, 0); /* First block */ + if(unlikely(err)) { + g_error("Can not map block"); + goto fail; } - 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; - } -} + /* If the time is lower or equal the beginning of the trace, + * go to the first event. */ + if(ltt_time_compare(time, tf->buffer.begin.timestamp) <= 0) { + ret = ltt_tracefile_read(tf); + goto found; /* There is either no event in the trace or the event points + to the first event in the trace */ + } -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(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_start->time), time); - t_time = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), time); - if(h_time == 0){ - int tmp; - if(t->which_block == 1) return; - err=readBlock(t,t->which_block-1); - if(err) g_error("Can not read tracefile: %s\n", t->name); - tmp = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), time); - if(tmp == 0) return ltt_tracefile_seek_time(t, time); - err=readBlock(t,t->which_block+1); - if(err) g_error("Can not read tracefile: %s\n", t->name); - }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); + err = map_block(tf, tf->num_blocks - 1); /* Last block */ + if(unlikely(err)) { + g_error("Can not map block"); + goto fail; } -} -void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) -{ - int err; - LttTime lttTime; - int headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_start->time), time); - int tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), time); - LttEvent ev; + /* If the time is after the end of the trace, get the last event. */ + if(ltt_time_compare(time, tf->buffer.end.timestamp) >= 0) { + /* While the ltt_tracefile_read doesn't return ERANGE or EPERM, + * continue reading. + */ + while(1) { + ret = ltt_tracefile_read(tf); + if(ret == ERANGE) goto found; /* ERANGE or EPERM */ + else if(ret) goto fail; + } + } - if(headTime < 0 && tailTime > 0){ - if(ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, - &t->a_block_end->time), - t->current_event_time) !=0) { - lttTime = getEventTime(t); - err = ltt_time_compare(lttTime, time); - if(err > 0){ - 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); - } - }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); + /* Binary search the block */ + high = tf->num_blocks - 1; + low = 0; + + while(1) { + block_num = ((high-low) / 2) + low; + + err = map_block(tf, block_num); + if(unlikely(err)) { + g_error("Can not map block"); + goto fail; } - }else if(headTime >= 0){ - if(t->which_block == 1){ - updateTracefile(t); - }else{ - 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); + if(high == low) { + /* We cannot divide anymore : this is what would happen if the time + * requested was exactly between two consecutive buffers'end and start + * timestamps. This is also what would happend if we didn't deal with out + * of span cases prior in this function. */ + /* The event is right in the buffer! + * (or in the next buffer first event) */ + while(1) { + ret = ltt_tracefile_read(tf); + if(ret == ERANGE) goto found; /* ERANGE or EPERM */ + else if(ret) goto fail; + + if(ltt_time_compare(time, tf->event.event_time) >= 0) + break; + } + + } if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) { + /* go to lower part */ + high = block_num; + } else if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) { + /* go to higher part */ + low = block_num; + } else {/* The event is right in the buffer! + (or in the next buffer first event) */ + while(1) { + ltt_tracefile_read(tf); + if(ret == ERANGE) goto found; /* ERANGE or EPERM */ + else if(ret) goto fail; + + if(ltt_time_compare(time, tf->event.event_time) >= 0) + break; } + goto found; } - }else if(tailTime < 0){ - if(t->which_block != t->block_number){ - ltt_tracefile_find_time_block(t, time, t->which_block+1, t->block_number); - return ltt_tracefile_seek_time(t, time); - }else { - t->cur_event_pos = t->buffer + t->block_size; - g_print("End of file\n"); - return; - } - }else if(tailTime == 0){ - 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; - t->prev_event_time.tv_nsec = 0; - return; } + +found: + return 0; + + /* Error handling */ +fail: + g_error("ltt_tracefile_seek_time failed on tracefile %s", + g_quark_to_string(tf->name)); + return EPERM; } -/***************************************************************************** - * 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, const LttEventPosition *ep) -{ - //if we are at the right place, just return - if(likely(t->which_block == ep->block_num && t->which_event == ep->event_num)) - return; +int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) { - 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; - - 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; - 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(unlikely(err == ERANGE)) g_error("event id is out of range\n"); - - return; + int err; + + if(ep->tracefile != tf) { + goto fail; } - //only block number and event index are available - //MD: warning : this is slow! - g_warning("using slow O(n) tracefile seek position"); + err = map_block(tf, ep->block); + if(unlikely(err)) { + g_error("Can not map block"); + goto fail; + } + + tf->event.offset = ep->offset; - LttEvent event; - while(likely(t->which_event < ep->event_num)) ltt_tracefile_read(t, &event); + err = ltt_tracefile_read_update_event(tf); + if(err) goto fail; + err = ltt_tracefile_read_op(tf); + if(err) goto fail; return; + +fail: + g_error("ltt_tracefile_seek_time failed on tracefile %s", + g_quark_to_string(tf->name)); +} + +/* Calculate the real event time based on the buffer boundaries */ +LttTime ltt_interpolate_time(LttTracefile *tf, LttEvent *event) +{ + LttTime time; + + g_assert(tf->trace->has_tsc); + + time = ltt_time_from_uint64( + (guint64)tf->buffer.tsc*tf->buffer.nsecs_per_cycle); + time = ltt_time_add(tf->buffer.begin.timestamp, time); + + return time; } /***************************************************************************** *Function name - * ltt_tracefile_read : read the current event, set the pointer to the next + * ltt_tracefile_read : Read the next event in the tracefile *Input params * t : tracefile *Return value - * LttEvent * : an event to be processed + * + * Returns 0 if an event can be used in tf->event. + * Returns ERANGE on end of trace. The event in tf->event still can be used. + * Returns EPERM on error. + * + * This function does make the tracefile event structure point to the event + * currently pointed to by the tf->event. + * + * Note : you must call a ltt_tracefile_seek to the beginning of the trace to + * reinitialize it after an error if you want results to be coherent. + * It would be the case if a end of trace last buffer has no event : the end + * of trace wouldn't be returned, but an error. + * We make the assumption there is at least one event per buffer. ****************************************************************************/ -LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) +int ltt_tracefile_read(LttTracefile *tf) { int err; - if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){ - if(unlikely(t->which_block == t->block_number)){ - return NULL; + err = ltt_tracefile_read_seek(tf); + if(err) return err; + err = ltt_tracefile_read_update_event(tf); + if(err) return err; + err = ltt_tracefile_read_op(tf); + if(err) return err; + + return 0; +} + +int ltt_tracefile_read_seek(LttTracefile *tf) +{ + int err; + + /* Get next buffer until we finally have an event, or end of trace */ + while(1) { + err = ltt_seek_next_event(tf); + if(unlikely(err == ENOPROTOOPT)) { + return EPERM; } - err = readBlock(t, t->which_block + 1); - if(unlikely(err))g_error("Can not read tracefile"); - } - event->event_id = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos); - if(unlikely(event->event_id == TRACE_TIME_HEARTBEAT)) - t->cur_heart_beat_number++; - - t->prev_event_time = t->current_event_time; - // t->current_event_time = getEventTime(t); - - event->time_delta = ltt_get_uint32(t->trace->reverse_byte_order, t->cur_event_pos + EVENT_ID_SIZE); - event->event_time = t->current_event_time; - event->event_cycle_count = t->cur_cycle_count; - - event->tracefile = t; - event->data = t->cur_event_pos + EVENT_HEADER_SIZE; - event->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; - event->overflow_nsec = t->overflow_nsec; - event->last_heartbeat = t->last_heartbeat; + /* Are we at the end of the buffer ? */ + if(err == ERANGE) { + if(unlikely(tf->buffer.index == tf->num_blocks-1)){ /* end of trace ? */ + return ERANGE; + } else { + /* get next block */ + err = map_block(tf, tf->buffer.index + 1); + if(unlikely(err)) { + g_error("Can not map block"); + return EPERM; + } + } + } else break; /* We found an event ! */ + } - /* end of workaround */ + return 0; +} +/* do specific operation on events */ +int ltt_tracefile_read_op(LttTracefile *tf) +{ + int err; + LttFacility *f; + void * pos; + LttEvent *event; + + event = &tf->event; - //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"); + /* do event specific operation */ - return event; + /* do something if its an heartbeat event : increment the heartbeat count */ + //if(event->facility_id == LTT_FACILITY_CORE) + // if(event->event_id == LTT_EVENT_HEARTBEAT) + // tf->cur_heart_beat_number++; + + return 0; } -/**************************************************************************** - *Function name - * readFile : wrap function to read from a file - *Input Params - * fd : file descriptor - * buf : buf to contain the content - * size : number of bytes to be read - * mesg : message to be printed if some thing goes wrong - *return value - * 0 : success - * EIO : can not read from the file - ****************************************************************************/ -int readFile(int fd, void * buf, size_t size, char * mesg) +/* same as ltt_tracefile_read, but does not seek to the next event nor call + * event specific operation. */ +int ltt_tracefile_read_update_event(LttTracefile *tf) { - 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; + int err; + LttFacility *f; + void * pos; + LttEvent *event; + + event = &tf->event; + pos = event->offset; + + /* Read event header */ + + //TODO align + + if(tf->trace->has_tsc) { + event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf), + pos); + /* 32 bits -> 64 bits tsc */ + /* note : still works for seek and non seek cases. */ + if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) { + tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL) + + 0x100000000ULL) + | (guint64)event->time.timestamp; + event->tsc = tf->buffer.tsc; + } else { + /* no overflow */ + tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL) + | (guint64)event->time.timestamp; + event->tsc = tf->buffer.tsc; + } + + event->event_time = ltt_interpolate_time(tf, event); + + pos += sizeof(guint32); + } else { + event->time.delta.tv_sec = 0; + event->time.delta.tv_nsec = ltt_get_uint32(LTT_GET_BO(tf), + pos) * NSEC_PER_USEC; + tf->buffer.tsc = 0; + event->tsc = tf->buffer.tsc; + + event->event_time = ltt_time_add(tf->buffer.begin.timestamp, + event->time.delta); + pos += sizeof(guint32); + } + + event->facility_id = ltt_get_uint8(LTT_GET_BO(tf), + pos); + pos += sizeof(guint8); + + event->event_id = ltt_get_uint8(LTT_GET_BO(tf), + pos); + pos += sizeof(guint8); + + event->data = pos; + + return 0; } /**************************************************************************** *Function name - * readBlock : read a block from the file + * map_block : map a block from the file *Input Params * lttdes : ltt trace file * whichBlock : the block which will be read @@ -1219,151 +1462,170 @@ int readFile(int fd, void * buf, size_t size, char * mesg) * EIO : can not read from the file ****************************************************************************/ -int readBlock(LttTracefile * tf, int whichBlock) +static gint map_block(LttTracefile * tf, guint block_num) { - off_t nbBytes; - guint32 lostSize; + struct ltt_block_start_header *header; + + g_assert(block_num < tf->num_blocks); - /* same block already opened requested */ - if((guint)whichBlock == tf->which_block) return 0; + if(tf->buffer.head != NULL) + munmap(tf->buffer.head, tf->buf_size); - if(likely(whichBlock - tf->which_block == 1 && tf->which_block != 0)){ - tf->prev_block_end_time = ltt_get_time(tf->trace->reverse_byte_order, - &tf->a_block_end->time); - tf->prev_event_time = ltt_get_time(tf->trace->reverse_byte_order, - &tf->a_block_end->time); - }else{ - tf->prev_block_end_time.tv_sec = 0; - tf->prev_block_end_time.tv_nsec = 0; - tf->prev_event_time.tv_sec = 0; - tf->prev_event_time.tv_nsec = 0; + /* Multiple of pages aligned head */ + tf->buffer.head = mmap(0, tf->block_size, PROT_READ, tf->fd, MAP_PRIVATE, + (off_t)tf->block_size * (off_t)block_num); + + if(tf->buffer.head == NULL) { + perror("Error in allocating memory for buffer of tracefile"); + goto map_error; } + g_assert(((guint)tf->buffer.head) & (8-1) == 0); // make sure it's aligned. + - nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET); - if(unlikely(nbBytes == -1)) return EINVAL; + tf->buffer.index = block_num; + + header = (struct ltt_block_start_header*)tf->buffer.head; + + tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf), + &header->begin.timestamp); + tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC; + tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf), + &header->begin.cycle_count); + tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf), + &header->end.timestamp); + tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC; + tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf), + &header->end.cycle_count); + tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf), + &header->lost_size); - 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 - - 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; + tf->buffer.tsc = tf->buffer.begin.cycle_count; + tf->event.tsc = tf->buffer.tsc; + + /* FIXME + * eventually support variable buffer size : will need a partial pre-read of + * the headers to create an index when we open the trace... eventually. */ + g_assert(tf->block_size == ltt_get_uint32(LTT_GET_BO(tf), + &header->buf_size)); - /* 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->trace->reverse_byte_order, tf->cur_event_pos + EVENT_ID_SIZE); - - getCyclePerNsec(tf); - - tf->overflow_nsec = - (-((double) - (ltt_get_uint64(tf->trace->reverse_byte_order, - &tf->a_block_start->cycle_count)&0xFFFFFFFF)) - * tf->nsec_per_cycle); + /* Now that the buffer is mapped, calculate the time interpolation for the + * block. */ + + tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf); + + /* Make the current event point to the beginning of the buffer : + * it means that the event read must get the first event. */ + tf->event.tracefile = tf; + tf->event.block = block_num; + tf->event.offset = tf->buffer.head; + + return 0; - tf->current_event_time = getEventTime(tf); +map_error: + return -errno; - return 0; } -/***************************************************************************** - *Function name - * updateTracefile : reinitialize the info of the block which is already - * in the buffer - *Input params - * tf : tracefile - ****************************************************************************/ - -void updateTracefile(LttTracefile * tf) +ssize_t ltt_get_event_size(LttTracefile *tf) { - tf->which_event = 1; - tf->cur_event_pos = tf->buffer; - tf->current_event_time = getEventTime(tf); - tf->cur_heart_beat_number = 0; + ssize_t size = 0; + + /* Specific handling of core events : necessary to read the facility control + * tracefile. */ + if(unlikely(tf->event.facility_id == LTT_FACILITY_CORE)) { + switch((enum ltt_core_events)tf->event.event_id) { + case LTT_EVENT_FACILITY_LOAD: + size = sizeof(struct LttFacilityLoad); + break; + case LTT_EVENT_FACILITY_UNLOAD: + size = sizeof(struct LttFacilityUnload); + break; + case LTT_EVENT_STATE_DUMP_FACILITY_LOAD: + size = sizeof(struct LttStateDumpFacilityLoad); + break; + case LTT_EVENT_HEARTBEAT: + size = sizeof(TimeHeartbeat); + break; + default: + g_warning("Error in getting event size : tracefile %s, " + "unknown event id %hhu in core facility.", + g_quark_to_string(tf->name), + tf->event.event_id); + goto event_id_error; - tf->prev_event_time.tv_sec = 0; - tf->prev_event_time.tv_nsec = 0; - tf->count = 0; + } - tf->overflow_nsec = - (-((double)ltt_get_uint64(tf->trace->reverse_byte_order, - &tf->a_block_start->cycle_count)) - * tf->nsec_per_cycle); + } else { + LttFacility *f = ltt_trace_get_facility_by_num(tf->trace, + tf->event.facility_id); + LttEventType *event_type = + ltt_facility_eventtype_get(f, tf->event.event_id); + size = get_fields_offsets(tf, event_type, tf->event.data); + } + return size; + +event_id_error: + return -1; } -/***************************************************************************** - *Function name - * skipEvent : go to the next event, update the fields of the current event - *Input params - * t : tracefile - *return value - * 0 : success - * ERANGE : event id is out of range - ****************************************************************************/ -int skipEvent(LttTracefile * t) +/* Take the tf current event offset and use the event facility id and event id + * to figure out where is the next event offset. + * + * This is an internal function not aiming at being used elsewhere : it will + * not jump over the current block limits. Please consider using + * ltt_tracefile_read to do this. + * + * Returns 0 on success + * ERANGE if we are at the end of the buffer. + * ENOPROTOOPT if an error occured when getting the current event size. + */ +static int ltt_seek_next_event(LttTracefile *tf) { - int evId; - void * evData; - LttEventType * evT; - LttField * rootFld; - - evId = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos); - evData = t->cur_event_pos + EVENT_HEADER_SIZE; + int ret = 0; + void *pos; + ssize_t event_size; + + /* seek over the buffer header if we are at the buffer start */ + if(tf->event.offset == tf->buffer.head) { + tf->event.offset += sizeof(struct ltt_block_start_header); + goto found; + } - 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)){ - t->cur_event_pos = t->buffer + t->block_size; - }else{ - t->cur_cycle_count = ltt_get_uint32(t->trace->reverse_byte_order, - t->cur_event_pos + EVENT_ID_SIZE); - t->which_event++; - t->current_event_time = getEventTime(t); + if(tf->event.offset == tf->buffer.head + tf->buffer.lost_size) { + ret = ERANGE; + goto found; } - return 0; + pos = tf->event.data; + + event_size = ltt_get_event_size(tf); + if(event_size < 0) goto error; + + pos += (size_t)event_size; + + tf->event.offset = pos; + +found: + return ret; + +error: + g_error("Error in ltt_seek_next_event for tracefile %s", + g_quark_to_string(tf->name)); + return ENOPROTOOPT; } /***************************************************************************** *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. + * calc_nsecs_per_cycle : calculate nsecs per cycle for current block *Input Params * t : tracefile ****************************************************************************/ -void getCyclePerNsec(LttTracefile * t) +static double calc_nsecs_per_cycle(LttTracefile * tf) { LttTime lBufTotalTime; /* Total time for this buffer */ double lBufTotalNSec; /* Total time for this buffer in nsecs */ @@ -1371,118 +1633,341 @@ void getCyclePerNsec(LttTracefile * t) /* Calculate the total time for this buffer */ lBufTotalTime = ltt_time_sub( - ltt_get_time(t->trace->reverse_byte_order, &t->a_block_end->time), - ltt_get_time(t->trace->reverse_byte_order, &t->a_block_start->time)); + ltt_get_time(LTT_GET_BO(tf), &tf->buffer.end.timestamp), + ltt_get_time(LTT_GET_BO(tf), &tf->buffer.begin.timestamp)); /* Calculate the total cycles for this bufffer */ - lBufTotalCycle = ltt_get_uint64(t->trace->reverse_byte_order, - &t->a_block_end->cycle_count); - lBufTotalCycle -= ltt_get_uint64(t->trace->reverse_byte_order, - &t->a_block_start->cycle_count); + lBufTotalCycle = ltt_get_uint64(LTT_GET_BO(tf), &tf->buffer.end.cycle_count); + lBufTotalCycle -= ltt_get_uint64(LTT_GET_BO(tf), + &tf->buffer.begin.cycle_count); /* Convert the total time to double */ lBufTotalNSec = ltt_time_to_double(lBufTotalTime); - t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle; + return lBufTotalNSec / (double)lBufTotalCycle; - /* Pre-multiply one overflow (2^32 cycles) by nsec_per_cycle */ - t->one_overflow_nsec = t->nsec_per_cycle * (double)0x100000000ULL; +} +#if 0 +void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD) +{ + LttField * rootFld = evT->root_field; + // rootFld->base_address = evD; + if(likely(rootFld)) + rootFld->field_size = getFieldtypeSize(tf, evT->facility, + evT, 0,0,rootFld, evD); } +#endif //0 -/**************************************************************************** +/***************************************************************************** *Function name - * getEventTime : obtain the time of an event - * NOTE : this function _really_ is on critical path. + * set_fields_offsets : set the precomputable offset of the fields *Input params - * tf : tracefile - *Return value - * LttTime : the time of the event + * tracefile : opened trace file + * event_type : the event type ****************************************************************************/ -static inline LttTime getEventTime(LttTracefile * tf) +void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) { - LttTime time; - LttCycleCount cycle_count; // cycle count for the current 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 = ltt_get_uint16(tf->trace->reverse_byte_order, - tf->cur_event_pos); - - cycle_count = ltt_get_uint32(tf->trace->reverse_byte_order, - tf->cur_event_pos + EVENT_ID_SIZE); + LttField *field = event_type->root_field; + enum field_status fixed_root = FIELD_FIXED, fixed_parent = FIELD_FIXED; + + if(likely(field)) + preset_field_type_size(tf, event_type, 0, 0, + &fixed_root, &fixed_parent, + field); + +} - gboolean comp_count = cycle_count < tf->pre_cycle_count; - tf->pre_cycle_count = cycle_count; +/***************************************************************************** + *Function name + * preset_field_type_size : set the fixed sizes of the field type + *Input params + * tf : tracefile + * event_type : event type + * offset_root : offset from the root + * offset_parent : offset from the parent + * fixed_root : Do we know a fixed offset to the root ? + * fixed_parent : Do we know a fixed offset to the parent ? + * field : field + ****************************************************************************/ +void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, + off_t offset_root, off_t offset_parent, + enum field_status *fixed_root, enum field_status *fixed_parent, + LttField *field) +{ + enum field_status local_fixed_root, local_fixed_parent; + guint i; + LttType *type; - if(unlikely(comp_count)) { - /* Overflow */ - tf->overflow_nsec += tf->one_overflow_nsec; - tf->count++; //increment overflow count - } + g_assert(field->fixed_root == FIELD_UNKNOWN); + g_assert(field->fixed_parent == FIELD_UNKNOWN); + g_assert(field->fixed_size == FIELD_UNKNOWN); - if(unlikely(evId == TRACE_BLOCK_START)) { - lEventNSec = 0; - } else if(unlikely(evId == TRACE_BLOCK_END)) { - lEventNSec = ((double) - (ltt_get_uint64(tf->trace->reverse_byte_order, - &tf->a_block_end->cycle_count) - - ltt_get_uint64(tf->trace->reverse_byte_order, - &tf->a_block_start->cycle_count)) - * tf->nsec_per_cycle); - } -#if 0 - /* 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; + type = field->field_type; + + field->fixed_root = *fixed_root; + if(field->fixed_root == FIELD_FIXED) + field->offset_root = offset_root; + else + field->offset_root = 0; + + field->fixed_parent = *fixed_parent; + if(field->fixed_parent == FIELD_FIXED) + field->offset_parent = offset_parent; + else + field->offset_parent = 0; + + size_t current_root_offset; + size_t current_offset; + enum field_status current_child_status, final_child_status; + size_t max_size; + + switch(type->type_class) { + case LTT_INT: + case LTT_UINT: + case LTT_FLOAT: + case LTT_ENUM: + field->field_size = ltt_type_size(tf->trace, type); + field->fixed_size = FIELD_FIXED; + break; + case LTT_POINTER: + field->field_size = (off_t)event_type->facility->pointer_size; + field->fixed_size = FIELD_FIXED; + break; + case LTT_LONG: + case LTT_ULONG: + field->field_size = (off_t)event_type->facility->pointer_size; + field->fixed_size = FIELD_FIXED; + break; + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + field->field_size = (off_t)event_type->facility->size_t_size; + field->fixed_size = FIELD_FIXED; + break; + case LTT_SEQUENCE: + local_fixed_root = FIELD_VARIABLE; + local_fixed_parent = FIELD_VARIABLE; + preset_field_type_size(tf, event_type, + 0, 0, + &local_fixed_root, &local_fixed_parent, + field->child[0]); + field->fixed_size = FIELD_VARIABLE; + field->field_size = 0; + break; + case LTT_STRING: + field->fixed_size = FIELD_VARIABLE; + field->field_size = 0; + break; + case LTT_ARRAY: + local_fixed_root = FIELD_VARIABLE; + local_fixed_parent = FIELD_VARIABLE; + preset_field_type_size(tf, event_type, + 0, 0, + &local_fixed_root, &local_fixed_parent, + field->child[0]); + field->fixed_size = field->child[0]->fixed_size; + if(field->fixed_size == FIELD_FIXED) + field->field_size = type->element_number * field->child[0]->field_size; + else + field->field_size = 0; + break; + case LTT_STRUCT: + current_root_offset = field->offset_root; + current_offset = 0; + current_child_status = FIELD_FIXED; + for(i=0;ielement_number;i++) { + preset_field_type_size(tf, event_type, + current_root_offset, current_offset, + fixed_root, ¤t_child_status, + field->child[i]); + if(current_child_status == FIELD_FIXED) { + current_root_offset += field->child[i]->field_size; + current_offset += field->child[i]->field_size; + } else { + current_root_offset = 0; + current_offset = 0; + } + } + if(current_child_status != FIELD_FIXED) { + *fixed_parent = current_child_status; + field->field_size = 0; + field->fixed_size = current_child_status; + } else { + field->field_size = current_offset; + field->fixed_size = FIELD_FIXED; + } + break; + case LTT_UNION: + current_root_offset = field->offset_root; + current_offset = 0; + max_size = 0; + final_child_status = FIELD_FIXED; + for(i=0;ielement_number;i++) { + enum field_status current_root_child_status = FIELD_FIXED; + enum field_status current_child_status = FIELD_FIXED; + preset_field_type_size(tf, event_type, + current_root_offset, current_offset, + ¤t_root_child_status, ¤t_child_status, + field->child[i]); + if(current_child_status != FIELD_FIXED) + final_child_status = current_child_status; + else + max_size = max(max_size, field->child[i]->field_size); + } + if(final_child_status != FIELD_FIXED) { + *fixed_root = final_child_status; + *fixed_parent = final_child_status; + field->field_size = 0; + field->fixed_size = current_child_status; + } else { + field->field_size = max_size; + field->fixed_size = FIELD_FIXED; + } + break; } - lTimeOffset = ltt_time_from_uint64(lEventNSec); - - time = ltt_time_add(ltt_get_time(tf->trace->reverse_byte_order, - &tf->a_block_start->time), lTimeOffset); - - return time; } + /***************************************************************************** *Function name - * setFieldsOffset : set offset of the fields + * get_field_type_size : set the fixed and dynamic sizes of the field type + * from the data read. *Input params - * tracefile : opened trace file - * evT : the event type - * evD : event data, it may be NULL + * tf : tracefile + * event_type : event type + * offset_root : offset from the root + * offset_parent : offset from the parent + * field : field + * data : a pointer to the event data. + *Returns the field type size. ****************************************************************************/ - -void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t) +size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type, + off_t offset_root, off_t offset_parent, + LttField *field, void *data) { - LttField * rootFld = evT->root_field; - // rootFld->base_address = evD; + size_t size = 0; + guint i; + LttType *type; + + g_assert(field->fixed_root != FIELD_UNKNOWN); + g_assert(field->fixed_parent != FIELD_UNKNOWN); + g_assert(field->fixed_size != FIELD_UNKNOWN); - if(likely(rootFld)) - rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t); + field->offset_root = offset_root; + field->offset_parent = offset_parent; + + type = field->field_type; + + switch(type->type_class) { + case LTT_INT: + case LTT_UINT: + case LTT_FLOAT: + case LTT_ENUM: + case LTT_POINTER: + case LTT_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + g_assert(field->fixed_size == FIELD_FIXED); + size = field->field_size; + break; + case LTT_SEQUENCE: + { + gint seqnum = ltt_get_uint(LTT_GET_BO(tf), + field->sequ_number_size, + data + offset_root); + + if(field->child[0]->fixed_size == FIELD_FIXED) { + size = field->sequ_number_size + + (seqnum * get_field_type_size(tf, event_type, + offset_root, offset_parent, + field->child[0], data)); + } else { + size += field->sequ_number_size; + for(i=0;ichild[0], data); + offset_root += child_size; + offset_parent += child_size; + size += child_size; + } + } + field->field_size = size; + } + break; + case LTT_STRING: + size = strlen((char*)(data+offset_root)) + 1;// length + \0 + field->field_size = size; + break; + case LTT_ARRAY: + if(field->fixed_size == FIELD_FIXED) + size = field->field_size; + else { + for(i=0;ifield_type->element_number;i++) { + size_t child_size; + child_size = get_field_type_size(tf, event_type, + offset_root, offset_parent, + field->child[0], data); + offset_root += child_size; + offset_parent += child_size; + size += child_size; + } + field->field_size = size; + } + break; + case LTT_STRUCT: + if(field->fixed_size == FIELD_FIXED) + size = field->field_size; + else { + size_t current_root_offset = offset_root; + size_t current_offset = 0; + size_t child_size = 0; + for(i=0;ielement_number;i++) { + child_size = get_field_type_size(tf, + event_type, current_root_offset, current_offset, + field->child[i], data); + current_offset += child_size; + current_root_offset += child_size; + + } + size = current_offset; + field->field_size = size; + } + break; + case LTT_UNION: + if(field->fixed_size == FIELD_FIXED) + size = field->field_size; + else { + size_t current_root_offset = field->offset_root; + size_t current_offset = 0; + for(i=0;ielement_number;i++) { + size = get_field_type_size(tf, event_type, + current_root_offset, current_offset, + field->child[i], data); + size = max(size, field->child[i]->field_size); + } + field->field_size = size; + } + break; + } + + return size; } + + +#if 0 /***************************************************************************** *Function name * getFieldtypeSize: get the size of the field type (primitive type) *Input params - * tracefile : opened trace file * evT : event type * offsetRoot : offset from the root * offsetParent : offset from the parrent @@ -1492,151 +1977,146 @@ void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t) * int : size of the field ****************************************************************************/ -static inline gint getFieldtypeSize(LttTracefile * t, +static inline gint getFieldtypeSize(LttTracefile *tf, LttEventType * evT, gint offsetRoot, - gint offsetParent, LttField * fld, void *evD, LttTrace *trace) + gint offsetParent, LttField * fld, void *evD) { gint size, size1, element_number, i, offset1, offset2; LttType * type = fld->field_type; - 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; - } + /* This likely has been tested with gcov : half of them.. */ + if(unlikely(fld->field_fixed == 1)){ + /* tested : none */ + if(unlikely(fld == evT->root_field)) { + size = fld->field_size; + goto end_getFieldtypeSize; } + } - /* From gcov profiling : half string, half struct, can we gain something - * from that ? (Mathieu) */ - switch(type->type_class) { - case LTT_ARRAY: - element_number = (int) type->element_number; - if(fld->field_fixed == -1){ - size = getFieldtypeSize(t, evT, offsetRoot, - 0,fld->child[0], NULL, trace); - if(size == 0){ //has string or sequence - fld->field_fixed = 0; - }else{ - fld->field_fixed = 1; - size *= element_number; - } - }else if(fld->field_fixed == 0){// has string or sequence - size = 0; - for(i=0;ichild[0], evD+size, trace); - } - }else size = fld->field_size; - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } - - break; - - case LTT_SEQUENCE: - size1 = (int) ltt_type_size(trace, type); - if(fld->field_fixed == -1){ - fld->sequ_number_size = size1; + /* 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(tf, evT, offsetRoot, + 0,fld->child[0], NULL); + if(size == 0){ //has string or sequence 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->trace->reverse_byte_order,size1,evD); - type->element_number = element_number; - if(fld->element_size > 0){ - size = element_number * fld->element_size; - }else{//sequence has string or sequence - size = 0; - for(i=0;ichild[0], evD+size+size1, trace); - } - } - size += size1; - } - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; + }else{ + fld->field_fixed = 1; + size *= element_number; } - - break; - - case LTT_STRING: + }else if(fld->field_fixed == 0){// has string or sequence 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' + for(i=0;ichild[0], evD+size); } + }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_STRUCT: - element_number = (int) type->element_number; - size = 0; - /* tested with gcov */ - if(unlikely(fld->field_fixed == -1)){ - offset1 = offsetRoot; - offset2 = 0; + break; + + case LTT_SEQUENCE: + size1 = (int) ltt_type_size(fac, type); + if(fld->field_fixed == -1){ + fld->sequ_number_size = size1; + fld->field_fixed = 0; + size = getFieldtypeSize(evT, offsetRoot, + 0,fld->child[0], NULL); + fld->element_size = size; + }else{//0: sequence + element_number = getIntNumber(tf,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[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; - } + size += getFieldtypeSize(tf, evT, + offsetRoot+size+size1,size+size1, + fld->child[0], evD+size+size1); } - 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; + } + size += size1; + } + if(unlikely(!evD)){ 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; + + 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); + if(likely(size1 > 0 && size >= 0)){ + size += size1; + if(likely(offset1 >= 0)) offset1 += size1; + offset2 += size1; + }else{ + size = -1; + offset1 = -1; + offset2 = -1; + } } - break; - } + 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); + 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(LTT_GET_BO(tf), 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; } fld->offset_root = offsetRoot; @@ -1647,64 +2127,66 @@ end_getFieldtypeSize: return size; } - +#endif //0 /***************************************************************************** *Function name - * getIntNumber : get an integer number + * get_int : get an integer number *Input params + * reverse_byte_order: must we reverse the byte order ? * size : the size of the integer - * evD : the event data + * ptr : the data pointer *Return value * gint64 : a 64 bits integer ****************************************************************************/ -gint64 getIntNumber(gboolean reverse_byte_order, int size, void *evD) +gint64 get_int(gboolean reverse_byte_order, gint size, void *data) { - gint64 i; + gint64 val; switch(size) { - case 1: i = *((gint8*)evD); break; - case 2: i = ltt_get_int16(reverse_byte_order, evD); break; - case 4: i = ltt_get_int32(reverse_byte_order, evD); break; - case 8: i = ltt_get_int64(reverse_byte_order, evD); break; - default: i = ltt_get_int64(reverse_byte_order, evD); - g_critical("getIntNumber : integer size %d unknown", size); + case 1: val = *((gint8*)data); break; + case 2: val = ltt_get_int16(reverse_byte_order, data); break; + case 4: val = ltt_get_int32(reverse_byte_order, data); break; + case 8: val = ltt_get_int64(reverse_byte_order, data); break; + default: val = ltt_get_int64(reverse_byte_order, data); + g_critical("get_int : integer size %d unknown", size); break; } - return i; + return val; } -#if 0 + /***************************************************************************** *Function name - * getDataEndianType : get the data type size and endian type of the local - * machine + * get_uint : get an unsigned integer number *Input params - * size : size of data type - * endian : endian type, little or big + * reverse_byte_order: must we reverse the byte order ? + * size : the size of the integer + * ptr : the data pointer + *Return value + * guint64 : a 64 bits unsigned integer ****************************************************************************/ -void getDataEndianType(LttArchSize * size, LttArchEndian * endian) +guint64 get_uint(gboolean reverse_byte_order, gint size, void *data) { - int i = 1; - char c = (char) i; - int sizeInt=sizeof(int), sizeLong=sizeof(long), sizePointer=sizeof(void *); - - if(c == 1) *endian = LTT_LITTLE_ENDIAN; - else *endian = LTT_BIG_ENDIAN; - - if(sizeInt == 2 && sizeLong == 4 && sizePointer == 4) - *size = LTT_LP32; - else if(sizeInt == 4 && sizeLong == 4 && sizePointer == 4) - *size = LTT_ILP32; - else if(sizeInt == 4 && sizeLong == 8 && sizePointer == 8) - *size = LTT_LP64; - else if(sizeInt == 8 && sizeLong == 8 && sizePointer == 8) - *size = LTT_ILP64; - else *size = LTT_UNKNOWN; + guint64 val; + + switch(size) { + case 1: val = *((gint8*)data); break; + case 2: val = ltt_get_uint16(reverse_byte_order, data); break; + case 4: val = ltt_get_uint32(reverse_byte_order, data); break; + case 8: val = ltt_get_uint64(reverse_byte_order, data); break; + default: val = ltt_get_uint64(reverse_byte_order, data); + g_critical("get_uint : unsigned integer size %d unknown", + size); + break; + } + + return val; } -#endif //0 + + /* get the node name of the system */ char * ltt_trace_system_description_node_name (LttSystemDescription * s) @@ -1752,3 +2234,13 @@ void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) *dest = *src; } +/* Before library loading... */ + +static void __attribute__((constructor)) init(void) +{ + LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); + LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); + + LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("control/facilities"); +} + diff --git a/ltt/branches/poly/ltt/type.c b/ltt/branches/poly/ltt/type.c index 7f134eda..e153d540 100644 --- a/ltt/branches/poly/ltt/type.c +++ b/ltt/branches/poly/ltt/type.c @@ -49,10 +49,10 @@ static unsigned floatSizes[] = { *Input params * et : an event type *Return value - * char * : the name of the event type + * GQuark : the name of the event type ****************************************************************************/ -gchar *ltt_eventtype_name(LttEventType *et) +GQuark ltt_eventtype_name(LttEventType *et) { return et->name; } @@ -85,20 +85,6 @@ LttFacility *ltt_eventtype_facility(LttEventType *et) return et->facility; } -/***************************************************************************** - *Function name - * ltt_eventtype_relative_id : get the relative id of the event type - *Input params - * et : an event type - *Return value - * unsigned : the relative id - ****************************************************************************/ - -unsigned ltt_eventtype_relative_id(LttEventType *et) -{ - return et->index; -} - /***************************************************************************** *Function name * ltt_eventtype_id : get the id of the event type @@ -108,9 +94,9 @@ unsigned ltt_eventtype_relative_id(LttEventType *et) * unsigned : the id ****************************************************************************/ -unsigned ltt_eventtype_id(LttEventType *et) +guint8 ltt_eventtype_id(LttEventType *et) { - return et->facility->base_id + et->index; + return et->index; } /***************************************************************************** @@ -151,7 +137,7 @@ LttField *ltt_eventtype_field(LttEventType *et) * char * : the name of the type ****************************************************************************/ -gchar *ltt_type_name(LttType *t) +GQuark ltt_type_name(LttType *t) { return t->element_name; } @@ -173,47 +159,58 @@ LttTypeEnum ltt_type_class(LttType *t) /***************************************************************************** *Function name * ltt_type_size : obtain the type size. The size is the number of bytes - * for primitive types (INT, UINT, FLOAT, ENUM), or the - * size for the unsigned integer length count for sequences + * for primitive types (INT, UINT, FLOAT, ENUM) + * or the size for the unsigned integer length count for + * sequences *Input params * tf : trace file * t : a type *Return value - * unsigned : the type size + * : the type size * returns 0 if erroneous, and show a critical warning message. ****************************************************************************/ -unsigned ltt_type_size(LttTrace * trace, LttType *t) +size_t ltt_type_size(LttTrace * trace, LttType *t) { - unsigned size; - if(unlikely(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY || - t->type_class==LTT_STRING || t->type_class==LTT_UNION)) { - size = 0; - } else { - if(t->type_class == LTT_FLOAT){ - size = floatSizes[t->size]; - }else{ + size_t size; + + switch(t->type_class) { + + case LTT_INT: + case LTT_UINT: + case LTT_SEQUENCE: + case LTT_ENUM: if(likely(t->size < INT_SIZES_NUMBER)) size = intSizes[t->size]; - else{ - LttArchSize archsize = trace->system_description->size; - if(archsize == LTT_LP32){ - if(t->size == 5) size = intSizes[SIZE_INT16]; - else size = intSizes[SIZE_INT32]; - } - else if(archsize == LTT_ILP32 || archsize == LTT_LP64){ - if(t->size == 5) size = intSizes[SIZE_INT32]; - else{ - if(archsize == LTT_ILP32) size = intSizes[SIZE_INT32]; - else size = intSizes[SIZE_INT64]; - } - } - else if(archsize == LTT_ILP64) size = intSizes[SIZE_INT64]; - } - } + else + goto error; + break; + case LTT_FLOAT: + if(likely(t->size < FLOAT_SIZES_NUMBER)) + size = floatSizes[t->size]; + else + goto error; + break; + case LTT_POINTER: + case LTT_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + case LTT_STRING: + case LTT_ARRAY: + case LTT_STRUCT: + case LTT_UNION: + goto error; + break; } return size; + + +error: + g_warning("no size known for the type"); + return 0; } /***************************************************************************** @@ -287,7 +284,7 @@ unsigned ltt_type_member_number(LttType *t) * LttType * : the type of structure member ****************************************************************************/ -LttType *ltt_type_member_type(LttType *t, unsigned i, gchar ** name) +LttType *ltt_type_member_type(LttType *t, unsigned i, GQuark *name) { LttType *member_type = NULL; @@ -296,7 +293,7 @@ LttType *ltt_type_member_type(LttType *t, unsigned i, gchar ** name) || (i >= t->element_number) )) { - *name = NULL; + *name = 0; } else { *name = t->element_type[i]->element_name; member_type = t->element_type[i]; @@ -317,14 +314,12 @@ LttType *ltt_type_member_type(LttType *t, unsigned i, gchar ** name) * char * : symbolic string associated with a value ****************************************************************************/ -char *ltt_enum_string_get(LttType *t, unsigned i) +GQuark ltt_enum_string_get(LttType *t, unsigned i) { - gchar *string = NULL; - if(likely(t->type_class == LTT_ENUM && i < t->element_number)) - string = t->enum_strings[i]; - - return string; + return t->enum_strings[i]; + else + return 0; } /***************************************************************************** diff --git a/ltt/branches/poly/ltt/type.h b/ltt/branches/poly/ltt/type.h index 01cbbb38..98e7b8c0 100644 --- a/ltt/branches/poly/ltt/type.h +++ b/ltt/branches/poly/ltt/type.h @@ -31,7 +31,7 @@ /* Obtain the name, description, facility, facility relative id, global id, type and root field for an eventtype */ -gchar *ltt_eventtype_name(LttEventType *et); +GQuark ltt_eventtype_name(LttEventType *et); gchar *ltt_eventtype_description(LttEventType *et); @@ -39,7 +39,7 @@ LttFacility *ltt_eventtype_facility(LttEventType *et); unsigned ltt_eventtype_relative_id(LttEventType *et); -unsigned ltt_eventtype_id(LttEventType *et); +guint8 ltt_eventtype_id(LttEventType *et); LttType *ltt_eventtype_type(LttEventType *et); @@ -50,7 +50,7 @@ LttField *ltt_eventtype_field(LttEventType *et); primitive types (INT, UINT, FLOAT, ENUM), or the size for the unsigned integer length count for sequences. */ -gchar *ltt_type_name(LttType *t); +GQuark ltt_type_name(LttType *t); LttTypeEnum ltt_type_class(LttType *t); @@ -74,13 +74,13 @@ unsigned ltt_type_member_number(LttType *t); /* The type of a data member in a structure. */ -LttType *ltt_type_member_type(LttType *t, unsigned i, char ** name); +LttType *ltt_type_member_type(LttType *t, unsigned i, GQuark *name); /* For enumerations, obtain the symbolic string associated with a value (0 to n - 1 for an enumeration of n elements). */ -gchar *ltt_enum_string_get(LttType *t, unsigned i); +GQuark ltt_enum_string_get(LttType *t, unsigned i); /* The fields form a tree representing a depth first search of the -- 2.34.1