control flow view works (state computation enabled) : has bugs with multiple cpus

[lttv.git] / ltt / branches / poly / lttv / lttv / tracecontext.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Michel Dagenais
 *
 * 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 program 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.
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>
#include <lttv/tracecontext.h>
#include <ltt/event.h>
#include <ltt/facility.h>
#include <ltt/trace.h>
#include <ltt/type.h>
#include <errno.h>




gint compare_tracefile(gconstpointer a, gconstpointer b)
{
  gint comparison = 0;

  const LttvTracefileContext *trace_a = (const LttvTracefileContext *)a;
  const LttvTracefileContext *trace_b = (const LttvTracefileContext *)b;

  if(likely(trace_a != trace_b)) {
    comparison = ltt_time_compare(trace_a->timestamp, trace_b->timestamp);
    if(unlikely(comparison == 0)) {
      if(trace_a->index < trace_b->index) comparison = -1;
      else if(trace_a->index > trace_b->index) comparison = 1;
      else if(trace_a->t_context->index < trace_b->t_context->index) 
        comparison = -1;
      else if(trace_a->t_context->index > trace_b->t_context->index)
        comparison = 1;
    }
  }
  return comparison;
}

struct _LttvTracesetContextPosition {
  GArray *ep;                        /* Array of LttEventPosition */
  GArray *tfc;                       /* Array of corresponding
                                        TracefileContext* */
  LttTime timestamp;                 /* Current time at the saved position */ 
                                     /* If ltt_time_infinite : no position is
                                      * set, else, a position is set (may be end
                                      * of trace, with ep->len == 0) */
};

void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts)
{
  LTTV_TRACESET_CONTEXT_GET_CLASS(self)->init(self, ts);
}


void lttv_context_fini(LttvTracesetContext *self)
{
  LTTV_TRACESET_CONTEXT_GET_CLASS(self)->fini(self);
}


LttvTracesetContext *
lttv_context_new_traceset_context(LttvTracesetContext *self)
{
  return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_traceset_context(self);
}




LttvTraceContext * 
lttv_context_new_trace_context(LttvTracesetContext *self)
{
  return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
}


LttvTracefileContext *
lttv_context_new_tracefile_context(LttvTracesetContext *self)
{
  return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
}

/****************************************************************************
 * lttv_traceset_context_compute_time_span
 *
 * Keep the time span is sync with on the fly addition and removal of traces
 * in a trace set. It must be called each time a trace is added/removed from
 * the traceset. It could be more efficient to call it only once a bunch
 * of traces are loaded, but the calculation is not long, so it's not
 * critical.
 *
 * Author : Xang Xiu Yang
 ***************************************************************************/
static void lttv_traceset_context_compute_time_span(
                                          LttvTracesetContext *self,
	                              				  TimeInterval *time_span)
{
  LttvTraceset * traceset = self->ts;
  int numTraces = lttv_traceset_number(traceset);
  int i;
  LttTime s, e;
  LttvTraceContext *tc;
  LttTrace * trace;

  time_span->start_time.tv_sec = 0;
  time_span->start_time.tv_nsec = 0;
  time_span->end_time.tv_sec = 0;
  time_span->end_time.tv_nsec = 0;
  
  for(i=0; i<numTraces;i++){
    tc = self->traces[i];
    trace = tc->t;

    ltt_trace_time_span_get(trace, &s, &e);

    if(i==0){
      time_span->start_time = s;
      time_span->end_time   = e;
    }else{
      if(s.tv_sec < time_span->start_time.tv_sec 
          || (s.tv_sec == time_span->start_time.tv_sec 
               && s.tv_nsec < time_span->start_time.tv_nsec))
	      time_span->start_time = s;
      if(e.tv_sec > time_span->end_time.tv_sec
          || (e.tv_sec == time_span->end_time.tv_sec 
               && e.tv_nsec > time_span->end_time.tv_nsec))
        time_span->end_time = e;      
    }
  }
}

static void init_tracefile_context(LttTracefile *tracefile,
                                    LttvTraceContext *tc)
{
  LttvTracefileContext *tfc;
  LttvTracesetContext *tsc = tc->ts_context;
  
  tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->new_tracefile_context(tsc);

  tfc->index = tc->tracefiles->len;
  tc->tracefiles = g_array_append_val(tc->tracefiles, tfc);

  tfc->tf = tracefile;

  tfc->t_context = tc;
  tfc->event = lttv_hooks_new();
  tfc->event_by_id = lttv_hooks_by_id_new();
  tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
}


