static gint map_block(LttTracefile * tf, guint block_num);
/* calculate nsec per cycles for current block */
-static double calc_nsecs_per_cycle(LttTracefile * t);
+#if 0
+static guint32 calc_nsecs_per_cycle(LttTracefile * t);
+static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles);
+#endif //0
/* go to the next event */
static int ltt_seek_next_event(LttTracefile *tf);
tf->buffer_header_size =
sizeof(struct ltt_block_start_header)
+ sizeof(struct ltt_trace_header_0_3);
+ g_warning("Unsupported trace version : %hhu.%hhu",
+ any->major_version, any->minor_version);
+ return 1;
+ }
+ break;
+ case 4:
+ {
+ struct ltt_trace_header_0_4 *vheader =
+ (struct ltt_trace_header_0_4 *)header;
+ tf->buffer_header_size =
+ sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_0_4);
+ if(t) {
+ t->start_freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_freq);
+ t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_tsc);
+ t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_monotonic);
+ t->start_time = ltt_get_time(LTT_GET_BO(tf),
+ &vheader->start_time);
+ }
}
break;
default:
- g_warning("Unsupported trace version : %hhu.%hhu",
+ g_warning("Unsupported trace version : %hhu.%hhu",
any->major_version, any->minor_version);
return 1;
}
g_assert(tf->trace->has_tsc);
- time = ltt_time_from_uint64(
- (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count) *
- tf->buffer.nsecs_per_cycle);
- time = ltt_time_add(tf->buffer.begin.timestamp, time);
+// time = ltt_time_from_uint64(
+// cycles_2_ns(tf, (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count)));
+ time = ltt_time_from_uint64((tf->buffer.tsc - tf->trace->start_tsc) * 1000000
+ / (double)tf->trace->start_freq);
+ //time = ltt_time_add(tf->buffer.begin.timestamp, time);
+ time = ltt_time_add(tf->trace->start_time, time);
return time;
}
header = (struct ltt_block_start_header*)tf->buffer.head;
- tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf),
- &header->begin.timestamp);
- tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC;
+#if 0
+ tf->buffer.begin.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ ltt_get_uint64(LTT_GET_BO(tf),
+ &header->begin.timestamp)
+ - tf->trace->start_monotonic),
+ tf->trace->start_time);
+#endif //0
//g_debug("block %u begin : %lu.%lu", block_num,
// tf->buffer.begin.timestamp.tv_sec, tf->buffer.begin.timestamp.tv_nsec);
tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
&header->begin.cycle_count);
- tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf),
- &header->end.timestamp);
- tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC;
+ tf->buffer.begin.freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &header->begin.freq);
+ tf->buffer.begin.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ (tf->buffer.begin.cycle_count
+ - tf->trace->start_tsc) * 1000000
+ / (double)tf->trace->start_freq),
+ tf->trace->start_time);
+#if 0
+
+ tf->buffer.end.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ ltt_get_uint64(LTT_GET_BO(tf),
+ &header->end.timestamp)
+ - tf->trace->start_monotonic),
+ tf->trace->start_time);
+#endif //0
//g_debug("block %u end : %lu.%lu", block_num,
// tf->buffer.end.timestamp.tv_sec, tf->buffer.end.timestamp.tv_nsec);
tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
&header->end.cycle_count);
+ tf->buffer.end.freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &header->end.freq);
tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf),
- &header->lost_size);
-
+ &header->lost_size);
+ tf->buffer.end.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ (tf->buffer.end.cycle_count
+ - tf->trace->start_tsc) * 1000000
+ / (double)tf->trace->start_freq),
+ tf->trace->start_time);
+
tf->buffer.tsc = tf->buffer.begin.cycle_count;
tf->event.tsc = tf->buffer.tsc;
+ tf->buffer.freq = tf->buffer.begin.freq;
/* FIXME
* eventually support variable buffer size : will need a partial pre-read of
/* Now that the buffer is mapped, calculate the time interpolation for the
* block. */
- tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
+// tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
+ //tf->buffer.cyc2ns_scale = calc_nsecs_per_cycle(tf);
/* Make the current event point to the beginning of the buffer :
* it means that the event read must get the first event. */
return ENOPROTOOPT;
}
-
+#if 0
/*****************************************************************************
*Function name
* calc_nsecs_per_cycle : calculate nsecs per cycle for current block
+ *
+ * 1.0 / (freq(khz) *1000) * 1000000000
*Input Params
* t : tracefile
****************************************************************************/
-
-static double calc_nsecs_per_cycle(LttTracefile * tf)
+/* from timer_tsc.c */
+#define CYC2NS_SCALE_FACTOR 10
+static guint32 calc_nsecs_per_cycle(LttTracefile * tf)
{
- LttTime lBufTotalTime; /* Total time for this buffer */
- double lBufTotalNSec; /* Total time for this buffer in nsecs */
- LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */
-
- /* Calculate the total time for this buffer */
- lBufTotalTime = ltt_time_sub(tf->buffer.end.timestamp,
- tf->buffer.begin.timestamp);
-
- /* Calculate the total cycles for this bufffer */
- lBufTotalCycle = tf->buffer.end.cycle_count;
- lBufTotalCycle -= tf->buffer.begin.cycle_count;
-
- /* Convert the total time to double */
- lBufTotalNSec = ltt_time_to_double(lBufTotalTime);
+ //return 1e6 / (double)tf->buffer.freq;
+ guint32 cpu_mhz = tf->buffer.freq / 1000;
+ guint32 cyc2ns_scale = (1000 << CYC2NS_SCALE_FACTOR)/cpu_mhz;
- return lBufTotalNSec / (double)lBufTotalCycle;
+ return cyc2ns_scale;
+ // return 1e6 / (double)tf->buffer.freq;
+}
+static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles)
+{
+ return (cycles * tf->buffer.cyc2ns_scale) >> CYC2NS_SCALE_FACTOR;
}
+#endif //0
+
#if 0
void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD)
{
projects / lttv.git / blobdiff