lib: add default clock snapshot property to packet beginning/end message

Packet beginning/end clock snapshot properties were removed from the
`bt_packet` object in a previous commit because they were considered
redundant with the time ranges given by the recently added discarded
events/packets messages.

Now it seems that those properties are needed in order for a message
iterator such as `flt.utils.trimmer` to know whether or not a given
packet beginning/end message is within a given time range. This removes
uncertainty for a class of filters and sinks.

The CTF format has a concept of packet with a specific end time in its
context, but not all source formats have this chance. For this reason,
instead of putting the beginning and end clock snapshot properties in
the `bt_packet` object itself, which would require any source to know
its packet's end time in advance, the packet beginning/end message
itself contains the property. For example, in this patch,
`src.text.dmesg` is modified to set the first event's clock snapshot as
the single packet beginning message's clock snapshot, and the last
event's clock snapshot as the single packet end message's clock
snapshot. Similar sources should take this approach, as those fields are
mandatory if the message's packet's stream's class has a registered
default clock class.

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>

diff --git a/include/babeltrace/graph/message-packet-beginning-const.h b/include/babeltrace/graph/message-packet-beginning-const.h
index 780671134e12c97dc9fda3c6c5b5daaa333f5eb1..c89df0a8bc4210bc82e6ef74d25ccad64068fdd8 100644 (file)
--- a/include/babeltrace/graph/message-packet-beginning-const.h
+++ b/include/babeltrace/graph/message-packet-beginning-const.h
@@ -34,6 +34,10 @@ extern "C" {
 extern const bt_packet *bt_message_packet_beginning_borrow_packet_const(
                const bt_message *message);
 
+extern bt_clock_snapshot_state
+bt_message_packet_beginning_borrow_default_clock_snapshot_const(
+               const bt_message *msg, const bt_clock_snapshot **snapshot);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/include/babeltrace/graph/message-packet-beginning.h b/include/babeltrace/graph/message-packet-beginning.h
index 0b60cc9619b1a8c73173dbc93a13e7537a1e075f..285b8601a0d212f804d81b3ed05e52fa1ec68024 100644 (file)
--- a/include/babeltrace/graph/message-packet-beginning.h
+++ b/include/babeltrace/graph/message-packet-beginning.h
@@ -36,6 +36,11 @@ bt_message *bt_message_packet_beginning_create(
                bt_self_message_iterator *message_iterator,
                const bt_packet *packet);
 
+extern
+bt_message *bt_message_packet_beginning_create_with_default_clock_snapshot(
+               bt_self_message_iterator *message_iterator,
+               const bt_packet *packet, uint64_t raw_value);
+
 extern bt_packet *bt_message_packet_beginning_borrow_packet(
                bt_message *message);
 

diff --git a/include/babeltrace/graph/message-packet-end-const.h b/include/babeltrace/graph/message-packet-end-const.h
index 8da580fb33c256396014b104de25777bfb0e02fa..596a2e497efc815bcf85822bcc88a8db853c002c 100644 (file)
--- a/include/babeltrace/graph/message-packet-end-const.h
+++ b/include/babeltrace/graph/message-packet-end-const.h
@@ -34,6 +34,10 @@ extern "C" {
 extern const bt_packet *bt_message_packet_end_borrow_packet_const(
                const bt_message *message);
 
+extern bt_clock_snapshot_state
+bt_message_packet_end_borrow_default_clock_snapshot_const(
+               const bt_message *msg, const bt_clock_snapshot **snapshot);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/include/babeltrace/graph/message-packet-end.h b/include/babeltrace/graph/message-packet-end.h
index 1d049ca1bb4222c45b782d41508804ebf59652e4..cb40f5ccdb58092af2cf15f65070c7ac625b5eff 100644 (file)
--- a/include/babeltrace/graph/message-packet-end.h
+++ b/include/babeltrace/graph/message-packet-end.h
@@ -36,6 +36,11 @@ bt_message *bt_message_packet_end_create(
                bt_self_message_iterator *message_iterator,
                const bt_packet *packet);
 
+extern
+bt_message *bt_message_packet_end_create_with_default_clock_snapshot(
+               bt_self_message_iterator *message_iterator,
+               const bt_packet *packet, uint64_t raw_value);
+
 extern bt_packet *bt_message_packet_end_borrow_packet(
                bt_message *message);
 

diff --git a/include/babeltrace/graph/message-packet-internal.h b/include/babeltrace/graph/message-packet-internal.h
index e34adf65664411f28209101b41c67ae1c81c6310..bcf6d1174dfdc800c1427e0977952cf70d839aa2 100644 (file)
--- a/include/babeltrace/graph/message-packet-internal.h
+++ b/include/babeltrace/graph/message-packet-internal.h
@@ -26,12 +26,14 @@
 
 #include <babeltrace/compiler-internal.h>
 #include <babeltrace/trace-ir/packet.h>
+#include <babeltrace/trace-ir/clock-snapshot-internal.h>
 #include <babeltrace/graph/message-internal.h>
 #include <babeltrace/assert-internal.h>
 
 struct bt_message_packet {
        struct bt_message parent;
        struct bt_packet *packet;
+       struct bt_clock_snapshot *default_cs;
 };
 
 BT_HIDDEN

diff --git a/lib/graph/message/packet.c b/lib/graph/message/packet.c
index adf64950a5e509652d3850096015ac3a8e2275e1..a61999aedc16ec39354b697f3d8afcc6e9fac665 100644 (file)
--- a/lib/graph/message/packet.c
+++ b/lib/graph/message/packet.c
@@ -30,6 +30,7 @@
 #include <babeltrace/trace-ir/stream-class.h>
 #include <babeltrace/trace-ir/stream.h>
 #include <babeltrace/trace-ir/stream-internal.h>
+#include <babeltrace/trace-ir/stream-class-internal.h>
 #include <babeltrace/graph/graph-internal.h>
 #include <babeltrace/graph/message-packet-beginning-const.h>
 #include <babeltrace/graph/message-packet-end-const.h>
@@ -78,9 +79,10 @@ struct bt_message *bt_message_packet_end_new(struct bt_graph *graph)
 }
 
 static inline
-struct bt_message *bt_message_packet_create(
+struct bt_message *create_packet_message(
                struct bt_self_component_port_input_message_iterator *msg_iter,
-               struct bt_packet *packet, struct bt_object_pool *pool)
+               struct bt_packet *packet, struct bt_object_pool *pool,
+               bool with_cs, uint64_t raw_value)
 {
        struct bt_message_packet *message = NULL;
        struct bt_stream *stream;
@@ -92,6 +94,14 @@ struct bt_message *bt_message_packet_create(
        BT_ASSERT(stream);
        stream_class = bt_stream_borrow_class(stream);
        BT_ASSERT(stream_class);
+       BT_ASSERT_PRE((with_cs && stream_class->default_clock_class) ||
+               (!with_cs && !stream_class->default_clock_class),
+               "Creating a packet message with a default clock snapshot, but without "
+               "a default clock class, or without a default clock snapshot, "
+               "but with a default clock class: ",
+               "%![stream-]+s, %![sc-]+S, with-cs=%d, "
+               "cs-val=%" PRIu64,
+               stream, stream_class, with_cs, raw_value);
        BT_LIB_LOGD("Creating packet message object: "
                "%![packet-]+a, %![stream-]+s, %![sc-]+S",
                packet, stream, stream_class);
@@ -101,6 +111,19 @@ struct bt_message *bt_message_packet_create(
                goto end;
        }
 
+       if (with_cs) {
+               BT_ASSERT(stream_class->default_clock_class);
+               message->default_cs = bt_clock_snapshot_create(
+                       stream_class->default_clock_class);
+               if (!message->default_cs) {
+                       bt_object_put_no_null_check(message);
+                       message = NULL;
+                       goto end;
+               }
+
+               bt_clock_snapshot_set_raw_value(message->default_cs, raw_value);
+       }
+
        BT_ASSERT(!message->packet);
        message->packet = packet;
        bt_object_get_no_null_check_no_parent_check(
@@ -123,8 +146,20 @@ struct bt_message *bt_message_packet_beginning_create(
                (void *) self_msg_iter;
 
        BT_ASSERT_PRE_NON_NULL(msg_iter, "Message iterator");
-       return bt_message_packet_create(msg_iter, (void *) packet,
-               &msg_iter->graph->packet_begin_msg_pool);
+       return create_packet_message(msg_iter, (void *) packet,
+               &msg_iter->graph->packet_begin_msg_pool, false, 0);
+}
+
+struct bt_message *bt_message_packet_beginning_create_with_default_clock_snapshot(
+               struct bt_self_message_iterator *self_msg_iter,
+               const struct bt_packet *packet, uint64_t raw_value)
+{
+       struct bt_self_component_port_input_message_iterator *msg_iter =
+               (void *) self_msg_iter;
+
+       BT_ASSERT_PRE_NON_NULL(msg_iter, "Message iterator");
+       return create_packet_message(msg_iter, (void *) packet,
+               &msg_iter->graph->packet_begin_msg_pool, true, raw_value);
 }
 
 struct bt_message *bt_message_packet_end_create(
@@ -135,8 +170,20 @@ struct bt_message *bt_message_packet_end_create(
                (void *) self_msg_iter;
 
        BT_ASSERT_PRE_NON_NULL(msg_iter, "Message iterator");
-       return bt_message_packet_create(msg_iter, (void *) packet,
-               &msg_iter->graph->packet_end_msg_pool);
+       return create_packet_message(msg_iter, (void *) packet,
+               &msg_iter->graph->packet_end_msg_pool, false, 0);
+}
+
+struct bt_message *bt_message_packet_end_create_with_default_clock_snapshot(
+               struct bt_self_message_iterator *self_msg_iter,
+               const struct bt_packet *packet, uint64_t raw_value)
+{
+       struct bt_self_component_port_input_message_iterator *msg_iter =
+               (void *) self_msg_iter;
+
+       BT_ASSERT_PRE_NON_NULL(msg_iter, "Message iterator");
+       return create_packet_message(msg_iter, (void *) packet,
+               &msg_iter->graph->packet_end_msg_pool, true, raw_value);
 }
 
 BT_HIDDEN
@@ -147,6 +194,12 @@ void bt_message_packet_destroy(struct bt_message *msg)
        BT_LIB_LOGD("Destroying packet message: %!+n", msg);
        BT_LIB_LOGD("Putting packet: %!+a", packet_msg->packet);
        BT_OBJECT_PUT_REF_AND_RESET(packet_msg->packet);
+
+       if (packet_msg->default_cs) {
+               bt_clock_snapshot_recycle(packet_msg->default_cs);
+               packet_msg->default_cs = NULL;
+       }
+
        g_free(msg);
 }
 
@@ -158,6 +211,12 @@ void recycle_packet_message(struct bt_message *msg, struct bt_object_pool *pool)
        BT_LIB_LOGD("Recycling packet message: %!+n", msg);
        bt_message_reset(msg);
        bt_object_put_no_null_check(&packet_msg->packet->base);
+
+       if (packet_msg->default_cs) {
+               bt_clock_snapshot_recycle(packet_msg->default_cs);
+               packet_msg->default_cs = NULL;
+       }
+
        packet_msg->packet = NULL;
        msg->graph = NULL;
        bt_object_pool_recycle_object(pool, msg);
@@ -224,3 +283,43 @@ const struct bt_packet *bt_message_packet_end_borrow_packet_const(
        return bt_message_packet_end_borrow_packet(
                (void *) message);
 }
+
+static inline
+enum bt_clock_snapshot_state
+borrow_packet_message_default_clock_snapshot_const(
+               const struct bt_message *message,
+               const struct bt_clock_snapshot **snapshot)
+{
+       struct bt_message_packet *packet_msg = (void *) message;
+
+       BT_ASSERT(message);
+       BT_ASSERT_PRE(packet_msg->packet->stream->class->default_clock_class,
+               "Message's stream's class has no default clock class: "
+               "%![msg-]+n, %![sc-]+S",
+               message, packet_msg->packet->stream->class);
+       BT_ASSERT_PRE_NON_NULL(snapshot, "Clock snapshot (output)");
+       *snapshot = packet_msg->default_cs;
+       return BT_CLOCK_SNAPSHOT_STATE_KNOWN;
+}
+
+enum bt_clock_snapshot_state
+bt_message_packet_beginning_borrow_default_clock_snapshot_const(
+               const struct bt_message *msg,
+               const struct bt_clock_snapshot **snapshot)
+{
+       BT_ASSERT_PRE_NON_NULL(msg, "Message");
+       BT_ASSERT_PRE_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_PACKET_BEGINNING);
+       return borrow_packet_message_default_clock_snapshot_const(
+               msg, snapshot);
+}
+
+enum bt_clock_snapshot_state
+bt_message_packet_end_borrow_default_clock_snapshot_const(
+               const struct bt_message *msg,
+               const struct bt_clock_snapshot **snapshot)
+{
+       BT_ASSERT_PRE_NON_NULL(msg, "Message");
+       BT_ASSERT_PRE_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_PACKET_END);
+       return borrow_packet_message_default_clock_snapshot_const(
+               msg, snapshot);
+}

diff --git a/plugins/ctf/common/msg-iter/msg-iter.c b/plugins/ctf/common/msg-iter/msg-iter.c
index 0a3b3861da4af0861fa5213fbaa8b028a700f10f..3800d07a3f2cb051b9785d44e98a23a77900f993 100644 (file)
--- a/plugins/ctf/common/msg-iter/msg-iter.c
+++ b/plugins/ctf/common/msg-iter/msg-iter.c
@@ -2511,8 +2511,16 @@ void create_msg_packet_beginning(struct bt_msg_iter *notit,
        }
 
        BT_ASSERT(notit->msg_iter);
-       msg = bt_message_packet_beginning_create(notit->msg_iter,
-               notit->packet);
+
+       if (notit->snapshots.beginning_clock == UINT64_C(-1)) {
+               msg = bt_message_packet_beginning_create(notit->msg_iter,
+                       notit->packet);
+       } else {
+               msg = bt_message_packet_beginning_create_with_default_clock_snapshot(
+                       notit->msg_iter, notit->packet,
+                       notit->snapshots.beginning_clock);
+       }
+
        if (!msg) {
                BT_LOGE("Cannot create packet beginning message: "
                        "notit-addr=%p, packet-addr=%p",
@@ -2541,8 +2549,16 @@ void create_msg_packet_end(struct bt_msg_iter *notit, bt_message **message)
        }
 
        BT_ASSERT(notit->msg_iter);
-       msg = bt_message_packet_end_create(notit->msg_iter,
-               notit->packet);
+
+       if (notit->snapshots.end_clock == UINT64_C(-1)) {
+               msg = bt_message_packet_end_create(notit->msg_iter,
+                       notit->packet);
+       } else {
+               msg = bt_message_packet_end_create_with_default_clock_snapshot(
+                       notit->msg_iter, notit->packet,
+                       notit->snapshots.end_clock);
+       }
+
        if (!msg) {
                BT_LOGE("Cannot create packet end message: "
                        "notit-addr=%p, packet-addr=%p",

diff --git a/plugins/text/dmesg/dmesg.c b/plugins/text/dmesg/dmesg.c
index 65d7dfed69f16a1156cca8e5adb8ab5465cad413..d73d2abe69c537b4896453887f9b468d1a12c187 100644 (file)
--- a/plugins/text/dmesg/dmesg.c
+++ b/plugins/text/dmesg/dmesg.c
@@ -50,6 +50,7 @@ struct dmesg_msg_iter {
        size_t linebuf_len;
        FILE *fp;
        bt_message *tmp_event_msg;
+       uint64_t last_clock_value;
 
        enum {
                STATE_EMIT_STREAM_BEGINNING,
@@ -527,6 +528,7 @@ skip_ts:
 
        if (dmesg_comp->clock_class) {
                bt_event_set_default_clock_snapshot(event, ts);
+               msg_iter->last_clock_value = ts;
        }
 
        goto end;
@@ -789,8 +791,16 @@ handle_state:
                break;
        case STATE_EMIT_PACKET_BEGINNING:
                BT_ASSERT(dmesg_msg_iter->tmp_event_msg);
-               *msg = bt_message_packet_beginning_create(
-                       dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet);
+
+               if (dmesg_comp->clock_class) {
+                       *msg = bt_message_packet_beginning_create_with_default_clock_snapshot(
+                               dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet,
+                               dmesg_msg_iter->last_clock_value);
+               } else {
+                       *msg = bt_message_packet_beginning_create(
+                               dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet);
+               }
+
                dmesg_msg_iter->state = STATE_EMIT_EVENT;
                break;
        case STATE_EMIT_EVENT:
@@ -799,8 +809,15 @@ handle_state:
                dmesg_msg_iter->tmp_event_msg = NULL;
                break;
        case STATE_EMIT_PACKET_END:
-               *msg = bt_message_packet_end_create(
-                       dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet);
+               if (dmesg_comp->clock_class) {
+                       *msg = bt_message_packet_end_create_with_default_clock_snapshot(
+                               dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet,
+                               dmesg_msg_iter->last_clock_value);
+               } else {
+                       *msg = bt_message_packet_end_create(
+                               dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet);
+               }
+
                dmesg_msg_iter->state = STATE_EMIT_STREAM_ACTIVITY_END;
                break;
        case STATE_EMIT_STREAM_ACTIVITY_END: