X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=6186fc2ca5e70da0cfb75b8745b5fa3d7b53451e;hb=1ee6a9affe396783f98e15de3ba27faf96cd1ccd;hp=6c3d35f3b8aa04c9c689d745c87f7d6e08a7d509;hpb=40331ba8619dc3bbb00f735f90f68522ac788829;p=lttv.git

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index 6c3d35f3..6186fc2c 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -33,41 +33,6 @@ void updateTracefile(LttTracefile * tf);
 /* go to the next event */
 int skipEvent(LttTracefile * t);
 
-/* compare two time (LttTime), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
-int timecmp(LttTime * t1, LttTime * t2);
-
-/* get an integer number */
-int getIntNumber(int size1, void *evD);
-
-
-/* Time operation macros for LttTime (struct timespec) */
-/*  (T3 = T2 - T1) */
-#define TimeSub(T3, T2, T1) \
-do \
-{\
-  (T3).tv_sec  = (T2).tv_sec  - (T1).tv_sec;  \
-  (T3).tv_nsec = (T2).tv_nsec - (T1).tv_nsec; \
-  if((T3).tv_nsec < 0)\
-    {\
-    (T3).tv_sec--;\
-    (T3).tv_nsec += 1000000000;\
-    }\
-} while(0)
-
-/*  (T3 = T2 + T1) */
-#define TimeAdd(T3, T2, T1) \
-do \
-{\
-  (T3).tv_sec  = (T2).tv_sec  + (T1).tv_sec;  \
-  (T3).tv_nsec = (T2).tv_nsec + (T1).tv_nsec; \
-  if((T3).tv_nsec >= 1000000000)\
-    {\
-    (T3).tv_sec += (T3).tv_nsec / 1000000000;\
-    (T3).tv_nsec = (T3).tv_nsec % 1000000000;\
-    }\
-} while(0)
-
-
 
 /*****************************************************************************
  *Function name
@@ -102,7 +67,11 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
 
   // Is the file large enough to contain a trace 
   if(lTDFStat.st_size < sizeof(BlockStart) + EVENT_HEADER_SIZE){
-    g_error("The input data file %s does not contain a trace\n", fileName);
+    g_print("The input data file %s does not contain a trace\n", fileName);
+    g_free(tf->name);
+    close(tf->fd);
+    g_free(tf);
+    return NULL;
   }
   
   //store the size of the file
@@ -129,6 +98,7 @@ void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
 {
   LttTracefile * tf;
   tf = ltt_tracefile_open(t,tracefile_name);
+  if(!tf) return;
   t->per_cpu_tracefile_number++;
   g_ptr_array_add(t->per_cpu_tracefiles, tf);
 }
@@ -144,11 +114,12 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name)
   int i;
 
   tf = ltt_tracefile_open(t,control_name);
+  if(!tf) return;
   t->control_tracefile_number++;
   g_ptr_array_add(t->control_tracefiles,tf);
 
   //parse facilities tracefile to get base_id
-  if(strcmp(control_name,"facilities") ==0){
+  if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){
     while(1){
       ev = ltt_tracefile_read(tf);
       if(!ev)return; // end of file
@@ -156,8 +127,8 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name)
       if(ev->event_id == TRACE_FACILITY_LOAD){
 	pos = ev->data;
 	fLoad.name = (char*)pos;
-	fLoad.checksum = *(LttChecksum*)(pos + sizeof(pos));
-	fLoad.base_code = *(uint32_t*)(pos + sizeof(pos) + sizeof(LttChecksum));
+	fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
+	fLoad.base_code = *(uint32_t*)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
 
 	for(i=0;i<t->facility_number;i++){
 	  f = (LttFacility*)g_ptr_array_index(t->facilities,i);
@@ -189,6 +160,7 @@ void ltt_tracefile_close(LttTracefile *t)
 {
   g_free(t->name);
   g_free(t->buffer);
+  close(t->fd);
   g_free(t);
 }
 
@@ -223,6 +195,7 @@ void getSystemInfo(LttSystemDescription* des, char * pathname)
   for(i=0;i<entry_number;i++){
     if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
       g_error("Not a valid file: %s\n", pathname);
+    buf[strlen(buf)-1] = '\0';
     ptr = buf;
     while(isspace(*ptr)) ptr++;
     switch(i){
@@ -297,24 +270,24 @@ void getSystemInfo(LttSystemDescription* des, char * pathname)
 	 if(strncmp("ltt_major_version=",ptr,18)!=0)
 	   g_error("Not a valid file: %s\n", pathname);
 	 ptr += 18; 
-	 ptr++;//skip begining "
-	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 //	 ptr++;//skip begining "
+	 //	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
 	 des->ltt_major_version = (unsigned)atoi(ptr);
 	 break;
        case 13:
 	 if(strncmp("ltt_minor_version=",ptr,18)!=0)
 	   g_error("Not a valid file: %s\n", pathname);
 	 ptr += 18; 
-	 ptr++;//skip begining "
-	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 //	 ptr++;//skip begining "
+	 //	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
 	 des->ltt_minor_version = (unsigned)atoi(ptr);
 	 break;
        case 14:
 	 if(strncmp("ltt_block_size=",ptr,15)!=0)
 	   g_error("Not a valid file: %s\n", pathname);
 	 ptr += 15; 
-	 ptr++;//skip begining "
-	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 //	 ptr++;//skip begining "
+	 //	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
 	 des->ltt_block_size = (unsigned)atoi(ptr);
 	 break;
        default:
@@ -354,6 +327,7 @@ void getFacilityInfo(LttTrace *t, char* eventdefs)
   int i,j;
   LttFacility * f;
   LttEventType * et;
+  char name[DIR_NAME_SIZE];
 
   dir = opendir(eventdefs);
   if(!dir) g_error("Can not open directory: %s\n", eventdefs);
@@ -361,12 +335,14 @@ void getFacilityInfo(LttTrace *t, char* eventdefs)
   while((entry = readdir(dir)) != NULL){
     ptr = &entry->d_name[strlen(entry->d_name)-4];
     if(strcmp(ptr,".xml") != 0) continue;
-    ltt_facility_open(t,entry->d_name);
+    strcpy(name,eventdefs);
+    strcat(name,entry->d_name);
+    ltt_facility_open(t,name);
   }  
   closedir(dir);
   
   for(j=0;j<t->facility_number;j++){
-    f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+    f = (LttFacility*)g_ptr_array_index(t->facilities, j);
     for(i=0; i<f->event_number; i++){
       et = f->events[i];
       setFieldsOffset(NULL, et, NULL, t);
@@ -378,16 +354,19 @@ void getControlFileInfo(LttTrace *t, char* control)
 {
   DIR * dir;
   struct dirent *entry;
+  char name[DIR_NAME_SIZE];
 
   dir = opendir(control);
   if(!dir) g_error("Can not open directory: %s\n", control);
 
   while((entry = readdir(dir)) != NULL){
-    if(strcmp(entry->d_name,"facilities") != 0 ||
-       strcmp(entry->d_name,"interrupts") != 0 ||
+    if(strcmp(entry->d_name,"facilities") != 0 &&
+       strcmp(entry->d_name,"interrupts") != 0 &&
        strcmp(entry->d_name,"processes") != 0) continue;
     
-    ltt_tracefile_open_control(t,entry->d_name);
+    strcpy(name,control);
+    strcat(name,entry->d_name);
+    ltt_tracefile_open_control(t,name);
   }  
   closedir(dir);
 }
@@ -396,14 +375,17 @@ void getCpuFileInfo(LttTrace *t, char* cpu)
 {
   DIR * dir;
   struct dirent *entry;
+  char name[DIR_NAME_SIZE];
 
   dir = opendir(cpu);
   if(!dir) g_error("Can not open directory: %s\n", cpu);
 
   while((entry = readdir(dir)) != NULL){
-    if(strcmp(entry->d_name,".") != 0 ||
+    if(strcmp(entry->d_name,".") != 0 &&
        strcmp(entry->d_name,"..") != 0 ){
-      ltt_tracefile_open_cpu(t,entry->d_name);
+      strcpy(name,cpu);
+      strcat(name,entry->d_name);
+      ltt_tracefile_open_cpu(t,name);
     }else continue;
   }  
   closedir(dir);
@@ -418,7 +400,7 @@ void getCpuFileInfo(LttTrace *t, char* cpu)
  *are released as well.
  ****************************************************************************/
 
