X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ftracecontext.c;h=a73e3d6ce608e12a8e66ecdab293f8afd23a9371;hb=698e81c2b57c2557ec70f7dfe53538d7359e0552;hp=d6ee6c4c85bd54c75e428ef0b09ebd6a654a8545;hpb=3865ea0940b718a7832b813a790f287140233efc;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/tracecontext.c b/ltt/branches/poly/lttv/lttv/tracecontext.c
index d6ee6c4c..a73e3d6c 100644
--- a/ltt/branches/poly/lttv/lttv/tracecontext.c
+++ b/ltt/branches/poly/lttv/lttv/tracecontext.c
@@ -26,11 +26,12 @@
 #include <ltt/facility.h>
 #include <ltt/trace.h>
 #include <ltt/type.h>
+#include <errno.h>
 
 
 
 
-static gint compare_tracefile(gconstpointer a, gconstpointer b)
+gint compare_tracefile(gconstpointer a, gconstpointer b)
 {
   gint comparison = 0;
 
@@ -47,18 +48,17 @@ static gint compare_tracefile(gconstpointer a, gconstpointer b)
       else if(trace_a->t_context->index > trace_b->t_context->index)
         comparison = 1;
     }
+  } else {
+    comparison = 0;
   }
+
   return comparison;
 }
 
-struct _LttvTraceContextPosition {
-  LttEventPosition **tf_pos;         /* Position in each tracefile       */
-  guint nb_tracefile;                /* Number of tracefiles (check)     */
-};
-
 struct _LttvTracesetContextPosition {
-  LttvTraceContextPosition *t_pos;    /* Position in each trace          */
-  guint nb_trace;                    /* Number of traces (check)         */
+  GArray *ep;                        /* Array of LttEventPosition */
+  GArray *tfc;                       /* Array of corresponding
+                                        TracefileContext* */
   LttTime timestamp;                 /* Current time at the saved position */
 };
 
@@ -350,7 +350,7 @@ void lttv_trace_context_add_hooks(LttvTraceContext *self,
   nb_tracefile = self->tracefiles->len;
 
   for(i = 0 ; i < nb_tracefile ; i++) {
-    tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
+    tfc = g_array_index(self->tracefiles, LttvTracefileContext*, i);
     lttv_tracefile_context_add_hooks(tfc,
                                      before_tracefile,
                                      event,
@@ -373,7 +373,7 @@ void lttv_trace_context_remove_hooks(LttvTraceContext *self,
   nb_tracefile = self->tracefiles->len;
 
   for(i = 0 ; i < nb_tracefile ; i++) {
-    tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
+    tfc = g_array_index(self->tracefiles, LttvTracefileContext*, i);
     lttv_tracefile_context_remove_hooks(tfc,
                                         after_tracefile,
                                         event,
@@ -388,18 +388,19 @@ void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
           LttvHooks *event, 
           LttvHooksById *event_by_id)
 {
-  guint i;
+  guint i, index;
 
   LttvHooks *hook;
   
   lttv_hooks_call(before_tracefile, self);
   lttv_hooks_add_list(self->event, event);
-  if(event_by_id != NULL)
-    for(i = 0; i < lttv_hooks_by_id_max_id(event_by_id); i++) {
-      hook = lttv_hooks_by_id_find(self->event_by_id, i);
-      lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, i));
+  if(event_by_id != NULL) {
+    for(i = 0; i < event_by_id->array->len; i++) {
+      index = g_array_index(event_by_id->array, guint, i);
+      hook = lttv_hooks_by_id_find(self->event_by_id, index);
+      lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, index));
     }
-
+  }
 }
 
 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
@@ -407,18 +408,19 @@ void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
            LttvHooks *event, 
            LttvHooksById *event_by_id)
 {
-  guint i;
+  guint i, index;
 
   LttvHooks *hook;
   
-
   lttv_hooks_remove_list(self->event, event);
-  if(event_by_id != NULL)
-    for(i = 0; i < lttv_hooks_by_id_max_id(event_by_id); i++) {
-      hook = lttv_hooks_by_id_get(self->event_by_id, i);
+  if(event_by_id != NULL) {
+    for(i = 0; i < event_by_id->array->len; i++) {
+      index = g_array_index(event_by_id->array, guint, i);
+      hook = lttv_hooks_by_id_get(self->event_by_id, index);
       if(hook != NULL)
-        lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, i));
+        lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, index));
     }
