From 7376c71d813475dad8cfd0c4cfd67e0dd69fa38a Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Thu, 9 May 2024 17:11:49 -0400 Subject: [PATCH] plugins/common/muxing: C++ify Change the code to be more idiomatic C++. I tried to keep the overall logic identical. The pattern where we look for the presence of both objects to compare (when we compare things that are optional) comes back often, so factor this out in a `_compareOptional` function. Similarly, comparing strings that can be null comes back often, factor this out in a `_compareStrings` function. The existing code isn't consistent about how to order things, when comparing one empty/null and one non-empty/non-null object. Sometimes, the empty object goes first, sometimes the non-empty object goes first. By factoring out these two functions, the message ordering changes slightly in some cases. I found two test cases that needed to be updated: - flt.utils.muxer/succeed/diff-stream-class-no-name.expect - flt.utils.muxer/succeed/diff-stream-no-name.expect It happens often that we want to compare and order scalar value. Factor this out in a `_compareLt` templated function. The starship operator from C++20 could probably replace this, in a distant future. Otherwise the rest should be pretty straightforward it's the same logic as before. Change-Id: If372de51ff5584d17705a0aed5597cea750597fa Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/12565 Tested-by: jenkins Reviewed-by: Philippe Proulx --- src/plugins/common/muxing/muxing.cpp | 1057 +++++------------ src/plugins/common/muxing/muxing.hpp | 50 +- src/plugins/ctf/lttng-live/lttng-live.cpp | 15 +- src/plugins/ctf/lttng-live/lttng-live.hpp | 4 + src/plugins/utils/muxer/msg-iter.cpp | 2 +- src/plugins/utils/muxer/msg-iter.hpp | 5 + .../succeed/diff-stream-class-no-name.expect | 6 +- .../succeed/diff-stream-no-name.expect | 6 +- 8 files changed, 383 insertions(+), 762 deletions(-) diff --git a/src/plugins/common/muxing/muxing.cpp b/src/plugins/common/muxing/muxing.cpp index 2568304c..a9984010 100644 --- a/src/plugins/common/muxing/muxing.cpp +++ b/src/plugins/common/muxing/muxing.cpp @@ -4,912 +4,485 @@ * Copyright 2019 Francis Deslauriers */ -#include -#include -#include - #include #include "common/assert.h" #include "common/common.h" -#include "common/macros.h" #include "common/uuid.h" +#include "cpp-common/bt2/message.hpp" #include "muxing.hpp" -struct message_to_compare -{ - const bt_message *msg; - const bt_trace *trace; - const bt_stream *stream; -}; - -struct messages_to_compare -{ - struct message_to_compare left; - struct message_to_compare right; -}; - -static int message_type_weight(const bt_message_type msg_type) -{ - int weight; - - switch (msg_type) { - case BT_MESSAGE_TYPE_STREAM_BEGINNING: - weight = 7; - break; - case BT_MESSAGE_TYPE_PACKET_BEGINNING: - weight = 6; - break; - case BT_MESSAGE_TYPE_EVENT: - weight = 5; - break; - case BT_MESSAGE_TYPE_DISCARDED_EVENTS: - weight = 4; - break; - case BT_MESSAGE_TYPE_PACKET_END: - weight = 3; - break; - case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: - weight = 2; - break; - case BT_MESSAGE_TYPE_DISCARDED_PACKETS: - weight = 1; - break; - case BT_MESSAGE_TYPE_STREAM_END: - weight = 0; - break; - default: - bt_common_abort(); - } - - return weight; -} +namespace muxing { /* - * Compare 2 messages to order them in a deterministic way based on their - * types. - * Returns -1 is left message must go first - * Returns 1 is right message must go first + * Compares two optional objects. + * + * A non-empty object comes before an empty object. Two empty objects + * are equal. + * + * If the two objects are non-empty, then call `comparator` to compare + * the contents of both objects. */ -static int compare_messages_by_type(struct messages_to_compare *msgs) +template +int MessageComparator::_compareOptionals(const bt2s::optional& left, + const bt2s::optional& right, + ComparatorT comparator) noexcept { - bt_message_type left_msg_type = bt_message_get_type(msgs->left.msg); - bt_message_type right_msg_type = bt_message_get_type(msgs->right.msg); - - return message_type_weight(right_msg_type) - message_type_weight(left_msg_type); -} + if (left && !right) { + return -1; + } -static int compare_events(const bt_event *left_event, const bt_event *right_event) -{ - int ret = 0; - const bt_event_class *left_event_class, *right_event_class; - uint64_t left_event_class_id, right_event_class_id; - const char *left_event_class_name, *right_event_class_name, *left_event_class_emf_uri, - *right_event_class_emf_uri; - bt_event_class_log_level left_event_class_log_level, right_event_class_log_level; - bt_property_availability left_log_level_avail, right_log_level_avail; - - left_event_class = bt_event_borrow_class_const(left_event); - right_event_class = bt_event_borrow_class_const(right_event); - - left_event_class_id = bt_event_class_get_id(left_event_class); - right_event_class_id = bt_event_class_get_id(right_event_class); - - if (left_event_class_id > right_event_class_id) { - ret = 1; - goto end; - } else if (left_event_class_id < right_event_class_id) { - ret = -1; - goto end; - } - - left_event_class_name = bt_event_class_get_name(left_event_class); - right_event_class_name = bt_event_class_get_name(right_event_class); - if (left_event_class_name && right_event_class_name) { - ret = strcmp(left_event_class_name, right_event_class_name); - if (ret != 0) { - goto end; - } - } else if (!left_event_class_name && right_event_class_name) { - ret = -1; - goto end; - } else if (left_event_class_name && !right_event_class_name) { - ret = 1; - goto end; - } - - left_log_level_avail = - bt_event_class_get_log_level(left_event_class, &left_event_class_log_level); - right_log_level_avail = - bt_event_class_get_log_level(right_event_class, &right_event_class_log_level); - - if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = left_event_class_log_level - right_event_class_log_level; - if (ret) { - goto end; - } - } else if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_log_level_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) { - ret = -1; - goto end; - } else if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE && - right_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = 1; - goto end; - } - - left_event_class_emf_uri = bt_event_class_get_emf_uri(left_event_class); - right_event_class_emf_uri = bt_event_class_get_emf_uri(right_event_class); - if (left_event_class_emf_uri && right_event_class_emf_uri) { - ret = strcmp(left_event_class_emf_uri, right_event_class_emf_uri); - if (ret != 0) { - goto end; - } - } else if (!left_event_class_emf_uri && right_event_class_emf_uri) { - ret = -1; - goto end; - } else if (left_event_class_emf_uri && !right_event_class_emf_uri) { - ret = 1; - goto end; + if (!left && right) { + return 1; + } + if (!left && !right) { + return 0; } -end: - return ret; + return comparator(*left, *right); } -static int compare_clock_classes(const bt_clock_class *left_cc, const bt_clock_class *right_cc) +/* + * Compares two optional borrowed objects. + * + * A non-empty object comes before an empty object. Two empty objects + * are equal. + * + * If the two objects are non-empty, then call `comparator` to compare + * the contents of both objects. + */ +template +int MessageComparator::_compareOptionalBorrowedObjects( + const bt2::OptionalBorrowedObject left, const bt2::OptionalBorrowedObject right, + ComparatorT comparator) noexcept { - int ret; - const char *left_clock_class_name, *right_clock_class_name; - bt_uuid left_clock_class_uuid, right_clock_class_uuid; - uint64_t left_freq, right_freq, left_prec, right_prec; - bool left_origin_is_unix, right_origin_is_unix; - - left_clock_class_uuid = bt_clock_class_get_uuid(left_cc); - right_clock_class_uuid = bt_clock_class_get_uuid(right_cc); - - if (left_clock_class_uuid && !right_clock_class_uuid) { - ret = -1; - goto end; - } else if (!left_clock_class_uuid && right_clock_class_uuid) { - ret = 1; - goto end; - } else if (left_clock_class_uuid && right_clock_class_uuid) { - ret = bt_uuid_compare(left_clock_class_uuid, right_clock_class_uuid); - if (ret != 0) { - goto end; - } + if (left && !right) { + return -1; } - left_origin_is_unix = bt_clock_class_origin_is_unix_epoch(left_cc); - right_origin_is_unix = bt_clock_class_origin_is_unix_epoch(right_cc); - - if (left_origin_is_unix != right_origin_is_unix) { - ret = left_origin_is_unix - right_origin_is_unix; - goto end; + if (!left && right) { + return 1; } - - left_clock_class_name = bt_clock_class_get_name(left_cc); - right_clock_class_name = bt_clock_class_get_name(right_cc); - - if (left_clock_class_name && !right_clock_class_name) { - ret = -1; - goto end; - } else if (!left_clock_class_name && right_clock_class_name) { - ret = 1; - goto end; - } else if (left_clock_class_name && right_clock_class_name) { - ret = strcmp(left_clock_class_name, right_clock_class_name); - if (ret != 0) { - goto end; - } + if (!left && !right) { + return 0; } - left_freq = bt_clock_class_get_frequency(left_cc); - right_freq = bt_clock_class_get_frequency(right_cc); + return comparator(*left, *right); +} - ret = right_freq - left_freq; - if (ret != 0) { - goto end; +/* + * Compare two (nullable) strings. + * + * A non-null string comes before a null string. Two null strings + * are equal. + * + * If both strings aren't null, then compare them with `std::strcmp`. + */ +int MessageComparator::_compareStrings(const bt2c::CStringView left, + const bt2c::CStringView right) noexcept +{ + if (left && !right) { + return -1; } - left_prec = bt_clock_class_get_precision(left_cc); - right_prec = bt_clock_class_get_precision(right_cc); + if (!left && right) { + return 1; + } - ret = right_prec - left_prec; - if (ret != 0) { - goto end; + if (!left && !right) { + return 0; } -end: - return ret; + return std::strcmp(left, right); } -static int compare_streams(const bt_stream *left_stream, const bt_stream *right_stream) +/* + * Returns a weight corresponding to `msgType` to sort message types in + * an arbitrary order. + * + * A lower weight means a higher priority (sorted before). + */ +int MessageComparator::_messageTypeWeight(const bt2::MessageType msgType) noexcept { - int ret = 0; - const char *left_stream_name, *right_stream_name, *left_stream_class_name, - *right_stream_class_name; - const bt_stream_class *left_stream_class, *right_stream_class; - const bt_clock_class *left_cc, *right_cc; - - /* - * No need to compare stream id as it was checked earlier and if we are - * here it means they are identical or both absent. - */ - BT_ASSERT_DBG(bt_stream_get_id(left_stream) == bt_stream_get_id(right_stream)); - - /* Compare stream name. */ - left_stream_name = bt_stream_get_name(left_stream); - right_stream_name = bt_stream_get_name(right_stream); - - if (left_stream_name && right_stream_name) { - ret = strcmp(left_stream_name, right_stream_name); - if (ret != 0) { - goto end; - } - } else if (!left_stream_name && right_stream_name) { - ret = -1; - goto end; - } else if (left_stream_name && !right_stream_name) { - ret = 1; - goto end; - } - - left_stream_class = bt_stream_borrow_class_const(left_stream); - right_stream_class = bt_stream_borrow_class_const(right_stream); - - /* - * No need to compare stream class id as it was checked earlier and if - * we are here it means they are identical. - */ - BT_ASSERT_DBG(bt_stream_class_get_id(left_stream_class) == - bt_stream_class_get_id(right_stream_class)); - - /* Compare stream class name. */ - left_stream_class_name = bt_stream_class_get_name(left_stream_class); - right_stream_class_name = bt_stream_class_get_name(right_stream_class); - - if (left_stream_class_name && right_stream_class_name) { - ret = strcmp(left_stream_class_name, right_stream_class_name); - if (ret != 0) { - goto end; - } - } else if (!left_stream_class_name && right_stream_class_name) { - ret = -1; - goto end; - } else if (left_stream_class_name && !right_stream_class_name) { - ret = 1; - goto end; - } - - /* Compare stream class automatic event class id assignment. */ - if (bt_stream_class_assigns_automatic_event_class_id(left_stream_class) && - !bt_stream_class_assigns_automatic_event_class_id(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_assigns_automatic_event_class_id(left_stream_class) && - bt_stream_class_assigns_automatic_event_class_id(right_stream_class)) { - ret = -1; - goto end; - } - - /* Compare stream class automatic stream id assignment. */ - if (bt_stream_class_assigns_automatic_stream_id(left_stream_class) && - !bt_stream_class_assigns_automatic_stream_id(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_assigns_automatic_stream_id(left_stream_class) && - bt_stream_class_assigns_automatic_stream_id(right_stream_class)) { - ret = -1; - goto end; - } + switch (msgType) { + case bt2::MessageType::StreamBeginning: + return 0; - /* Compare stream class support of discarded events. */ - if (bt_stream_class_supports_discarded_events(left_stream_class) && - !bt_stream_class_supports_discarded_events(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_supports_discarded_events(left_stream_class) && - bt_stream_class_supports_discarded_events(right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::PacketBeginning: + return 1; - /* Compare stream class discarded events default clock snapshot. */ - if (bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class) && - !bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class) && - bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::Event: + return 2; - /* Compare stream class support of packets. */ - if (bt_stream_class_supports_packets(left_stream_class) && - !bt_stream_class_supports_packets(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_supports_packets(left_stream_class) && - bt_stream_class_supports_packets(right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::DiscardedEvents: + return 3; - if (bt_stream_class_supports_packets(left_stream_class)) { - /* - * Compare stream class presence of discarded packets beginning default - * clock snapshot. - */ - if (bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class) && - !bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_packets_have_beginning_default_clock_snapshot( - left_stream_class) && - bt_stream_class_packets_have_beginning_default_clock_snapshot( - right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::PacketEnd: + return 4; - /* - * Compare stream class presence of discarded packets end default clock - * snapshot. - */ - if (bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class) && - !bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class) && - bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::MessageIteratorInactivity: + return 5; - /* Compare stream class support of discarded packets. */ - if (bt_stream_class_supports_discarded_packets(left_stream_class) && - !bt_stream_class_supports_discarded_packets(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_supports_discarded_packets(left_stream_class) && - bt_stream_class_supports_discarded_packets(right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::DiscardedPackets: + return 6; - /* Compare stream class discarded packets default clock snapshot. */ - if (bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class) && - !bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class)) { - ret = 1; - goto end; - } else if (!bt_stream_class_discarded_packets_have_default_clock_snapshots( - left_stream_class) && - bt_stream_class_discarded_packets_have_default_clock_snapshots( - right_stream_class)) { - ret = -1; - goto end; - } + case bt2::MessageType::StreamEnd: + return 7; } - /* Compare the clock classes associated to the stream classes. */ - left_cc = bt_stream_class_borrow_default_clock_class_const(left_stream_class); - right_cc = bt_stream_class_borrow_default_clock_class_const(right_stream_class); - - if (!left_cc && !right_cc) { - ret = compare_clock_classes(left_cc, right_cc); + bt_common_abort(); +} - if (ret != 0) { - goto end; - } - } else if (left_cc && !right_cc) { - ret = -1; - goto end; - } else if (!left_cc && right_cc) { - ret = 1; - goto end; +/* + * Compares two values using operator<(). + */ +template +int MessageComparator::_compareLt(const T left, const T right) noexcept +{ + if (left < right) { + return -1; + } else if (right < left) { + return 1; + } else { + return 0; } - -end: - return ret; } -static int compare_clock_snapshots(const bt_clock_snapshot *left_cs, - const bt_clock_snapshot *right_cs) +int MessageComparator::_compareMsgsTypes(const bt2::MessageType left, + const bt2::MessageType right) noexcept { - uint64_t left_cs_value = bt_clock_snapshot_get_value(left_cs); - uint64_t right_cs_value = bt_clock_snapshot_get_value(right_cs); - - return left_cs_value - right_cs_value; + return _compareLt(_messageTypeWeight(left), _messageTypeWeight(right)); } -static const bt_stream *borrow_stream(const bt_message *msg) +int MessageComparator::_compareUuids(const bt2c::UuidView left, const bt2c::UuidView right) noexcept { - bt_message_type msg_type = bt_message_get_type(msg); - const bt_stream *stream = NULL; - const bt_packet *packet = NULL; - const bt_event *event = NULL; - - switch (msg_type) { - case BT_MESSAGE_TYPE_STREAM_BEGINNING: - stream = bt_message_stream_beginning_borrow_stream_const(msg); - break; - case BT_MESSAGE_TYPE_STREAM_END: - stream = bt_message_stream_end_borrow_stream_const(msg); - break; - case BT_MESSAGE_TYPE_PACKET_BEGINNING: - packet = bt_message_packet_beginning_borrow_packet_const(msg); - stream = bt_packet_borrow_stream_const(packet); - break; - case BT_MESSAGE_TYPE_PACKET_END: - packet = bt_message_packet_end_borrow_packet_const(msg); - stream = bt_packet_borrow_stream_const(packet); - break; - case BT_MESSAGE_TYPE_EVENT: - event = bt_message_event_borrow_event_const(msg); - stream = bt_event_borrow_stream_const(event); - break; - case BT_MESSAGE_TYPE_DISCARDED_EVENTS: - stream = bt_message_discarded_events_borrow_stream_const(msg); - break; - case BT_MESSAGE_TYPE_DISCARDED_PACKETS: - stream = bt_message_discarded_packets_borrow_stream_const(msg); - break; - case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: - goto end; - default: - bt_common_abort(); - } - -end: - return stream; + return bt_uuid_compare(left.data(), right.data()); } -static const bt_trace *borrow_trace(const bt_message *msg) +int MessageComparator::_compareOptUuids(const bt2s::optional& left, + const bt2s::optional& right) noexcept { - const bt_trace *trace = NULL; - const bt_stream *stream = NULL; - - stream = borrow_stream(msg); - if (stream) { - trace = bt_stream_borrow_trace_const(stream); - } - - return trace; + return _compareOptionals(left, right, _compareUuids); } -static int compare_messages_by_trace_name(struct messages_to_compare *msgs) +int MessageComparator::_compareEventClasses(const bt2::ConstEventClass left, + const bt2::ConstEventClass right) noexcept { - int ret = 0; - const char *left_trace_name = NULL, *right_trace_name = NULL; - - if (msgs->left.trace && !msgs->right.trace) { - ret = -1; - goto end; + if (const auto ret = _compareLt(left.id(), right.id())) { + return ret; } - if (!msgs->left.trace && msgs->right.trace) { - ret = 1; - goto end; + if (const auto ret = _compareStrings(left.name(), right.name())) { + return ret; } - if (!msgs->left.trace && !msgs->right.trace) { - ret = 0; - goto end; + if (const auto ret = _compareOptionals(left.logLevel(), right.logLevel(), + _compareLt)) { + return ret; } - left_trace_name = bt_trace_get_name(msgs->left.trace); - right_trace_name = bt_trace_get_name(msgs->right.trace); + return _compareStrings(left.emfUri(), right.emfUri()); +} + +int MessageComparator::_compareClockClasses(const bt2::ConstClockClass left, + const bt2::ConstClockClass right) noexcept +{ + if (const auto ret = _compareOptUuids(left.uuid(), right.uuid())) { + return ret; + } - if (left_trace_name && !right_trace_name) { - ret = -1; - goto end; + if (const auto ret = _compareLt(left.origin().isUnixEpoch(), right.origin().isUnixEpoch())) { + return ret; } - if (!left_trace_name && right_trace_name) { - ret = 1; - goto end; + if (const auto ret = _compareStrings(left.name(), right.name())) { + return ret; } - if (!left_trace_name && !right_trace_name) { - ret = 0; - goto end; + if (const auto ret = _compareLt(left.frequency(), right.frequency())) { + return ret; } - ret = strcmp(left_trace_name, right_trace_name); -end: - return ret; + return _compareLt(left.precision(), right.precision()); } -static int compare_messages_by_trace_uuid(struct messages_to_compare *msgs) +int MessageComparator::_compareStreamsSameIds(const bt2::ConstStream left, + const bt2::ConstStream right) noexcept { - int ret = 0; - bt_uuid left_trace_uuid = NULL, right_trace_uuid = NULL; + BT_ASSERT_DBG(left.id() == right.id()); - if (msgs->left.trace && !msgs->right.trace) { - ret = -1; - goto end; + if (const auto ret = _compareStrings(left.name(), right.name())) { + return ret; } - if (!msgs->left.trace && msgs->right.trace) { - ret = 1; - goto end; - } - - if (!msgs->left.trace && !msgs->right.trace) { - ret = 0; - goto end; - } + const auto leftCls = left.cls(); + const auto rightCls = right.cls(); - left_trace_uuid = bt_trace_get_uuid(msgs->left.trace); - right_trace_uuid = bt_trace_get_uuid(msgs->right.trace); + BT_ASSERT_DBG(leftCls.id() == rightCls.id()); - if (left_trace_uuid && !right_trace_uuid) { - ret = -1; - goto end; + if (const auto ret = _compareStrings(leftCls.name(), rightCls.name())) { + return ret; } - if (!left_trace_uuid && right_trace_uuid) { - ret = 1; - goto end; + if (const auto ret = _compareLt(leftCls.assignsAutomaticEventClassId(), + rightCls.assignsAutomaticEventClassId())) { + return ret; } - if (!left_trace_uuid && !right_trace_uuid) { - ret = 0; - goto end; + if (const auto ret = + _compareLt(leftCls.assignsAutomaticStreamId(), rightCls.assignsAutomaticStreamId())) { + return ret; } - ret = bt_uuid_compare(left_trace_uuid, right_trace_uuid); -end: - return ret; -} - -static int compare_messages_by_stream_class_id(struct messages_to_compare *msgs) -{ - int ret = 0; - uint64_t left_stream_class_id = 0, right_stream_class_id = 0; - - if (msgs->left.stream && !msgs->right.stream) { - ret = -1; - goto end; + /* Compare stream class support of discarded events. */ + if (const auto ret = + _compareLt(leftCls.supportsDiscardedEvents(), rightCls.supportsDiscardedEvents())) { + return ret; } - if (!msgs->left.stream && msgs->right.stream) { - ret = 1; - goto end; + /* Compare stream class discarded events default clock snapshot. */ + if (const auto ret = _compareLt(leftCls.discardedEventsHaveDefaultClockSnapshots(), + rightCls.discardedEventsHaveDefaultClockSnapshots())) { + return ret; } - if (!msgs->left.stream && !msgs->right.stream) { - ret = 0; - goto end; + /* Compare stream class support of packets. */ + if (const auto ret = _compareLt(leftCls.supportsPackets(), rightCls.supportsPackets())) { + return ret; } - left_stream_class_id = bt_stream_class_get_id(bt_stream_borrow_class_const(msgs->left.stream)); + if (leftCls.supportsPackets()) { + /* + * Compare stream class presence of discarded packets beginning default + * clock snapshot. + */ + if (const auto ret = _compareLt(leftCls.packetsHaveBeginningClockSnapshot(), + rightCls.packetsHaveBeginningClockSnapshot())) { + return ret; + } - right_stream_class_id = - bt_stream_class_get_id(bt_stream_borrow_class_const(msgs->right.stream)); + /* + * Compare stream class presence of discarded packets end default clock + * snapshot. + */ + if (const auto ret = _compareLt(leftCls.packetsHaveEndClockSnapshot(), + rightCls.packetsHaveEndClockSnapshot())) { + return ret; + } + + /* Compare stream class support of discarded packets. */ + if (const auto ret = _compareLt(leftCls.supportsDiscardedPackets(), + rightCls.supportsDiscardedPackets())) { + return ret; + } - if (left_stream_class_id == right_stream_class_id) { - ret = 0; - goto end; + /* Compare stream class discarded packets default clock snapshot. */ + if (const auto ret = _compareLt(leftCls.discardedPacketsHaveDefaultClockSnapshots(), + rightCls.discardedPacketsHaveDefaultClockSnapshots())) { + return ret; + } } - ret = (left_stream_class_id < right_stream_class_id) ? -1 : 1; + /* Compare the clock classes associated to the stream classes. */ + return _compareOptionalBorrowedObjects(leftCls.defaultClockClass(), + rightCls.defaultClockClass(), _compareClockClasses); +} -end: - return ret; +int MessageComparator::_compareClockSnapshots(const bt2::ConstClockSnapshot left, + const bt2::ConstClockSnapshot right) noexcept +{ + return _compareLt(left.value(), right.value()); } -static int compare_messages_by_stream_id(struct messages_to_compare *msgs) +namespace { + +bt2::OptionalBorrowedObject borrowStream(const bt2::ConstMessage msg) noexcept { - int ret = 0; - uint64_t left_stream_id = 0, right_stream_id = 0; + switch (msg.type()) { + case bt2::MessageType::StreamBeginning: + return msg.asStreamBeginning().stream(); - if (msgs->left.stream && !msgs->right.stream) { - ret = -1; - goto end; - } + case bt2::MessageType::StreamEnd: + return msg.asStreamEnd().stream(); - if (!msgs->left.stream && msgs->right.stream) { - ret = 1; - goto end; - } + case bt2::MessageType::PacketBeginning: + return msg.asPacketBeginning().packet().stream(); - if (!msgs->left.stream && !msgs->right.stream) { - ret = 0; - goto end; - } + case bt2::MessageType::PacketEnd: + return msg.asPacketEnd().packet().stream(); - left_stream_id = bt_stream_get_id(msgs->left.stream); - right_stream_id = bt_stream_get_id(msgs->right.stream); + case bt2::MessageType::Event: + return msg.asEvent().event().stream(); - if (left_stream_id == right_stream_id) { - ret = 0; - goto end; - } + case bt2::MessageType::DiscardedEvents: + return msg.asDiscardedEvents().stream(); - ret = (left_stream_id < right_stream_id) ? -1 : 1; + case bt2::MessageType::DiscardedPackets: + return msg.asDiscardedPackets().stream(); -end: - return ret; + case bt2::MessageType::MessageIteratorInactivity: + return {}; + } + + bt_common_abort(); } -static int compare_messages_same_type(struct messages_to_compare *msgs) +} /* namespace */ + +int MessageComparator::_compareMessagesSameType(const bt2::ConstMessage left, + const bt2::ConstMessage right) noexcept { - int ret = 0; - - /* - * Both messages are of the same type, we must compare characteristics of - * the messages such as the attributes of the event in a event message. - */ - BT_ASSERT_DBG(bt_message_get_type(msgs->left.msg) == bt_message_get_type(msgs->right.msg)); - - switch (bt_message_get_type(msgs->left.msg)) { - case BT_MESSAGE_TYPE_STREAM_BEGINNING: - /* Fall-through */ - case BT_MESSAGE_TYPE_STREAM_END: - /* Fall-through */ - case BT_MESSAGE_TYPE_PACKET_BEGINNING: - /* Fall-through */ - case BT_MESSAGE_TYPE_PACKET_END: - ret = compare_streams(msgs->left.stream, msgs->right.stream); - if (ret) { - goto end; - } + BT_ASSERT_DBG(left.type() == right.type()); + + switch (left.type()) { + case bt2::MessageType::StreamBeginning: + case bt2::MessageType::StreamEnd: + case bt2::MessageType::PacketBeginning: + case bt2::MessageType::PacketEnd: + return _compareStreamsSameIds(*borrowStream(left), *borrowStream(right)); - break; - case BT_MESSAGE_TYPE_EVENT: + case bt2::MessageType::Event: { - const bt_event *left_event, *right_event; - left_event = bt_message_event_borrow_event_const(msgs->left.msg); - right_event = bt_message_event_borrow_event_const(msgs->right.msg); + const auto leftEvent = left.asEvent().event(); + const auto rightEvent = right.asEvent().event(); - ret = compare_events(left_event, right_event); - if (ret) { - goto end; + if (const auto ret = _compareEventClasses(leftEvent.cls(), rightEvent.cls())) { + return ret; } - ret = compare_streams(msgs->left.stream, msgs->right.stream); - if (ret) { - goto end; - } - break; + return _compareStreamsSameIds(leftEvent.stream(), rightEvent.stream()); } - case BT_MESSAGE_TYPE_DISCARDED_EVENTS: - { - const bt_stream_class *left_stream_class; - bt_property_availability left_event_count_avail, right_event_count_avail; - uint64_t left_event_count, right_event_count; + case bt2::MessageType::DiscardedEvents: + { /* * Compare streams first to check if there is a * mismatch about discarded event related configuration * in the stream class. */ - ret = compare_streams(msgs->left.stream, msgs->right.stream); - if (ret) { - goto end; + + const auto leftDiscEv = left.asDiscardedEvents(); + const auto rightDiscEv = right.asDiscardedEvents(); + + if (const auto ret = _compareStreamsSameIds(leftDiscEv.stream(), rightDiscEv.stream())) { + return ret; } - left_stream_class = bt_stream_borrow_class_const(msgs->left.stream); - if (bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class)) { - const bt_clock_snapshot *left_beg_cs = - bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const( - msgs->left.msg); - const bt_clock_snapshot *right_beg_cs = - bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const( - msgs->right.msg); - const bt_clock_snapshot *left_end_cs = - bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs->left.msg); - const bt_clock_snapshot *right_end_cs = - bt_message_discarded_events_borrow_end_default_clock_snapshot_const( - msgs->right.msg); - - ret = compare_clock_snapshots(left_beg_cs, right_beg_cs); - if (ret) { - goto end; - } + if (leftDiscEv.stream().cls().discardedEventsHaveDefaultClockSnapshots()) { + const auto leftBegCs = leftDiscEv.beginningDefaultClockSnapshot(); + const auto rightBegCs = rightDiscEv.beginningDefaultClockSnapshot(); + const auto leftEndCs = leftDiscEv.endDefaultClockSnapshot(); + const auto rightEndCs = rightDiscEv.endDefaultClockSnapshot(); - ret = compare_clock_snapshots(left_end_cs, right_end_cs); - if (ret) { - goto end; + if (const auto ret = _compareClockSnapshots(leftBegCs, rightBegCs)) { + return ret; } - ret = compare_clock_classes(bt_clock_snapshot_borrow_clock_class_const(left_beg_cs), - bt_clock_snapshot_borrow_clock_class_const(right_beg_cs)); - if (ret != 0) { - goto end; + if (const auto ret = _compareClockSnapshots(leftEndCs, rightEndCs)) { + return ret; } - } - left_event_count_avail = - bt_message_discarded_events_get_count(msgs->left.msg, &left_event_count); - right_event_count_avail = - bt_message_discarded_events_get_count(msgs->right.msg, &right_event_count); - if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = left_event_count - right_event_count; - if (ret != 0) { - goto end; + if (const auto ret = + _compareClockClasses(leftBegCs.clockClass(), rightBegCs.clockClass())) { + return ret; } - } else if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_event_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) { - ret = -1; - goto end; - } else if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE && - right_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = 1; - goto end; } - break; + return _compareOptionals(leftDiscEv.count(), rightDiscEv.count(), + _compareLt); } - case BT_MESSAGE_TYPE_DISCARDED_PACKETS: + case bt2::MessageType::DiscardedPackets: { - const bt_stream_class *left_stream_class; - bt_property_availability left_packet_count_avail, right_packet_count_avail; - uint64_t left_packet_count, right_packet_count; + const auto leftDiscPkts = left.asDiscardedPackets(); + const auto rightDiscPkts = right.asDiscardedPackets(); /* * Compare streams first to check if there is a * mismatch about discarded packets related * configuration in the stream class. */ - ret = compare_streams(msgs->left.stream, msgs->right.stream); - if (ret) { - goto end; + if (const auto ret = + _compareStreamsSameIds(leftDiscPkts.stream(), rightDiscPkts.stream())) { + return ret; } - left_stream_class = bt_stream_borrow_class_const(msgs->left.stream); - - if (bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class)) { - const bt_clock_snapshot *left_beg_cs = - bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const( - msgs->left.msg); - const bt_clock_snapshot *right_beg_cs = - bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const( - msgs->right.msg); - const bt_clock_snapshot *left_end_cs = - bt_message_discarded_packets_borrow_end_default_clock_snapshot_const( - msgs->left.msg); - const bt_clock_snapshot *right_end_cs = - bt_message_discarded_packets_borrow_end_default_clock_snapshot_const( - msgs->right.msg); - - ret = compare_clock_snapshots(left_beg_cs, right_beg_cs); - if (ret) { - goto end; - } + if (leftDiscPkts.stream().cls().discardedPacketsHaveDefaultClockSnapshots()) { + const auto leftBegCs = leftDiscPkts.beginningDefaultClockSnapshot(); + const auto rightBegCs = rightDiscPkts.beginningDefaultClockSnapshot(); + const auto leftEndCs = leftDiscPkts.endDefaultClockSnapshot(); + const auto rightEndCs = rightDiscPkts.endDefaultClockSnapshot(); - ret = compare_clock_snapshots(left_end_cs, right_end_cs); - if (ret) { - goto end; + if (const auto ret = _compareClockSnapshots(leftBegCs, rightBegCs)) { + return ret; } - ret = compare_clock_classes(bt_clock_snapshot_borrow_clock_class_const(left_beg_cs), - bt_clock_snapshot_borrow_clock_class_const(right_beg_cs)); - if (ret != 0) { - goto end; + if (const auto ret = _compareClockSnapshots(leftEndCs, rightEndCs)) { + return ret; } - } - left_packet_count_avail = - bt_message_discarded_packets_get_count(msgs->left.msg, &left_packet_count); - right_packet_count_avail = - bt_message_discarded_packets_get_count(msgs->right.msg, &right_packet_count); - if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = left_packet_count - right_packet_count; - if (ret != 0) { - goto end; + if (const auto ret = + _compareClockClasses(leftBegCs.clockClass(), rightBegCs.clockClass())) { + return ret; } - } else if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE && - right_packet_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) { - ret = -1; - goto end; - } else if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE && - right_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) { - ret = 1; - goto end; } - break; + return _compareOptionals(leftDiscPkts.count(), leftDiscPkts.count(), + _compareLt); } - case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: + case bt2::MessageType::MessageIteratorInactivity: { - const bt_clock_snapshot *left_cs = - bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(msgs->left.msg); - const bt_clock_snapshot *right_cs = - bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(msgs->right.msg); - - ret = compare_clock_snapshots(left_cs, right_cs); - if (ret != 0) { - goto end; - } + const auto leftCs = left.asMessageIteratorInactivity().clockSnapshot(); + const auto rightCs = right.asMessageIteratorInactivity().clockSnapshot(); - ret = compare_clock_classes(bt_clock_snapshot_borrow_clock_class_const(left_cs), - bt_clock_snapshot_borrow_clock_class_const(right_cs)); - if (ret != 0) { - goto end; + if (const auto ret = _compareClockSnapshots(leftCs, rightCs)) { + return ret; } - break; + return _compareClockClasses(leftCs.clockClass(), rightCs.clockClass()); } - default: - bt_common_abort(); } -end: - return ret; + bt_common_abort(); } -int common_muxing_compare_messages(const bt_message *left_msg, const bt_message *right_msg) +int MessageComparator::compare(const bt2::ConstMessage left, + const bt2::ConstMessage right) const noexcept { - int ret = 0; - struct messages_to_compare msgs; - - BT_ASSERT_DBG(left_msg != right_msg); + BT_ASSERT_DBG(left.libObjPtr() != right.libObjPtr()); - msgs.left.msg = left_msg; - msgs.left.trace = borrow_trace(left_msg); - msgs.left.stream = borrow_stream(left_msg); + if (const auto ret = _compareOptionalBorrowedObjects( + borrowStream(left), borrowStream(right), + [](const bt2::ConstStream leftStream, const bt2::ConstStream rightStream) { + const auto leftTrace = leftStream.trace(); + const auto rightTrace = rightStream.trace(); - msgs.right.msg = right_msg; - msgs.right.trace = borrow_trace(right_msg); - msgs.right.stream = borrow_stream(right_msg); + /* Compare trace UUIDs. */ + if (const auto ret = _compareOptUuids(leftTrace.uuid(), rightTrace.uuid())) { + return ret; + } - /* Same timestamp: compare trace UUIDs. */ - ret = compare_messages_by_trace_uuid(&msgs); - if (ret) { - goto end; - } + /* Compare trace names. */ + if (const auto ret = _compareStrings(leftTrace.name(), rightTrace.name())) { + return ret; + } - /* Same timestamp and trace UUID: compare trace names. */ - ret = compare_messages_by_trace_name(&msgs); - if (ret) { - goto end; - } + /* Compare stream class IDs. */ + if (const auto ret = _compareLt(leftStream.cls().id(), rightStream.cls().id())) { + return ret; + } - /* - * Same timestamp, trace name, and trace UUID: compare stream class - * IDs. - */ - ret = compare_messages_by_stream_class_id(&msgs); - if (ret) { - goto end; + /* Compare stream IDs. */ + return _compareLt(leftStream.id(), rightStream.id()); + })) { + return ret; } - /* - * Same timestamp, trace name, trace UUID, and stream class ID: compare - * stream IDs. - */ - ret = compare_messages_by_stream_id(&msgs); - if (ret) { - goto end; + if (const auto ret = _compareMsgsTypes(left.type(), right.type())) { + return ret; } - if (bt_message_get_type(msgs.left.msg) != bt_message_get_type(msgs.right.msg)) { - /* - * The messages are of different type, we order (arbitrarily) - * in the following way: - * SB < PB < EV < DE < MI < PE < DP < SE - */ - ret = compare_messages_by_type(&msgs); - if (ret) { - goto end; - } - } else { - /* The messages are of the same type. */ - ret = compare_messages_same_type(&msgs); - if (ret) { - goto end; - } - } - -end: - return ret; + return _compareMessagesSameType(left, right); } + +} /* namespace muxing */ diff --git a/src/plugins/common/muxing/muxing.hpp b/src/plugins/common/muxing/muxing.hpp index 9f9aacd4..c3fa5c2b 100644 --- a/src/plugins/common/muxing/muxing.hpp +++ b/src/plugins/common/muxing/muxing.hpp @@ -7,11 +7,53 @@ #ifndef BABELTRACE_PLUGINS_COMMON_MUXING_MUXING_HPP #define BABELTRACE_PLUGINS_COMMON_MUXING_MUXING_HPP -#include +#include "cpp-common/bt2/message.hpp" -#include "common/macros.h" +namespace muxing { -BT_EXTERN_C int common_muxing_compare_messages(const bt_message *left_msg, - const bt_message *right_msg); +class MessageComparator final +{ +public: + int compare(bt2::ConstMessage left, bt2::ConstMessage right) const noexcept; + +private: + static int _messageTypeWeight(const bt2::MessageType msgType) noexcept; + + template + static int _compareOptionals(const bt2s::optional& left, + const bt2s::optional& right, + ComparatorT comparator) noexcept; + + template + static int _compareOptionalBorrowedObjects(const bt2::OptionalBorrowedObject left, + const bt2::OptionalBorrowedObject right, + ComparatorT comparator) noexcept; + + static int _compareStrings(const bt2c::CStringView left, + const bt2c::CStringView right) noexcept; + + template + static int _compareLt(const T left, const T right) noexcept; + + static int _compareMsgsTypes(const bt2::MessageType left, + const bt2::MessageType right) noexcept; + static int _compareUuids(const bt2c::UuidView left, const bt2c::UuidView right) noexcept; + static int _compareOptUuids(const bt2s::optional& left, + const bt2s::optional& right) noexcept; + static int _compareEventClasses(const bt2::ConstEventClass left, + const bt2::ConstEventClass right) noexcept; + static int _compareClockClasses(const bt2::ConstClockClass left, + const bt2::ConstClockClass right) noexcept; + static int _compareStreamsSameIds(const bt2::ConstStream left, + const bt2::ConstStream right) noexcept; + static int _compareClockSnapshots(const bt2::ConstClockSnapshot left, + const bt2::ConstClockSnapshot right) noexcept; + static int _compareMessagesSameType(const bt2::ConstMessage left, + const bt2::ConstMessage right) noexcept; + static int _compareMessages(const bt2::ConstMessage left, + const bt2::ConstMessage right) noexcept; +}; + +} /* namespace muxing */ #endif /* BABELTRACE_PLUGINS_COMMON_MUXING_MUXING_HPP */ diff --git a/src/plugins/ctf/lttng-live/lttng-live.cpp b/src/plugins/ctf/lttng-live/lttng-live.cpp index 8b61cb9d..2b242e26 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.cpp +++ b/src/plugins/ctf/lttng-live/lttng-live.cpp @@ -1056,9 +1056,8 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, * deterministic way. */ BT_ASSERT_DBG(stream_iter != youngest_candidate_stream_iter); - int ret = common_muxing_compare_messages( - stream_iter->current_msg->libObjPtr(), - youngest_candidate_stream_iter->current_msg->libObjPtr()); + int ret = lttng_live_msg_iter->msgComparator.compare( + *stream_iter->current_msg, *youngest_candidate_stream_iter->current_msg); if (ret < 0) { /* * The `youngest_candidate_stream_iter->current_msg` @@ -1163,9 +1162,8 @@ next_stream_iterator_for_session(struct lttng_live_msg_iter *lttng_live_msg_iter * Order the messages in an arbitrary but * deterministic way. */ - int ret = common_muxing_compare_messages( - stream_iter->current_msg->libObjPtr(), - youngest_candidate_stream_iter->current_msg->libObjPtr()); + int ret = lttng_live_msg_iter->msgComparator.compare( + *stream_iter->current_msg, *youngest_candidate_stream_iter->current_msg); if (ret < 0) { /* * The `youngest_candidate_stream_iter->current_msg` @@ -1366,9 +1364,8 @@ lttng_live_msg_iter_next(bt_self_message_iterator *self_msg_it, bt_message_array * Order the messages in an arbitrary but * deterministic way. */ - int ret = common_muxing_compare_messages( - candidate_stream_iter->current_msg->libObjPtr(), - youngest_stream_iter->current_msg->libObjPtr()); + int ret = lttng_live_msg_iter->msgComparator.compare( + *candidate_stream_iter->current_msg, *youngest_stream_iter->current_msg); if (ret < 0) { /* * The `candidate_stream_iter->current_msg` diff --git a/src/plugins/ctf/lttng-live/lttng-live.hpp b/src/plugins/ctf/lttng-live/lttng-live.hpp index 384cc424..563cf14c 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.hpp +++ b/src/plugins/ctf/lttng-live/lttng-live.hpp @@ -19,6 +19,8 @@ #include "cpp-common/bt2/message.hpp" #include "cpp-common/vendor/fmt/format.h" /* IWYU pragma: keep */ +#include "plugins/common/muxing/muxing.hpp" + #include "../common/src/metadata/metadata-stream-parser-utils.hpp" #include "../common/src/msg-iter.hpp" #include "viewer-connection.hpp" @@ -366,6 +368,8 @@ struct lttng_live_msg_iter /* True if the iterator was interrupted. */ bool was_interrupted = false; + + muxing::MessageComparator msgComparator; }; enum lttng_live_iterator_status diff --git a/src/plugins/utils/muxer/msg-iter.cpp b/src/plugins/utils/muxer/msg-iter.cpp index 16502ec8..c0ca5ee1 100644 --- a/src/plugins/utils/muxer/msg-iter.cpp +++ b/src/plugins/utils/muxer/msg-iter.cpp @@ -389,7 +389,7 @@ bool MsgIter::_HeapComparator::operator()( * message is considered older than the second, which corresponds to * this comparator returning `true`. */ - const auto res = common_muxing_compare_messages(msgA.libObjPtr(), msgB.libObjPtr()) < 0; + const auto res = _mMsgComparator.compare(msgA, msgB) < 0; BT_CPPLOGT("Timestamps are considered equal; comparing other properties: oldest={}", res ? "A" : "B"); diff --git a/src/plugins/utils/muxer/msg-iter.hpp b/src/plugins/utils/muxer/msg-iter.hpp index 73620b5e..e359c39e 100644 --- a/src/plugins/utils/muxer/msg-iter.hpp +++ b/src/plugins/utils/muxer/msg-iter.hpp @@ -14,6 +14,8 @@ #include "cpp-common/bt2/self-message-iterator-configuration.hpp" #include "cpp-common/bt2c/prio-heap.hpp" +#include "plugins/common/muxing/muxing.hpp" + #include "clock-correlation-validator/clock-correlation-validator.hpp" #include "upstream-msg-iter.hpp" @@ -37,6 +39,9 @@ private: private: bt2c::Logger _mLogger; + + /* Message comparator */ + muxing::MessageComparator _mMsgComparator; }; public: diff --git a/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-class-no-name.expect b/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-class-no-name.expect index b87875d5..343f70a9 100644 --- a/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-class-no-name.expect +++ b/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-class-no-name.expect @@ -1,20 +1,20 @@ [0 cycles, 0 ns from origin] {Trace 0, Stream class ID 0, Stream ID 0} Stream beginning: + Class name: one Trace: Stream (ID 0, Class ID 0) [0 cycles, 0 ns from origin] {Trace 1, Stream class ID 0, Stream ID 0} Stream beginning: - Class name: one Trace: Stream (ID 0, Class ID 0) [193 cycles, 193,000,000,000 ns from origin] -{Trace 1, Stream class ID 0, Stream ID 0} +{Trace 0, Stream class ID 0, Stream ID 0} Stream end [386 cycles, 386,000,000,000 ns from origin] -{Trace 0, Stream class ID 0, Stream ID 0} +{Trace 1, Stream class ID 0, Stream ID 0} Stream end diff --git a/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-no-name.expect b/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-no-name.expect index 6e9e43df..494155ed 100644 --- a/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-no-name.expect +++ b/tests/data/plugins/flt.utils.muxer/succeed/diff-stream-no-name.expect @@ -1,20 +1,20 @@ [0 cycles, 0 ns from origin] {Trace 0, Stream class ID 0, Stream ID 0} Stream beginning: + Name: one Trace: Stream (ID 0, Class ID 0) [0 cycles, 0 ns from origin] {Trace 1, Stream class ID 0, Stream ID 0} Stream beginning: - Name: one Trace: Stream (ID 0, Class ID 0) [193 cycles, 193,000,000,000 ns from origin] -{Trace 1, Stream class ID 0, Stream ID 0} +{Trace 0, Stream class ID 0, Stream ID 0} Stream end [386 cycles, 386,000,000,000 ns from origin] -{Trace 0, Stream class ID 0, Stream ID 0} +{Trace 1, Stream class ID 0, Stream ID 0} Stream end -- 2.34.1