X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=3451d769ce207c6693785759f9db93b1b27ff351;hb=45e14832eebe9f25938b2c668d8ef1acd56a2436;hp=acd9954b872010b8cab1807afd9955f35737ab74;hpb=63c35f6c3a742bb0bcd558c4899221231bcb05d7;p=lttv.git

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index acd9954b..3451d769 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -24,6 +24,8 @@
 #include <sys/types.h>
 #include <errno.h>
 #include <unistd.h>
+#include <math.h>
+#include <glib/gstdio.h>
 
 // For realpath
 #include <limits.h>
@@ -37,6 +39,7 @@
 #include <ltt/facility.h>
 #include <ltt/event.h>
 #include <ltt/type.h>
+#include <ltt/ltt-types.h>
 
 #define DIR_NAME_SIZE 256
 #define __UNUSED__ __attribute__((__unused__))
@@ -44,6 +47,7 @@
 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
 
+#define g_close close
 
 /* obtain the time of an event */
 
@@ -61,7 +65,7 @@ static inline gint getFieldtypeSize(LttTracefile * tf,
 		     gint offsetParent, LttField *fld, void *evD, LttTrace* t);
 
 /* read a fixed size or a block information from the file (fd) */
-int readFile(int fd, void * buf, size_t size, char * mesg);
+int readFile(int fd, void * buf, size_t size, gchar * mesg);
 int readBlock(LttTracefile * tf, int whichBlock);
 
 /* calculate cycles per nsec for current block */
