X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Fevent.c;h=395d46b114ef68d9ded7a7456f7f5f91effe99ec;hb=1d1df11d0582bef07ef2b33e8e82a75b08f32be4;hp=3b28f57616ed5baa6eb0ff74c3fc2fffdbfc6584;hpb=449cb9d7c0cdefefcf7a698a54e95168f24c5d4c;p=lttv.git

diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c
index 3b28f576..395d46b1 100644
--- a/ltt/branches/poly/ltt/event.c
+++ b/ltt/branches/poly/ltt/event.c
@@ -17,6 +17,9 @@
  */
 
 #include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
 #include <asm/types.h>
 #include <linux/byteorder/swab.h>
 
@@ -26,12 +29,24 @@
 #include <ltt/event.h>
 #include <ltt/trace.h>
 
+
+LttEvent *ltt_event_new()
+{
+  return g_new(LttEvent, 1);
+}
+
+void ltt_event_destroy(LttEvent *event)
+{
+  g_free(event);
+}
+
+
 /*****************************************************************************
  *Function name
  *    ltt_event_refresh_fields   : refresh fields of an event 
  *Input params
  *    offsetRoot      : offset from the root
- *    offsetParent    : offset from the parrent
+ *    offsetParent    : offset from the parent
  *    fld             : field
  *    evD             : event data
  *Return value
@@ -44,6 +59,62 @@ int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
   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);
+        }
+      }else size = fld->field_size;
+      break;
+
+    case 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;
+      }
+      break;
+
+    case LTT_STRING:
+      size = strlen((char*)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);
+          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;
@@ -52,9 +123,9 @@ int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
     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, 
+	      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;
@@ -65,8 +136,8 @@ int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
     }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 += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, 
+				       	 fld->child[0], evD+size+size1);
       }	
       size += size1;
     }
@@ -78,14 +149,15 @@ int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
       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=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;
@@ -155,21 +227,19 @@ LttField *ltt_event_field(LttEvent *e)
 {
   LttField * field;
   LttEventType * event_type = ltt_event_eventtype(e);
-  if(!event_type) return NULL;
+  if(unlikely(!event_type)) return NULL;
   field = event_type->root_field;
-  if(!field) return NULL;
+  if(unlikely(!field)) return NULL;
 
   //check if the field need refresh
-  if(e->which_block != event_type->latest_block ||
-     e->which_event != event_type->latest_event){
+  if(likely(e->which_block != event_type->latest_block ||
+            e->which_event != event_type->latest_event)){
 
     event_type->latest_block = e->which_block;
     event_type->latest_event = e->which_event;
     
-    if(field->field_fixed == 1)return field;
-
-    //refresh the field
-    ltt_event_refresh_fields(0, 0, field, e->data);    
+    if(unlikely(field->field_fixed != 1))
+      ltt_event_refresh_fields(0, 0, field, e->data);
   }
   return field;
 }
@@ -217,9 +287,17 @@ void ltt_event_position(LttEvent *e, LttEventPosition *ep)
   ep->event_time        = e->event_time;
   ep->event_cycle_count = e->event_cycle_count;
   ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
-  ep->old_position      = FALSE;
+  ep->old_position      = TRUE;
   ep->event_offset      = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
   ep->tf                = e->tracefile;
+
+  /* This is a workaround for fast position seek */
+  ep->last_event_pos = e->last_event_pos;
+  ep->prev_block_end_time = e->prev_block_end_time;
+  ep->prev_event_time = e->prev_event_time;
+  ep->pre_cycle_count = e->pre_cycle_count;
+  ep->count = e->count;
+  /* end of workaround */
 }
 
 LttEventPosition * ltt_event_position_new()
