ltt/branches/poly/ltt/event.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Xiangxiu Yang
   3  *               2006 Mathieu Desnoyers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License Version 2.1 as published by the Free Software Foundation.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <glib.h>
  28
  29 #include <asm/types.h>
  30 #include <byteswap.h>
  31
  32 #include "parser.h"
  33 #include <ltt/ltt.h>
  34 #include "ltt-private.h"
  35 #include <ltt/event.h>
  36 #include <ltt/trace.h>
  37 #include <ltt/ltt-types.h>
  38 #include <ltt/markers.h>
  39
  40
  41 void compute_fields_offsets(LttTracefile *tf,
  42     LttFacility *fac, LttField *field, off_t *offset, void *root,
  43     guint is_compact);
  44
  45
  46 LttEvent *ltt_event_new()
  47 {
  48   return g_new(LttEvent, 1);
  49 }
  50
  51 void ltt_event_destroy(LttEvent *event)
  52 {
  53   g_free(event);
  54 }
  55
  56
  57 /*****************************************************************************
  58  *Function name
  59  *    ltt_event_eventtype_id: get event type id
  60  *                            (base id + position of the event)
  61  *Input params
  62  *    e                     : an instance of an event type
  63  *Return value
  64  *    unsigned              : event type id
  65  ****************************************************************************/
  66
  67 uint16_t ltt_event_eventtype_id(const LttEvent *e)
  68 {
  69   return e->event_id;
  70 }
  71
  72 /*****************************************************************************
  73  *Function name
  74  *    ltt_event_facility : get the facility of the event
  75  *Input params
  76  *    e                  : an instance of an event type
  77  *Return value
  78  *    struct marker_info *: the marker associated with the event
  79  ****************************************************************************/
  80
  81 struct marker_info *ltt_event_marker(const LttEvent *e)
  82 {
  83   return marker_get_info_from_id(e->tracefile->trace, e->event_id);
  84 }
  85
  86 /*****************************************************************************
  87  *Function name
  88  *    ltt_event_time : get the time of the event
  89  *Input params
  90  *    e              : an instance of an event type
  91  *Return value
  92  *    LttTime       : the time of the event
  93  ****************************************************************************/
  94
  95 LttTime ltt_event_time(const LttEvent *e)
  96 {
  97   return e->event_time;
  98 }
  99
 100 /*****************************************************************************
 101  *Function name
 102  *    ltt_event_time : get the cycle count of the event
 103  *Input params
 104  *    e              : an instance of an event type
 105  *Return value
 106  *    LttCycleCount  : the cycle count of the event
 107  ****************************************************************************/
 108
 109 LttCycleCount ltt_event_cycle_count(const LttEvent *e)
 110 {
 111   return e->tsc;
 112 }
 113
 114 /*****************************************************************************
 115  *Function name
 116  *    ltt_event_position_get : get the event position data
 117  *Input params
 118  *    e                  : an instance of an event type
 119  *    ep                 : a pointer to event's position structure
 120  *    tf                 : tracefile pointer
 121  *    block              : current block
 122  *    offset             : current offset
 123  *    tsc                : current tsc
 124  ****************************************************************************/
 125 void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
 126         guint *block, guint *offset, guint64 *tsc)
 127 {
 128   *tf = ep->tracefile;
 129   *block = ep->block;
 130   *offset = ep->offset;
 131   *tsc = ep->tsc;
 132 }
 133
 134
 135 void ltt_event_position_set(LttEventPosition *ep, LttTracefile *tf,
 136         guint block, guint offset, guint64 tsc)
 137 {
 138   ep->tracefile = tf;
 139   ep->block = block;
 140   ep->offset = offset;
 141   ep->tsc = tsc;
 142 }
 143
 144
 145 /*****************************************************************************
 146  *Function name
 147  *    ltt_event_position : get the event's position
 148  *Input params
 149  *    e                  : an instance of an event type
 150  *    ep                 : a pointer to event's position structure
 151  ****************************************************************************/
 152
 153 void ltt_event_position(LttEvent *e, LttEventPosition *ep)
 154 {
 155   ep->tracefile = e->tracefile;
 156   ep->block = e->block;
 157   ep->offset = e->offset;
 158   ep->tsc = e->tsc;
 159 }
 160
 161 LttEventPosition * ltt_event_position_new()
 162 {
 163   return g_new(LttEventPosition, 1);
 164 }
 165
 166
 167 /*****************************************************************************
 168  * Function name
 169  *    ltt_event_position_compare : compare two positions
 170  *    A NULL value is infinite.
 171  * Input params
 172  *    ep1                    : a pointer to event's position structure
 173  *    ep2                    : a pointer to event's position structure
 174  * Return
 175  *    -1 is ep1 < ep2
 176  *    1 if ep1 > ep2
 177  *    0 if ep1 == ep2
 178  ****************************************************************************/
 179
 180
 181 gint ltt_event_position_compare(const LttEventPosition *ep1,
 182                                 const LttEventPosition *ep2)
 183 {
 184   if(ep1 == NULL && ep2 == NULL)
 185       return 0;
 186   if(ep1 != NULL && ep2 == NULL)
 187       return -1;
 188   if(ep1 == NULL && ep2 != NULL)
 189       return 1;
 190
 191    if(ep1->tracefile != ep2->tracefile)
 192     g_error("ltt_event_position_compare on different tracefiles makes no sense");
 193
 194   if(ep1->block < ep2->block)
 195     return -1;
 196   if(ep1->block > ep2->block)
 197     return 1;
 198   if(ep1->offset < ep2->offset)
 199     return -1;
 200   if(ep1->offset > ep2->offset)
 201     return 1;
 202   return 0;
 203 }
 204
 205 /*****************************************************************************
 206  * Function name
 207  *    ltt_event_position_copy : copy position
 208  * Input params
 209  *    src                    : a pointer to event's position structure source
 210  *    dest                   : a pointer to event's position structure dest
 211  * Return
 212  *    void
 213  ****************************************************************************/
 214 void ltt_event_position_copy(LttEventPosition *dest,
 215                              const LttEventPosition *src)
 216 {
 217   if(src == NULL)
 218     dest = NULL;
 219   else
 220     *dest = *src;
 221 }
 222
 223
 224
 225 LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep)
 226 {
 227   return ep->tracefile;
 228 }
 229
 230 /*****************************************************************************
 231  *Function name
 232  *    ltt_event_cpu_i: get the cpu id where the event happens
 233  *Input params
 234  *    e              : an instance of an event type
 235  *Return value
 236  *    unsigned       : the cpu id
 237  ****************************************************************************/
 238
 239 unsigned ltt_event_cpu_id(LttEvent *e)
 240 {
 241   return e->tracefile->cpu_num;
 242 }
 243
 244 /*****************************************************************************
 245  *Function name
 246  *    ltt_event_data : get the raw data for the event
 247  *Input params
 248  *    e              : an instance of an event type
 249  *Return value
 250  *    void *         : pointer to the raw data for the event
 251  ****************************************************************************/
 252
 253 void *ltt_event_data(LttEvent *e)
 254 {
 255   return e->data;
 256 }
 257
 258 /*****************************************************************************
 259  *Function name
 260  *    ltt_event_field_element_number
 261  *                   : The number of elements in a sequence field is specific
 262  *                     to each event. This function returns the number of
 263  *                     elements for an array or sequence field in an event.
 264  *Input params
 265  *    e              : an instance of an event type
 266  *    f              : a field of the instance
 267  *Return value
 268  *    unsigned       : the number of elements for an array/sequence field
 269  ****************************************************************************/
 270 guint64 ltt_event_field_element_number(LttEvent *e, LttField *f)
 271 {
 272   if(f->field_type.type_class != LTT_ARRAY &&
 273      f->field_type.type_class != LTT_SEQUENCE)
 274     return 0;
 275
 276   if(f->field_type.type_class == LTT_ARRAY)
 277     return f->field_type.size;
 278   return ltt_event_get_long_unsigned(e, &g_array_index(f->field_type.fields,
 279                                                  LttField, 0));
 280 }
 281
 282 /*****************************************************************************
 283  *Function name
 284  *    ltt_event_field_element_select
 285  *                   : Set the currently selected element for a sequence or
 286  *                     array field
 287  *                     O(1) because of offset array.
 288  *Input params
 289  *    e              : an instance of an event type
 290  *    f              : a field of the instance
 291  *    i              : the ith element (0, ...)
 292  *returns : the child field, at the right index, updated.
 293  ****************************************************************************/
 294 LttField *ltt_event_field_element_select(LttEvent *e, LttField *f, gulong i)
 295 {
 296   gulong element_number;
 297   LttField *field;
 298   unsigned int k;
 299   size_t size;
 300   LttEventType *event_type;
 301   off_t new_offset;
 302
 303   if(f->field_type.type_class != LTT_ARRAY &&
 304      f->field_type.type_class != LTT_SEQUENCE)
 305     return NULL;
 306
 307   element_number  = ltt_event_field_element_number(e,f);
 308   event_type = ltt_event_eventtype(e);
 309   /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number
 310    */
 311   if(i >= element_number) return NULL;
 312
 313   if(f->field_type.type_class == LTT_ARRAY) {
 314    field = &g_array_index(f->field_type.fields, LttField, 0);
 315   } else {
 316    field = &g_array_index(f->field_type.fields, LttField, 1);
 317   }
 318
 319   if(field->field_size != 0) {
 320     if(f->array_offset + (i * field->field_size) == field->offset_root)
 321       return field; /* fixed length child, already at the right offset */
 322     else
 323       new_offset = f->array_offset + (i * field->field_size);
 324   } else {
 325     /* Var. len. child */
 326     new_offset = g_array_index(f->dynamic_offsets, off_t, i);
 327   }
 328   compute_fields_offsets(e->tracefile,
 329       ltt_event_facility(e), field, &new_offset, e->data, 0);
 330
 331   return field;
 332 }
 333
 334
 335 off_t ltt_event_field_offset(LttEvent *e, LttField *f)
 336 {
 337   return f->offset_root;
 338 }
 339
 340
 341
 342 /*****************************************************************************
 343  * These functions extract data from an event after architecture specific
 344  * conversions
 345  ****************************************************************************/
 346 guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f)
 347 {
 348   gboolean reverse_byte_order;
 349   if(unlikely(f->field_type.network)) {
 350     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 351   } else {
 352     reverse_byte_order = LTT_GET_BO(e->tracefile);
 353   }
 354
 355   switch(f->field_size) {
 356   case 1:
 357     {
 358       guint8 x = *(guint8 *)(e->data + f->offset_root);
 359       return (guint32) x;
 360     }
 361     break;
 362   case 2:
 363     return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
 364     break;
 365   case 4:
 366     return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
 367     break;
 368   case 8:
 369   default:
 370     g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
 371     return 0;
 372     break;
 373   }
 374 }
 375
 376 gint32 ltt_event_get_int(LttEvent *e, LttField *f)
 377 {
 378   gboolean reverse_byte_order;
 379   if(unlikely(f->field_type.network)) {
 380     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 381   } else {
 382     reverse_byte_order = LTT_GET_BO(e->tracefile);
 383   }
 384
 385   switch(f->field_size) {
 386   case 1:
 387     {
 388       gint8 x = *(gint8 *)(e->data + f->offset_root);
 389       return (gint32) x;
 390     }
 391     break;
 392   case 2:
 393     return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
 394     break;
 395   case 4:
 396     return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
 397     break;
 398   case 8:
 399   default:
 400     g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
 401     return 0;
 402     break;
 403   }
 404 }
 405
 406 guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 407 {
 408   gboolean reverse_byte_order;
 409   if(unlikely(f->field_type.network)) {
 410     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 411   } else {
 412     reverse_byte_order = LTT_GET_BO(e->tracefile);
 413   }
 414
 415   switch(f->field_size) {
 416   case 1:
 417     {
 418       guint8 x = *(guint8 *)(e->data + f->offset_root);
 419       return (guint64) x;
 420     }
 421     break;
 422   case 2:
 423     return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
 424     break;
 425   case 4:
 426     return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
 427     break;
 428   case 8:
 429     return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root);
 430     break;
 431   default:
 432     g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
 433     return 0;
 434     break;
 435   }
 436 }
 437
 438 gint64 ltt_event_get_long_int(LttEvent *e, LttField *f)
 439 {
 440   gboolean reverse_byte_order;
 441   if(unlikely(f->field_type.network)) {
 442     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 443   } else {
 444     reverse_byte_order = LTT_GET_BO(e->tracefile);
 445   }
 446
 447   switch(f->field_size) {
 448   case 1:
 449     {
 450       gint8 x = *(gint8 *)(e->data + f->offset_root);
 451       return (gint64) x;
 452     }
 453     break;
 454   case 2:
 455     return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
 456     break;
 457   case 4:
 458     return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
 459     break;
 460   case 8:
 461     return ltt_get_int64(reverse_byte_order, e->data + f->offset_root);
 462     break;
 463   default:
 464     g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
 465     return 0;
 466     break;
 467   }
 468 }
 469
 470 float ltt_event_get_float(LttEvent *e, LttField *f)
 471 {
 472   gboolean reverse_byte_order;
 473   if(unlikely(f->field_type.network)) {
 474     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 475   } else {
 476     g_assert(LTT_HAS_FLOAT(e->tracefile));
 477     reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
 478   }
 479
 480   g_assert(f->field_type.type_class == LTT_FLOAT && f->field_size == 4);
 481
 482   if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root);
 483   else{
 484     void *ptr = e->data + f->offset_root;
 485     guint32 value = bswap_32(*(guint32*)ptr);
 486     return *(float*)&value;
 487   }
 488 }
 489
 490 double ltt_event_get_double(LttEvent *e, LttField *f)
 491 {
 492   gboolean reverse_byte_order;
 493   if(unlikely(f->field_type.network)) {
 494     reverse_byte_order = (g_ntohs(0x1) != 0x1);
 495   } else {
 496     g_assert(LTT_HAS_FLOAT(e->tracefile));
 497     reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
 498   }
 499
 500   if(f->field_size == 4)
 501     return ltt_event_get_float(e, f);
 502
 503   g_assert(f->field_type.type_class == LTT_FLOAT && f->field_size == 8);
 504
 505   if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root);
 506   else {
 507     void *ptr = e->data + f->offset_root;
 508     guint64 value = bswap_64(*(guint64*)ptr);
 509     return *(double*)&value;
 510   }
 511 }
 512
 513 /*****************************************************************************
 514  * The string obtained is only valid until the next read from
 515  * the same tracefile.
 516  ****************************************************************************/
 517 char *ltt_event_get_string(LttEvent *e, LttField *f)
 518 {
 519   g_assert(f->field_type.type_class == LTT_STRING);
 520
 521   return (gchar*)g_strdup((gchar*)(e->data + f->offset_root));
 522 }
 523
 524 /*****************************************************************************
 525  *Function name
 526  *    compute_fields_offsets : set the precomputable offset of the fields
 527  *Input params
 528  *    fac : facility
 529  *    field : the field
 530  *    offset : pointer to the current offset, must be incremented
 531  ****************************************************************************/
 532
 533 #if 0
 534 void compute_fields_offsets(LttTracefile *tf,
 535     LttFacility *fac, LttField *field, off_t *offset, void *root, guint is_compact)
 536 {
 537   LttType *type = &field->field_type;
 538
 539   if(unlikely(is_compact)) {
 540     g_assert(field->field_size != 0);
 541     /* FIXME THIS IS A HUUUUUGE hack :
 542      * offset is between the compact_data field in struct LttEvent
 543      * and the address of the field root in the memory map.
 544      * ark. Both will stay at the same addresses while the event
 545      * is readable, so it's ok.
 546      */
 547     field->offset_root = (unsigned long)(&tf->event.compact_data)
 548                                 - (unsigned long)root;
 549     field->fixed_root = FIELD_FIXED;
 550     return;
 551   }
 552
 553   switch(type->type_class) {
 554     case LTT_INT_FIXED:
 555     case LTT_UINT_FIXED:
 556     case LTT_POINTER:
 557     case LTT_CHAR:
 558     case LTT_UCHAR:
 559     case LTT_SHORT:
 560     case LTT_USHORT:
 561     case LTT_INT:
 562     case LTT_UINT:
 563     case LTT_LONG:
 564     case LTT_ULONG:
 565     case LTT_SIZE_T:
 566     case LTT_SSIZE_T:
 567     case LTT_OFF_T:
 568     case LTT_FLOAT:
 569     case LTT_ENUM:
 570       if(field->fixed_root == FIELD_VARIABLE) {
 571         /* Align offset on type size */
 572         *offset += ltt_align(*offset, get_alignment(field),
 573                              fac->alignment);
 574         /* remember offset */
 575         field->offset_root = *offset;
 576         /* Increment offset */
 577         *offset += field->field_size;
 578       } else {
 579         //g_debug("type before offset : %llu %llu %u\n", *offset,
 580         //    field->offset_root,
 581         //    field->field_size);
 582         *offset = field->offset_root;
 583         *offset += field->field_size;
 584         //g_debug("type after offset : %llu\n", *offset);
 585       }
 586       break;
 587     case LTT_STRING:
 588       if(field->fixed_root == FIELD_VARIABLE) {
 589         field->offset_root = *offset;
 590       }
 591       *offset += strlen((gchar*)(root+*offset)) + 1;
 592       /* Realign the data */
 593       *offset += ltt_align(*offset, fac->pointer_size,
 594                            fac->alignment);
 595       break;
 596     case LTT_ARRAY:
 597       g_assert(type->fields->len == 1);
 598       {
 599         off_t local_offset;
 600         LttField *child = &g_array_index(type->fields, LttField, 0);
 601         if(field->fixed_root == FIELD_VARIABLE) {
 602           *offset += ltt_align(*offset, get_alignment(field),
 603                               fac->alignment);
 604           /* remember offset */
 605           field->offset_root = *offset;
 606           field->array_offset = *offset;
 607         }
 608
 609         if(field->field_size != 0) {
 610           /* Increment offset */
 611           /* field_size is the array size in bytes */
 612           *offset = field->offset_root + field->field_size;
 613         } else {
 614           guint i;
 615           *offset = field->array_offset;
 616           field->dynamic_offsets = g_array_set_size(field->dynamic_offsets,
 617                                                     0);
 618           for(i=0; i<type->size; i++) {
 619             g_array_append_val(field->dynamic_offsets, *offset);
 620             compute_fields_offsets(tf, fac, child, offset, root, is_compact);
 621           }
 622         }
 623   //      local_offset = field->array_offset;
 624   //      /* Set the offset at position 0 */
 625   //      compute_fields_offsets(tf, fac, child, &local_offset, root);
 626       }
 627       break;
 628     case LTT_SEQUENCE:
 629       g_assert(type->fields->len == 2);
 630       {
 631         off_t local_offset;
 632         LttField *child;
 633         guint i;
 634         guint num_elem;
 635         if(field->fixed_root == FIELD_VARIABLE) {
 636           *offset += ltt_align(*offset, get_alignment(field),
 637                               fac->alignment);
 638           /* remember offset */
 639           field->offset_root = *offset;
 640
 641           child = &g_array_index(type->fields, LttField, 0);
 642           compute_fields_offsets(tf, fac, child, offset, root, is_compact);
 643           child = &g_array_index(type->fields, LttField, 1);
 644           *offset += ltt_align(*offset, get_alignment(child),
 645                                fac->alignment);
 646           field->array_offset = *offset;
 647
 648         } else {
 649           child = &g_array_index(type->fields, LttField, 1);
 650         }
 651         *offset = field->array_offset;
 652         field->dynamic_offsets = g_array_set_size(field->dynamic_offsets,
 653                                                   0);
 654         num_elem = ltt_event_field_element_number(&tf->event, field);
 655         for(i=0; i<num_elem; i++) {
 656           g_array_append_val(field->dynamic_offsets, *offset);
 657           compute_fields_offsets(tf, fac, child, offset, root, is_compact);
 658         }
 659         g_assert(num_elem == field->dynamic_offsets->len);
 660
 661         /* Realign the data */
 662         *offset += ltt_align(*offset, fac->pointer_size,
 663                              fac->alignment);
 664
 665  //       local_offset = field->array_offset;
 666  //       /* Set the offset at position 0 */
 667  //       compute_fields_offsets(tf, fac, child, &local_offset, root);
 668       }
 669       break;
 670     case LTT_STRUCT:
 671       {
 672         LttField *child;
 673         guint i;
 674         gint ret=0;
 675         if(field->fixed_root == FIELD_VARIABLE) {
 676           *offset += ltt_align(*offset, get_alignment(field),
 677                                fac->alignment);
 678           /* remember offset */
 679           field->offset_root = *offset;
 680         } else {
 681           *offset = field->offset_root;
 682         }
 683         for(i=0; i<type->fields->len; i++) {
 684           child = &g_array_index(type->fields, LttField, i);
 685           compute_fields_offsets(tf, fac, child, offset, root, is_compact);
 686         }
 687       }
 688       break;
 689     case LTT_UNION:
 690       {
 691         LttField *child;
 692         guint i;
 693         gint ret=0;
 694         if(field->fixed_root == FIELD_VARIABLE) {
 695           *offset += ltt_align(*offset, get_alignment(field),
 696                                fac->alignment);
 697           /* remember offset */
 698           field->offset_root = *offset;
 699         }
 700         for(i=0; i<type->fields->len; i++) {
 701           *offset = field->offset_root;
 702           child = &g_array_index(type->fields, LttField, i);
 703           compute_fields_offsets(tf, fac, child, offset, root, is_compact);
 704         }
 705         *offset = field->offset_root + field->field_size;
 706       }
 707       break;
 708     case LTT_NONE:
 709     default:
 710       g_error("compute_fields_offsets : unknown type");
 711   }
 712
 713 }
 714
 715
 716 /*****************************************************************************
 717  *Function name
 718  *    compute_offsets : set the dynamically computable offsets of an event type
 719  *Input params
 720  *    tf : tracefile
 721  *    event : event type
 722  *
 723  ****************************************************************************/
 724 void compute_offsets(LttTracefile *tf, LttFacility *fac,
 725     LttEventType *event, off_t *offset, void *root)
 726 {
 727   guint i;
 728
 729   /* compute all variable offsets */
 730   for(i=0; i<event->fields->len; i++) {
 731     //g_debug("computing offset %u of %u\n", i, event->fields->len-1);
 732     LttField *field = &g_array_index(event->fields, LttField, i);
 733     if(event->has_compact_data && i == 0)
 734             compute_fields_offsets(tf, fac, field, offset, root, 1);
 735     else
 736             compute_fields_offsets(tf, fac, field, offset, root, 0);
 737   }
 738
 739 }
 740 #endif //0