@@ -160,7 +164,7 @@ static void  parser_characters   (GMarkupParseContext __UNUSED__ *context,
  *                       : a pointer to a tracefile
  ****************************************************************************/ 
 
-LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
+LttTracefile* ltt_tracefile_open(LttTrace * t, gchar * fileName)
 {
   LttTracefile * tf;
   struct stat    lTDFStat;    /* Trace data file status */
@@ -170,7 +174,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
   //open the file
   tf->name = g_strdup(fileName);
   tf->trace = t;
-  tf->fd = open(fileName, O_RDONLY, 0);
+  tf->fd = g_open(fileName, O_RDONLY, 0);
   if(tf->fd < 0){
     g_warning("Unable to open input data file %s\n", fileName);
     g_free(tf->name);
@@ -182,7 +186,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
   if(fstat(tf->fd, &lTDFStat) < 0){
     g_warning("Unable to get the status of the input data file %s\n", fileName);
     g_free(tf->name);
-    close(tf->fd);
+    g_close(tf->fd);
     g_free(tf);
     return NULL;
   }
@@ -191,7 +195,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
   if(lTDFStat.st_size < (off_t)(sizeof(BlockStart) + EVENT_HEADER_SIZE)){
     g_print("The input data file %s does not contain a trace\n", fileName);
     g_free(tf->name);
-    close(tf->fd);
+    g_close(tf->fd);
     g_free(tf);
     return NULL;
   }
@@ -203,7 +207,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
   tf->which_block = 0;
 
   //allocate memory to contain the info of a block
-  tf->buffer = (void *) g_new(char, t->system_description->ltt_block_size);
+  tf->buffer = (void *) g_new(gchar, t->system_description->ltt_block_size);
 
   //read the first block
   if(readBlock(tf,1)) exit(1);
@@ -216,7 +220,7 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
  *Open control and per cpu tracefiles
  ****************************************************************************/
 
-void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
+void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name)
 {
   LttTracefile * tf;
   tf = ltt_tracefile_open(t,tracefile_name);
@@ -225,7 +229,7 @@ void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
   g_ptr_array_add(t->per_cpu_tracefiles, tf);
 }
 
-gint ltt_tracefile_open_control(LttTrace *t, char * control_name)
+gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name)
 {
   LttTracefile * tf;
   LttEvent ev;
@@ -249,7 +253,7 @@ gint ltt_tracefile_open_control(LttTrace *t, char * control_name)
 
       if(ev.event_id == TRACE_FACILITY_LOAD){
 	pos = ev.data;
-	fLoad.name = (char*)pos;
+	fLoad.name = (gchar*)pos;
 	fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
 	fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
 
@@ -297,10 +301,12 @@ void ltt_tracefile_close(LttTracefile *t)
 /*****************************************************************************
  *Get system information
  ****************************************************************************/
-gint getSystemInfo(LttSystemDescription* des, char * pathname)
+gint getSystemInfo(LttSystemDescription* des, gchar * pathname)
 {
-  FILE * fp;
-  char buf[DIR_NAME_SIZE];
+  int fd;
+  GIOChannel *iochan;
+  gchar *buf = NULL;
+  gsize length;
 
   GMarkupParseContext * context;
   GError * error = NULL;
@@ -313,27 +319,52 @@ gint getSystemInfo(LttSystemDescription* des, char * pathname)
       NULL   /*  error        */
     };
 
-  fp = fopen(pathname,"r");
-  if(!fp){
+  fd = g_open(pathname, O_RDONLY, 0);
+  if(fd == -1){
     g_warning("Can not open file : %s\n", pathname);
     return -1;
   }
   
+  iochan = g_io_channel_unix_new(fd);
+  
   context = g_markup_parse_context_new(&markup_parser, 0, des,NULL);
   
-  while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){
-    if(!g_markup_parse_context_parse(context, buf, DIR_NAME_SIZE, &error)){
+  //while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){
+  while(g_io_channel_read_line(iochan, &buf, &length, NULL, &error)
+      != G_IO_STATUS_EOF) {
+
+    if(error != NULL) {
+      g_warning("Can not read xml file: \n%s\n", error->message);
+      g_error_free(error);
+    }
+    if(!g_markup_parse_context_parse(context, buf, length, &error)){
       if(error != NULL) {
         g_warning("Can not parse xml file: \n%s\n", error->message);
         g_error_free(error);
       }
       g_markup_parse_context_free(context);
-      fclose(fp);
+
+      g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
+      if(error != NULL) {
+        g_warning("Can not close file: \n%s\n", error->message);
+        g_error_free(error);
+      }
+
+      close(fd);
       return -1;
     }
   }
   g_markup_parse_context_free(context);
-  fclose(fp);
+
+  g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
+  if(error != NULL) {
+    g_warning("Can not close file: \n%s\n", error->message);
+    g_error_free(error);
+  }
+
+  g_close(fd);
+
+  g_free(buf);
   return 0;
 }
 
@@ -341,30 +372,31 @@ gint getSystemInfo(LttSystemDescription* des, char * pathname)
  *The following functions get facility/tracefile information
  ****************************************************************************/
 
-gint getFacilityInfo(LttTrace *t, char* eventdefs)
+gint getFacilityInfo(LttTrace *t, gchar* eventdefs)
 {
-  DIR * dir;
-  struct dirent *entry;
-  char * ptr;
+  GDir * dir;
+  const gchar * name;
   unsigned int i,j;
   LttFacility * f;
   LttEventType * et;
-  char name[DIR_NAME_SIZE];
+  gchar fullname[DIR_NAME_SIZE];
+  GError * error = NULL;
+
+  dir = g_dir_open(eventdefs, 0, &error);
 
-  dir = opendir(eventdefs);
-  if(!dir) {
-    g_warning("Can not open directory: %s\n", eventdefs);
+  if(error != NULL) {
+    g_warning("Can not open directory: %s, %s\n", eventdefs, error->message);
+    g_error_free(error);
     return -1;
   }
 
-  while((entry = readdir(dir)) != NULL){
-    ptr = &entry->d_name[strlen(entry->d_name)-4];
-    if(strcmp(ptr,".xml") != 0) continue;
-    strcpy(name,eventdefs);
-    strcat(name,entry->d_name);
-    ltt_facility_open(t,name);
-  }  
-  closedir(dir);
+  while((name = g_dir_read_name(dir)) != NULL){
+    if(!g_pattern_match_simple("*.xml", name)) continue;
+    strcpy(fullname,eventdefs);
+    strcat(fullname,name);
+    ltt_facility_open(t,fullname);
+  }
+  g_dir_close(dir);
   
   for(j=0;j<t->facility_number;j++){
     f = (LttFacility*)g_ptr_array_index(t->facilities, j);
@@ -376,54 +408,60 @@ gint getFacilityInfo(LttTrace *t, char* eventdefs)
   return 0;
 }
 
-gint getControlFileInfo(LttTrace *t, char* control)
+gint getControlFileInfo(LttTrace *t, gchar* control)
 {
-  DIR * dir;
-  struct dirent *entry;
-  char name[DIR_NAME_SIZE];
+  GDir * dir;
+  const gchar *name;
+  gchar fullname[DIR_NAME_SIZE];
+  GError * error = NULL;
 
-  dir = opendir(control);
-  if(!dir) {
-    g_warning("Can not open directory: %s\n", control);
+  dir = g_dir_open(control, 0, &error);
+
+  if(error != NULL) {
+    g_warning("Can not open directory: %s, %s\n", control, error->message);
+    g_error_free(error);
     return -1;
   }
 
-  while((entry = readdir(dir)) != NULL){
-    if(strcmp(entry->d_name,"facilities") != 0 &&
-       strcmp(entry->d_name,"interrupts") != 0 &&
-       strcmp(entry->d_name,"processes") != 0) continue;
+  while((name = g_dir_read_name(dir)) != NULL){
+    if(strcmp(name,"facilities") != 0 &&
+       strcmp(name,"interrupts") != 0 &&
+       strcmp(name,"processes") != 0) continue;
     
-    strcpy(name,control);
-    strcat(name,entry->d_name);
-    if(ltt_tracefile_open_control(t,name))
+    strcpy(fullname,control);
+    strcat(fullname,name);
+    if(ltt_tracefile_open_control(t,fullname)) {
+      g_dir_close(dir);
       return -1;
+    }
   }  
-  closedir(dir);
+  g_dir_close(dir);
   return 0;
 }
 
 gint getCpuFileInfo(LttTrace *t, char* cpu)
 {
-  DIR * dir;
-  struct dirent *entry;
-  char name[DIR_NAME_SIZE];
+  GDir * dir;
+  const gchar * name;
+  gchar fullname[DIR_NAME_SIZE];
+  GError * error = NULL;
 
-  dir = opendir(cpu);
-  if(!dir) {
-    g_warning("Can not open directory: %s\n", cpu);
+  dir = g_dir_open(cpu, 0, &error);
+
+  if(error != NULL) {
+    g_warning("Can not open directory: %s, %s\n", cpu, error->message);
+    g_error_free(error);
     return -1;
   }
 
-  while((entry = readdir(dir)) != NULL){
-    if(strcmp(entry->d_name,".") != 0 &&
-       strcmp(entry->d_name,"..") != 0 &&
-       strcmp(entry->d_name,".svn") != 0){      
-      strcpy(name,cpu);
-      strcat(name,entry->d_name);
-      ltt_tracefile_open_cpu(t,name);
+  while((name = g_dir_read_name(dir)) != NULL){
+    if(strcmp(name,".svn") != 0){     /* . and .. already excluded */
+      strcpy(fullname,cpu);
+      strcat(fullname,name);
+      ltt_tracefile_open_cpu(t,fullname);
     }else continue;
   }  
-  closedir(dir);
+  g_dir_close(dir);
   return 0;
 }
 
@@ -446,7 +484,7 @@ gint getCpuFileInfo(LttTrace *t, char* cpu)
  * forgotten cases (.. were not used correctly before).
  *
  ****************************************************************************/
-void get_absolute_pathname(const char *pathname, char * abs_pathname)
+void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
 {
   abs_pathname[0] = '\0';
 
@@ -461,16 +499,16 @@ void get_absolute_pathname(const char *pathname, char * abs_pathname)
   return;
 }
 
-LttTrace *ltt_trace_open(const char *pathname)
+LttTrace *ltt_trace_open(const gchar *pathname)
 {
   LttTrace  * t;
   LttSystemDescription * sys_description;
-  char eventdefs[DIR_NAME_SIZE];
-  char info[DIR_NAME_SIZE];
-  char control[DIR_NAME_SIZE];
-  char cpu[DIR_NAME_SIZE];
-  char tmp[DIR_NAME_SIZE];
-  char abs_path[DIR_NAME_SIZE];
+  gchar eventdefs[DIR_NAME_SIZE];
+  gchar info[DIR_NAME_SIZE];
+  gchar control[DIR_NAME_SIZE];
+  gchar cpu[DIR_NAME_SIZE];
+  gchar tmp[DIR_NAME_SIZE];
+  gchar abs_path[DIR_NAME_SIZE];
   gboolean has_slash = FALSE;
 
   get_absolute_pathname(pathname, abs_path);
@@ -503,8 +541,8 @@ LttTrace *ltt_trace_open(const char *pathname)
   t->control_tracefiles = g_ptr_array_new();
   t->per_cpu_tracefiles = g_ptr_array_new();
   t->facilities         = g_ptr_array_new();
-  getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian));
-
+  //getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian));
+  
   //get system description  
   strcpy(tmp,info);
   strcat(tmp,"system.xml");
@@ -517,8 +555,15 @@ LttTrace *ltt_trace_open(const char *pathname)
     g_free(t);
     return NULL;
   }
-
-
+  
+  /* Set the reverse byte order between trace and reader */
+  if(sys_description->endian == LTT_LITTLE_ENDIAN 
+          && G_BYTE_ORDER != G_LITTLE_ENDIAN) {
+    t->reverse_byte_order = 1;
+  } else if(sys_description->endian == LTT_BIG_ENDIAN
+          && G_BYTE_ORDER != G_BIG_ENDIAN) {
+    t->reverse_byte_order = 1;
+  } else t->reverse_byte_order = 0;
 
   //get facilities info
   if(getFacilityInfo(t,eventdefs)) {
@@ -807,9 +852,9 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
   for(i=0;i<t->control_tracefile_number;i++){
     tf = g_ptr_array_index(t->control_tracefiles, i);
     readBlock(tf,1);
-    startTmp = tf->a_block_start->time;    
+    startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time);
     readBlock(tf,tf->block_number);
-    endTmp = tf->a_block_end->time;
+    endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time);
     if(i==0){
       startSmall = startTmp;
       endBig     = endTmp;
@@ -823,9 +868,9 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
   for(i=0;i<t->per_cpu_tracefile_number;i++){
     tf = g_ptr_array_index(t->per_cpu_tracefiles, i);
     readBlock(tf,1);
-    startTmp = tf->a_block_start->time;    
+    startTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_start->time);
     readBlock(tf,tf->block_number);
-    endTmp = tf->a_block_end->time;
+    endTmp = ltt_get_time(t->reverse_byte_order, &tf->a_block_end->time);
     if(j == 0 && i==0){
       startSmall = startTmp;
       endBig     = endTmp;
@@ -877,22 +922,26 @@ void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time,
   if(err) g_error("Can not read tracefile: %s\n", t->name); 
   if(start_block == end_block)return;
 
-  tailTime = ltt_time_compare(t->a_block_end->time, time);
+  tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                           &t->a_block_end->time), time);
   if(tailTime >= 0) return;
   
   err=readBlock(t,end_block);
   if(err) g_error("Can not read tracefile: %s\n", t->name); 
   if(start_block+1 == end_block)return;
   
-  headTime = ltt_time_compare(t->a_block_start->time, time);
+  headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                           &t->a_block_start->time), time);
   if(headTime <= 0 ) return;
   
   tmp_block = (end_block + start_block)/2;
   err=readBlock(t,tmp_block);
   if(err) g_error("Can not read tracefile: %s\n", t->name); 
 
-  headTime = ltt_time_compare(t->a_block_start->time, time);
-  tailTime = ltt_time_compare(t->a_block_end->time, time);
+  headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                           &t->a_block_start->time), time);
+  tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                           &t->a_block_end->time), time);
   if(headTime <= 0 && tailTime >= 0) return;
   
   if(headTime > 0){
@@ -917,14 +966,17 @@ void ltt_tracefile_backward_find_time_block(LttTracefile *t, LttTime time)
   int t_time, h_time, err;
   err=readBlock(t,t->which_block-1);
   if(err) g_error("Can not read tracefile: %s\n", t->name); 
-  h_time = ltt_time_compare(t->a_block_start->time, time);
-  t_time = ltt_time_compare(t->a_block_end->time, time);
+  h_time = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                         &t->a_block_start->time), time);
+  t_time = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                         &t->a_block_end->time), time);
   if(h_time == 0){
     int tmp;
     if(t->which_block == 1) return;
     err=readBlock(t,t->which_block-1);
     if(err) g_error("Can not read tracefile: %s\n", t->name); 
-    tmp = ltt_time_compare(t->a_block_end->time, time);
+    tmp = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                        &t->a_block_end->time), time);
     if(tmp == 0) return ltt_tracefile_seek_time(t, time);
     err=readBlock(t,t->which_block+1);
     if(err) g_error("Can not read tracefile: %s\n", t->name);     
