X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=97ac57cc35f260c6c27af23e15d217f56725524e;hb=a8c0f09de06b94e9420d286e1541c39092fff434;hp=bf2af685da903f8bdc30670b18ff888e58d89d9b;hpb=c87b2140ab19ea9d568e928b2609c71d3ba34562;p=lttv.git

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index bf2af685..97ac57cc 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -5,9 +5,11 @@
 #include <dirent.h>
 #include <linux/errno.h>  
 
-#include <ltt/LTTTypes.h>  
 #include "parser.h"
+#include <ltt/ltt.h>
+#include "ltt-private.h"
 #include <ltt/trace.h>
+#include <ltt/facility.h>
 
 #define DIR_NAME_SIZE 256
 
@@ -33,10 +35,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
@@ -112,7 +110,7 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name)
   LttTracefile * tf;
   LttEvent * ev;
   LttFacility * f;
-  uint16_t evId;
+  guint16 evId;
   void * pos;
   FacilityLoad fLoad;
   int i;
@@ -132,7 +130,7 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name)
 	pos = ev->data;
 	fLoad.name = (char*)pos;
 	fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
-	fLoad.base_code = *(uint32_t*)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
+	fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
 
 	for(i=0;i<t->facility_number;i++){
 	  f = (LttFacility*)g_ptr_array_index(t->facilities,i);
@@ -149,7 +147,6 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name)
       }else if(ev->event_id == TRACE_BLOCK_END){
 	break;
       }else g_error("Not valid facilities trace file\n");
-      g_free(ev);
     }
   }
 }
@@ -405,7 +402,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;
@@ -464,6 +461,22 @@ LttTrace *ltt_trace_open(char *pathname)
   return t;
 }
 
+char * ltt_trace_name(LttTrace *t)
+{
+  return t->pathname;
+}
+
+
+/******************************************************************************
+ * 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;
@@ -572,7 +585,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;
   }
@@ -662,6 +675,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
  ****************************************************************************/
@@ -671,6 +730,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 
@@ -679,63 +747,136 @@ char *ltt_tracefile_name(LttTracefile *tf)
  *    t                      : tracefile
  *    time                   : criteria of the time
  ****************************************************************************/
+void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time, 
+				   int start_block, int end_block)
+{
+  int err, tmp_block, s, e; 
+  int headTime;
+  int tailTime;
+  
+  err=readBlock(t,start_block);
+  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);
+  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);
+  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);
+  if(headTime <= 0 && tailTime >= 0) return;
+  
+  if(headTime > 0){
+    s = start_block + 1;
+    e = tmp_block - 1;
+    if(s <= e)
+      ltt_tracefile_find_time_block(t, time, s, e);
+    else return;
+  }
+
+  if(tailTime < 0){
+    s = tmp_block + 1;
+    e = end_block - 1;
+    if(s <= e)
+      ltt_tracefile_find_time_block(t, time, s, e);
+    else return;
+  }  
+}
+
+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);
+  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);
+    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);     
+  }else if(h_time > 0){
+    ltt_tracefile_find_time_block(t, time, 1, t->which_block);
+    return ltt_tracefile_seek_time(t, time) ;    
+  }else{
+    if(t_time >= 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);    
+  }
+}
 
 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);
 	}
-	g_free(ev);
-	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 ){
-	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) ;
+      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 )){
+	ltt_tracefile_backward_find_time_block(t, time);
       }else{
 	updateTracefile(t);
       }
     }
   }else if(tailTime < 0){
     if(t->which_block != t->block_number){
-      err=readBlock(t,t->which_block+1);
-      if(err) g_error("Can not read tracefile: %s\n", t->name); 
+      ltt_tracefile_find_time_block(t, time, t->which_block+1, t->block_number);
+      return ltt_tracefile_seek_time(t, time);
     }else {
-      g_print("End of file\n");      
+     t->cur_event_pos = t->buffer + t->block_size;
+     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;
@@ -744,6 +885,32 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
   }
 }
 
+/*****************************************************************************
+ * 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
@@ -755,31 +922,27 @@ 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){
-      g_free(lttEvent);
       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));
+  lttEvent->event_id = (int)(*(guint16 *)(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);
 
-  lttEvent->time_delta = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
+  lttEvent->time_delta = *(guint32 *)(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;
@@ -789,6 +952,8 @@ LttEvent *ltt_tracefile_read(LttTracefile *t)
   err = skipEvent(t);
   if(err == ERANGE) g_error("event id is out of range\n");
 
+  lttEvent->event_cycle_count = t->cur_cycle_count;
+
   return lttEvent;
 }
 
@@ -831,7 +996,7 @@ int readFile(int fd, void * buf, size_t size, char * mesg)
 int readBlock(LttTracefile * tf, int whichBlock)
 {
   off_t nbBytes;
-  uint32_t lostSize;
+  guint32 lostSize;
 
   if(whichBlock - tf->which_block == 1 && tf->which_block != 0){
     tf->prev_block_end_time = tf->a_block_end->time;
@@ -850,9 +1015,10 @@ int readBlock(LttTracefile * tf, int whichBlock)
     return EIO;
 
   tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE);
-  lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t));
+  lostSize = *(guint32 *)(tf->buffer + tf->block_size - sizeof(guint32));
   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;
@@ -902,7 +1068,7 @@ int skipEvent(LttTracefile * t)
   LttEventType * evT;
   LttField * rootFld;
 
-  evId   = (int)(*(uint16_t *)(t->cur_event_pos));
+  evId   = (int)(*(guint16 *)(t->cur_event_pos));
   evData = t->cur_event_pos + EVENT_HEADER_SIZE;
 
   evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
@@ -947,14 +1113,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,30 +1143,49 @@ LttTime getEventTime(LttTracefile * tf)
   LttCycleCount lEventTotalCycle; // Total cycles from start for event
   double        lEventNSec;       // Total usecs from start for event
   LttTime       lTimeOffset;      // Time offset in struct LttTime
-  uint16_t      evId;
-  
-  evId = *(uint16_t*)tf->cur_event_pos;
-  if(evId == TRACE_BLOCK_START)
+  guint16       evId;
+  gint64        nanoSec, tmpCycleCount = (((guint64)1)<<32);
+  static LttCycleCount preCycleCount = 0;
+  static int   count = 0;
+
+  evId = *(guint16 *)tf->cur_event_pos;
+  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
+  cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
   
+  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;
 
-  // 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;
+  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;
 }
 
@@ -1150,24 +1337,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
@@ -1181,11 +1350,11 @@ int timecmp(LttTime * t1, LttTime * t2)
 
 int getIntNumber(int size, void *evD)
 {
-  int64_t i;
-  if(size == 1)      i = *(int8_t *)evD;
-  else if(size == 2) i = *(int16_t *)evD;
-  else if(size == 4) i = *(int32_t *)evD;
-  else if(size == 8) i = *(int64_t *)evD;
+  gint64 i;
+  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;
  
   return (int) i;
 }
@@ -1219,3 +1388,34 @@ void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
   else *size = LTT_UNKNOWN;
 }
 
+/* get the node name of the system */
+
+char * ltt_trace_system_description_node_name (LttSystemDescription * s)
+{
+  return s->node_name;
+}
+
+
+/* get the domain name of the system */
+
+char * ltt_trace_system_description_domain_name (LttSystemDescription * s)
+{
+  return s->domain_name;
+}
+
+
+/* get the description of the system */
+
+char * ltt_trace_system_description_description (LttSystemDescription * s)
+{
+  return s->description;
+}
+
+
+/* get the start time of the trace */
+
+LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
+{
+  return s->trace_start;
+}
+