Populate event header from mapped timestamp clock

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/formats/ctf/ir/event.c b/formats/ctf/ir/event.c
index e63f0de295fd779042940ec0a2f12fae59277b3d..c4fe4b4870726a0310a4abdf5b4fc9834ad680cc 100644 (file)
--- a/formats/ctf/ir/event.c
+++ b/formats/ctf/ir/event.c
@@ -777,30 +777,6 @@ end:
        return ret;
 }
 
-BT_HIDDEN
-int bt_ctf_event_set_timestamp(struct bt_ctf_event *event,
-               uint64_t timestamp)
-{
-       int ret = 0;
-
-       assert(event);
-       if (event->timestamp) {
-               ret = -1;
-               goto end;
-       }
-
-       event->timestamp = timestamp;
-end:
-       return ret;
-}
-
-BT_HIDDEN
-uint64_t bt_ctf_event_get_timestamp(struct bt_ctf_event *event)
-{
-       assert(event);
-       return event->timestamp;
-}
-
 BT_HIDDEN
 int bt_ctf_event_populate_event_header(struct bt_ctf_event *event)
 {
@@ -824,10 +800,28 @@ int bt_ctf_event_populate_event_header(struct bt_ctf_event *event)
        timestamp_field = bt_ctf_field_structure_get_field(event->event_header,
                "timestamp");
        if (timestamp_field) {
-               ret = set_integer_field_value(timestamp_field,
-                       (uint64_t) event->timestamp);
-               if (ret) {
-                       goto end;
+               struct bt_ctf_field_type *timestamp_field_type =
+                       bt_ctf_field_get_type(timestamp_field);
+               struct bt_ctf_clock *mapped_clock;
+
+               assert(timestamp_field_type);
+               mapped_clock = bt_ctf_field_type_integer_get_mapped_clock(
+                       timestamp_field_type);
+               bt_ctf_field_type_put(timestamp_field_type);
+               if (mapped_clock) {
+                       uint64_t timestamp = bt_ctf_clock_get_time(
+                               mapped_clock);
+
+                       bt_ctf_clock_put(mapped_clock);
+                       if (timestamp == (uint64_t) -1ULL) {
+                               goto end;
+                       }
+
+                       ret = set_integer_field_value(timestamp_field,
+                               timestamp);
+                       if (ret) {
+                               goto end;
+                       }
                }
        }
 end:

diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c
index 93982b3b48b13796a61f194862f1bc30a04c0b44..a903264963572ecc89279cb4b8f14781687ce909 100644 (file)
--- a/formats/ctf/ir/stream.c
+++ b/formats/ctf/ir/stream.c
@@ -500,7 +500,6 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
                struct bt_ctf_event *event)
 {
        int ret = 0;
-       uint64_t timestamp;
        struct bt_ctf_field *event_context_copy = NULL;
 
        if (!stream || !event) {
@@ -534,12 +533,6 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
                }
        }
 
-       timestamp = bt_ctf_clock_get_time(stream->stream_class->clock);
-       ret = bt_ctf_event_set_timestamp(event, timestamp);
-       if (ret) {
-               goto end;
-       }
-
        bt_ctf_event_get(event);
        /* Save the new event along with its associated stream event context */
        g_ptr_array_add(stream->events, event);
@@ -680,6 +673,50 @@ end:
        return ret;
 }
 
+static
+int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *timestamp)
+{
+       int ret = 0;
+       struct bt_ctf_field *timestamp_field = NULL;
+       struct bt_ctf_field_type *timestamp_field_type = NULL;
+
+       timestamp_field = bt_ctf_field_structure_get_field(event_header,
+               "timestamp");
+       if (!timestamp_field) {
+               ret = -1;
+               goto end;
+       }
+
+       timestamp_field_type = bt_ctf_field_get_type(timestamp_field);
+       assert(timestamp_field_type);
+       if (bt_ctf_field_type_get_type_id(timestamp_field_type) !=
+               CTF_TYPE_INTEGER) {
+               ret = -1;
+               goto end;
+       }
+
+       if (bt_ctf_field_type_integer_get_signed(timestamp_field_type)) {
+               int64_t val;
+
+               ret = bt_ctf_field_signed_integer_get_value(timestamp_field,
+                       &val);
+               if (ret) {
+                       goto end;
+               }
+               *timestamp = (uint64_t) val;
+       } else {
+               ret = bt_ctf_field_unsigned_integer_get_value(timestamp_field,
+                       timestamp);
+               if (ret) {
+                       goto end;
+               }
+       }
+end:
+       bt_ctf_field_put(timestamp_field);
+       bt_ctf_field_type_put(timestamp_field_type);
+       return ret;
+}
+
 int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 {
        int ret = 0;
@@ -714,24 +751,28 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                goto end;
        }
 