@@ -942,12 +994,16 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
 {
   int err;
   LttTime lttTime;
-  int headTime = ltt_time_compare(t->a_block_start->time, time);
-  int tailTime = ltt_time_compare(t->a_block_end->time, time);
+  int headTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                               &t->a_block_start->time), time);
+  int tailTime = ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order,
+                                               &t->a_block_end->time), time);
   LttEvent ev;
 
   if(headTime < 0 && tailTime > 0){
-    if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) {
+    if(ltt_time_compare(ltt_get_time(t->trace->reverse_byte_order, 
+                                     &t->a_block_end->time),
+                        t->current_event_time) !=0) {
       lttTime = getEventTime(t);
       err = ltt_time_compare(lttTime, time);
       if(err > 0){
@@ -1077,19 +1133,19 @@ LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event)
     if(unlikely(err))g_error("Can not read tracefile");    
   }
 
-  event->event_id = (int)(*(guint16 *)(t->cur_event_pos));
+  event->event_id = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos);
   if(unlikely(event->event_id == TRACE_TIME_HEARTBEAT))
     t->cur_heart_beat_number++;
 
   t->prev_event_time  = t->current_event_time;
   //  t->current_event_time = getEventTime(t);
 
-  event->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
+  event->time_delta = ltt_get_uint32(t->trace->reverse_byte_order, t->cur_event_pos + EVENT_ID_SIZE);
   event->event_time = t->current_event_time;
   event->event_cycle_count = t->cur_cycle_count;
 
   event->tracefile = t;
