ltt/branches/poly/ltt/event.c

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