static void
init(LttvTracesetContext *self, LttvTraceset *ts)
{
  guint i, nb_trace;

  LttvTraceContext *tc;

  GData **tracefiles_groups;

  struct compute_tracefile_group_args args;

  nb_trace = lttv_traceset_number(ts);
  self->ts = ts;
  self->traces = g_new(LttvTraceContext *, nb_trace);
  self->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
  self->ts_a = lttv_traceset_attribute(ts);
  self->sync_position = lttv_traceset_context_position_new();
  for(i = 0 ; i < nb_trace ; i++) {
    tc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
    self->traces[i] = tc;

    tc->ts_context = self;
    tc->index = i;
    tc->vt = lttv_traceset_get(ts, i);
    tc->t = lttv_trace(tc->vt);
    tc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
    tc->t_a = lttv_trace_attribute(tc->vt);
    tc->tracefiles = g_array_sized_new(FALSE, TRUE,
                        sizeof(LttvTracefileContext*), 10);

    tracefiles_groups = ltt_trace_get_tracefiles_groups(tc->t);
    if(tracefiles_groups != NULL) {
      args.func = (ForEachTraceFileFunc)init_tracefile_context;
      args.func_args = tc;

      g_datalist_foreach(tracefiles_groups, 
                            (GDataForeachFunc)compute_tracefile_group,
                            &args);
    }
      
#if 0
    nb_control = ltt_trace_control_tracefile_number(tc->t);
    nb_per_cpu = ltt_trace_per_cpu_tracefile_number(tc->t);
    nb_tracefile = nb_control + nb_per_cpu;
    tc->tracefiles = g_new(LttvTracefileContext *, nb_tracefile);

    for(j = 0 ; j < nb_tracefile ; j++) {
      tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
      tc->tracefiles[j] = tfc;
      tfc->index = j;

      if(j < nb_control) {
        tfc->control = TRUE;
        tfc->tf = ltt_trace_control_tracefile_get(tc->t, j);
      }
      else {
        tfc->control = FALSE;
        tfc->tf = ltt_trace_per_cpu_tracefile_get(tc->t, j - nb_control);
      }

      tfc->t_context = tc;
      tfc->e = ltt_event_new();
      tfc->event = lttv_hooks_new();
      tfc->event_by_id = lttv_hooks_by_id_new();
      tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
    }
#endif //0

  }
  self->pqueue = g_tree_new(compare_tracefile);
  lttv_process_traceset_seek_time(self, ltt_time_zero);
  lttv_traceset_context_compute_time_span(self, &self->time_span);

}


void fini(LttvTracesetContext *self)
{
  guint i, j, nb_trace, nb_tracefile;

  LttvTraceContext *tc;

  LttvTracefileContext **tfc;

  LttvTraceset *ts = self->ts;

  g_tree_destroy(self->pqueue);
  g_object_unref(self->a);
  lttv_traceset_context_position_destroy(self->sync_position);

  nb_trace = lttv_traceset_number(ts);

  for(i = 0 ; i < nb_trace ; i++) {
    tc = self->traces[i];

    g_object_unref(tc->a);

    nb_tracefile = tc->tracefiles->len;

    for(j = 0 ; j < nb_tracefile ; j++) {
      tfc = &g_array_index(tc->tracefiles, LttvTracefileContext*, j);
      lttv_hooks_destroy((*tfc)->event);
      lttv_hooks_by_id_destroy((*tfc)->event_by_id);
      g_object_unref((*tfc)->a);
      g_object_unref(*tfc);
    }
    g_array_free(tc->tracefiles, TRUE);
    g_object_unref(tc);
  }
  g_free(self->traces);
}


void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
    LttvHooks *before_traceset,
    LttvHooks *before_trace, 
    LttvHooks *before_tracefile,
    LttvHooks *event,
    LttvHooksById *event_by_id)
{
  LttvTraceset *ts = self->ts;

  guint i, nb_trace;

  LttvTraceContext *tc;

  lttv_hooks_call(before_traceset, self);

  nb_trace = lttv_traceset_number(ts);

  for(i = 0 ; i < nb_trace ; i++) {
    tc = self->traces[i];
    lttv_trace_context_add_hooks(tc,
                                 before_trace,
                                 before_tracefile,
                                 event,
                                 event_by_id);
  }
}