-  event->data = t->cur_event_pos + EVENT_HEADER_SIZE;  
+  event->data = t->cur_event_pos + EVENT_HEADER_SIZE;
   event->which_block = t->which_block;
   event->which_event = t->which_event;
 
@@ -1141,176 +1197,6 @@ int readFile(int fd, void * buf, size_t size, char * mesg)
    return 0;
 }
 
-/*****************************************************************************
- *Function name
- *    skipEvent_pre_read_cycles : go to the next event,
- *             update the necessary fields of the current event
- *             increment the cycle counter, save it at the end.
- *Input params 
- *    t         : tracefile
- *return value 
- *    0               : success
- *    ERANGE          : event id is out of range
- ****************************************************************************/
-#if 0
-int skipEvent_pre_read_cycles(LttTracefile * t)
-{
-  int evId;
-  void * evData;
-  LttEventType * evT;
-  LttField * rootFld;
-
-  evId   = (int)(*(guint16 *)(t->cur_event_pos));
-  evData = t->cur_event_pos + EVENT_HEADER_SIZE;
-
-  evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
-    
-  if(likely(evT)) rootFld = evT->root_field;
-  else return ERANGE;
-  
-  if(likely(rootFld)){
-    //event has string/sequence or the last event is not the same event
-    if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event)
-       && rootFld->field_fixed == 0)){
-      setFieldsOffset(t, evT, evData, t->trace);
-    }
-    t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size;
-  }else t->cur_event_pos += EVENT_HEADER_SIZE;
-    
-  //evT->latest_block = t->which_block;
-  //evT->latest_event = t->which_event;
-  
-  //the next event is in the next block
-  //if(unlikely(evId == TRACE_BLOCK_END)){
-    // Specify end of buffer reached.
-  //  t->cur_event_pos = t->buffer + t->block_size;
-  //}else{
-    //g_critical("COUNT : %lu", t->cur_cycle_count);
-    //t->which_event++;
-   // t->current_event_time = getEventTime(t);
-  //}
-
-  return 0;
-}
-#endif //0
-
-
-
-/*****************************************************************************
- *Function name
- *    ltt_tracefile_pre_read_cycles : 
- *          read the current event, increment the cycle counter
- *Input params
- *    t                  : tracefile
- *Return value
- * False : end of bloc reached
- ****************************************************************************/
-#if 0
-gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf)
-{
-  int err;
-  //LttEvent event;
-
- // if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){
-    //if(unlikely(t->which_block == t->block_number)){
-    //  return FALSE;
-    //}
-   // return FALSE; // end of bloc reached
-    //err = readBlock(t, t->which_block + 1);
-    //if(unlikely(err))g_error("Can not read tracefile");    
-  //}
-
-  //event.event_id = (int)(*(guint16 *)(t->cur_event_pos));
-  //if(unlikely(event.event_id == TRACE_TIME_HEARTBEAT))
-  //  t->cur_heart_beat_number++;
-
-  //t->prev_event_time  = t->current_event_time;
-  //  t->current_event_time = getEventTime(t);
-
-  //event.time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
-  //event.event_time = t->current_event_time;
-  //event.event_cycle_count = t->cur_cycle_count;
-
-  //event.tracefile = t;
-  //event.data = t->cur_event_pos + EVENT_HEADER_SIZE;  
-  //event.which_block = t->which_block;
-  //event.which_event = t->which_event;
-
-  /* This is a workaround for fast position seek */
-  //event.last_event_pos = t->last_event_pos;
-  //event.prev_block_end_time = t->prev_block_end_time;
-  //event.prev_event_time = t->prev_event_time;
-  //event.pre_cycle_count = t->pre_cycle_count;
-  //event.count = t->count;
-  //event.last_heartbeat = t->last_heartbeat;
-  /* end of workaround */
-
-
-  /* Increment the cycle counter for the bloc */
-  LttTime       time;
-  LttCycleCount cycle_count;      // cycle count for the current event
-  LttCycleCount lEventTotalCycle; // Total cycles from start for event
-  LttCycleCount lEventNSec;       // Total nsecs from start for event
-  LttTime       lTimeOffset;      // Time offset in struct LttTime
-  guint16       evId;
-
-  evId = *(guint16 *)tf->cur_event_pos;
- 
-  // Calculate total time in cycles from start of buffer for this event
-  cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
-  //g_debug("event cycle count %llu", cycle_count);
-  //
-  //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
-  //LttCycleCount res_delta_count;
-  gboolean comp_count = cycle_count < tf->pre_cycle_count;
-  tf->pre_cycle_count = cycle_count;
-  
-  if(unlikely(comp_count)) {
-    /* Wrapped */
-    tf->count++; //increment wrap count
-  }
-  
-  //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
-  //if(unlikely(delta_count < 0)) {
-  //  tf->count++; //increment wrap count
-    // keep in mind that delta_count is negative here.
-  //  res_delta_count = delta_count + 0x100000000ULL ;
-  //} else
-  //  res_delta_count = (LttCycleCount)delta_count;
-  
-  //cycle_count += (LttCycleCount)tf->count << 32;  
-  
-  //FIXME (MD)
-  //  if(tf->cur_heart_beat_number > tf->count)
-  //    cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;  
-
-  //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
-  tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
-  //g_debug("cur cycle count %llu", tf->cur_cycle_count);
-
-
-
-
-  if(unlikely(evId == TRACE_BLOCK_START)){
-    //g_debug("BLOCK START");
-  }else if(unlikely(evId == TRACE_BLOCK_END)){
-    //g_debug("BLOCK END");
-
-    /* The goal of all this pre reading */
-    tf->a_block_end->cycle_count = tf->cur_cycle_count;
-    //g_debug("end of block cycle count : %llu", tf->cur_cycle_count);
-
-    return FALSE;
-  }
-
-  //update the fields of the current event and go to the next event
-  err = skipEvent_pre_read_cycles(tf);
-  if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
-
-
-  return TRUE;
-}
-#endif //0
 
 /****************************************************************************
  *Function name
@@ -1333,8 +1219,10 @@ int readBlock(LttTracefile * tf, int whichBlock)
   if((guint)whichBlock == tf->which_block) return 0;
   
   if(likely(whichBlock - tf->which_block == 1 && tf->which_block != 0)){
-    tf->prev_block_end_time = tf->a_block_end->time;
-    tf->prev_event_time     = tf->a_block_end->time;
+    tf->prev_block_end_time = ltt_get_time(tf->trace->reverse_byte_order,
+                                           &tf->a_block_end->time);
+    tf->prev_event_time     = ltt_get_time(tf->trace->reverse_byte_order,
+                                           &tf->a_block_end->time);
   }else{
     tf->prev_block_end_time.tv_sec = 0;
     tf->prev_block_end_time.tv_nsec = 0;
@@ -1365,66 +1253,15 @@ int readBlock(LttTracefile * tf, int whichBlock)
   /* read the whole block to precalculate total of cycles in it */
   tf->count = 0;
   tf->pre_cycle_count = 0;
