X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Fevent.c;h=0c208c48dd8f4ce2a7728b90e5b2326f4fedd65d;hb=dd3a6d3981f13150b4262a418f5ee00c715eda71;hp=cf0b21f5c541f255100c993d10cd60eece45a7bc;hpb=f2923fb2ab6ecc36c74e7845b7b07fe96d3d6d67;p=lttv.git

diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c
index cf0b21f5..0c208c48 100644
--- a/ltt/branches/poly/ltt/event.c
+++ b/ltt/branches/poly/ltt/event.c
@@ -1,19 +1,20 @@
 /* This file is part of the Linux Trace Toolkit viewer
  * Copyright (C) 2003-2004 Xiangxiu Yang
+ *               2006 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
- * published by the Free Software Foundation;
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License Version 2.1 as published by the Free Software Foundation.
  *
- * This program is distributed in the hope that it will be useful,
+ * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
- * MA 02111-1307, USA.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
  */
 
 #ifdef HAVE_CONFIG_H
@@ -38,7 +39,7 @@
 
 
 void compute_fields_offsets(LttTracefile *tf,
-    LttFacility *fac, LttField *field, off_t *offset, void *root);
+    LttFacility *fac, LttField *field, off_t *offset, void *root, guint is_compact);
 
 
 LttEvent *ltt_event_new()
@@ -52,137 +53,6 @@ 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 
- *Input params
- *    offsetRoot      : offset from the root
- *    offsetParent    : offset from the parent
- *    fld             : field
- *    evD             : event data
- *    reverse_byte_order : 1 or 0
- *Return value
- *    int             : size of the field
- ****************************************************************************/
-
-int ltt_event_refresh_fields(int offsetRoot,int offsetParent, 
-			     LttField * fld, void *evD, gboolean reverse_byte_order)
-{
-  int size, size1, element_number, i, offset1, offset2;
-  LttType * type = fld->field_type;
-
-  switch(type->type_class) {
-    case LTT_ARRAY:
-      element_number = (int) type->element_number;
-      if(fld->field_fixed == 0){// has string or sequence
-        size = 0;
-        for(i=0;i<element_number;i++){
-          size += ltt_event_refresh_fields(offsetRoot+size,size, 
-             fld->child[0], evD+size, reverse_byte_order);
-        }
-      }else size = fld->field_size;
-      break;
-
-    case LTT_SEQUENCE:
-      size1 = fld->sequ_number_size;
-      element_number = getIntNumber(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;i<element_number;i++){
-          size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, 
-                   fld->child[0], evD+size+size1, reverse_byte_order);
-        }	
-        size += size1;
-      }
-      break;
-
-    case LTT_STRING:
-      size = strlen((gchar*)evD) + 1; //include end : '\0'
-      break;
-
-    case LTT_STRUCT:
-      element_number = (int) type->element_number;
-      if(fld->field_fixed == 0){
-        offset1 = offsetRoot;
-        offset2 = 0;
-        for(i=0;i<element_number;i++){
-          size=ltt_event_refresh_fields(offset1,offset2,
-                               fld->child[i],evD+offset2, reverse_byte_order);
-          offset1 += size;
-          offset2 += size;
-        }      
-        size = offset2;
-      }else size = fld->field_size;
-      break;
-      
-    case LTT_UNION:
-      size = fld->field_size;
-      break;
-
-    default:
-      size = fld->field_size;
-  }
-
-#if 0
-  if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
-     type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
-    size = fld->field_size;
-  }else if(type->type_class == LTT_ARRAY){
-    element_number = (int) type->element_number;
-    if(fld->field_fixed == 0){// has string or sequence
-      size = 0;
-      for(i=0;i<element_number;i++){
-	      size += ltt_event_refresh_fields(offsetRoot+size,size, 
-					 fld->child[0], evD+size);
-      }
-    }else size = fld->field_size;
-  }else if(type->type_class == LTT_SEQUENCE){
-    size1 = fld->sequ_number_size;
-    element_number = getIntNumber(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;i<element_number;i++){
-	      size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, 
-				       	 fld->child[0], evD+size+size1);
-      }	
-      size += size1;
-    }
-  }else if(type->type_class == LTT_STRING){
-    size = strlen((char*)evD) + 1; //include end : '\0'
-  }else if(type->type_class == LTT_STRUCT){
-    element_number = (int) type->element_number;
-    if(fld->field_fixed == 0){
-      offset1 = offsetRoot;
-      offset2 = 0;
-      for(i=0;i<element_number;i++){
-	      size=ltt_event_refresh_fields(offset1,offset2,
-                                      fld->child[i],evD+offset2);
-      	offset1 += size;
-      	offset2 += size;
-      }      
-      size = offset2;
-    }else size = fld->field_size;
-  }
-#endif //0
-  fld->offset_root     = offsetRoot;
-  fld->offset_parent   = offsetParent;
-  fld->fixed_root      = (offsetRoot==-1)   ? 0 : 1;
-  fld->fixed_parent    = (offsetParent==-1) ? 0 : 1;
-  fld->field_size      = size;
-
-  return size;
-}
-#endif //0
-
-
 /*****************************************************************************
  *Function name
  *    ltt_event_eventtype_id: get event type id 
@@ -300,6 +170,16 @@ void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
 }
 
 
+void ltt_event_position_set(LttEventPosition *ep, LttTracefile *tf,
+        guint block, guint offset, guint64 tsc)
+{
+  ep->tracefile = tf;
+  ep->block = block;
+  ep->offset = offset;
+  ep->tsc = tsc;
+}
+
+
 /*****************************************************************************
  *Function name
  *    ltt_event_position : get the event's position
@@ -484,7 +364,7 @@ LttField *ltt_event_field_element_select(LttEvent *e, LttField *f, gulong i)
     new_offset = g_array_index(f->dynamic_offsets, off_t, i);
   }
   compute_fields_offsets(e->tracefile, 
-      ltt_event_facility(e), field, &new_offset, e->data);
+      ltt_event_facility(e), field, &new_offset, e->data, 0);
 
   return field;
 }
@@ -503,100 +383,137 @@ off_t ltt_event_field_offset(LttEvent *e, LttField *f)
  ****************************************************************************/
 guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f)
 {
-  gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
-
-  LttTypeEnum t = f->field_type.type_class;
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    reverse_byte_order = LTT_GET_BO(e->tracefile);
+  }
 
-  if(f->field_size == 1){
-    guint8 x = *(guint8 *)(e->data + f->offset_root);
-    return (guint32) x;    
-  }else if(f->field_size == 2){
+  switch(f->field_size) {
+  case 1:
+    {
+      guint8 x = *(guint8 *)(e->data + f->offset_root);
+      return (guint32) x;    
+    }
+    break;
+  case 2:
     return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 4){
+    break;
+  case 4:
     return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
+    break;
+  case 8:
+  default:
+    g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
+    return 0;
+    break;
   }
-#if 0
-  else if(f->field_size == 8){
-    guint64 x = *(guint64 *)(e->data + f->offset_root);
-    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
-      return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);    
-    else
-      return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);    
-  }
-#endif //0
-  g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
-  return 0;
 }
 
 gint32 ltt_event_get_int(LttEvent *e, LttField *f)
 {
-  gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    reverse_byte_order = LTT_GET_BO(e->tracefile);
+  }
 
-  if(f->field_size == 1){
-    gint8 x = *(gint8 *)(e->data + f->offset_root);
-    return (gint32) x;    
-  }else if(f->field_size == 2){
+  switch(f->field_size) {
+  case 1:
+    {
+      gint8 x = *(gint8 *)(e->data + f->offset_root);
+      return (gint32) x;    
+    }
+    break;
+  case 2:
     return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 4){
+    break;
+  case 4:
     return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
+    break;
+  case 8:
+  default:
+    g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
+    return 0;
+    break;
   }
-#if 0
-  else if(f->field_size == 8){
-    gint64 x = *(gint64 *)(e->data + f->offset_root);
-    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
-      return (int) (revFlag ? GINT64_FROM_BE(x): x);    
-    else
-      return (int) (revFlag ? GINT64_FROM_LE(x): x);    
-  }
-#endif //0
-  g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
-  return 0;
 }
 
 guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 {
-  gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
-
-  LttTypeEnum t = f->field_type.type_class;
-
-  if(f->field_size == 1){
-    guint8 x = *(guint8 *)(e->data + f->offset_root);
-    return (guint64) x;    
-  }else if(f->field_size == 2){
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    reverse_byte_order = LTT_GET_BO(e->tracefile);
+  }
+  
+  switch(f->field_size) {
+  case 1:
+    {
+      guint8 x = *(guint8 *)(e->data + f->offset_root);
+      return (guint64) x;    
+    }
+    break;
+  case 2:
     return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 4){
+    break;
+  case 4:
     return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 8){
+    break;
+  case 8:
     return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root);
+    break;
+  default:
+    g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
+    return 0;
+    break;
   }