+  }
 
   lttv_hooks_call(after_tracefile, self);
 }
@@ -619,41 +621,10 @@ static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
   return TRUE;
 }
 
+static gboolean test_tree(gpointer key, gpointer value, gpointer user_data) {
 
-/* Put all the tracefiles at the tracefile context position */
-void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *self)
-{
-  guint iter_trace, nb_trace;
-
-  LttvTraceContext *tc;
-
-  nb_trace = lttv_traceset_number(self->ts);
-  
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-    tc = self->traces[iter_trace];
-    {
-      /* each trace */
-      guint iter_tf, nb_tracefile;
-
-      LttvTracefileContext *tfc;
-
-      nb_tracefile = tc->tracefiles->len;
-
-      for(iter_tf = 0 ; iter_tf < nb_tracefile ; iter_tf++) {
-        tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, iter_tf);
-        {
-          /* each tracefile */
-          //ltt_tracefile_copy(tfc->tf_sync_data, tfc->tf);
-          LttEventPosition *ep = ltt_event_position_new();
-
-          ltt_event_position(ltt_tracefile_get_event(tfc->tf), ep);
-          
-          ltt_tracefile_seek_position(tfc->tf, ep);
-          g_free(ep);
-        }
-      }
-    }
-  }
+  g_assert(((LttvTracefileContext *)user_data) != (LttvTracefileContext *)value);
+  return FALSE;
 }
 
 
@@ -685,7 +656,7 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self,
 {
   GTree *pqueue = self->pqueue;
 
-  guint id;
+  guint fac_id, ev_id, id;
 
   LttvTracefileContext *tfc;
 
@@ -693,6 +664,8 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self,
   
   unsigned count = 0;
 
+  guint read_ret = FALSE;
+
   gboolean last_ret = FALSE; /* return value of the last hook list called */
 
   /* Get the next event from the pqueue, call its hooks, 
@@ -718,7 +691,7 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self,
      */
 
     if(unlikely(last_ret == TRUE ||
-                count >= nb_events ||
+                ((count >= nb_events) && (nb_events != G_MAXULONG)) ||
      (end_position!=NULL&&lttv_traceset_context_ctx_pos_compare(self,
                                                           end_position) == 0)||
        ltt_time_compare(end, tfc->timestamp) <= 0))
@@ -729,18 +702,30 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self,
     /* Get the tracefile with an event for the smallest time found. If two
        or more tracefiles have events for the same time, hope that lookup
        and remove are consistent. */
-
+    
     g_tree_remove(pqueue, tfc);
+
+    g_tree_foreach(pqueue, test_tree, tfc);
     count++;
     
     e = ltt_tracefile_get_event(tfc->tf);
-    id = ltt_event_eventtype_id(e);
+    fac_id = ltt_event_facility_id(e);
+    ev_id = ltt_event_eventtype_id(e);
+    id = GET_HOOK_ID(fac_id, ev_id);
     last_ret = lttv_hooks_call_merge(tfc->event, tfc,
                         lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
 
-    if(likely(!ltt_tracefile_read(tfc->tf))) {
+    read_ret = ltt_tracefile_read(tfc->tf);
+
+    if(likely(!read_ret)) {
+      g_debug("got someting");
       tfc->timestamp = ltt_event_time(e);
 	    g_tree_insert(pqueue, tfc, tfc);
+    } else {
+      if(read_ret == ERANGE)
+        g_debug("End of trace");
+      else
+        g_error("Error happened in lttv_process_traceset_middle");
     }
   }
 }
@@ -763,6 +748,9 @@ void lttv_process_traceset_end(LttvTracesetContext *self,
                                      event_by_id);
 }
 
+/* Subtile modification : 
+ * if tracefile has no event at or after the time requested, it is not put in
+ * the queue, as the next read would fail. */
 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
 {
   guint i, nb_tracefile;
@@ -778,10 +766,13 @@ void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
   for(i = 0 ; i < nb_tracefile ; i++) {
     tfc = g_array_index(self->tracefiles, LttvTracefileContext*, i);
     ret = ltt_tracefile_seek_time(tfc->tf, start);
-    if(ret) g_error("error in lttv_process_trace_seek_time seek");
+    if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");
     g_tree_remove(pqueue, tfc);
-    tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
-    g_tree_insert(pqueue, tfc, tfc);
+
+    if(ret == 0) { /* not ERANGE especially */
+      tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
+      g_tree_insert(pqueue, tfc, tfc);
+    }
   }
 }
 