-  tf->cur_cycle_count = 0;
-  //g_debug("precalculating cycles begin for block %i", whichBlock);
-  /* End of block event already has 64 bits cycle counter! */
-  //while(likely(ltt_tracefile_pre_read_cycles(tf)));
-  /* Rough approximation of cycles per usec to calculate
-   * the real block start and end time.
-   */
-  getCyclePerNsec(tf);
-  /* we are at end position, make end time more precise */
-  /* Start overflow_nsec to a negative value : takes account of the 
-   * start of block cycle counter */
-  //tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
-   //                                 * tf->nsec_per_cycle);
-  /* put back the numbers corresponding to end time */
-  //tf->overflow_nsec += tf->one_overflow_nsec * tf->count;
-
-  //tf->a_block_end->time = getEventTime(tf);  
- 
-  /* Make start time more precise */
-  /* Start overflow_nsec to a negative value : takes account of the 
-   * start of block cycle counter */
-  tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
-                                        * tf->nsec_per_cycle);
-
-  tf->a_block_start->time = getEventTime(tf);
-
-
-  {
-    guint64 lEventNSec;
-    LttTime lTimeOffset;
-    /* End time more precise */
-    lEventNSec = ((double)
-                 (tf->a_block_end->cycle_count - tf->a_block_start->cycle_count)
-                           * tf->nsec_per_cycle);
-    //g_assert(lEventNSec >= 0);
-    lTimeOffset = ltt_time_from_uint64(lEventNSec);
-    tf->a_block_end->time = ltt_time_add(tf->a_block_start->time, lTimeOffset); 
-  }
+  tf->cur_cycle_count = ltt_get_uint32(tf->trace->reverse_byte_order, tf->cur_event_pos + EVENT_ID_SIZE);
 
