t->prev_event_time = ep->prev_event_time;
t->pre_cycle_count = ep->pre_cycle_count;
t->count = ep->count;
+ t->overflow_nsec = ep->overflow_nsec;
/* end of workaround */
//update the fields of the current event and go to the next event
event->prev_event_time = t->prev_event_time;
event->pre_cycle_count = t->pre_cycle_count;
event->count = t->count;
+ event->overflow_nsec = t->overflow_nsec;
+
/* end of workaround */
// 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;
+ //
+ //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)) {
+ //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;
+ // res_delta_count = delta_count + 0x100000000ULL ;
+ //} else
+ // res_delta_count = (LttCycleCount)delta_count;
//cycle_count += (LttCycleCount)tf->count << 32;
// 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;
- g_debug("cur cycle count %llu", tf->cur_cycle_count);
+ //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");
+ //g_debug("BLOCK START");
}else if(unlikely(evId == TRACE_BLOCK_END)){
- g_debug("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);
+ //g_debug("end of block cycle count : %llu", tf->cur_cycle_count);
+
return FALSE;
}
off_t nbBytes;
guint32 lostSize;
+ /* same block already opened requested */
+ 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;
/* read the whole block to precalculate total of cycles in it */
tf->count = 0;
tf->pre_cycle_count = 0;
- tf->cur_cycle_count = tf->a_block_start->cycle_count;
+ tf->cur_cycle_count = 0;
+ //g_debug("precalculating cycles begin for block %i", whichBlock);
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);
+
+ //g_debug("precalculating cycles end for block %i", whichBlock);
/* 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;
+ /* 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);
+
+ /* 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->current_event_time = getEventTime(tf);
tf->prev_event_time.tv_sec = 0;
tf->prev_event_time.tv_nsec = 0;
+ tf->count = 0;
+
+ tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
+ * tf->nsec_per_cycle);
+
}
/*****************************************************************************
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
{
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
+ //LttCycleCount lEventTotalCycle; // Total cycles from start for event
+ gint64 lEventNSec; // Total nsecs from start for event
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;
+ //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
+ 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->overflow_nsec += tf->one_overflow_nsec;
+ tf->count++; //increment overflow 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;
+ //
+ //
+ // 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;
+
+
+
+#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);
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 = (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);
-
+ //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.
+ 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);
return time;
projects / lttv.git / blobdiff