@@ -800,62 +791,25 @@ void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
 }
 
 
-gboolean lttv_process_tracefile_seek_position(LttvTracefileContext *self, 
-                                              const LttEventPosition *pos)
-{
-  LttvTracefileContext *tfc = self;
-
-  GTree *pqueue = self->t_context->ts_context->pqueue;
-  
-  ltt_tracefile_seek_position(tfc->tf, pos);
-  g_tree_remove(pqueue, tfc);
-  tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
-  g_tree_insert(pqueue, tfc, tfc);
-
-  return TRUE;
-}
-
-gboolean lttv_process_trace_seek_position(LttvTraceContext *self, 
-                                        const LttvTraceContextPosition *pos)
-{
-  guint i, nb_tracefile;
-
-  LttvTracefileContext *tfc;
-
-  nb_tracefile = self->tracefiles->len;
-
-  if(nb_tracefile != pos->nb_tracefile)
-    return FALSE; /* Error */
-
-  for(i = 0 ; i < nb_tracefile ; i++) {
-    tfc = g_array_index(self->tracefiles, LttvTracefileContext*, i);
-    lttv_process_tracefile_seek_position(tfc, pos->tf_pos[i]);
-  }
-
-  return TRUE;
-}
-
-
-
 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self, 
                                         const LttvTracesetContextPosition *pos)
 {
-  guint i, nb_trace;
-  gboolean sum_ret = TRUE;
-
+  guint i;
   LttvTraceContext *tc;
+  LttvTracefileContext *tfc;
 
-  nb_trace = lttv_traceset_number(self->ts);
+  g_tree_destroy(self->pqueue);
+  self->pqueue = g_tree_new(compare_tracefile);
   
-  if(nb_trace != pos->nb_trace)
-    return FALSE; /* Error */
-
-  for(i = 0 ; i < nb_trace ; i++) {
-    tc = self->traces[i];
-    sum_ret = sum_ret && lttv_process_trace_seek_position(tc, &pos->t_pos[i]);
+  for(i=0;i<pos->ep->len; i++) {
+    LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
+    LttvTracefileContext *tfc = 
+      g_array_index(pos->tfc, LttvTracefileContext*, i);
+    g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
+    tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
+    g_tree_insert(self->pqueue, tfc, tfc);
   }
-
-  return sum_ret;
+  return TRUE;
 }
 
 
@@ -914,7 +868,7 @@ lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
 
   GArray *facilities;
 
-  guint i, fac_id;
+  guint i, fac_id, ev_id;
 
   LttvTraceHookByFacility *thf, *first_thf;
 
@@ -935,14 +889,17 @@ lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
   fac_id = g_array_index(facilities, guint, 0);
   f = ltt_trace_get_facility_by_num(t, fac_id);
 
-  et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
+  et = ltt_facility_eventtype_get_by_name(f, event);
   if(unlikely(et == NULL)) goto event_error;
   
   thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
   g_array_index(th->fac_list, LttvTraceHookByFacility*, 0)
         = thf;
+
+  ev_id = ltt_eventtype_id(et);
+  
   thf->h = h;
-  thf->id = ltt_eventtype_id(et);
+  thf->id = GET_HOOK_ID(fac_id, ev_id);
   thf->f1 = find_field(et, field1);
   thf->f2 = find_field(et, field2);
   thf->f3 = find_field(et, field3);
@@ -960,8 +917,9 @@ lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
     thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
     g_array_index(th->fac_list, LttvTraceHookByFacility*, i)
           = thf;
+    ev_id = ltt_eventtype_id(et);
     thf->h = h;
-    thf->id = ltt_eventtype_id(et);
+    thf->id = GET_HOOK_ID(fac_id, ev_id);
     thf->f1 = find_field(et, field1);
     if(check_fields_compatibility(first_et, et,
         first_thf->f1, thf->f1))
@@ -1006,139 +964,90 @@ void lttv_trace_hook_destroy(LttvTraceHook *th)
 
 LttvTracesetContextPosition *lttv_traceset_context_position_new()
 {
-  return g_new(LttvTracesetContextPosition,1);
+  LttvTracesetContextPosition *pos = g_new(LttvTracesetContextPosition,1);
+  pos->ep = g_array_sized_new(FALSE, TRUE, sizeof(LttEventPosition*),
+                              10);
+  pos->tfc = g_array_sized_new(FALSE, TRUE, sizeof(LttvTracefileContext*),
+                              10);
+  pos->timestamp = ltt_time_infinite;
+  return pos;
 }
 
-
-void lttv_traceset_context_position_save(const LttvTracesetContext *self,
-                                    LttvTracesetContextPosition *pos)
+gboolean traverse_get_tfc(gpointer key, gpointer value, gpointer data)
 {
-  guint nb_trace, nb_tracefile;
-  guint iter_trace, iter_tracefile;
-  
-  LttvTraceContext *tc;
-  
-  LttvTracefileContext *tfc;
+  LttvTracefileContext *tfc = (LttvTracefileContext *)value;
+  LttvTracesetContextPosition *pos = (LttvTracesetContextPosition *)data;
 
-  LttEvent *event;
+  LttEvent *event = ltt_tracefile_get_event(tfc->tf);
+  LttEventPosition *ep = ltt_event_position_new();
+  
+  ltt_event_position(event, ep);
 
-  LttTime timestamp = self->time_span.end_time;
+  g_array_append_val(pos->ep, ep);
+  g_array_append_val(pos->tfc, tfc);
 
-  pos->nb_trace = nb_trace = lttv_traceset_number(self->ts);
-  pos->t_pos = g_new(LttvTraceContextPosition, nb_trace);
+  if(ltt_time_compare(tfc->timestamp, pos->timestamp) < 0)
+    pos->timestamp = tfc->timestamp;
   
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-    tc = self->traces[iter_trace];
+  return 0;
+}
 
-    nb_tracefile = tc->tracefiles->len;
-    pos->t_pos[iter_trace].nb_tracefile = nb_tracefile;
-      
-    pos->t_pos[iter_trace].tf_pos = g_new(LttEventPosition*, nb_tracefile);
-    for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
-      tfc = g_array_index(tc->tracefiles, LttvTracefileContext*,
-                            iter_tracefile);
-      event = ltt_tracefile_get_event(tfc->tf);
-      if(event!=NULL) {
-        pos->t_pos[iter_trace].tf_pos[iter_tracefile] 
-                                                = ltt_event_position_new();
-        ltt_event_position(event, 
-                           pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
-      } else {
-        pos->t_pos[iter_trace].tf_pos[iter_tracefile] = NULL;
-      }
-      if(ltt_time_compare(tfc->timestamp, timestamp) < 0)
-        timestamp = tfc->timestamp;
-    }
-  }
-  pos->timestamp = timestamp;
+/* Subtile modification :
+ * only save the tracefiles that are loaded in the pqueue */
+void lttv_traceset_context_position_save(const LttvTracesetContext *self,
+                                    LttvTracesetContextPosition *pos)
+{
+  g_tree_foreach(self->pqueue, traverse_get_tfc, pos);
 }
 
 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
 {
-  guint nb_trace;
-  guint iter_trace, iter_tracefile;
-  
-  nb_trace = pos->nb_trace;
-  
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-    for(iter_tracefile = 0; iter_tracefile < 
-                        pos->t_pos[iter_trace].nb_tracefile;
-                        iter_tracefile++) {
-      if(pos->t_pos[iter_trace].tf_pos[iter_tracefile] != NULL)
-        g_free(pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
-    }
-    g_free(pos->t_pos[iter_trace].tf_pos);
-  }
-  g_free(pos->t_pos);
-
+  int i;
+  for(i=0;i<pos->ep->len;i++)
+    g_free(g_array_index(pos->ep, LttEventPosition*, i));
+  g_array_free(pos->ep, TRUE);
+  g_array_free(pos->tfc, TRUE);
+  g_free(pos);
 }
 
 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
                                    const LttvTracesetContextPosition *src)
 {
-  guint nb_trace, nb_tracefile;
-  guint iter_trace, iter_tracefile;
+  int i;
   
-  nb_trace = dest->nb_trace = src->nb_trace;
-  dest->t_pos = g_new(LttvTraceContextPosition, nb_trace);
- 
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-
-    nb_tracefile = src->t_pos[iter_trace].nb_tracefile;
-    
-    dest->t_pos[iter_trace].nb_tracefile = nb_tracefile;
-
-    dest->t_pos[iter_trace].tf_pos = g_new(LttEventPosition*, nb_tracefile);
-
-    for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
-      dest->t_pos[iter_trace].tf_pos[iter_tracefile] = 
-                      ltt_event_position_new();
-      if(src->t_pos[iter_trace].tf_pos[iter_tracefile] != NULL)
-        ltt_event_position_copy(
-              dest->t_pos[iter_trace].tf_pos[iter_tracefile],
-              src->t_pos[iter_trace].tf_pos[iter_tracefile]);
-      else
-        dest->t_pos[iter_trace].tf_pos[iter_tracefile] = NULL;
-    }
+  g_array_set_size(dest->ep, src->ep->len);
+  g_array_set_size(dest->tfc, src->tfc->len);
+  
+  for(i=0;i<src->ep->len;i++) {
+    g_array_index(dest->ep, LttEventPosition*, i) = ltt_event_position_new();
+    ltt_event_position_copy(
+        g_array_index(dest->ep, LttEventPosition*, i),
+        g_array_index(src->ep, LttEventPosition*, i));
+  }
+  for(i=0;i<src->tfc->len;i++) {
+    g_array_index(dest->tfc, LttvTracefileContext*, i) =
+                    g_array_index(src->tfc, LttvTracefileContext*, i);
   }