-  
-  //g_debug("precalculating cycles end for block %i", whichBlock);
-
-#if 0
-  /* put back pointer at the beginning */
-  tf->count = 0;
-  tf->pre_cycle_count = 0;
-  tf->cur_cycle_count = 0;
-  tf->which_event = 1;
-  tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev
-  tf->cur_heart_beat_number = 0;
-  tf->last_heartbeat = NULL;
-#endif //0
-
-  /* recalculate the cycles per nsec, with now more precise start and end time
-   */
   getCyclePerNsec(tf);
-  tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
-                                        * tf->nsec_per_cycle);
-
 
+  tf->overflow_nsec = 
+               (-((double)
+               (ltt_get_uint64(tf->trace->reverse_byte_order,
+                               &tf->a_block_start->cycle_count)&0xFFFFFFFF))
+                                        * tf->nsec_per_cycle);
 
   tf->current_event_time = getEventTime(tf);  
 
@@ -1450,7 +1287,9 @@ void updateTracefile(LttTracefile * tf)
   tf->prev_event_time.tv_nsec = 0;
   tf->count = 0;
 
-  tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
+  tf->overflow_nsec = 
+    (-((double)ltt_get_uint64(tf->trace->reverse_byte_order,
+                              &tf->a_block_start->cycle_count))
                                         * tf->nsec_per_cycle);
 
 }
@@ -1472,7 +1311,7 @@ int skipEvent(LttTracefile * t)
   LttEventType * evT;
   LttField * rootFld;
 
-  evId   = (int)(*(guint16 *)(t->cur_event_pos));
+  evId   = ltt_get_uint16(t->trace->reverse_byte_order, t->cur_event_pos);
   evData = t->cur_event_pos + EVENT_HEADER_SIZE;
 
   evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
@@ -1496,6 +1335,8 @@ int skipEvent(LttTracefile * t)
   if(unlikely(evId == TRACE_BLOCK_END)){
     t->cur_event_pos = t->buffer + t->block_size;
   }else{
+    t->cur_cycle_count = ltt_get_uint32(t->trace->reverse_byte_order,
+                                t->cur_event_pos + EVENT_ID_SIZE);
     t->which_event++;
     t->current_event_time = getEventTime(t);
   }