-  g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
-  return 0;
 }
 
 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 = LTT_GET_BO(e->tracefile);
-
-  if(f->field_size == 1){
-    gint8 x = *(gint8 *)(e->data + f->offset_root);
-    return (gint64) x;    
-  }else if(f->field_size == 2){
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    reverse_byte_order = LTT_GET_BO(e->tracefile);
+  }
+  
+  switch(f->field_size) {
+  case 1:
+    {
+      gint8 x = *(gint8 *)(e->data + f->offset_root);
+      return (gint64) x;    
+    }
+    break;
+  case 2:
     return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 4){
+    break;
+  case 4:
     return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
-  }else if(f->field_size == 8){
+    break;
+  case 8:
     return ltt_get_int64(reverse_byte_order, e->data + f->offset_root);
+    break;
+  default:
+    g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
+    return 0;
+    break;
   }
-  g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
-  return 0;
 }
 
 float ltt_event_get_float(LttEvent *e, LttField *f)
 {
-  g_assert(LTT_HAS_FLOAT(e->tracefile));
-  gboolean reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    g_assert(LTT_HAS_FLOAT(e->tracefile));
+    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
+  }
 
   g_assert(f->field_type.type_class == LTT_FLOAT && f->field_size == 4);
 
@@ -610,8 +527,13 @@ float ltt_event_get_float(LttEvent *e, LttField *f)
 
 double ltt_event_get_double(LttEvent *e, LttField *f)
 {
-  g_assert(LTT_HAS_FLOAT(e->tracefile));
-  gboolean reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
+  gboolean reverse_byte_order;
+  if(unlikely(f->field_type.network)) {
+    reverse_byte_order = (g_ntohs(0x1) != 0x1);
+  } else {
+    g_assert(LTT_HAS_FLOAT(e->tracefile));
+    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
+  }
 
   if(f->field_size == 4)
     return ltt_event_get_float(e, f);
@@ -637,163 +559,6 @@ char *ltt_event_get_string(LttEvent *e, LttField *f)
   return (gchar*)g_strdup((gchar*)(e->data + f->offset_root));
 }
 
-
-/*****************************************************************************
- *Function name
- *    get_field_type_size : set the fixed and dynamic sizes of the field type
- *    from the data read.
- *Input params 
- *    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.
- ****************************************************************************/
- // TODO
-// Change this function so it uses a *to offset value incrementation, just like
-// genevent-new instead of returning a size. What is of interest here is the
-// offset needed to read each field.
-//
-// Precomputed ones can be returned directly. Otherwise, the field is flagged
-// "VARIABLE OFFSET" and must be computed dynamically. The dynamic processing
-// of an offset takes the last known fixed offset, and then dynamically
-// calculates all variable field offsets from it.
-//
-// After a VARIABLE SIZE element, all fields have a variable offset.
-// Also, is an array or a sequence has variable length child, we must pass
-// through all of them, saving the offsets in the dynamic_offsets array.
-
-#if 0
-size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type,
-    off_t offset_root, off_t offset_parent,
-    LttField *field, void *data)
-{
-  size_t size = 0;
-  guint i;
-  LttType *type;
-	off_t align;
-  
-  g_assert(field->fixed_root != FIELD_UNKNOWN);
-  g_assert(field->fixed_parent != FIELD_UNKNOWN);
-  g_assert(field->fixed_size != FIELD_UNKNOWN);
-
-  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;
-      align = ltt_align(field->offset_root,
-																size, event_type->facility->alignment);
-			field->offset_root += align;
-			field->offset_parent += align;
-			size += align;
-      break;
-    case LTT_SEQUENCE:
-      {
-				/* FIXME : check the type of sequence identifier */
-        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;i<seqnum;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_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;i<field->field_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;i<type->element_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;i<type->element_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;
-}
-#endif //0
-
-
-
-
-
 /*****************************************************************************
  *Function name
  *    compute_fields_offsets : set the precomputable offset of the fields
@@ -805,10 +570,24 @@ size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type,
 
 
 void compute_fields_offsets(LttTracefile *tf, 
-    LttFacility *fac, LttField *field, off_t *offset, void *root)
+    LttFacility *fac, LttField *field, off_t *offset, void *root, guint is_compact)
 {
   LttType *type = &field->field_type;
 
+  if(unlikely(is_compact)) {
+    g_assert(field->field_size != 0);
+    /* FIXME THIS IS A HUUUUUGE hack :
+     * offset is between the compact_data field in struct LttEvent
+     * and the address of the field root in the memory map.
+     * ark. Both will stay at the same addresses while the event
+     * is readable, so it's ok.
+     */
+    field->offset_root = (unsigned long)(&tf->event.compact_data)
+    				- (unsigned long)root;
+    field->fixed_root = FIELD_FIXED;
+    return;
+  }
+
   switch(type->type_class) {
     case LTT_INT_FIXED:
     case LTT_UINT_FIXED:
@@ -876,7 +655,7 @@ void compute_fields_offsets(LttTracefile *tf,
                                                     0);
           for(i=0; i<type->size; i++) {
             g_array_append_val(field->dynamic_offsets, *offset);
-            compute_fields_offsets(tf, fac, child, offset, root);
+            compute_fields_offsets(tf, fac, child, offset, root, is_compact);
           }
         }
   //      local_offset = field->array_offset;