void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
    LttvHooks *after_traceset,
    LttvHooks *after_trace, 
    LttvHooks *after_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id)
{

  LttvTraceset *ts = self->ts;

  guint i, nb_trace;

  LttvTraceContext *tc;

  nb_trace = lttv_traceset_number(ts);

  for(i = 0 ; i < nb_trace ; i++) {
    tc = self->traces[i];
    lttv_trace_context_remove_hooks(tc,
                                    after_trace,
                                    after_tracefile,
                                    event,
                                    event_by_id);
  }

  lttv_hooks_call(after_traceset, self);


}

void lttv_trace_context_add_hooks(LttvTraceContext *self,
    LttvHooks *before_trace, 
    LttvHooks *before_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id)
{
  guint i, nb_tracefile;

  LttvTracefileContext **tfc;

  lttv_hooks_call(before_trace, self);

  nb_tracefile = self->tracefiles->len;

  for(i = 0 ; i < nb_tracefile ; i++) {
    tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
    lttv_tracefile_context_add_hooks(*tfc,
                                     before_tracefile,
                                     event,
                                     event_by_id);
  }
}



void lttv_trace_context_remove_hooks(LttvTraceContext *self,
    LttvHooks *after_trace, 
    LttvHooks *after_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id)
{
  guint i, nb_tracefile;

  LttvTracefileContext **tfc;

  nb_tracefile = self->tracefiles->len;

  for(i = 0 ; i < nb_tracefile ; i++) {
    tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
    lttv_tracefile_context_remove_hooks(*tfc,
                                        after_tracefile,
                                        event,
                                        event_by_id);
  }

  lttv_hooks_call(after_trace, self);
}

void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
          LttvHooks *before_tracefile,
          LttvHooks *event, 
          LttvHooksById *event_by_id)
{
  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 < 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,
           LttvHooks *after_tracefile,
           LttvHooks *event, 
           LttvHooksById *event_by_id)
{
  guint i, index;

  LttvHooks *hook;
  
  lttv_hooks_remove_list(self->event, event);
  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, index));
    }
  }

  lttv_hooks_call(after_tracefile, self);
}



void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *tfc,
					    unsigned i,
					    LttvHooks *event_by_id)
{
  LttvHooks * h;
  h = lttv_hooks_by_id_find(tfc->event_by_id, i);
  lttv_hooks_add_list(h, event_by_id);
}

void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *tfc,
					       unsigned i)
{
  lttv_hooks_by_id_remove(tfc->event_by_id, i);
}

static LttvTracesetContext *
new_traceset_context(LttvTracesetContext *self)
{
  return g_object_new(LTTV_TRACESET_CONTEXT_TYPE, NULL);
}


static LttvTraceContext * 
new_trace_context(LttvTracesetContext *self)
{
  return g_object_new(LTTV_TRACE_CONTEXT_TYPE, NULL);
}


static LttvTracefileContext *
new_tracefile_context(LttvTracesetContext *self)
{
  return g_object_new(LTTV_TRACEFILE_CONTEXT_TYPE, NULL);
}


static void
traceset_context_instance_init (GTypeInstance *instance, gpointer g_class)
{
  /* Be careful of anything which would not work well with shallow copies */
}


static void
traceset_context_finalize (LttvTracesetContext *self)
{
  G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACESET_CONTEXT_TYPE)))
      ->finalize(G_OBJECT(self));
}


static void
traceset_context_class_init (LttvTracesetContextClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self))traceset_context_finalize;
  klass->init = init;
  klass->fini = fini;
  klass->new_traceset_context = new_traceset_context;
  klass->new_trace_context = new_trace_context;
  klass->new_tracefile_context = new_tracefile_context;
}


GType 
lttv_traceset_context_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTracesetContextClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) traceset_context_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTracesetContext),
      0,      /* n_preallocs */
      (GInstanceInitFunc) traceset_context_instance_init, /* instance_init */
      NULL    /* Value handling */
    };

    type = g_type_register_static (G_TYPE_OBJECT, "LttvTracesetContextType", 
        &info, 0);
  }
  return type;
}