@@ -1517,31 +1358,27 @@ void getCyclePerNsec(LttTracefile * t)
 {
   LttTime           lBufTotalTime; /* Total time for this buffer */
   double            lBufTotalNSec; /* Total time for this buffer in nsecs */
-  double            lBufTotalCycle;/* Total cycles for this buffer */
+  LttCycleCount     lBufTotalCycle;/* Total cycles for this buffer */
 
   /* Calculate the total time for this buffer */
-  lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time);
+  lBufTotalTime = ltt_time_sub(
+       ltt_get_time(t->trace->reverse_byte_order, &t->a_block_end->time),
+       ltt_get_time(t->trace->reverse_byte_order, &t->a_block_start->time));
 
   /* Calculate the total cycles for this bufffer */
-  lBufTotalCycle  = t->a_block_end->cycle_count;
-  lBufTotalCycle -= t->a_block_start->cycle_count;
+  lBufTotalCycle  = ltt_get_uint64(t->trace->reverse_byte_order,
+                          &t->a_block_end->cycle_count);
+  lBufTotalCycle -= ltt_get_uint64(t->trace->reverse_byte_order,
+                          &t->a_block_start->cycle_count);
 
-  /* Convert the total time to nsecs */
+  /* Convert the total time to double */
   lBufTotalNSec  = ltt_time_to_double(lBufTotalTime);
   
   t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle;
+
   /* Pre-multiply one overflow (2^32 cycles) by nsec_per_cycle */
   t->one_overflow_nsec = t->nsec_per_cycle * (double)0x100000000ULL;
 
-  /* See : http://www.azillionmonkeys.com/qed/adiv.html */
-  // precalculate the reciprocal, so divisions will be really fast.
-  // 2^32-1 == 0xFFFFFFFFULL
-  //{
-  //  double int_res = lBufTotalCycle/lBufTotalNSec;
-  //  t->cycles_per_nsec_reciprocal = 
-  //            ((0xFFFF+int_res)/int_res);
-  //}
-
 }
 
 /****************************************************************************
@@ -1563,93 +1400,18 @@ static inline LttTime getEventTime(LttTracefile * tf)
   LttTime       lTimeOffset;      // Time offset in struct LttTime
   guint16       evId;
 
-  evId = *(guint16 *)tf->cur_event_pos;
-  //if(unlikely(evId == TRACE_BLOCK_START)){
-  //  tf->count = 0;
-  //  tf->pre_cycle_count = 0;
-  //  tf->cur_cycle_count = tf->a_block_start->cycle_count;
-  //  return tf->a_block_start->time;
-  //}//else if(unlikely(evId == TRACE_BLOCK_END)){
-    //tf->count = 0;
-    //tf->pre_cycle_count = 0;
-    //tf->cur_cycle_count = tf->a_block_end->cycle_count;
-    //return tf->a_block_end->time;
-  //}
-  
-  // Calculate total time in cycles from start of buffer for this event
-
+  evId = ltt_get_uint16(tf->trace->reverse_byte_order,
+                          tf->cur_event_pos);
   
- 
-  //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
-  //if(unlikely(delta_count < 0)) {
-  //  tf->count++; //increment wrap count
-    // keep in mind that delta_count is negative here.
-  //  res_delta_count = delta_count + 0x100000000ULL ;
-  //} else
-  //  res_delta_count = (LttCycleCount)delta_count;
-  
-  //cycle_count += (LttCycleCount)tf->count << 32;  
-  
-  //FIXME (MD)
-  //  if(tf->cur_heart_beat_number > tf->count)
-  //    cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;  
-
-  //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
-  //
-  //
-  // Total cycle counter of the event.
-  //tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
-
-  //g_debug("cur cycle count %llu", tf->cur_cycle_count);
-
-  // Total number of cycles since the beginning of the block
-  //lEventTotalCycle = tf->cur_cycle_count
-  //                       - tf->a_block_start->cycle_count;
+  cycle_count = ltt_get_uint32(tf->trace->reverse_byte_order,
+                          tf->cur_event_pos + EVENT_ID_SIZE);
 
-
-
-#if 0
-  // Calculate total time in cycles from start of buffer for this event
-  cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
-  
-  if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
-  tf->pre_cycle_count = cycle_count;
-  cycle_count += (LttCycleCount)tf->count << 32;  
-  
-  //FIXME (MD)
-  //  if(tf->cur_heart_beat_number > tf->count)
-  //    cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;  
-
-  tf->cur_cycle_count = cycle_count;
-
-  lEventTotalCycle  = cycle_count;
-  lEventTotalCycle -= tf->a_block_start->cycle_count;
-#endif //0
-  // Convert it to nsecs
-  //lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle;
-  //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16;
-  
-  // Determine offset in struct LttTime 
-  //lTimeOffset = ltt_time_from_double(lEventNSec);
-  //
-  // We do not substract block start cycle count here, it has already been done
-  // on the overflow_nsec
-  // The result should never be negative, because the cycle count of
-  // the event following the block start should be >= the previous one.
-  
-   /* keep the overflow count correct. The heartbeat event makes sure
-    * that we do not miss an overflow.*/
-  
-  cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
-  //g_debug("event cycle count %llu", cycle_count);
-  //
-  //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
-  //LttCycleCount res_delta_count;
   gboolean comp_count = cycle_count < tf->pre_cycle_count;
