Add state saving functions and update processTrace accordingly.

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

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index 5c45d56623a3b53db1b374610413c02da1b018d2..07b8ab3a837a1f3d5cb7a69124a1f58f5482df87 100644 (file)
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -33,10 +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);
-
-
 
 /*****************************************************************************
  *Function name
@@ -404,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;
@@ -463,6 +459,16 @@ LttTrace *ltt_trace_open(char *pathname)
   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;
@@ -571,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;
   }
@@ -683,8 +689,8 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
       j = 1;
       continue;
     }
-    if(timecmp(&startSmall,&startTmp) > 0) startSmall = startTmp;
-    if(timecmp(&endBig,&endTmp) < 0) endBig = endTmp;
+    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++){
@@ -698,8 +704,8 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
       endBig     = endTmp;
       continue;
     }
-    if(timecmp(&startSmall,&startTmp) > 0) startSmall = startTmp;
-    if(timecmp(&endBig,&endTmp) < 0) endBig = endTmp;
+    if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp;
+    if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp;
   }
 
   *start = startSmall;
@@ -738,37 +744,42 @@ 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){
-      while(1){
-       ev = ltt_tracefile_read(t);
-       if(ev == NULL){
-         g_print("End of file\n");      
+    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);
        }
-       lttTime = getEventTime(t);
-       err = timecmp(&lttTime, &time);
-       if(err >= 0)return;
-      }
-    }else return;    
-  }else if(headTime > 0){
+      }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 ){
        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) ;
@@ -785,10 +796,8 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
       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;
@@ -930,6 +939,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;
@@ -1024,7 +1034,7 @@ 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;
@@ -1032,7 +1042,7 @@ void getCyclePerNsec(LttTracefile * t)
 
   /* Convert the total time to nsecs */
   lBufTotalNSec  = lBufTotalTime.tv_sec;
-  lBufTotalNSec *= NANSECOND_CONST; 
+  lBufTotalNSec *= NANOSECONDS_PER_SECOND; 
   lBufTotalNSec += lBufTotalTime.tv_nsec;
   
   t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec;
@@ -1092,10 +1102,10 @@ LttTime getEventTime(LttTracefile * tf)
   nanoSec    = lEventNSec;
 
   // Determine offset in struct LttTime 
-  lTimeOffset.tv_nsec = nanoSec % NANSECOND_CONST;
-  lTimeOffset.tv_sec  = nanoSec / NANSECOND_CONST;
+  lTimeOffset.tv_nsec = nanoSec % NANOSECONDS_PER_SECOND;
+  lTimeOffset.tv_sec  = nanoSec / NANOSECONDS_PER_SECOND;
 
-  TimeAdd(time, tf->a_block_start->time, lTimeOffset);  
+  time = ltt_time_add(tf->a_block_start->time, lTimeOffset);  
   
   return time;
 }
@@ -1248,24 +1258,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)
-{
-  if(t1->tv_sec < t2->tv_sec) return -1;
-  if(t1->tv_sec > t2->tv_sec) return 1;
-  if(t1->tv_nsec < t2->tv_nsec) return -1;
-  if(t1->tv_nsec > t2->tv_nsec) return 1;
-  return 0;
-}
 
 /*****************************************************************************
  *Function name