@@ -247,6 +325,8 @@ void ltt_event_position_get(LttEventPosition *ep,
 /*****************************************************************************
  *Function name
  *    ltt_event_position_set : set the block number and index of the event
+ *    It does put the old_position gboolean to FALSE, as it is impossible
+ *    to know the quick position to seek in the tracefile.
  *Input params
  *    ep                     : a pointer to event's position structure
  *    block_number           : the block number of the event
@@ -256,10 +336,106 @@ void ltt_event_position_get(LttEventPosition *ep,
 void ltt_event_position_set(LttEventPosition *ep,
     unsigned block_number, unsigned index_in_block)
 {
+  if(ep->block_num != block_number || ep->event_num != index_in_block)
+    ep->old_position = FALSE;
+
   ep->block_num = block_number;
-  ep->event_num = index_in_block;  
+  ep->event_num = index_in_block;
+  
 }
 
+/*****************************************************************************
+ * Function name
+ *    ltt_event_position_compare : compare two positions
+ *    A NULL value is infinite.
+ * Input params
+ *    ep1                    : a pointer to event's position structure
+ *    ep2                    : a pointer to event's position structure
+ * Return
+ *    -1 is ep1 < ep2
+ *    1 if ep1 > ep2
+ *    0 if ep1 == ep2
+ ****************************************************************************/
+
+
+gint ltt_event_position_compare(const LttEventPosition *ep1,
+                                const LttEventPosition *ep2)
+{
+  if(ep1->tf != ep2->tf)
+    g_error("ltt_event_position_compare on different tracefiles makes no sense");
+  if(ep1 == NULL && ep2 == NULL)
+      return 0;
+  if(ep1 != NULL && ep2 == NULL)
+      return -1;
+  if(ep1 == NULL && ep2 != NULL)
+      return 1;
+    
+  if(ep1->block_num < ep2->block_num)
+    return -1;
+  if(ep1->block_num > ep2->block_num)
+    return 1;
+  if(ep1->event_num < ep2->event_num)
+    return -1;
+  if(ep1->event_num > ep2->event_num)
+    return 1;
+  return 0;
+}
+
+/*****************************************************************************
+ * Function name
+ *    ltt_event_event_position_compare : compare two positions, one in event,
+ *    other in position opaque structure.
+ * Input params
+ *    event                  : a pointer to event structure
+ *    ep                     : a pointer to event's position structure
+ * Return
+ *    -1 is event < ep
+ *    1 if event > ep
+ *    0 if event == ep
+ ****************************************************************************/
+
+gint ltt_event_event_position_compare(const LttEvent *event,
+                                      const LttEventPosition *ep)
+{
+  if(event == NULL && ep == NULL)
+      return 0;
+  if(event != NULL && ep == NULL)
+      return -1;
+  if(event == NULL && ep != NULL)
+      return 1;
+
+  g_assert(event->tracefile == ep->tf);
+ 
+  if(event->which_block < ep->block_num)
+    return -1;
+  if(event->which_block > ep->block_num)
+    return 1;
+  if(event->which_event < ep->event_num)
+    return -1;
+  if(event->which_event > ep->event_num)
+    return 1;
+  return 0;
+}
+
+/*****************************************************************************
+ * Function name
+ *    ltt_event_position_copy : copy position
+ * Input params
+ *    src                    : a pointer to event's position structure source
+ *    dest                   : a pointer to event's position structure dest
+ * Return
+ *    void
+ ****************************************************************************/
+void ltt_event_position_copy(LttEventPosition *dest,
+                             const LttEventPosition *src)
+{
+  if(src == NULL)
+    dest = NULL;
+  else
+    *dest = *src;
+}
+
+
 /*****************************************************************************
  *Function name
  *    ltt_event_cpu_i: get the cpu id where the event happens
@@ -342,7 +518,8 @@ void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 {
   unsigned element_number;
   LttField *fld;
-  int k, size;
+  unsigned int k;
+  int size;
   void *evD;
  
   if(f->field_type->type_class != LTT_ARRAY &&
@@ -350,7 +527,9 @@ void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
     return ;
 
   element_number  = ltt_event_field_element_number(e,f);
-  if((element_number-1) < i || i < 0) return;
+  /* Sanity check for i : 1..n only, and must be lower or equal element_number
+   */
+  if(element_number < i || i == 0) return;
   
   fld = f->child[0];
   
@@ -359,7 +538,6 @@ void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
   for(k=0;k<i;k++){
     size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
   }
-
   f->current_element = i - 1;
 }
 
@@ -374,8 +552,7 @@ unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
                 e->tracefile->trace->system_description->endian ? 0:1;
   LttTypeEnum t = f->field_type->type_class;
 
-  if(t != LTT_UINT && t != LTT_ENUM)
-    g_error("The type of the field is not unsigned int\n");
+  g_assert(t == LTT_UINT || t == LTT_ENUM);
 
   if(f->field_size == 1){
     guint8 x = *(guint8 *)(e->data + f->offset_root);
@@ -399,6 +576,8 @@ unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
     else
       return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);    
   }
+  g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
+  return 0;
 }
 
 int ltt_event_get_int(LttEvent *e, LttField *f)
@@ -406,8 +585,7 @@ int ltt_event_get_int(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_INT)
-    g_error("The type of the field is not int\n");
+  g_assert(f->field_type->type_class == LTT_INT);
 
   if(f->field_size == 1){
     gint8 x = *(gint8 *)(e->data + f->offset_root);
@@ -431,6 +609,8 @@ int ltt_event_get_int(LttEvent *e, LttField *f)
     else
       return (int) (revFlag ? GINT64_FROM_LE(x): x);    
   }
+  g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
+  return 0;
 }
 
 unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
@@ -439,8 +619,7 @@ unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
                 e->tracefile->trace->system_description->endian ? 0:1;
   LttTypeEnum t = f->field_type->type_class;
 
-  if(t != LTT_UINT && t != LTT_ENUM)
-    g_error("The type of the field is not unsigned long\n");
+  g_assert(t == LTT_UINT || t == LTT_ENUM);
 
   if(f->field_size == 1){
     guint8 x = *(guint8 *)(e->data + f->offset_root);
@@ -464,6 +643,8 @@ unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
     else
       return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x);    
   }
+  g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
+  return 0;
 }
 
 long int ltt_event_get_long_int(LttEvent *e, LttField *f)
@@ -471,8 +652,7 @@ long int 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;
 
-  if( f->field_type->type_class != LTT_INT)
-    g_error("The type of the field is not long int\n");
+  g_assert( f->field_type->type_class == LTT_INT);
 
   if(f->field_size == 1){
     gint8 x = *(gint8 *)(e->data + f->offset_root);
@@ -496,6 +676,8 @@ long int ltt_event_get_long_int(LttEvent *e, LttField *f)
     else
       return (long) (revFlag ? GINT64_FROM_LE(x): x);    
   }
+  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)
@@ -503,16 +685,14 @@ float ltt_event_get_float(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_FLOAT || 
-     (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
-    g_error("The type of the field is not float\n");
+  g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
 
   if(revFlag == 0) return *(float *)(e->data + f->offset_root);
   else{
     guint32 aInt;
     memcpy((void*)&aInt, e->data + f->offset_root, 4);
     aInt = ___swab32(aInt);
-    return *((float*)&aInt);
+    return ((float)aInt);
   }
 }
 
@@ -521,16 +701,14 @@ double ltt_event_get_double(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_FLOAT || 
-     (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
-    g_error("The type of the field is not double\n");
+  g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
 
   if(revFlag == 0) return *(double *)(e->data + f->offset_root);
   else{
     guint64 aInt;
     memcpy((void*)&aInt, e->data + f->offset_root, 8);
     aInt = ___swab64(aInt);
-    return *((double *)&aInt);
+    return ((double)aInt);
   }
 }
 
@@ -541,7 +719,7 @@ double ltt_event_get_double(LttEvent *e, LttField *f)
 
 char *ltt_event_get_string(LttEvent *e, LttField *f)
 {
-  if(f->field_type->type_class != LTT_STRING)
-    g_error("The field contains no string\n");
+  g_assert(f->field_type->type_class == LTT_STRING);
+
   return (char*)g_strdup((char*)(e->data + f->offset_root));
 }