static void
trace_context_instance_init (GTypeInstance *instance, gpointer g_class)
{
  /* Be careful of anything which would not work well with shallow copies */
}


static void
trace_context_finalize (LttvTraceContext *self)
{
  G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACE_CONTEXT_TYPE)))->
      finalize(G_OBJECT(self));
}


static void
trace_context_class_init (LttvTraceContextClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self)) trace_context_finalize;
}


GType 
lttv_trace_context_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTraceContextClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) trace_context_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTraceContext),
      0,      /* n_preallocs */
      (GInstanceInitFunc) trace_context_instance_init,    /* instance_init */
      NULL    /* Value handling */
    };

    type = g_type_register_static (G_TYPE_OBJECT, "LttvTraceContextType", 
        &info, 0);
  }
  return type;
}


static void
tracefile_context_instance_init (GTypeInstance *instance, gpointer g_class)
{
  /* Be careful of anything which would not work well with shallow copies */
}


static void
tracefile_context_finalize (LttvTracefileContext *self)
{
  G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACEFILE_CONTEXT_TYPE)))
      ->finalize(G_OBJECT(self));
}


static void
tracefile_context_class_init (LttvTracefileContextClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self))tracefile_context_finalize;
}


GType 
lttv_tracefile_context_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTracefileContextClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) tracefile_context_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTracefileContext),
      0,      /* n_preallocs */
      (GInstanceInitFunc) tracefile_context_instance_init,    /* instance_init */
      NULL    /* Value handling */
    };

    type = g_type_register_static (G_TYPE_OBJECT, "LttvTracefileContextType", 
        &info, 0);
  }
  return type;
}



static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
  g_assert(key == value);
  *((LttvTracefileContext **)user_data) = (LttvTracefileContext *)value;
  return TRUE;
}

#ifdef DEBUG
// Test to see if pqueue is traversed in the right order.
static LttTime test_time;

static gboolean test_tree(gpointer key, gpointer value, gpointer user_data) {

  LttvTracefileContext *tfc = (LttvTracefileContext *)key;

  g_debug("Tracefile name %s, time %lu.%lu, tfi %u, ti %u",
      g_quark_to_string(ltt_tracefile_name(tfc->tf)),
      tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec,
      tfc->index, tfc->t_context->index);
  
  if(user_data != NULL) {
    if(((LttvTracefileContext *)user_data) == (LttvTracefileContext *)value) {
      g_assert(compare_tracefile(user_data, value) == 0);
    } else
      g_assert(compare_tracefile(user_data, value) != 0);
  }
  g_assert(ltt_time_compare(test_time, tfc->timestamp) <= 0);
  test_time.tv_sec = tfc->timestamp.tv_sec;
  test_time.tv_nsec = tfc->timestamp.tv_nsec;

  
  //g_assert(((LttvTracefileContext *)user_data) != (LttvTracefileContext *)value);
  return FALSE;
}
#endif //DEBUG



void lttv_process_traceset_begin(LttvTracesetContext *self,
                                 LttvHooks       *before_traceset,
                                 LttvHooks       *before_trace,
                                 LttvHooks       *before_tracefile,
                                 LttvHooks       *event,
                                 LttvHooksById   *event_by_id)
{

  /* simply add hooks in context. _before hooks are called by add_hooks. */
  /* It calls all before_traceset, before_trace, and before_tracefile hooks. */
  lttv_traceset_context_add_hooks(self,
                                  before_traceset,
                                  before_trace,
                                  before_tracefile,
                                  event,
                                  event_by_id);
  
}

enum read_state { LAST_NONE, LAST_OK, LAST_EMPTY };

/* Note : a _middle must be preceded from a _seek or another middle */
guint lttv_process_traceset_middle(LttvTracesetContext *self,
                              LttTime end,
                              guint nb_events,
                              const LttvTracesetContextPosition *end_position)
{
  GTree *pqueue = self->pqueue;

  guint fac_id, ev_id, id;

  LttvTracefileContext *tfc;

  LttEvent *e;
  
  unsigned count = 0;

  guint read_ret;

  enum read_state last_read_state = LAST_NONE;

  gboolean last_ret = FALSE; /* return value of the last hook list called */

  /* Get the next event from the pqueue, call its hooks, 
     reinsert in the pqueue the following event from the same tracefile 
     unless the tracefile is finished or the event is later than the 
     end time. */

  while(TRUE) {
    tfc = NULL;
    g_tree_foreach(pqueue, get_first, &tfc);
    /* End of traceset : tfc is NULL */
    if(unlikely(tfc == NULL))
    {
      return count;
    }

    /* Have we reached :
     * - the maximum number of events specified?
     * - the end position ?
     * - the end time ?
     * then the read is finished. We leave the queue in the same state and
     * break the loop.
     */

    if(unlikely(last_ret == TRUE ||
                ((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))
    {
      return count;
    }
    
    /* 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. */
 
#ifdef DEBUG
    test_time.tv_sec = 0;
    test_time.tv_nsec = 0;
    g_debug("test tree before remove");
    g_tree_foreach(pqueue, test_tree, tfc);
#endif //DEBUG
    g_tree_remove(pqueue, tfc);

#ifdef DEBUG
    test_time.tv_sec = 0;
    test_time.tv_nsec = 0;
    g_debug("test tree after remove");
    g_tree_foreach(pqueue, test_tree, tfc);
#endif //DEBUG

    e = ltt_tracefile_get_event(tfc->tf);

    if(last_read_state != LAST_EMPTY) {
      /* Only call hooks if the last read has given an event or if we are at the
       * first pass (not if last read returned end of tracefile) */
      count++;
      
      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);
    }
    
    read_ret = ltt_tracefile_read(tfc->tf);

    if(likely(!read_ret)) {
      g_debug("An event is ready");
      tfc->timestamp = ltt_event_time(e);
      g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
	    g_tree_insert(pqueue, tfc, tfc);
#ifdef DEBUG
      test_time.tv_sec = 0;
      test_time.tv_nsec = 0;
      g_debug("test tree after event ready");
      g_tree_foreach(pqueue, test_tree, NULL);
#endif //DEBUG

      last_read_state = LAST_OK;
    } else {
      tfc->timestamp = ltt_time_infinite;

      if(read_ret == ERANGE) {
        last_read_state = LAST_EMPTY;
        g_debug("End of trace");
      } else
        g_error("Error happened in lttv_process_traceset_middle");
    }
  }
}


void lttv_process_traceset_end(LttvTracesetContext *self,
                               LttvHooks           *after_traceset,
                               LttvHooks           *after_trace,
                               LttvHooks           *after_tracefile,
                               LttvHooks           *event,
                               LttvHooksById       *event_by_id)
{
  /* Remove hooks from context. _after hooks are called by remove_hooks. */
  /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
  lttv_traceset_context_remove_hooks(self,
                                     after_traceset,
                                     after_trace,
                                     after_tracefile,
                                     event,
                                     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;

  gint ret;
  
  LttvTracefileContext **tfc;

  nb_tracefile = self->tracefiles->len;

  g_tree_destroy(self->ts_context->pqueue);
  self->ts_context->pqueue = g_tree_new(compare_tracefile);

  GTree *pqueue = self->ts_context->pqueue;

  for(i = 0 ; i < nb_tracefile ; i++) {
    tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);

    //g_tree_remove(pqueue, *tfc);
    
    ret = ltt_tracefile_seek_time((*tfc)->tf, start);
    if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");

    if(ret == 0) { /* not ERANGE especially */
      (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
      g_assert(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0);
      g_tree_insert(pqueue, (*tfc), (*tfc));
    } else {
      (*tfc)->timestamp = ltt_time_infinite;
    }
  }
#ifdef DEBUG
  test_time.tv_sec = 0;
  test_time.tv_nsec = 0;
  g_debug("test tree after seek_time");
  g_tree_foreach(pqueue, test_tree, NULL);
#endif //DEBUG



}


void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
{
  guint i, nb_trace;

  LttvTraceContext *tc;

  nb_trace = lttv_traceset_number(self->ts);
  for(i = 0 ; i < nb_trace ; i++) {
    tc = self->traces[i];
    lttv_process_trace_seek_time(tc, start);
  }
}


gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self, 
                                        const LttvTracesetContextPosition *pos)
{
  guint i;
  
  /* If a position is set, seek the traceset to this position */
  if(ltt_time_compare(pos->timestamp, ltt_time_infinite) != 0) {
    g_tree_destroy(self->pqueue);
    self->pqueue = g_tree_new(compare_tracefile);
    
    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);
      if(*ep != NULL) {
        if(ltt_tracefile_seek_position((*tfc)->tf, *ep) != 0)
          return 1;
        (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
        g_assert(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0);
        g_tree_insert(self->pqueue, (*tfc), (*tfc));
      } else {
        (*tfc)->timestamp = ltt_time_infinite;
      }
    }
  }
#ifdef DEBUG
  test_time.tv_sec = 0;
  test_time.tv_nsec = 0;
  g_debug("test tree after seek_position");
  g_tree_foreach(self->pqueue, test_tree, NULL);
#endif //DEBUG



  return 0;
}