-LttTrace *ltt_trace_open(char *pathname)
+LttTrace *ltt_trace_open(const char *pathname)
 {
   LttTrace  * t;
   LttSystemDescription * sys_description;
@@ -465,18 +447,28 @@ LttTrace *ltt_trace_open(char *pathname)
   strcat(tmp,"system.xml");
   getSystemInfo(sys_description, tmp);
 
+  //get facilities info
+  getFacilityInfo(t,eventdefs);
+  
   //get control tracefile info
   getControlFileInfo(t,control);
 
   //get cpu tracefile info
   getCpuFileInfo(t,cpu);
 
-  //get facilities info
-  getFacilityInfo(t,eventdefs);
-  
   return t;
 }
 
+/******************************************************************************
+ * When we copy a trace, we want all the opening actions to happen again :
+ * the trace will be reopened and totally independant from the original.
+ * That's why we call ltt_trace_open.
+ *****************************************************************************/
+LttTrace *ltt_trace_copy(LttTrace *self)
+{
+  return ltt_trace_open(self->pathname);
+}
+
 void ltt_trace_close(LttTrace *t)
 {
   int i;
@@ -503,23 +495,25 @@ void ltt_trace_close(LttTrace *t)
     tf = (LttTracefile*)g_ptr_array_index(t->control_tracefiles,i);
     ltt_tracefile_close(tf);
   }