+
   tf->pre_cycle_count = cycle_count;
   
   if(unlikely(comp_count)) {
-    /* Wrapped */
+    /* Overflow */
     tf->overflow_nsec += tf->one_overflow_nsec;
     tf->count++; //increment overflow count
   }
@@ -1658,18 +1420,16 @@ static inline LttTime getEventTime(LttTracefile * tf)
      lEventNSec = 0;
   } else if(unlikely(evId == TRACE_BLOCK_END)) {
     lEventNSec = ((double)
-                 (tf->a_block_end->cycle_count - tf->a_block_start->cycle_count)
+          (ltt_get_uint64(tf->trace->reverse_byte_order,
+                            &tf->a_block_end->cycle_count) 
+           - ltt_get_uint64(tf->trace->reverse_byte_order,
+                            &tf->a_block_start->cycle_count))
                            * tf->nsec_per_cycle);
-    g_printf("CYCLES COUNTED : %llu",
-        (gint64)((double)cycle_count * tf->nsec_per_cycle)
-                                +tf->overflow_nsec 
-                                +tf->a_block_start->cycle_count);
-
-    
   }
-  /* heartbeat cycle counter is only numheartbeat<<32, not meaningful
-   */
 #if 0
+  /* If you want to make heart beat a special case and use their own 64 bits
+   * TSC, activate this.
+   */
   else if(unlikely(evId == TRACE_TIME_HEARTBEAT)) {
 
     tf->last_heartbeat = (TimeHeartbeat*)(tf->cur_event_pos+EVENT_HEADER_SIZE);
@@ -1679,15 +1439,14 @@ static inline LttTime getEventTime(LttTracefile * tf)
   }
 #endif //0
   else {
-  
     lEventNSec = (gint64)((double)cycle_count * tf->nsec_per_cycle)
                                 +tf->overflow_nsec;
   }
 
-  //g_assert(lEventNSec >= 0);
   lTimeOffset = ltt_time_from_uint64(lEventNSec);
   
-  time = ltt_time_add(tf->a_block_start->time, lTimeOffset);  
+  time = ltt_time_add(ltt_get_time(tf->trace->reverse_byte_order,
+                                   &tf->a_block_start->time), lTimeOffset);  
   
   return time;
 }
@@ -1782,7 +1541,7 @@ static inline gint getFieldtypeSize(LttTracefile * t,
                                   0,fld->child[0], NULL, trace);      
           fld->element_size = size;
         }else{//0: sequence
-          element_number = getIntNumber(size1,evD);
+          element_number = getIntNumber(t->trace->reverse_byte_order,size1,evD);
           type->element_number = element_number;
           if(fld->element_size > 0){
             size = element_number * fld->element_size;
@@ -1891,30 +1650,23 @@ end_getFieldtypeSize:
  *    gint64          : a 64 bits integer
  ****************************************************************************/
 
-gint64 getIntNumber(int size, void *evD)
+gint64 getIntNumber(gboolean reverse_byte_order, int size, void *evD)
 {
   gint64 i;
 
   switch(size) {
-    case 1: i = *(gint8 *)evD; break;
-    case 2: i = *(gint16 *)evD; break;
-    case 4: i = *(gint32 *)evD; break;
-    case 8: i = *(gint64 *)evD; break;
-    default: i = *(gint64 *)evD;
+    case 1: i = *((gint8*)evD); break;
+    case 2: i = ltt_get_int16(reverse_byte_order, evD); break;
+    case 4: i = ltt_get_int32(reverse_byte_order, evD); break;
+    case 8: i = ltt_get_int64(reverse_byte_order, evD); break;
+    default: i = ltt_get_int64(reverse_byte_order, evD);
              g_critical("getIntNumber : integer size %d unknown", size);
              break;
   }
 
-#if 0
-  if(size == 1)      i = *(gint8 *)evD;
-  else if(size == 2) i = *(gint16 *)evD;
-  else if(size == 4) i = *(gint32 *)evD;
-  else if(size == 8) i = *(gint64 *)evD;
-#endif //0
-
-  return (gint64)i;
+  return i;
 }
-
+#if 0
 /*****************************************************************************
  *Function name
  *    getDataEndianType : get the data type size and endian type of the local
@@ -1943,7 +1695,7 @@ void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
     *size = LTT_ILP64;
   else *size = LTT_UNKNOWN;
 }
-
+#endif //0
 /* get the node name of the system */
 
 char * ltt_trace_system_description_node_name (LttSystemDescription * s)