static LttField *
find_field(LttEventType *et, const GQuark field)
{
  LttType *t;

  LttField *f;

  guint i, nb;

  GQuark name;

  /* Field is unset */
  if(field == 0) return NULL;
  
  f = ltt_eventtype_field(et);
  t = ltt_eventtype_type(et);
  g_assert(ltt_type_class(t) == LTT_STRUCT);
  nb = ltt_type_member_number(t);
  for(i = 0 ; i < nb ; i++) {
    ltt_type_member_type(t, i, &name);
    if(name == field) break;
  }
  g_assert(i < nb);
  return ltt_field_member(f, i);
}

LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th, 
                                                 guint facility_id)
{
  return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id);
}

/* Get the first facility corresponding to the name. As the types must be
 * compatible, it is relevant to use the field name and sizes of the first
 * facility to create data structures and assume the data will be compatible
 * thorough the trace */
LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th)
{
  g_assert(th->fac_list->len > 0);
  return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0);
}


/* Returns 0 on success, -1 if fails. */
gint
lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event, 
    GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data,
    LttvTraceHook *th)
{
  LttFacility *f;

  LttEventType *et, *first_et;

  GArray *facilities;

  guint i, fac_id, ev_id;

  LttvTraceHookByFacility *thf, *first_thf;

  facilities = ltt_trace_facility_get_by_name(t, facility);

  if(unlikely(facilities == NULL)) goto facility_error;

  th->fac_index = g_array_sized_new(FALSE, TRUE,
             sizeof(LttvTraceHookByFacility),
             NUM_FACILITIES);
  th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES);

  th->fac_list = g_array_sized_new(FALSE, TRUE,
             sizeof(LttvTraceHookByFacility*),
             facilities->len);
  th->fac_list = g_array_set_size(th->fac_list, facilities->len);
  
  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, 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 = 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);
  thf->hook_data = hook_data;
  
  first_thf = thf;
  first_et = et;

  /* Check for type compatibility too */
  for(i=1;i<facilities->len;i++) {
    fac_id = g_array_index(facilities, guint, i);
    f = ltt_trace_get_facility_by_num(t, fac_id);

    et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
    if(unlikely(et == NULL)) goto event_error;
    
    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 = 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))
      goto type_error;
        
    thf->f2 = find_field(et, field2);
    if(check_fields_compatibility(first_et, et,
        first_thf->f2, thf->f2))
      goto type_error;

    thf->f3 = find_field(et, field3);
    if(check_fields_compatibility(first_et, et,
        first_thf->f3, thf->f3))
      goto type_error;
    thf->hook_data = hook_data;
  }

  return 0;

type_error:
  goto free;
event_error:
  g_error("Event type %s does not exist", 
      g_quark_to_string(ltt_eventtype_name(et)));
  goto free;
facility_error:
  g_error("No %s facility", g_quark_to_string(facility));
  goto free;
free:
  g_array_free(th->fac_index, TRUE);
  g_array_free(th->fac_list, TRUE);
  th->fac_index = NULL;
  th->fac_list = NULL;
  return -1;
}

void lttv_trace_hook_destroy(LttvTraceHook *th)
{
  g_array_free(th->fac_index, TRUE);
  g_array_free(th->fac_list, TRUE);
}


LttvTracesetContextPosition *lttv_traceset_context_position_new()
{
  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;
}

/* Save all positions, the ones not in the pqueue will have NULL
 * ep. */