-  g_ptr_array_free(t->control_tracefiles, FALSE);
+  g_ptr_array_free(t->control_tracefiles, TRUE);
 
   //free per_cpu_tracefiles
   for(i=0;i<t->per_cpu_tracefile_number;i++){
     tf = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,i);
     ltt_tracefile_close(tf);
   }
-  g_ptr_array_free(t->per_cpu_tracefiles, FALSE);
+  g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
 
   //free facilities
   for(i=0;i<t->facility_number;i++){
     f = (LttFacility*)g_ptr_array_index(t->facilities,i);
     ltt_facility_close(f);
   }
-  g_ptr_array_free(t->facilities, FALSE);
+  g_ptr_array_free(t->facilities, TRUE);
 
   g_free(t);
+ 
+  g_blow_chunks();
 }
 
 
@@ -562,7 +556,7 @@ unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position)
 {
   int i, count=0;
   LttFacility * f;
-  for(i=0;i=t->facility_number;i++){
+  for(i=0;i<t->facility_number;i++){
     f = (LttFacility*)g_ptr_array_index(t->facilities, i);
     if(strcmp(f->name,name)==0){
       count++;
@@ -583,7 +577,7 @@ unsigned ltt_trace_eventtype_number(LttTrace *t)
   int i;
   unsigned count = 0;
   LttFacility * f;
-  for(i=0;i=t->facility_number;i++){
+  for(i=0;i<t->facility_number;i++){
     f = (LttFacility*)g_ptr_array_index(t->facilities, i);
     count += f->event_number;
   }
@@ -665,7 +659,7 @@ int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i)
 
 LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i)
 {
-  return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);  
+  return (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);  
 }
 
 LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i)
@@ -673,6 +667,52 @@ LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i)
   return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
 }
 