-
   dest->timestamp = src->timestamp;
 }
 
 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
                                         const LttvTracesetContextPosition *pos)
 {
-  guint nb_trace, nb_tracefile;
-  guint iter_trace, iter_tracefile;
-  gint ret;
-
-  LttvTraceContext *tc;
-  
-  LttvTracefileContext *tfc;
+  int i;
+  int ret;
 
-  LttEvent *event;
+  for(i=0;i<pos->ep->len;i++) {
+    LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
+    LttvTracefileContext *tfc = 
+      g_array_index(pos->tfc, LttvTracefileContext*, i);
 
-  nb_trace = lttv_traceset_number(self->ts);
+    LttEvent *event = ltt_tracefile_get_event(tfc->tf);
 
-  if(unlikely(pos->nb_trace != nb_trace))
-    g_error("lttv_traceset_context_ctx_pos_compare : nb_trace does not match.");
-  
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-    tc = self->traces[iter_trace];
-    nb_tracefile = tc->tracefiles->len;
+    ret = ltt_event_position_compare((LttEventPosition*)event, 
+                                      ep);
+    if(ret != 0) return ret;
 
-    if(unlikely(pos->t_pos[iter_trace].nb_tracefile != nb_tracefile))
-      g_error("lttv_traceset_context_ctx_pos_compare : nb_tracefile does not match.");
-
-    for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
-      tfc = g_array_index(tc->tracefiles, LttvTracefileContext*,
-                            iter_tracefile);
-      event = ltt_tracefile_get_event(tfc->tf);
-      ret = ltt_event_position_compare((LttEventPosition*)event, 
-                             pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
-      if(ret != 0)
-        return ret;
-    }
   }
   return 0;
 }