void lttv_traceset_context_position_save(const LttvTracesetContext *self,
                                    LttvTracesetContextPosition *pos)
{
  guint i;
  guint num_traces = lttv_traceset_number(self->ts);

  for(i=0; i<num_traces;i++) {
    GArray * tracefiles = self->traces[i]->tracefiles;
    guint j;
    guint num_tracefiles = tracefiles->len;

    for(j=0;j<num_tracefiles;j++) {
      LttvTracefileContext **tfc = &g_array_index(tracefiles,
          LttvTracefileContext*, j);

      LttEvent *event = ltt_tracefile_get_event((*tfc)->tf);
      LttEventPosition *ep;

      if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) {
        ep = ltt_event_position_new();
        ltt_event_position(event, ep);
        if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0)
          pos->timestamp = (*tfc)->timestamp;
      } else {
        ep = NULL;
      }
      g_array_append_val(pos->tfc, *tfc);
      g_array_append_val(pos->ep, ep);
    }

  }
}

void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
{
  int i;
  LttEventPosition **ep;
  
  for(i=0;i<pos->ep->len;i++) {
    ep = &g_array_index(pos->ep, LttEventPosition*, i);
    if(*ep != NULL)
      g_free(*ep);
  }
  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)
{
  int i;
  LttEventPosition **src_ep, **dest_ep;
  
  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++) {
    src_ep = &g_array_index(src->ep, LttEventPosition*, i);
    dest_ep = &g_array_index(dest->ep, LttEventPosition*, i);
    if(*src_ep != NULL) {
      *dest_ep = ltt_event_position_new();
      ltt_event_position_copy(
          *dest_ep,
          *src_ep);
    } else
      *dest_ep = NULL;
  }
  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)
{
  int i;
  int ret = 0;
  
  if(pos->ep->len == 0) {
    if(lttv_traceset_number(self->ts) == 0) return 0;
    else return 1;
  }
  if(lttv_traceset_number(self->ts) == 0)
    return -1;
  
  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);
    
    if(ep == NULL) {
      if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0) {
        ret = -1;
      }
    } else {
      if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) == 0) {
        ret = 1;
      } else {
        LttEvent *event = ltt_tracefile_get_event(tfc->tf);

        ret = ltt_event_position_compare((LttEventPosition*)event, 
                                          ep);
      }
    }
    if(ret != 0) return ret;

  }
  return 0;
}


gint lttv_traceset_context_pos_pos_compare(
                                  const LttvTracesetContextPosition *pos1,
                                  const LttvTracesetContextPosition *pos2)
{
  int i, j;
  int ret;
  
  if(pos1->ep->len == 0) {
    if(pos2->ep->len == 0) return 0;
    else return 1;
  }
  if(pos2->ep->len == 0)
    return -1;
  
  for(i=0;i<pos1->ep->len;i++) {
    LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i);
    LttvTracefileContext *tfc1 = g_array_index(pos1->tfc,
                                      LttvTracefileContext*, i);
    
    if(ep1 != NULL) {
      for(j=0;j<pos2->ep->len;j++) {
        LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
        LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
                                           LttvTracefileContext*, j);
        if(tfc1 == tfc2) {
          if(ep2 != NULL)
            ret = ltt_event_position_compare(ep1, ep2);
          else
            ret = -1;

          if(ret != 0) return ret;
        }
      }
    } else {
      for(j=0;j<pos2->ep->len;j++) {
        LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
        LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
                                           LttvTracefileContext*, j);
        if(tfc1 == tfc2) {
          if(ep2 != NULL) ret = 1;
        }
      }
    }
  }
  return 0;
}


LttTime lttv_traceset_context_position_get_time(
                                  const LttvTracesetContextPosition *pos)
{
  return pos->timestamp;
}


LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
{
  GTree *pqueue = self->pqueue;
  LttvTracefileContext *tfc = NULL;

  g_tree_foreach(pqueue, get_first, &tfc);

  return tfc;
}

/* lttv_process_traceset_synchronize_tracefiles
 *
 * Use the sync_position field of the trace set context to synchronize each
 * tracefile with the previously saved position.
 *
 * If no previous position has been saved, it simply does nothing.
 */
void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc)
{
  g_assert(lttv_process_traceset_seek_position(tsc, tsc->sync_position) == 0);
}




void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc)
{
  lttv_traceset_context_position_save(tsc, tsc->sync_position);
}