+/*****************************************************************************
+ * Get the start time and end time of the trace 
+ ****************************************************************************/
+
+void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
+{
+  LttTime startSmall, startTmp, endBig, endTmp;
+  int i, j=0;
+  LttTracefile * tf;
+
+  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;    
+    readBlock(tf,tf->block_number);
+    endTmp = tf->a_block_end->time;
+    if(i==0){
+      startSmall = startTmp;
+      endBig     = endTmp;
+      j = 1;
+      continue;
+    }
+    if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp;
+    if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp;
+  }
+
+  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;    
+    readBlock(tf,tf->block_number);
+    endTmp = tf->a_block_end->time;
+    if(j == 0 && i==0){
+      startSmall = startTmp;
+      endBig     = endTmp;
+      continue;
+    }
+    if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp;
+    if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp;
+  }
+
+  *start = startSmall;
+  *end = endBig;
+}
+
+
 /*****************************************************************************
  *Get the name of a tracefile
  ****************************************************************************/
@@ -682,6 +722,15 @@ char *ltt_tracefile_name(LttTracefile *tf)
   return tf->name;
 }
 
+/*****************************************************************************
+ * Get the number of blocks in the tracefile 
+ ****************************************************************************/
+
+unsigned ltt_tracefile_block_number(LttTracefile *tf)
+{
+  return tf->block_number; 
+}
+
 /*****************************************************************************
  *Function name
  *    ltt_tracefile_seek_time: seek to the first event of the trace with time 
@@ -695,33 +744,44 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
 {
   int err;
   LttTime lttTime;
-  int headTime = timecmp(&(t->a_block_start->time), &time);
-  int tailTime = timecmp(&(t->a_block_end->time), &time);
-  
+  int headTime = ltt_time_compare(t->a_block_start->time, time);
+  int tailTime = ltt_time_compare(t->a_block_end->time, time);
+  LttEvent * ev;
+
   if(headTime < 0 && tailTime > 0){
-    lttTime = getEventTime(t);
-    err = timecmp(&lttTime, &time);
-    if(err > 0){
-      if(t->which_event==2 || timecmp(&t->prev_event_time,&time)<0){
-	return;
-      }else{
-	updateTracefile(t);
-	return ltt_tracefile_seek_time(t, time);
-      }
-    }else if(err < 0){
-      err = t->which_block;
-      if(ltt_tracefile_read(t) == NULL){
-	g_printf("End of file\n");      
-	return;
-      }
-      if(t->which_block == err)
-	return ltt_tracefile_seek_time(t,time);
-    }else return;    
-  }else if(headTime > 0){
+    if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) {
+      lttTime = getEventTime(t);
+      err = ltt_time_compare(lttTime, time);
+      if(err > 0){
+	if(t->which_event==2 || (&t->prev_event_time,&time)<0){
+	  return;
+	}else{
+	  updateTracefile(t);
+	  return ltt_tracefile_seek_time(t, time);
+	}
+      }else if(err < 0){
+	while(1){
+	  ev = ltt_tracefile_read(t);
+	  if(ev == NULL){
+	    g_print("End of file\n");      
+	    return;
+	  }
+	  lttTime = getEventTime(t);
+	  err = ltt_time_compare(lttTime, time);
+	  if(err >= 0)return;
+	}
+      }else return;    
+    }else{//we are at the end of the block
+      updateTracefile(t);
+      return ltt_tracefile_seek_time(t, time);      
+    }
+  }else if(headTime >= 0){
     if(t->which_block == 1){
       updateTracefile(t);      
     }else{
-      if(timecmp(&(t->prev_block_end_time),&time) >= 0 ){
+      if(ltt_time_compare(t->prev_block_end_time, time) >= 0 ||
+	 (t->prev_block_end_time.tv_sec == 0 && 
+	  t->prev_block_end_time.tv_nsec == 0 )){
 	err=readBlock(t,t->which_block-1);
 	if(err) g_error("Can not read tracefile: %s\n", t->name); 
 	return ltt_tracefile_seek_time(t, time) ;
@@ -734,18 +794,46 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
       err=readBlock(t,t->which_block+1);
       if(err) g_error("Can not read tracefile: %s\n", t->name); 
     }else {
-      g_printf("End of file\n");      
+      g_print("End of file\n");      
       return;      
     }    
     if(tailTime < 0) return ltt_tracefile_seek_time(t, time);
-  }else if(headTime == 0){
-    updateTracefile(t);
   }else if(tailTime == 0){
-    t->cur_event_pos = t->a_block_end - EVENT_HEADER_SIZE;
+    t->cur_event_pos = t->last_event_pos;
+    t->current_event_time = time;  
+    t->cur_heart_beat_number = 0;
+    t->prev_event_time.tv_sec = 0;
+    t->prev_event_time.tv_nsec = 0;
     return;
   }
 }
 
+/*****************************************************************************
+ * Seek to the first event with position equal or larger to ep 
+ ****************************************************************************/
+
+void ltt_tracefile_seek_position(LttTracefile *t, LttEventPosition *ep)
+{
+  //if we are at the right place, just return
+  if(t->which_block == ep->block_num && t->which_event == ep->event_num)
+    return;
+  
+  if(t->which_block == ep->block_num) updateTracefile(t);
+  else readBlock(t,ep->block_num);
+
+  //event offset is availiable
+  if(ep->old_position){
+    t->cur_heart_beat_number = ep->heart_beat_number;
+    t->cur_event_pos = t->buffer + ep->event_offset;
+    return;
+  }
+
+  //only block number and event index are availiable
+  while(t->which_event < ep->event_num) ltt_tracefile_read(t);
+
+  return;
+}
+
 /*****************************************************************************
  *Function name
  *    ltt_tracefile_read : read the current event, set the pointer to the next
@@ -757,30 +845,37 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
 
 LttEvent *ltt_tracefile_read(LttTracefile *t)
 {
-  LttEvent * lttEvent = (LttEvent *)g_new(LttEvent, 1);
+  LttEvent * lttEvent = &t->an_event;
   int err;
 
+  if(t->cur_event_pos == t->buffer + t->block_size){
+    if(t->which_block == t->block_number){
+      return NULL;
+    }
+    err = readBlock(t, t->which_block + 1);
+    if(err)g_error("Can not read tracefile");    
+  }
+
   lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos));
   if(lttEvent->event_id == TRACE_TIME_HEARTBEAT)
     t->cur_heart_beat_number++;
 
   t->prev_event_time  = t->current_event_time;
-  t->current_event_time = getEventTime(t);
+  //  t->current_event_time = getEventTime(t);
 
   lttEvent->time_delta = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
   lttEvent->event_time = t->current_event_time;
 
-  lttEvent->event_cycle_count = ((uint64_t)1)<<32  * t->cur_heart_beat_number 
-                                + lttEvent->time_delta;
-
   lttEvent->tracefile = t;
   lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE;  
+  lttEvent->which_block = t->which_block;
+  lttEvent->which_event = t->which_event;
 
   //update the fields of the current event and go to the next event
   err = skipEvent(t);
-  if(err == ENOENT) return NULL;
   if(err == ERANGE) g_error("event id is out of range\n");
-  if(err)g_error("Can not read tracefile\n");
+
+  lttEvent->event_cycle_count = t->cur_cycle_count;
 
   return lttEvent;
 }
@@ -829,14 +924,11 @@ int readBlock(LttTracefile * tf, int whichBlock)
   if(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->current_event_time  = tf->a_block_end->time;
   }else{
     tf->prev_block_end_time.tv_sec = 0;
     tf->prev_block_end_time.tv_nsec = 0;
     tf->prev_event_time.tv_sec = 0;
     tf->prev_event_time.tv_nsec = 0;
-    tf->current_event_time.tv_sec = 0;
-    tf->current_event_time.tv_nsec = 0;
   }
 
   nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET);
@@ -849,6 +941,7 @@ int readBlock(LttTracefile * tf, int whichBlock)
   lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t));
   tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size - 
 				lostSize + EVENT_HEADER_SIZE); 
+  tf->last_event_pos = tf->buffer + tf->block_size - lostSize;
 
   tf->which_block = whichBlock;
   tf->which_event = 1;
@@ -857,7 +950,7 @@ int readBlock(LttTracefile * tf, int whichBlock)
 
   getCyclePerNsec(tf);
 
-  //  tf->current_event_time = getEventTime(tf);  
+  tf->current_event_time = getEventTime(tf);  
 
   return 0;  
 }
@@ -874,9 +967,7 @@ void updateTracefile(LttTracefile * tf)
 {
   tf->which_event = 1;
   tf->cur_event_pos = tf->buffer;
-  //  tf->current_event_time = getEventTime(tf);  
-  tf->current_event_time.tv_sec = 0;  
-  tf->current_event_time.tv_nsec = 0;  
+  tf->current_event_time = getEventTime(tf);  
   tf->cur_heart_beat_number = 0;
 
   tf->prev_event_time.tv_sec = 0;
@@ -890,9 +981,6 @@ void updateTracefile(LttTracefile * tf)
  *    t         : tracefile
  *return value 
  *    0               : success
- *    EINVAL          : lseek fail
- *    EIO             : can not read from the file
- *    ENOENT          : end of file
  *    ERANGE          : event id is out of range
  ****************************************************************************/
 