@@ -1148,30 +1057,25 @@ gint lttv_traceset_context_pos_pos_compare(
                                   const LttvTracesetContextPosition *pos1,
                                   const LttvTracesetContextPosition *pos2)
 {
-  guint nb_trace, nb_tracefile;
-  guint iter_trace, iter_tracefile;
+  int i, j;
+  int ret;
   
-  gint ret;
-
-  nb_trace = pos1->nb_trace;
-  if(unlikely(nb_trace != pos2->nb_trace))
-    g_error("lttv_traceset_context_pos_pos_compare : nb_trace does not match.");
-
-  for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
-
-    nb_tracefile = pos1->t_pos[iter_trace].nb_tracefile;
-    if(unlikely(nb_tracefile != pos2->t_pos[iter_trace].nb_tracefile))
-      g_error("lttv_traceset_context_ctx_pos_compare : nb_tracefile does not match.");
+  for(i=0;i<pos1->ep->len;i++) {
+    LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i);
+    LttTracefile *tf1 = ltt_event_position_tracefile(ep1);
+    
+    for(j=0;j<pos2->ep->len;j++) {
+      LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
+      LttTracefile *tf2 = ltt_event_position_tracefile(ep2);
 
-    for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
-      ret = ltt_event_position_compare(
-                pos1->t_pos[iter_trace].tf_pos[iter_tracefile],
-                pos2->t_pos[iter_trace].tf_pos[iter_tracefile]);
-      if(ret != 0) 
-        return ret;
+      if(tf1 == tf2) {
+        ret = ltt_event_position_compare(ep1, ep2);
+        if(ret != 0) return ret;
+      }
     }
   }
   return 0;
+
 }