ltt/branches/poly/ltt/event.c

   1 #include <stdio.h>
   2 #include <asm/types.h>
   3 #include <linux/byteorder/swab.h>
   4 #include <ltt/LTTTypes.h>
   5 #include "parser.h"
   6 #include <ltt/event.h>
   7
   8 /*****************************************************************************
   9  *Function name
  10  *    ltt_event_refresh_fields   : refresh fields of an event
  11  *Input params
  12  *    offsetRoot      : offset from the root
  13  *    offsetParent    : offset from the parrent
  14  *    fld             : field
  15  *    evD             : event data
  16  *Return value
  17  *    int             : size of the field
  18  ****************************************************************************/
  19
  20 int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
  21                              LttField * fld, void *evD)
  22 {
  23   int size, size1, element_number, i, offset1, offset2;
  24   LttType * type = fld->field_type;
  25
  26   if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
  27      type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
  28     size = fld->field_size;
  29   }else if(type->type_class == LTT_ARRAY){
  30     element_number = (int) type->element_number;
  31     if(fld->field_fixed == 0){// has string or sequence
  32       size = 0;
  33       for(i=0;i<element_number;i++){
  34         size += ltt_event_refresh_fields(offsetRoot+size,size,
  35                                          fld->child[0], evD+size);
  36       }
  37     }else size = fld->field_size;
  38   }else if(type->type_class == LTT_SEQUENCE){
  39     size1 = fld->sequ_number_size;
  40     element_number = getIntNumber(size1,evD);
  41     type->element_number = element_number;
  42     if(fld->element_size > 0){
  43       size = element_number * fld->element_size;
  44     }else{//sequence has string or sequence
  45       size = 0;
  46       for(i=0;i<element_number;i++){
  47         size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
  48                                          fld->child[0], evD+size+size1);
  49       }
  50       size += size1;
  51     }
  52   }else if(type->type_class == LTT_STRING){
  53     size = strlen((char*)evD) + 1; //include end : '\0'
  54   }else if(type->type_class == LTT_STRUCT){
  55     element_number = (int) type->element_number;
  56     if(fld->field_fixed == 0){
  57       offset1 = offsetRoot;
  58       offset2 = 0;
  59       for(i=0;i<element_number;i++){
  60         size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
  61         offset1 += size;
  62         offset2 += size;
  63       }
  64       size = offset2;
  65     }else size = fld->field_size;
  66   }
  67
  68   fld->offset_root     = offsetRoot;
  69   fld->offset_parent   = offsetParent;
  70   fld->fixed_root      = (offsetRoot==-1)   ? 0 : 1;
  71   fld->fixed_parent    = (offsetParent==-1) ? 0 : 1;
  72   fld->field_size      = size;
  73
  74   return size;
  75 }
  76
  77 /*****************************************************************************
  78  *Function name
  79  *    ltt_event_eventtype_id: get event type id
  80  *                            (base id + position of the event)
  81  *Input params
  82  *    e                     : an instance of an event type
  83  *Return value
  84  *    unsigned              : event type id
  85  ****************************************************************************/
  86
  87 unsigned ltt_event_eventtype_id(LttEvent *e)
  88 {
  89   return (unsigned) e->event_id;
  90 }
  91
  92 /*****************************************************************************
  93  *Function name
  94  *    ltt_event_facility : get the facility of the event
  95  *Input params
  96  *    e                  : an instance of an event type
  97  *Return value
  98  *    LttFacility *     : the facility of the event
  99  ****************************************************************************/
 100
 101 LttFacility *ltt_event_facility(LttEvent *e)
 102 {
 103   LttTrace * trace = e->tracefile->trace;
 104   unsigned id = e->event_id;
 105   return ltt_trace_facility_by_id(trace,id);
 106 }
 107
 108 /*****************************************************************************
 109  *Function name
 110  *    ltt_event_eventtype : get the event type of the event
 111  *Input params
 112  *    e                   : an instance of an event type
 113  *Return value
 114  *    LttEventType *     : the event type of the event
 115  ****************************************************************************/
 116
 117 LttEventType *ltt_event_eventtype(LttEvent *e)
 118 {
 119   LttFacility* facility = ltt_event_facility(e);
 120   if(!facility) return NULL;
 121   return facility->events[e->event_id - facility->base_id];
 122 }
 123
 124 /*****************************************************************************
 125  *Function name
 126  *    ltt_event_field : get the root field of the event
 127  *Input params
 128  *    e               : an instance of an event type
 129  *Return value
 130  *    LttField *      : the root field of the event
 131  ****************************************************************************/
 132
 133 LttField *ltt_event_field(LttEvent *e)
 134 {
 135   LttField * field;
 136   LttEventType * event_type = ltt_event_eventtype(e);
 137   if(!event_type) return NULL;
 138   field = event_type->root_field;
 139   if(!field) return NULL;
 140
 141   //check if the field need refresh
 142   if(e->which_block != event_type->latest_block ||
 143      e->which_event != event_type->latest_event){
 144
 145     event_type->latest_block = e->which_block;
 146     event_type->latest_event = e->which_event;
 147
 148     if(field->field_fixed == 1)return field;
 149
 150     //refresh the field
 151     ltt_event_refresh_fields(0, 0, field, e->data);
 152   }
 153   return field;
 154 }
 155
 156 /*****************************************************************************
 157  *Function name
 158  *    ltt_event_time : get the time of the event
 159  *Input params
 160  *    e              : an instance of an event type
 161  *Return value
 162  *    LttTime       : the time of the event
 163  ****************************************************************************/
 164
 165 LttTime ltt_event_time(LttEvent *e)
 166 {
 167   return e->event_time;
 168 }
 169
 170 /*****************************************************************************
 171  *Function name
 172  *    ltt_event_time : get the cycle count of the event
 173  *Input params
 174  *    e              : an instance of an event type
 175  *Return value
 176  *    LttCycleCount  : the cycle count of the event
 177  ****************************************************************************/
 178
 179 LttCycleCount ltt_event_cycle_count(LttEvent *e)
 180 {
 181   return e->event_cycle_count;
 182 }
 183
 184 /*****************************************************************************
 185  *Function name
 186  *    ltt_event_cpu_i: get the cpu id where the event happens
 187  *Input params
 188  *    e              : an instance of an event type
 189  *Return value
 190  *    unsigned       : the cpu id
 191  ****************************************************************************/
 192
 193 unsigned ltt_event_cpu_id(LttEvent *e)
 194 {
 195   return (unsigned)atoi(e->tracefile->name);
 196 }
 197
 198 /*****************************************************************************
 199  *Function name
 200  *    ltt_event_data : get the raw data for the event
 201  *Input params
 202  *    e              : an instance of an event type
 203  *Return value
 204  *    void *         : pointer to the raw data for the event
 205  ****************************************************************************/
 206
 207 void *ltt_event_data(LttEvent *e)
 208 {
 209   return e->data;
 210 }
 211
 212 /*****************************************************************************
 213  *Function name
 214  *    ltt_event_field_element_number
 215  *                   : The number of elements in a sequence field is specific
 216  *                     to each event. This function returns the number of
 217  *                     elements for an array or sequence field in an event.
 218  *Input params
 219  *    e              : an instance of an event type
 220  *    f              : a field of the instance
 221  *Return value
 222  *    unsigned       : the number of elements for an array/sequence field
 223  ****************************************************************************/
 224
 225 unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
 226 {
 227   if(f->field_type->type_class != LTT_ARRAY &&
 228      f->field_type->type_class != LTT_SEQUENCE)
 229     return 0;
 230
 231   if(f->field_type->type_class == LTT_ARRAY)
 232     return f->field_type->element_number;
 233   return (unsigned)  getIntNumber(f->sequ_number_size, e + f->offset_root);
 234 }
 235
 236 /*****************************************************************************
 237  *Function name
 238  *    ltt_event_field_element_select
 239  *                   : Set the currently selected element for a sequence or
 240  *                     array field
 241  *Input params
 242  *    e              : an instance of an event type
 243  *    f              : a field of the instance
 244  *    i              : the ith element
 245  ****************************************************************************/
 246
 247 void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 248 {
 249   unsigned element_number;
 250   LttField *fld;
 251   int k, size;
 252   void *evD;
 253
 254   if(f->field_type->type_class != LTT_ARRAY &&
 255      f->field_type->type_class != LTT_SEQUENCE)
 256     return ;
 257
 258   element_number  = ltt_event_field_element_number(e,f);
 259   if((element_number-1) < i || i < 0) return;
 260
 261   fld = f->child[0];
 262
 263   evD = e->data + f->offset_root;
 264   size = 0;
 265   for(k=0;k<i;k++){
 266     size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
 267   }
 268
 269   f->current_element = i - 1;
 270 }
 271
 272 /*****************************************************************************
 273  * These functions extract data from an event after architecture specific
 274  * conversions
 275  ****************************************************************************/
 276
 277 unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
 278 {
 279   int revFlag = e->tracefile->trace->my_arch_endian ==
 280                 e->tracefile->trace->system_description->endian ? 0:1;
 281   LttTypeEnum t = f->field_type->type_class;
 282
 283   if(t != LTT_UINT && t != LTT_ENUM)
 284     g_error("The type of the field is not unsigned int\n");
 285
 286   if(f->field_size == 1){
 287     uint8_t x = *(uint8_t*)(e->data + f->offset_root);
 288     return (unsigned int) x;
 289   }else if(f->field_size == 2){
 290     uint16_t x = *(uint16_t*)(e->data + f->offset_root);
 291     return (unsigned int) (revFlag ? BREV16(x): x);
 292   }else if(f->field_size == 4){
 293     uint32_t x = *(uint32_t*)(e->data + f->offset_root);
 294     return (unsigned int) (revFlag ? BREV32(x): x);
 295   }else if(f->field_size == 8){
 296     uint64_t x = *(uint64_t*)(e->data + f->offset_root);
 297     return (unsigned int) (revFlag ? BREV64(x): x);
 298   }
 299 }
 300
 301 int ltt_event_get_int(LttEvent *e, LttField *f)
 302 {
 303   int revFlag = e->tracefile->trace->my_arch_endian ==
 304                 e->tracefile->trace->system_description->endian ? 0:1;
 305
 306   if(f->field_type->type_class != LTT_INT)
 307     g_error("The type of the field is not int\n");
 308
 309   if(f->field_size == 1){
 310     int8_t x = *(int8_t*)(e->data + f->offset_root);
 311     return (int) x;
 312   }else if(f->field_size == 2){
 313     int16_t x = *(int16_t*)(e->data + f->offset_root);
 314     return (int) (revFlag ? BREV16(x): x);
 315   }else if(f->field_size == 4){
 316     int32_t x = *(int32_t*)(e->data + f->offset_root);
 317     return (int) (revFlag ? BREV32(x): x);
 318   }else if(f->field_size == 8){
 319     int64_t x = *(int64_t*)(e->data + f->offset_root);
 320     return (int) (revFlag ? BREV64(x): x);
 321   }
 322 }
 323
 324 unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 325 {
 326   int revFlag = e->tracefile->trace->my_arch_endian ==
 327                 e->tracefile->trace->system_description->endian ? 0:1;
 328   LttTypeEnum t = f->field_type->type_class;
 329
 330   if(t != LTT_UINT && t != LTT_ENUM)
 331     g_error("The type of the field is not unsigned long\n");
 332
 333   if(f->field_size == 1){
 334     uint8_t x = *(uint8_t*)(e->data + f->offset_root);
 335     return (unsigned long) x;
 336   }else if(f->field_size == 2){
 337     uint16_t x = *(uint16_t*)(e->data + f->offset_root);
 338     return (unsigned long) (revFlag ? BREV16(x): x);
 339   }else if(f->field_size == 4){
 340     uint32_t x = *(uint32_t*)(e->data + f->offset_root);
 341     return (unsigned long) (revFlag ? BREV32(x): x);
 342   }else if(f->field_size == 8){
 343     uint64_t x = *(uint64_t*)(e->data + f->offset_root);
 344     return (unsigned long) (revFlag ? BREV64(x): x);
 345   }
 346 }
 347
 348 long int ltt_event_get_long_int(LttEvent *e, LttField *f)
 349 {
 350   int revFlag = e->tracefile->trace->my_arch_endian ==
 351                 e->tracefile->trace->system_description->endian ? 0:1;
 352
 353   if( f->field_type->type_class != LTT_INT)
 354     g_error("The type of the field is not long int\n");
 355
 356   if(f->field_size == 1){
 357     int8_t x = *(int8_t*)(e->data + f->offset_root);
 358     return (long) x;
 359   }else if(f->field_size == 2){
 360     int16_t x = *(int16_t*)(e->data + f->offset_root);
 361     return (long) (revFlag ? BREV16(x): x);
 362   }else if(f->field_size == 4){
 363     int32_t x = *(int32_t*)(e->data + f->offset_root);
 364     return (long) (revFlag ? BREV32(x): x);
 365   }else if(f->field_size == 8){
 366     int64_t x = *(int64_t*)(e->data + f->offset_root);
 367     return (long) (revFlag ? BREV64(x): x);
 368   }
 369 }
 370
 371 float ltt_event_get_float(LttEvent *e, LttField *f)
 372 {
 373   int revFlag = e->tracefile->trace->my_arch_endian ==
 374                 e->tracefile->trace->system_description->endian ? 0:1;
 375
 376   if(f->field_type->type_class != LTT_FLOAT ||
 377      (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
 378     g_error("The type of the field is not float\n");
 379
 380   if(revFlag == 0) return *(float *)(e->data + f->offset_root);
 381   else{
 382     uint32_t aInt;
 383     memcpy((void*)&aInt, e->data + f->offset_root, 4);
 384     aInt = ___swab32(aInt);
 385     return *((float*)&aInt);
 386   }
 387 }
 388
 389 double ltt_event_get_double(LttEvent *e, LttField *f)
 390 {
 391   int revFlag = e->tracefile->trace->my_arch_endian ==
 392                 e->tracefile->trace->system_description->endian ? 0:1;
 393
 394   if(f->field_type->type_class != LTT_FLOAT ||
 395      (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
 396     g_error("The type of the field is not double\n");
 397
 398   if(revFlag == 0) return *(double *)(e->data + f->offset_root);
 399   else{
 400     uint64_t aInt;
 401     memcpy((void*)&aInt, e->data + f->offset_root, 8);
 402     aInt = ___swab64(aInt);
 403     return *((double *)&aInt);
 404   }
 405 }
 406
 407 /*****************************************************************************
 408  * The string obtained is only valid until the next read from
 409  * the same tracefile.
 410  ****************************************************************************/
 411
 412 char *ltt_event_get_string(LttEvent *e, LttField *f)
 413 {
 414   if(f->field_type->type_class != LTT_STRING)
 415     g_error("The field contains no string\n");
 416   return (char*)g_strdup((char*)(e->data + f->offset_root));
 417 }