@@ -905,28 +993,30 @@ int skipEvent(LttTracefile * t)
 
   evId   = (int)(*(uint16_t *)(t->cur_event_pos));
   evData = t->cur_event_pos + EVENT_HEADER_SIZE;
-  evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
 
+  evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
+    
   if(evT) rootFld = evT->root_field;
   else return ERANGE;
   
-  //event has string/sequence or the last event is not the same event
-  if((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;
-
+  if(rootFld){
+    //event has string/sequence or the last event is not the same event
+    if((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(evId == TRACE_BLOCK_END){
-    if(t->which_block == t->block_number) return ENOENT;
-    err = readBlock(t, t->which_block + 1);
-    if(err) return err;
+    t->cur_event_pos = t->buffer + t->block_size;
   }else{
     t->which_event++;
+    t->current_event_time = getEventTime(t);
   }
 
   return 0;
@@ -946,14 +1036,16 @@ void getCyclePerNsec(LttTracefile * t)
   LttCycleCount     lBufTotalCycle;/* Total cycles for this buffer */
 
   /* Calculate the total time for this buffer */
-  TimeSub(lBufTotalTime,t->a_block_end->time, t->a_block_start->time);
+  lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time);
 
   /* Calculate the total cycles for this bufffer */
-  lBufTotalCycle = t->a_block_end->cycle_count 
-                   - t->a_block_start->cycle_count;
+  lBufTotalCycle  = t->a_block_end->cycle_count;
+  lBufTotalCycle -= t->a_block_start->cycle_count;
 
   /* Convert the total time to nsecs */
-  lBufTotalNSec = lBufTotalTime.tv_sec * 1000000000 + lBufTotalTime.tv_nsec;
+  lBufTotalNSec  = lBufTotalTime.tv_sec;
+  lBufTotalNSec *= NANOSECONDS_PER_SECOND; 
+  lBufTotalNSec += lBufTotalTime.tv_nsec;
   
   t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec;
 }
@@ -975,29 +1067,48 @@ LttTime getEventTime(LttTracefile * tf)
   double        lEventNSec;       // Total usecs from start for event
   LttTime       lTimeOffset;      // Time offset in struct LttTime
   uint16_t      evId;
-  
+  int64_t       nanoSec, tmpCycleCount = (((uint64_t)1)<<32);
+  static LttCycleCount preCycleCount = 0;
+  static int   count = 0;
+
   evId = *(uint16_t*)tf->cur_event_pos;
-  if(evId == TRACE_BLOCK_START)
+  if(evId == TRACE_BLOCK_START){
+    count = 0;
+    preCycleCount = 0;
+    tf->cur_cycle_count = tf->a_block_start->cycle_count;
     return tf->a_block_start->time;
-  else if(evId == TRACE_BLOCK_END)
+  }else if(evId == TRACE_BLOCK_END){
+    count = 0;
+    preCycleCount = 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 
+  // Calculate total time in cycles from start of buffer for this event
   cycle_count = (LttCycleCount)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
-  if(tf->cur_heart_beat_number)
-    cycle_count += ((uint64_t)1)<<32  * tf->cur_heart_beat_number;
-  lEventTotalCycle = cycle_count - tf->a_block_start->cycle_count;
+  
+  if(cycle_count < preCycleCount)count++;
+  preCycleCount = cycle_count;
+  cycle_count += tmpCycleCount * count;  
+  
+  if(tf->cur_heart_beat_number > count)
+    cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - count);  
+
+  tf->cur_cycle_count = cycle_count;
+
+  lEventTotalCycle  = cycle_count;
+  lEventTotalCycle -= tf->a_block_start->cycle_count;
 
   // Convert it to nsecs
   lEventNSec = lEventTotalCycle / tf->cycle_per_nsec;
-  
-  // Determine offset in struct LttTime 
-  lTimeOffset.tv_nsec = (long)lEventNSec % 1000000000;
-  lTimeOffset.tv_sec  = (long)lEventNSec / 1000000000;
+  nanoSec    = lEventNSec;
 
-  TimeAdd(time, tf->a_block_start->time, lTimeOffset);  
+  // Determine offset in struct LttTime 
+  lTimeOffset.tv_nsec = nanoSec % NANOSECONDS_PER_SECOND;
+  lTimeOffset.tv_sec  = nanoSec / NANOSECONDS_PER_SECOND;
 
+  time = ltt_time_add(tf->a_block_start->time, lTimeOffset);  
+  
   return time;
 }
 
@@ -1015,7 +1126,8 @@ void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t)
   LttField * rootFld = evT->root_field;
   //  rootFld->base_address = evD;
 
-  rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t);  
+  if(rootFld)
+    rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t);  
 }
 
 /*****************************************************************************
@@ -1038,7 +1150,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
   int size, size1, element_number, i, offset1, offset2;
   LttType * type = fld->field_type;
 
-  if(!t){
+  if(t){
     if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){
       return fld->field_size;
     } 
@@ -1076,6 +1188,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
   }else if(type->type_class == LTT_SEQUENCE){
     size1 = (int) ltt_type_size(trace, type);
     if(fld->field_fixed == -1){
+      fld->sequ_number_size = size1;
       fld->field_fixed = 0;
       size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL, trace);      
       fld->element_size = size;
@@ -1099,7 +1212,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
     if(fld->field_fixed == -1){
       fld->field_fixed = 0;
     }else{//0: string
-      size = sizeof((char*)evD) + 1; //include end : '\0'
+      size = strlen((char*)evD) + 1; //include end : '\0'
     }
 
   }else if(type->type_class == LTT_STRUCT){
@@ -1147,24 +1260,6 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
   return size;
 }
 
-/*****************************************************************************
- *Function name
- *    timecmp   : compare two time
- *Input params 
- *    t1        : first time
- *    t2        : second time
- *Return value
- *    int       : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2
- ****************************************************************************/
-
-int timecmp(LttTime * t1, LttTime * t2)
-{
-  LttTime T;
-  TimeSub(T, *t1, *t2);
-  if(T.tv_sec == 0 && T.tv_nsec == 0) return 0;
-  else if(T.tv_sec > 0 || (T.tv_sec==0 && T.tv_nsec > 0)) return 1;
-  else return -1;
-}
 
 /*****************************************************************************
  *Function name