git-svn-id: http://ltt.polymtl.ca/svn@240 04897980-b3bd-0310-b5e0-8ef037075253

diff --git a/ltt/branches/poly/ltt/convert/convert.c b/ltt/branches/poly/ltt/convert/convert.c
index 60dc3a6031498a751fcb14726df56d5577a8a0cb..b996b8b2bffc914e9e3997a2fc2145a45922fd56 100644 (file)
--- a/ltt/branches/poly/ltt/convert/convert.c
+++ b/ltt/branches/poly/ltt/convert/convert.c
@@ -124,7 +124,7 @@ int main(int argc, char ** argv){
   trace_file_system * tFileSys;
   uint16_t newId, startId, tmpId;
   uint8_t  evId;
-  uint32_t time_delta, startTimeDelta;
+  uint32_t time_delta, startTimeDelta, previous_time_delta;
   void * cur_pos, *end_pos;
   buffer_start start, start_proc, start_intr;
   buffer_start end, end_proc, end_intr;
@@ -344,6 +344,7 @@ int main(int argc, char ** argv){
 
     startId = newId;
     startTimeDelta = time_delta;
+    previous_time_delta = time_delta;
     start.seconds = tBufStart->Time.tv_sec;
     start.nanoseconds = tBufStart->Time.tv_usec;
     start.cycle_count = tBufStart->TSC;
@@ -448,6 +449,11 @@ int main(int argc, char ** argv){
       time_delta = *(uint32_t*)cur_pos;
       cur_pos += sizeof(uint32_t); 
 
+      if(time_delta < previous_time_delta){
+       end.cycle_count += OVERFLOW_FIGURE;
+      }
+      previous_time_delta = time_delta;
+
       if(ltt_log_cpu){
        write_to_buffer(write_pos[cpu_id],(void*)&newId,sizeof(uint16_t));
        write_to_buffer(write_pos[cpu_id],(void*)&time_delta, sizeof(uint32_t));        
@@ -582,7 +588,7 @@ int main(int argc, char ** argv){
          beat.cycle_count = start.cycle_count + beat_count * OVERFLOW_FIGURE;
          event_size = 0;
 
-         end.cycle_count += OVERFLOW_FIGURE;
+         //      end.cycle_count += OVERFLOW_FIGURE;
 
          write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
          write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));

diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c
index 7ef6737728bbba7cbeebd9ee8cc58f81205fd019..46333ffbb4fb50df99703e1f69dfcfc3322ad806 100644 (file)
--- a/ltt/branches/poly/ltt/event.c
+++ b/ltt/branches/poly/ltt/event.c
@@ -196,8 +196,9 @@ void ltt_event_position(LttEvent *e, LttEventPosition *ep)
   ep->event_time        = e->event_time;
   ep->event_cycle_count = e->event_cycle_count;
   ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
-  ep->old_position      = TRUE;
+  ep->old_position      = FALSE;
   ep->event_offset      = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
+  ep->tf                = e->tracefile;
 }
 
 /*****************************************************************************
@@ -210,10 +211,11 @@ void ltt_event_position(LttEvent *e, LttEventPosition *ep)
  ****************************************************************************/
 
 void ltt_event_position_get(LttEventPosition *ep,
-    unsigned *block_number, unsigned *index_in_block)
+    unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf)
 {
   *block_number   = ep->block_num;
   *index_in_block = ep->event_num;
+  *tf             = ep->tf;
 }
 
 /*****************************************************************************
@@ -229,7 +231,7 @@ void ltt_event_position_set(LttEventPosition *ep,
     unsigned block_number, unsigned index_in_block)
 {
   ep->block_num = block_number;
-  ep->event_num = index_in_block;
+  ep->event_num = index_in_block;  
 }
 
 /*****************************************************************************

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index 43334ed366d727fcb1527ed7ef7b411ed178004e..5c45d56623a3b53db1b374610413c02da1b018d2 100644 (file)
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -855,9 +855,6 @@ LttEvent *ltt_tracefile_read(LttTracefile *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;
@@ -867,6 +864,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;
 }
 
@@ -1028,11 +1027,13 @@ void getCyclePerNsec(LttTracefile * t)
   TimeSub(lBufTotalTime,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 *= NANSECOND_CONST; 
+  lBufTotalNSec += lBufTotalTime.tv_nsec;
   
   t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec;
 }
@@ -1054,29 +1055,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;
-  
+  nanoSec    = lEventNSec;
+
   // Determine offset in struct LttTime 
-  lTimeOffset.tv_nsec = (long)lEventNSec % 1000000000;
-  lTimeOffset.tv_sec  = (long)lEventNSec / 1000000000;
+  lTimeOffset.tv_nsec = nanoSec % NANSECOND_CONST;
+  lTimeOffset.tv_sec  = nanoSec / NANSECOND_CONST;
 
   TimeAdd(time, tf->a_block_start->time, lTimeOffset);  
-
+  
   return time;
 }