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
 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_cpu_i: get the cpu id where the event happens
 186  *Input params
 187  *    e              : an instance of an event type
 188  *Return value
 189  *    unsigned       : the cpu id
 190  ****************************************************************************/
 191
 192 unsigned ltt_event_cpu_id(LttEvent *e)
 193 {
 194   return (unsigned)atoi(e->tracefile->name);
 195 }
 196
 197 /*****************************************************************************
 198  *Function name
 199  *    ltt_event_data : get the raw data for the event
 200  *Input params
 201  *    e              : an instance of an event type
 202  *Return value
 203  *    void *         : pointer to the raw data for the event
 204  ****************************************************************************/
 205
 206 void *ltt_event_data(LttEvent *e)
 207 {
 208   return e->data;
 209 }
 210
 211 /*****************************************************************************
 212  *Function name
 213  *    ltt_event_field_element_number
 214  *                   : The number of elements in a sequence field is specific
 215  *                     to each event. This function returns the number of
 216  *                     elements for an array or sequence field in an event.
 217  *Input params
 218  *    e              : an instance of an event type
 219  *    f              : a field of the instance
 220  *Return value
 221  *    unsigned       : the number of elements for an array/sequence field
 222  ****************************************************************************/
 223
 224 unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
 225 {
 226   if(f->field_type->type_class != LTT_ARRAY &&
 227      f->field_type->type_class != LTT_SEQUENCE)
 228     return 0;
 229
 230   if(f->field_type->type_class == LTT_ARRAY)
 231     return f->field_type->element_number;
 232   return (unsigned)  getIntNumber(f->sequ_number_size, e + f->offset_root);
 233 }
 234
 235 /*****************************************************************************
 236  *Function name
 237  *    ltt_event_field_element_select
 238  *                   : Set the currently selected element for a sequence or
 239  *                     array field
 240  *Input params
 241  *    e              : an instance of an event type
 242  *    f              : a field of the instance
 243  *    i              : the ith element
 244  ****************************************************************************/
 245
 246 void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 247 {
 248   unsigned element_number;
 249   LttField *fld;
 250   int k, size;
 251   void *evD;
 252
 253   if(f->field_type->type_class != LTT_ARRAY &&
 254      f->field_type->type_class != LTT_SEQUENCE)
 255     return ;
 256
 257   element_number  = ltt_event_field_element_number(e,f);
 258   if((element_number-1) < i || i < 0) return;
 259
 260   fld = f->child[0];
 261
 262   evD = e->data + f->offset_root;
 263   size = 0;
 264   for(k=0;k<i;k++){
 265     size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
 266   }
 267
 268   f->current_element = i - 1;
 269 }
 270
 271 /*****************************************************************************
 272  * These functions extract data from an event after architecture specific
 273  * conversions
 274  ****************************************************************************/
 275
 276 unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
 277 {
 278   int revFlag = e->tracefile->trace->my_arch_endian ==
 279                 e->tracefile->trace->system_description->endian ? 0:1;
 280   LttTypeEnum t = f->field_type->type_class;
 281
 282   if(t != LTT_UINT && t != LTT_ENUM)
 283     g_error("The type of the field is not unsigned int\n");
 284
 285   if(f->field_size == 1){
 286     uint8_t x = *(uint8_t*)(e->data + f->offset_root);
 287     return (unsigned int) x;
 288   }else if(f->field_size == 2){
 289     uint16_t x = *(uint16_t*)(e->data + f->offset_root);
 290     return (unsigned int) (revFlag ? BREV16(x): x);
 291   }else if(f->field_size == 4){
 292     uint32_t x = *(uint32_t*)(e->data + f->offset_root);
 293     return (unsigned int) (revFlag ? BREV32(x): x);
 294   }else if(f->field_size == 8){
 295     uint64_t x = *(uint64_t*)(e->data + f->offset_root);
 296     return (unsigned int) (revFlag ? BREV64(x): x);
 297   }
 298 }
 299
 300 int ltt_event_get_int(LttEvent *e, LttField *f)
 301 {
 302   int revFlag = e->tracefile->trace->my_arch_endian ==
 303                 e->tracefile->trace->system_description->endian ? 0:1;
 304
 305   if(f->field_type->type_class != LTT_INT)
 306     g_error("The type of the field is not int\n");
 307
 308   if(f->field_size == 1){
 309     int8_t x = *(int8_t*)(e->data + f->offset_root);
 310     return (int) x;
 311   }else if(f->field_size == 2){
 312     int16_t x = *(int16_t*)(e->data + f->offset_root);
 313     return (int) (revFlag ? BREV16(x): x);
 314   }else if(f->field_size == 4){
 315     int32_t x = *(int32_t*)(e->data + f->offset_root);
 316     return (int) (revFlag ? BREV32(x): x);
 317   }else if(f->field_size == 8){
 318     int64_t x = *(int64_t*)(e->data + f->offset_root);
 319     return (int) (revFlag ? BREV64(x): x);
 320   }
 321 }
 322
 323 unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 324 {
 325   int revFlag = e->tracefile->trace->my_arch_endian ==
 326                 e->tracefile->trace->system_description->endian ? 0:1;
 327   LttTypeEnum t = f->field_type->type_class;
 328
 329   if(t != LTT_UINT && t != LTT_ENUM)
 330     g_error("The type of the field is not unsigned long\n");
 331
 332   if(f->field_size == 1){
 333     uint8_t x = *(uint8_t*)(e->data + f->offset_root);
 334     return (unsigned long) x;
 335   }else if(f->field_size == 2){
 336     uint16_t x = *(uint16_t*)(e->data + f->offset_root);
 337     return (unsigned long) (revFlag ? BREV16(x): x);
 338   }else if(f->field_size == 4){
 339     uint32_t x = *(uint32_t*)(e->data + f->offset_root);
 340     return (unsigned long) (revFlag ? BREV32(x): x);
 341   }else if(f->field_size == 8){
 342     uint64_t x = *(uint64_t*)(e->data + f->offset_root);
 343     return (unsigned long) (revFlag ? BREV64(x): x);
 344   }
 345 }
 346
 347 long int ltt_event_get_long_int(LttEvent *e, LttField *f)
 348 {
 349   int revFlag = e->tracefile->trace->my_arch_endian ==
 350                 e->tracefile->trace->system_description->endian ? 0:1;
 351
 352   if( f->field_type->type_class != LTT_INT)
 353     g_error("The type of the field is not long int\n");
 354
 355   if(f->field_size == 1){
 356     int8_t x = *(int8_t*)(e->data + f->offset_root);
 357     return (long) x;
 358   }else if(f->field_size == 2){
 359     int16_t x = *(int16_t*)(e->data + f->offset_root);
 360     return (long) (revFlag ? BREV16(x): x);
 361   }else if(f->field_size == 4){
 362     int32_t x = *(int32_t*)(e->data + f->offset_root);
 363     return (long) (revFlag ? BREV32(x): x);
 364   }else if(f->field_size == 8){
 365     int64_t x = *(int64_t*)(e->data + f->offset_root);
 366     return (long) (revFlag ? BREV64(x): x);
 367   }
 368 }
 369
 370 float ltt_event_get_float(LttEvent *e, LttField *f)
 371 {
 372   int revFlag = e->tracefile->trace->my_arch_endian ==
 373                 e->tracefile->trace->system_description->endian ? 0:1;
 374
 375   if(f->field_type->type_class != LTT_FLOAT ||
 376      (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
 377     g_error("The type of the field is not float\n");
 378
 379   if(revFlag == 0) return *(float *)(e->data + f->offset_root);
 380   else{
 381     uint32_t aInt;
 382     memcpy((void*)&aInt, e->data + f->offset_root, 4);
 383     aInt = ___swab32(aInt);
 384     return *((float*)&aInt);
 385   }
 386 }
 387
 388 double ltt_event_get_double(LttEvent *e, LttField *f)
 389 {
 390   int revFlag = e->tracefile->trace->my_arch_endian ==
 391                 e->tracefile->trace->system_description->endian ? 0:1;
 392
 393   if(f->field_type->type_class != LTT_FLOAT ||
 394      (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
 395     g_error("The type of the field is not double\n");
 396
 397   if(revFlag == 0) return *(double *)(e->data + f->offset_root);
 398   else{
 399     uint64_t aInt;
 400     memcpy((void*)&aInt, e->data + f->offset_root, 8);
 401     aInt = ___swab64(aInt);
 402     return *((double *)&aInt);
 403   }
 404 }
 405
 406 /*****************************************************************************
 407  * The string obtained is only valid until the next read from
 408  * the same tracefile.
 409  ****************************************************************************/
 410
 411 char *ltt_event_get_string(LttEvent *e, LttField *f)
 412 {
 413   if(f->field_type->type_class != LTT_STRING)
 414     g_error("The field contains no string\n");
 415   return (char*)g_strdup((char*)(e->data + f->offset_root));
 416 }