2 * SPDX-License-Identifier: MIT
4 * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
7 #include <babeltrace2/babeltrace.h>
13 #include "common/assert.h"
14 #include "common/common.h"
15 #include "common/macros.h"
16 #include "common/uuid.h"
20 struct message_to_compare
{
21 const bt_message
*msg
;
22 const bt_trace
*trace
;
23 const bt_stream
*stream
;
26 struct messages_to_compare
{
27 struct message_to_compare left
;
28 struct message_to_compare right
;
32 int message_type_weight(const bt_message_type msg_type
)
37 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
40 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
43 case BT_MESSAGE_TYPE_EVENT
:
46 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
49 case BT_MESSAGE_TYPE_PACKET_END
:
52 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
55 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
58 case BT_MESSAGE_TYPE_STREAM_END
:
69 * Compare 2 messages to order them in a deterministic way based on their
71 * Returns -1 is left message must go first
72 * Returns 1 is right message must go first
75 int compare_messages_by_type(struct messages_to_compare
*msgs
)
77 bt_message_type left_msg_type
= bt_message_get_type(msgs
->left
.msg
);
78 bt_message_type right_msg_type
= bt_message_get_type(msgs
->right
.msg
);
80 return message_type_weight(right_msg_type
) -
81 message_type_weight(left_msg_type
);
85 int compare_events(const bt_event
*left_event
, const bt_event
*right_event
)
88 const bt_event_class
*left_event_class
, *right_event_class
;
89 uint64_t left_event_class_id
, right_event_class_id
;
90 const char *left_event_class_name
, *right_event_class_name
,
91 *left_event_class_emf_uri
, *right_event_class_emf_uri
;
92 bt_event_class_log_level left_event_class_log_level
, right_event_class_log_level
;
93 bt_property_availability left_log_level_avail
, right_log_level_avail
;
95 left_event_class
= bt_event_borrow_class_const(left_event
);
96 right_event_class
= bt_event_borrow_class_const(right_event
);
98 left_event_class_id
= bt_event_class_get_id(left_event_class
);
99 right_event_class_id
= bt_event_class_get_id(right_event_class
);
101 if (left_event_class_id
> right_event_class_id
) {
104 } else if (left_event_class_id
< right_event_class_id
) {
109 left_event_class_name
= bt_event_class_get_name(left_event_class
);
110 right_event_class_name
= bt_event_class_get_name(right_event_class
);
111 if (left_event_class_name
&& right_event_class_name
) {
112 ret
= strcmp(left_event_class_name
, right_event_class_name
);
116 } else if (!left_event_class_name
&& right_event_class_name
) {
119 } else if (left_event_class_name
&& !right_event_class_name
) {
124 left_log_level_avail
= bt_event_class_get_log_level(left_event_class
,
125 &left_event_class_log_level
);
126 right_log_level_avail
= bt_event_class_get_log_level(right_event_class
,
127 &right_event_class_log_level
);
129 if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
130 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
131 ret
= left_event_class_log_level
- right_event_class_log_level
;
135 } else if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
136 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
139 } else if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
140 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
145 left_event_class_emf_uri
= bt_event_class_get_emf_uri(left_event_class
);
146 right_event_class_emf_uri
= bt_event_class_get_emf_uri(right_event_class
);
147 if (left_event_class_emf_uri
&& right_event_class_emf_uri
) {
148 ret
= strcmp(left_event_class_emf_uri
, right_event_class_emf_uri
);
152 } else if (!left_event_class_emf_uri
&& right_event_class_emf_uri
) {
155 } else if (left_event_class_emf_uri
&& !right_event_class_emf_uri
) {
166 int compare_clock_classes(const bt_clock_class
*left_cc
,
167 const bt_clock_class
*right_cc
)
170 const char *left_clock_class_name
, *right_clock_class_name
;
171 bt_uuid left_clock_class_uuid
, right_clock_class_uuid
;
172 uint64_t left_freq
, right_freq
, left_prec
, right_prec
;
173 bool left_origin_is_unix
, right_origin_is_unix
;
175 left_clock_class_uuid
= bt_clock_class_get_uuid(left_cc
);
176 right_clock_class_uuid
= bt_clock_class_get_uuid(right_cc
);
178 if (left_clock_class_uuid
&& !right_clock_class_uuid
) {
181 } else if (!left_clock_class_uuid
&& right_clock_class_uuid
) {
184 } else if (left_clock_class_uuid
&& right_clock_class_uuid
) {
185 ret
= bt_uuid_compare(left_clock_class_uuid
,
186 right_clock_class_uuid
);
192 left_origin_is_unix
= bt_clock_class_origin_is_unix_epoch(left_cc
);
193 right_origin_is_unix
= bt_clock_class_origin_is_unix_epoch(right_cc
);
195 if (left_origin_is_unix
!= right_origin_is_unix
) {
196 ret
= left_origin_is_unix
- right_origin_is_unix
;
200 left_clock_class_name
= bt_clock_class_get_name(left_cc
);
201 right_clock_class_name
= bt_clock_class_get_name(right_cc
);
203 if (left_clock_class_name
&& !right_clock_class_name
) {
206 } else if (!left_clock_class_name
&& right_clock_class_name
) {
209 } else if (left_clock_class_name
&& right_clock_class_name
) {
210 ret
= strcmp(left_clock_class_name
, right_clock_class_name
);
216 left_freq
= bt_clock_class_get_frequency(left_cc
);
217 right_freq
= bt_clock_class_get_frequency(right_cc
);
219 ret
= right_freq
- left_freq
;
224 left_prec
= bt_clock_class_get_precision(left_cc
);
225 right_prec
= bt_clock_class_get_precision(right_cc
);
227 ret
= right_prec
- left_prec
;
237 int compare_streams(const bt_stream
*left_stream
, const bt_stream
*right_stream
)
240 const char *left_stream_name
, *right_stream_name
,
241 *left_stream_class_name
, *right_stream_class_name
;
242 const bt_stream_class
*left_stream_class
, *right_stream_class
;
243 const bt_clock_class
*left_cc
, *right_cc
;
246 * No need to compare stream id as it was checked earlier and if we are
247 * here it means they are identical or both absent.
249 BT_ASSERT_DBG(bt_stream_get_id(left_stream
) ==
250 bt_stream_get_id(right_stream
));
252 /* Compare stream name. */
253 left_stream_name
= bt_stream_get_name(left_stream
);
254 right_stream_name
= bt_stream_get_name(right_stream
);
256 if (left_stream_name
&& right_stream_name
) {
257 ret
= strcmp(left_stream_name
, right_stream_name
);
261 } else if (!left_stream_name
&& right_stream_name
) {
264 } else if (left_stream_name
&& !right_stream_name
) {
269 left_stream_class
= bt_stream_borrow_class_const(left_stream
);
270 right_stream_class
= bt_stream_borrow_class_const(right_stream
);
273 * No need to compare stream class id as it was checked earlier and if
274 * we are here it means they are identical.
276 BT_ASSERT_DBG(bt_stream_class_get_id(left_stream_class
) ==
277 bt_stream_class_get_id(right_stream_class
));
279 /* Compare stream class name. */
280 left_stream_class_name
= bt_stream_class_get_name(left_stream_class
);
281 right_stream_class_name
= bt_stream_class_get_name(right_stream_class
);
283 if (left_stream_class_name
&& right_stream_class_name
) {
284 ret
= strcmp(left_stream_class_name
, right_stream_class_name
);
288 } else if (!left_stream_class_name
&& right_stream_class_name
) {
291 } else if (left_stream_class_name
&& !right_stream_class_name
) {
296 /* Compare stream class automatic event class id assignment. */
297 if (bt_stream_class_assigns_automatic_event_class_id(left_stream_class
) &&
298 !bt_stream_class_assigns_automatic_event_class_id(right_stream_class
)) {
301 } else if (!bt_stream_class_assigns_automatic_event_class_id(left_stream_class
) &&
302 bt_stream_class_assigns_automatic_event_class_id(right_stream_class
)) {
307 /* Compare stream class automatic stream id assignment. */
308 if (bt_stream_class_assigns_automatic_stream_id(left_stream_class
) &&
309 !bt_stream_class_assigns_automatic_stream_id(right_stream_class
)) {
312 } else if (!bt_stream_class_assigns_automatic_stream_id(left_stream_class
) &&
313 bt_stream_class_assigns_automatic_stream_id(right_stream_class
)) {
318 /* Compare stream class support of discarded events. */
319 if (bt_stream_class_supports_discarded_events(left_stream_class
) &&
320 !bt_stream_class_supports_discarded_events(right_stream_class
)) {
323 } else if (!bt_stream_class_supports_discarded_events(left_stream_class
) &&
324 bt_stream_class_supports_discarded_events(right_stream_class
)) {
329 /* Compare stream class discarded events default clock snapshot. */
330 if (bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class
) &&
331 !bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class
)) {
334 } else if (!bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class
) &&
335 bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class
)) {
340 /* Compare stream class support of packets. */
341 if (bt_stream_class_supports_packets(left_stream_class
) &&
342 !bt_stream_class_supports_packets(right_stream_class
)) {
345 } else if (!bt_stream_class_supports_packets(left_stream_class
) &&
346 bt_stream_class_supports_packets(right_stream_class
)) {
351 if (bt_stream_class_supports_packets(left_stream_class
)) {
353 * Compare stream class presence of discarded packets beginning default
356 if (bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class
) &&
357 !bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class
)) {
360 } else if (!bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class
) &&
361 bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class
)) {
367 * Compare stream class presence of discarded packets end default clock
370 if (bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class
) &&
371 !bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class
)) {
374 } else if (!bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class
) &&
375 bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class
)) {
380 /* Compare stream class support of discarded packets. */
381 if (bt_stream_class_supports_discarded_packets(left_stream_class
) &&
382 !bt_stream_class_supports_discarded_packets(right_stream_class
)) {
385 } else if (!bt_stream_class_supports_discarded_packets(left_stream_class
) &&
386 bt_stream_class_supports_discarded_packets(right_stream_class
)) {
391 /* Compare stream class discarded packets default clock snapshot. */
392 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class
) &&
393 !bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class
)) {
396 } else if (!bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class
) &&
397 bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class
)) {
403 /* Compare the clock classes associated to the stream classes. */
404 left_cc
= bt_stream_class_borrow_default_clock_class_const(left_stream_class
);
405 right_cc
= bt_stream_class_borrow_default_clock_class_const(right_stream_class
);
407 if (!left_cc
&& !right_cc
) {
408 ret
= compare_clock_classes(left_cc
, right_cc
);
413 } else if (left_cc
&& !right_cc
) {
416 } else if (!left_cc
&& right_cc
) {
426 int compare_clock_snapshots(const bt_clock_snapshot
*left_cs
,
427 const bt_clock_snapshot
*right_cs
)
429 uint64_t left_cs_value
= bt_clock_snapshot_get_value(left_cs
);
430 uint64_t right_cs_value
= bt_clock_snapshot_get_value(right_cs
);
432 return left_cs_value
- right_cs_value
;
436 const bt_stream
*borrow_stream(const bt_message
*msg
)
438 bt_message_type msg_type
= bt_message_get_type(msg
);
439 const bt_stream
*stream
= NULL
;
440 const bt_packet
*packet
= NULL
;
441 const bt_event
*event
= NULL
;
444 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
445 stream
= bt_message_stream_beginning_borrow_stream_const(msg
);
447 case BT_MESSAGE_TYPE_STREAM_END
:
448 stream
= bt_message_stream_end_borrow_stream_const(msg
);
450 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
451 packet
= bt_message_packet_beginning_borrow_packet_const(msg
);
452 stream
= bt_packet_borrow_stream_const(packet
);
454 case BT_MESSAGE_TYPE_PACKET_END
:
455 packet
= bt_message_packet_end_borrow_packet_const(msg
);
456 stream
= bt_packet_borrow_stream_const(packet
);
458 case BT_MESSAGE_TYPE_EVENT
:
459 event
= bt_message_event_borrow_event_const(msg
);
460 stream
= bt_event_borrow_stream_const(event
);
462 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
463 stream
= bt_message_discarded_events_borrow_stream_const(msg
);
465 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
466 stream
= bt_message_discarded_packets_borrow_stream_const(msg
);
468 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
479 const bt_trace
*borrow_trace(const bt_message
*msg
)
481 const bt_trace
*trace
= NULL
;
482 const bt_stream
*stream
= NULL
;
484 stream
= borrow_stream(msg
);
486 trace
= bt_stream_borrow_trace_const(stream
);
493 int compare_messages_by_trace_name(struct messages_to_compare
*msgs
)
496 const char *left_trace_name
= NULL
, *right_trace_name
= NULL
;
498 if (msgs
->left
.trace
&& !msgs
->right
.trace
) {
503 if (!msgs
->left
.trace
&& msgs
->right
.trace
) {
508 if (!msgs
->left
.trace
&& !msgs
->right
.trace
) {
513 left_trace_name
= bt_trace_get_name(msgs
->left
.trace
);
514 right_trace_name
= bt_trace_get_name(msgs
->right
.trace
);
516 if (left_trace_name
&& !right_trace_name
) {
521 if (!left_trace_name
&& right_trace_name
) {
526 if (!left_trace_name
&& !right_trace_name
) {
531 ret
= strcmp(left_trace_name
, right_trace_name
);
537 int compare_messages_by_trace_uuid(struct messages_to_compare
*msgs
)
540 bt_uuid left_trace_uuid
= NULL
, right_trace_uuid
= NULL
;
542 if (msgs
->left
.trace
&& !msgs
->right
.trace
) {
547 if (!msgs
->left
.trace
&& msgs
->right
.trace
) {
552 if (!msgs
->left
.trace
&& !msgs
->right
.trace
) {
557 left_trace_uuid
= bt_trace_get_uuid(msgs
->left
.trace
);
558 right_trace_uuid
= bt_trace_get_uuid(msgs
->right
.trace
);
560 if (left_trace_uuid
&& !right_trace_uuid
) {
565 if (!left_trace_uuid
&& right_trace_uuid
) {
570 if (!left_trace_uuid
&& !right_trace_uuid
) {
575 ret
= bt_uuid_compare(left_trace_uuid
, right_trace_uuid
);
581 int compare_messages_by_stream_class_id(struct messages_to_compare
*msgs
)
584 uint64_t left_stream_class_id
= 0, right_stream_class_id
= 0;
586 if (msgs
->left
.stream
&& !msgs
->right
.stream
) {
591 if (!msgs
->left
.stream
&& msgs
->right
.stream
) {
596 if (!msgs
->left
.stream
&& !msgs
->right
.stream
) {
601 left_stream_class_id
= bt_stream_class_get_id(
602 bt_stream_borrow_class_const(msgs
->left
.stream
));
604 right_stream_class_id
= bt_stream_class_get_id(
605 bt_stream_borrow_class_const(msgs
->right
.stream
));
607 if (left_stream_class_id
== right_stream_class_id
) {
612 ret
= (left_stream_class_id
< right_stream_class_id
) ? -1 : 1;
619 int compare_messages_by_stream_id(struct messages_to_compare
*msgs
)
622 uint64_t left_stream_id
= 0, right_stream_id
= 0;
624 if (msgs
->left
.stream
&& !msgs
->right
.stream
) {
629 if (!msgs
->left
.stream
&& msgs
->right
.stream
) {
634 if (!msgs
->left
.stream
&& !msgs
->right
.stream
) {
639 left_stream_id
= bt_stream_get_id(msgs
->left
.stream
);
640 right_stream_id
= bt_stream_get_id(msgs
->right
.stream
);
642 if (left_stream_id
== right_stream_id
) {
647 ret
= (left_stream_id
< right_stream_id
) ? -1 : 1;
654 int compare_messages_same_type(struct messages_to_compare
*msgs
)
659 * Both messages are of the same type, we must compare characteristics of
660 * the messages such as the attributes of the event in a event message.
662 BT_ASSERT_DBG(bt_message_get_type(msgs
->left
.msg
) ==
663 bt_message_get_type(msgs
->right
.msg
));
665 switch (bt_message_get_type(msgs
->left
.msg
)) {
666 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
668 case BT_MESSAGE_TYPE_STREAM_END
:
670 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
672 case BT_MESSAGE_TYPE_PACKET_END
:
673 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
679 case BT_MESSAGE_TYPE_EVENT
:
681 const bt_event
*left_event
, *right_event
;
682 left_event
= bt_message_event_borrow_event_const(msgs
->left
.msg
);
683 right_event
= bt_message_event_borrow_event_const(msgs
->right
.msg
);
685 ret
= compare_events(left_event
, right_event
);
690 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
696 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
698 const bt_stream_class
*left_stream_class
;
699 bt_property_availability left_event_count_avail
,
700 right_event_count_avail
;
701 uint64_t left_event_count
, right_event_count
;
704 * Compare streams first to check if there is a
705 * mismatch about discarded event related configuration
706 * in the stream class.
708 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
713 left_stream_class
= bt_stream_borrow_class_const(msgs
->left
.stream
);
714 if (bt_stream_class_discarded_events_have_default_clock_snapshots(
715 left_stream_class
)) {
716 const bt_clock_snapshot
*left_beg_cs
=
717 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs
->left
.msg
);
718 const bt_clock_snapshot
*right_beg_cs
=
719 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs
->right
.msg
);
720 const bt_clock_snapshot
*left_end_cs
=
721 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs
->left
.msg
);
722 const bt_clock_snapshot
*right_end_cs
=
723 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs
->right
.msg
);
725 ret
= compare_clock_snapshots(left_beg_cs
, right_beg_cs
);
730 ret
= compare_clock_snapshots(left_end_cs
, right_end_cs
);
735 ret
= compare_clock_classes(
736 bt_clock_snapshot_borrow_clock_class_const(left_beg_cs
),
737 bt_clock_snapshot_borrow_clock_class_const(right_beg_cs
));
743 left_event_count_avail
=
744 bt_message_discarded_events_get_count(
745 msgs
->left
.msg
, &left_event_count
);
746 right_event_count_avail
=
747 bt_message_discarded_events_get_count(
748 msgs
->right
.msg
, &right_event_count
);
749 if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
750 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
751 ret
= left_event_count
- right_event_count
;
755 } else if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
756 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
759 } else if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
760 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
767 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
769 const bt_stream_class
*left_stream_class
;
770 bt_property_availability left_packet_count_avail
,
771 right_packet_count_avail
;
772 uint64_t left_packet_count
, right_packet_count
;
775 * Compare streams first to check if there is a
776 * mismatch about discarded packets related
777 * configuration in the stream class.
779 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
784 left_stream_class
= bt_stream_borrow_class_const(msgs
->left
.stream
);
786 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(
787 left_stream_class
)) {
788 const bt_clock_snapshot
*left_beg_cs
=
789 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs
->left
.msg
);
790 const bt_clock_snapshot
*right_beg_cs
=
791 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs
->right
.msg
);
792 const bt_clock_snapshot
*left_end_cs
=
793 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs
->left
.msg
);
794 const bt_clock_snapshot
*right_end_cs
=
795 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs
->right
.msg
);
797 ret
= compare_clock_snapshots(left_beg_cs
, right_beg_cs
);
802 ret
= compare_clock_snapshots(left_end_cs
, right_end_cs
);
807 ret
= compare_clock_classes(
808 bt_clock_snapshot_borrow_clock_class_const(left_beg_cs
),
809 bt_clock_snapshot_borrow_clock_class_const(right_beg_cs
));
815 left_packet_count_avail
= bt_message_discarded_packets_get_count(
816 msgs
->left
.msg
, &left_packet_count
);
817 right_packet_count_avail
= bt_message_discarded_packets_get_count(
818 msgs
->right
.msg
, &right_packet_count
);
819 if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
820 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
821 ret
= left_packet_count
- right_packet_count
;
825 } else if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
826 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
829 } else if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
830 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
837 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
839 const bt_clock_snapshot
*left_cs
=
840 bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(msgs
->left
.msg
);
841 const bt_clock_snapshot
*right_cs
=
842 bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(msgs
->right
.msg
);
844 ret
= compare_clock_snapshots(left_cs
, right_cs
);
849 ret
= compare_clock_classes(
850 bt_clock_snapshot_borrow_clock_class_const(left_cs
),
851 bt_clock_snapshot_borrow_clock_class_const(right_cs
));
866 int common_muxing_compare_messages(const bt_message
*left_msg
,
867 const bt_message
*right_msg
)
870 struct messages_to_compare msgs
;
872 BT_ASSERT_DBG(left_msg
!= right_msg
);
874 msgs
.left
.msg
= left_msg
;
875 msgs
.left
.trace
= borrow_trace(left_msg
);
876 msgs
.left
.stream
= borrow_stream(left_msg
);
878 msgs
.right
.msg
= right_msg
;
879 msgs
.right
.trace
= borrow_trace(right_msg
);
880 msgs
.right
.stream
= borrow_stream(right_msg
);
882 /* Same timestamp: compare trace UUIDs. */
883 ret
= compare_messages_by_trace_uuid(&msgs
);
888 /* Same timestamp and trace UUID: compare trace names. */
889 ret
= compare_messages_by_trace_name(&msgs
);
895 * Same timestamp, trace name, and trace UUID: compare stream class
898 ret
= compare_messages_by_stream_class_id(&msgs
);
904 * Same timestamp, trace name, trace UUID, and stream class ID: compare
907 ret
= compare_messages_by_stream_id(&msgs
);
912 if (bt_message_get_type(msgs
.left
.msg
) !=
913 bt_message_get_type(msgs
.right
.msg
)) {
915 * The messages are of different type, we order (arbitrarily)
916 * in the following way:
917 * SB < PB < EV < DE < MI < PE < DP < SE
919 ret
= compare_messages_by_type(&msgs
);
924 /* The messages are of the same type. */
925 ret
= compare_messages_same_type(&msgs
);