-       timestamp_begin = ((struct bt_ctf_event *) g_ptr_array_index(
-               stream->events, 0))->timestamp;
-       timestamp_end = ((struct bt_ctf_event *) g_ptr_array_index(
-               stream->events, stream->events->len - 1))->timestamp;
-
        /* Set the default context attributes if present and unset. */
-       ret = set_structure_field_integer(stream->packet_context,
-               "timestamp_begin", timestamp_begin);
-       if (ret) {
-               goto end;
+       if (!get_event_header_timestamp(
+               ((struct bt_ctf_event *) g_ptr_array_index(
+               stream->events, 0))->event_header, &timestamp_begin)) {
+               ret = set_structure_field_integer(stream->packet_context,
+                       "timestamp_begin", timestamp_begin);
+               if (ret) {
+                       goto end;
+               }
        }
 
-       ret = set_structure_field_integer(stream->packet_context,
-               "timestamp_end", timestamp_end);
-       if (ret) {
-               goto end;
-       }
+       if (!get_event_header_timestamp(
+               ((struct bt_ctf_event *) g_ptr_array_index(
+               stream->events, stream->events->len - 1))->event_header,
+               &timestamp_end)) {
 
+               ret = set_structure_field_integer(stream->packet_context,
+                       "timestamp_end", timestamp_end);
+               if (ret) {
+                       goto end;
+               }
+       }
        ret = set_structure_field_integer(stream->packet_context,
                "content_size", UINT64_MAX);
        if (ret) {
@@ -775,26 +816,12 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
        for (i = 0; i < stream->events->len; i++) {
                struct bt_ctf_event *event = g_ptr_array_index(
                        stream->events, i);
-               uint32_t event_id = bt_ctf_event_class_get_id(
-                       event->event_class);
-               uint64_t timestamp = bt_ctf_event_get_timestamp(event);
 
                ret = bt_ctf_field_reset(event->event_header);
                if (ret) {
                        goto end;
                }
 
-               ret = set_structure_field_integer(event->event_header,
-                       "id", event_id);
-               if (ret) {
-                       goto end;
-               }
-               ret = set_structure_field_integer(event->event_header,
-                       "timestamp", timestamp);
-               if (ret) {
-                       goto end;
-               }
-
                /* Write event header */
                ret = bt_ctf_field_serialize(event->event_header,
                        &stream->pos);

diff --git a/include/babeltrace/ctf-ir/event-internal.h b/include/babeltrace/ctf-ir/event-internal.h
index b3e05c773c01169b6e9762b1b1fa6cf984357b68..d26a9b990562050ed391b586661b41a4c5a94318 100644 (file)
--- a/include/babeltrace/ctf-ir/event-internal.h
+++ b/include/babeltrace/ctf-ir/event-internal.h
@@ -50,7 +50,6 @@ struct bt_ctf_event_class {
 
 struct bt_ctf_event {
        struct bt_ctf_ref ref_count;
-       uint64_t timestamp;
        struct bt_ctf_event_class *event_class;
        struct bt_ctf_field *event_header;
        struct bt_ctf_field *context_payload;
@@ -80,12 +79,6 @@ BT_HIDDEN
 int bt_ctf_event_serialize(struct bt_ctf_event *event,
                struct ctf_stream_pos *pos);
 
-BT_HIDDEN
-int bt_ctf_event_set_timestamp(struct bt_ctf_event *event, uint64_t timestamp);
-
-BT_HIDDEN
-uint64_t bt_ctf_event_get_timestamp(struct bt_ctf_event *event);
-
 /*
  * Attempt to populate the "id" and "timestamp" fields of the event header if
  * they are present, unset and their types are integers.