Fix: --clock-force-correlate to handle trace collections gathered from various nodes
authorMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Sun, 26 Aug 2012 19:08:06 +0000 (15:08 -0400)
committerMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Sun, 26 Aug 2012 19:08:06 +0000 (15:08 -0400)
Currently, traces generated by lttng have the "absolute" flag set to 0,
because they are based on the monotonic clock, which is not perfectly
correlated across nodes.

Fix a couple of minor issue in the handling of --clock-force-correlate
that now allow to use it to force correlation of traces taken with the
monotonic clock source, with "offset" approximation populated using NTP
time.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
formats/ctf/ctf.c
formats/ctf/events-private.h
formats/ctf/metadata/ctf-visitor-generate-io-struct.c
include/babeltrace/babeltrace-internal.h
lib/trace-collection.c

index a2403a77ab8d8906e18e59cb41d6a68684e2ba7a..f43fe91789d21d109c0adf407a0b7e951201ca39 100644 (file)
@@ -1517,7 +1517,7 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
        if (ret)
                goto error_def;
        /*
-        * For now, only a single slock is supported.
+        * For now, only a single clock per trace is supported.
         */
        file_stream->parent.current_clock = td->single_clock;
        ret = create_stream_packet_index(td, file_stream);
@@ -1746,7 +1746,7 @@ int ctf_open_mmap_stream_read(struct ctf_trace *td,
                goto error_index;
 
        /*
-        * For now, only a single slock is supported.
+        * For now, only a single clock per trace is supported.
         */
        file_stream->parent.current_clock = td->single_clock;
 
index 6208e563d2315f94994f88c183041bacc8d3d65c..a3caf7aed9092796e2e79e95b999a678c5d45baf 100644 (file)
@@ -33,7 +33,12 @@ uint64_t ctf_get_real_timestamp(struct ctf_stream_definition *stream,
        uint64_t ts_nsec;
        struct ctf_trace *trace = stream->stream_class->trace;
        struct trace_collection *tc = trace->collection;
-       uint64_t tc_offset = tc->single_clock_offset_avg;
+       uint64_t tc_offset;
+
+       if (tc->clock_use_offset_avg)
+               tc_offset = tc->single_clock_offset_avg;
+       else
+               tc_offset = trace->single_clock->offset;
 
        ts_nsec = clock_cycles_to_ns(stream->current_clock, timestamp);
        ts_nsec += tc_offset;   /* Add offset */
index 500482f57f03f5c77b445dc92938a12b4fe779c2..43fdcb22442386cace3e60553842e3b5c7eabd82 100644 (file)
@@ -2360,7 +2360,7 @@ int ctf_clock_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
        }
        if (!CTF_CLOCK_FIELD_IS_SET(clock, name)) {
                ret = -EPERM;
-               fprintf(fd, "[error] %s: missing namefield in clock declaration\n", __func__);
+               fprintf(fd, "[error] %s: missing name field in clock declaration\n", __func__);
                goto error;
        }
        if (g_hash_table_size(trace->clocks) > 0) {
index 2137c23f5e74c9c941fc5b16671633d489d7f038..29354a4a0eaa5f4503fec218c2aa0489a042d308 100644 (file)
@@ -46,6 +46,7 @@ struct trace_collection {
        uint64_t offset_first;
        int64_t delta_offset_first_sum;
        int offset_nr;
+       int clock_use_offset_avg;
 };
 
 extern int opt_all_field_names,
index 1c78f280fe0bcb128d3da85dbdfdf5a0e5daa6b4..9b60986f5018e98c54e870c471cf498d36d79839 100644 (file)
@@ -39,24 +39,24 @@ static void check_clock_match(gpointer key, gpointer value, gpointer user_data)
        struct clock_match *match = user_data;
        struct ctf_clock *clock_a = value, *clock_b;
 
-       if (clock_a->uuid != 0) {
+       if (clock_a->absolute) {
                /*
-                * Lookup the the trace clocks into the collection
-                * clocks.
+                * Absolute time references, such as NTP, are looked up
+                * by clock name.
                 */
                clock_b = g_hash_table_lookup(match->clocks,
-                       (gpointer) (unsigned long) clock_a->uuid);
+                       (gpointer) (unsigned long) clock_a->name);
                if (clock_b) {
                        match->clock_match = clock_b;
                        return;
                }
-       } else if (clock_a->absolute) {
+       } else if (clock_a->uuid != 0) {
                /*
-                * Absolute time references, such as NTP, are looked up
-                * by clock name.
+                * Lookup the the trace clocks into the collection
+                * clocks.
                 */
                clock_b = g_hash_table_lookup(match->clocks,
-                       (gpointer) (unsigned long) clock_a->name);
+                       (gpointer) (unsigned long) clock_a->uuid);
                if (clock_b) {
                        match->clock_match = clock_b;
                        return;
@@ -95,8 +95,9 @@ static void clock_add(gpointer key, gpointer value, gpointer user_data)
                                (gpointer) (unsigned long) v);
                if (!tc_clock) {
                        /*
-                        * For now, we only support CTF that has one
-                        * single clock uuid or name (absolute ref).
+                        * For now we only support CTF that has one
+                        * single clock uuid or name (absolute ref) per
+                        * trace.
                         */
                        if (g_hash_table_size(tc_clocks) > 0) {
                                fprintf(stderr, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
@@ -111,12 +112,13 @@ static void clock_add(gpointer key, gpointer value, gpointer user_data)
                        g_hash_table_insert(tc_clocks,
                                (gpointer) (unsigned long) v,
                                value);
-               } else {
+               } else if (!t_clock->absolute) {
                        int64_t diff_ns;
 
                        /*
-                        * Check that the offsets match. If not, warn
-                        * the user that we do an arbitrary choice.
+                        * For non-absolute clocks, check that the
+                        * offsets match. If not, warn the user that we
+                        * do an arbitrary choice.
                         */
                        diff_ns = clock_offset_ns(tc_clock) - clock_offset_ns(t_clock);
                        printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
@@ -134,6 +136,8 @@ static void clock_add(gpointer key, gpointer value, gpointer user_data)
                        clock_match->tc->single_clock_offset_avg =
                                clock_match->tc->offset_first
                                + (clock_match->tc->delta_offset_first_sum / clock_match->tc->offset_nr);
+                       /* Time need to use offset average */
+                       clock_match->tc->clock_use_offset_avg = 1;
                }
        }
 }
This page took 0.041589 seconds and 4 git commands to generate.