@@ -898,7 +677,7 @@ void compute_fields_offsets(LttTracefile *tf,
           field->offset_root = *offset;
 
           child = &g_array_index(type->fields, LttField, 0);
-          compute_fields_offsets(tf, fac, child, offset, root);
+          compute_fields_offsets(tf, fac, child, offset, root, is_compact);
           child = &g_array_index(type->fields, LttField, 1);
           *offset += ltt_align(*offset, get_alignment(child),
                                fac->alignment);
@@ -913,7 +692,7 @@ void compute_fields_offsets(LttTracefile *tf,
         num_elem = ltt_event_field_element_number(&tf->event, field);
         for(i=0; i<num_elem; i++) {
           g_array_append_val(field->dynamic_offsets, *offset);
-          compute_fields_offsets(tf, fac, child, offset, root);
+          compute_fields_offsets(tf, fac, child, offset, root, is_compact);
         }
         g_assert(num_elem == field->dynamic_offsets->len);
 
@@ -932,7 +711,7 @@ void compute_fields_offsets(LttTracefile *tf,
         guint i;
         gint ret=0;
         if(field->fixed_root == FIELD_VARIABLE) {
-          *offset += ltt_align(*offset, get_alignment(fac, field),
+          *offset += ltt_align(*offset, get_alignment(field),
                                fac->alignment);
           /* remember offset */
           field->offset_root = *offset;
@@ -941,7 +720,7 @@ void compute_fields_offsets(LttTracefile *tf,
         }
         for(i=0; i<type->fields->len; i++) {
           child = &g_array_index(type->fields, LttField, i);
-          compute_fields_offsets(tf, fac, child, offset, root);
+          compute_fields_offsets(tf, fac, child, offset, root, is_compact);
         }
       }
       break;
@@ -959,7 +738,7 @@ void compute_fields_offsets(LttTracefile *tf,
         for(i=0; i<type->fields->len; i++) {
           *offset = field->offset_root;
           child = &g_array_index(type->fields, LttField, i);
-          compute_fields_offsets(tf, fac, child, offset, root);
+          compute_fields_offsets(tf, fac, child, offset, root, is_compact);
         }
         *offset = field->offset_root + field->field_size;
       }
@@ -989,7 +768,10 @@ void compute_offsets(LttTracefile *tf, LttFacility *fac,
   for(i=0; i<event->fields->len; i++) {
     //g_debug("computing offset %u of %u\n", i, event->fields->len-1);
     LttField *field = &g_array_index(event->fields, LttField, i);
-    compute_fields_offsets(tf, fac, field, offset, root);
+    if(event->has_compact_data && i == 0)
+	    compute_fields_offsets(tf, fac, field, offset, root, 1);
+    else
+	    compute_fields_offsets(tf, fac, field, offset, root, 0);
   }
 
 }