2 * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #include <babeltrace2/babeltrace.h>
29 #include "common/assert.h"
30 #include "common/macros.h"
31 #include "common/uuid.h"
35 struct message_to_compare
{
36 const bt_message
*msg
;
37 const bt_trace
*trace
;
38 const bt_stream
*stream
;
41 struct messages_to_compare
{
42 struct message_to_compare left
;
43 struct message_to_compare right
;
47 int message_type_weight(const bt_message_type msg_type
)
52 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
55 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
58 case BT_MESSAGE_TYPE_EVENT
:
61 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
64 case BT_MESSAGE_TYPE_PACKET_END
:
67 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
70 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
73 case BT_MESSAGE_TYPE_STREAM_END
:
84 * Compare 2 messages to order them in a determinitic way based on their
86 * Returns -1 is left mesage must go first
87 * Returns 1 is right mesage must go first
90 int compare_messages_by_type(struct messages_to_compare
*msgs
)
92 bt_message_type left_msg_type
= bt_message_get_type(msgs
->left
.msg
);
93 bt_message_type right_msg_type
= bt_message_get_type(msgs
->right
.msg
);
95 return message_type_weight(right_msg_type
) -
96 message_type_weight(left_msg_type
);
100 int compare_events(const bt_event
*left_event
, const bt_event
*right_event
)
103 const bt_event_class
*left_event_class
, *right_event_class
;
104 uint64_t left_event_class_id
, right_event_class_id
;
105 const char *left_event_class_name
, *right_event_class_name
,
106 *left_event_class_emf_uri
, *right_event_class_emf_uri
;
107 bt_event_class_log_level left_event_class_log_level
, right_event_class_log_level
;
108 bt_property_availability left_log_level_avail
, right_log_level_avail
;
110 left_event_class
= bt_event_borrow_class_const(left_event
);
111 right_event_class
= bt_event_borrow_class_const(right_event
);
113 left_event_class_id
= bt_event_class_get_id(left_event_class
);
114 right_event_class_id
= bt_event_class_get_id(right_event_class
);
116 if (left_event_class_id
> right_event_class_id
) {
119 } else if (left_event_class_id
< right_event_class_id
) {
124 left_event_class_name
= bt_event_class_get_name(left_event_class
);
125 right_event_class_name
= bt_event_class_get_name(right_event_class
);
126 if (left_event_class_name
&& right_event_class_name
) {
127 ret
= strcmp(left_event_class_name
, right_event_class_name
);
131 } else if (!left_event_class_name
&& right_event_class_name
) {
134 } else if (left_event_class_name
&& !right_event_class_name
) {
139 left_log_level_avail
= bt_event_class_get_log_level(left_event_class
,
140 &left_event_class_log_level
);
141 right_log_level_avail
= bt_event_class_get_log_level(right_event_class
,
142 &right_event_class_log_level
);
144 if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
145 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
146 ret
= left_event_class_log_level
- right_event_class_log_level
;
150 } else if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
151 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
154 } else if (left_log_level_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
155 right_log_level_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
160 left_event_class_emf_uri
= bt_event_class_get_emf_uri(left_event_class
);
161 right_event_class_emf_uri
= bt_event_class_get_emf_uri(right_event_class
);
162 if (left_event_class_emf_uri
&& right_event_class_emf_uri
) {
163 ret
= strcmp(left_event_class_emf_uri
, right_event_class_emf_uri
);
167 } else if (!left_event_class_emf_uri
&& right_event_class_emf_uri
) {
170 } else if (left_event_class_emf_uri
&& !right_event_class_emf_uri
) {
180 int compare_streams(const bt_stream
*left_stream
, const bt_stream
*right_stream
)
183 const char *left_stream_name
, *right_stream_name
,
184 *left_stream_class_name
, *right_stream_class_name
;
185 const bt_stream_class
*left_stream_class
, *right_stream_class
;
188 * No need to compare stream id as it was checked earlier and if we are
189 * here it means they are identical or both absent.
191 BT_ASSERT(bt_stream_get_id(left_stream
) ==
192 bt_stream_get_id(right_stream
));
194 /* Compare stream name. */
195 left_stream_name
= bt_stream_get_name(left_stream
);
196 right_stream_name
= bt_stream_get_name(right_stream
);
198 if (left_stream_name
&& right_stream_name
) {
199 ret
= strcmp(left_stream_name
, right_stream_name
);
203 } else if (!left_stream_name
&& right_stream_name
) {
206 } else if (left_stream_name
&& !right_stream_name
) {
211 left_stream_class
= bt_stream_borrow_class_const(left_stream
);
212 right_stream_class
= bt_stream_borrow_class_const(right_stream
);
215 * No need to compare stream class id as it was checked earlier and if
216 * we are here it means they are identical.
218 BT_ASSERT(bt_stream_class_get_id(left_stream_class
) ==
219 bt_stream_class_get_id(right_stream_class
));
221 /* Compare stream class name. */
222 left_stream_class_name
= bt_stream_class_get_name(left_stream_class
);
223 right_stream_class_name
= bt_stream_class_get_name(right_stream_class
);
225 if (left_stream_class_name
&& right_stream_class_name
) {
226 ret
= strcmp(left_stream_class_name
, right_stream_class_name
);
230 } else if (!left_stream_class_name
&& right_stream_class_name
) {
233 } else if (left_stream_class_name
&& !right_stream_class_name
) {
238 /* Compare stream class automatic event class id assignment. */
239 if (bt_stream_class_assigns_automatic_event_class_id(left_stream_class
) &&
240 !bt_stream_class_assigns_automatic_event_class_id(right_stream_class
)) {
243 } else if (!bt_stream_class_assigns_automatic_event_class_id(left_stream_class
) &&
244 bt_stream_class_assigns_automatic_event_class_id(right_stream_class
)) {
249 /* Compare stream class automatic stream id assignment. */
250 if (bt_stream_class_assigns_automatic_stream_id(left_stream_class
) &&
251 !bt_stream_class_assigns_automatic_stream_id(right_stream_class
)) {
254 } else if (!bt_stream_class_assigns_automatic_stream_id(left_stream_class
) &&
255 bt_stream_class_assigns_automatic_stream_id(right_stream_class
)) {
260 /* Compare stream class support of discarded events. */
261 if (bt_stream_class_supports_discarded_events(left_stream_class
) &&
262 !bt_stream_class_supports_discarded_events(right_stream_class
)) {
265 } else if (!bt_stream_class_supports_discarded_events(left_stream_class
) &&
266 bt_stream_class_supports_discarded_events(right_stream_class
)) {
271 /* Compare stream class discarded events default clock snapshot. */
272 if (bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class
) &&
273 !bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class
)) {
276 } else if (!bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class
) &&
277 bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class
)) {
282 /* Compare stream class support of packets. */
283 if (bt_stream_class_supports_packets(left_stream_class
) &&
284 !bt_stream_class_supports_packets(right_stream_class
)) {
287 } else if (!bt_stream_class_supports_packets(left_stream_class
) &&
288 bt_stream_class_supports_packets(right_stream_class
)) {
293 if (!bt_stream_class_supports_packets(left_stream_class
)) {
294 /* Skip all packet related checks. */
299 * Compare stream class presence of discarded packets beginning default
302 if (bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class
) &&
303 !bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class
)) {
306 } else if (!bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class
) &&
307 bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class
)) {
313 * Compare stream class presence of discarded packets end default clock
316 if (bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class
) &&
317 !bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class
)) {
320 } else if (!bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class
) &&
321 bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class
)) {
326 /* Compare stream class support of discarded packets. */
327 if (bt_stream_class_supports_discarded_packets(left_stream_class
) &&
328 !bt_stream_class_supports_discarded_packets(right_stream_class
)) {
331 } else if (!bt_stream_class_supports_discarded_packets(left_stream_class
) &&
332 bt_stream_class_supports_discarded_packets(right_stream_class
)) {
337 /* Compare stream class discarded packets default clock snapshot. */
338 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class
) &&
339 !bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class
)) {
342 } else if (!bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class
) &&
343 bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class
)) {
353 int compare_clock_snapshots_and_clock_classes(const bt_clock_snapshot
*left_cs
,
354 const bt_clock_snapshot
*right_cs
)
357 uint64_t left_freq
, right_freq
, left_prec
, right_prec
;
358 uint64_t left_cs_value
, right_cs_value
;
359 const bt_clock_class
*left_clock_class
, *right_clock_class
;
360 const char *left_clock_class_name
, *right_clock_class_name
;
361 left_cs_value
= bt_clock_snapshot_get_value(left_cs
);
362 right_cs_value
= bt_clock_snapshot_get_value(right_cs
);
363 bt_uuid left_clock_class_uuid
, right_clock_class_uuid
;
365 ret
= left_cs_value
- right_cs_value
;
370 left_clock_class
= bt_clock_snapshot_borrow_clock_class_const(left_cs
);
371 right_clock_class
= bt_clock_snapshot_borrow_clock_class_const(right_cs
);
373 left_clock_class_uuid
= bt_clock_class_get_uuid(left_clock_class
);
374 right_clock_class_uuid
= bt_clock_class_get_uuid(right_clock_class
);
376 if (left_clock_class_uuid
&& !right_clock_class_uuid
) {
379 } else if (!left_clock_class_uuid
&& right_clock_class_uuid
) {
382 } else if (left_clock_class_uuid
&& right_clock_class_uuid
) {
383 ret
= bt_uuid_compare(left_clock_class_uuid
,
384 right_clock_class_uuid
);
391 left_clock_class_name
= bt_clock_class_get_name(left_clock_class
);
392 right_clock_class_name
= bt_clock_class_get_name(right_clock_class
);
394 if (left_clock_class_name
&& !right_clock_class_name
) {
397 } else if (!left_clock_class_name
&& right_clock_class_name
) {
400 } else if (left_clock_class_name
&& right_clock_class_name
) {
401 ret
= strcmp(left_clock_class_name
, right_clock_class_name
);
407 left_freq
= bt_clock_class_get_frequency(left_clock_class
);
408 right_freq
= bt_clock_class_get_frequency(right_clock_class
);
410 ret
= right_freq
- left_freq
;
415 left_prec
= bt_clock_class_get_precision(left_clock_class
);
416 right_prec
= bt_clock_class_get_precision(right_clock_class
);
418 ret
= right_prec
- left_prec
;
428 const bt_stream
*borrow_stream(const bt_message
*msg
)
430 bt_message_type msg_type
= bt_message_get_type(msg
);
431 const bt_stream
*stream
= NULL
;
432 const bt_packet
*packet
= NULL
;
433 const bt_event
*event
= NULL
;
436 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
437 stream
= bt_message_stream_beginning_borrow_stream_const(msg
);
439 case BT_MESSAGE_TYPE_STREAM_END
:
440 stream
= bt_message_stream_end_borrow_stream_const(msg
);
442 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
443 packet
= bt_message_packet_beginning_borrow_packet_const(msg
);
444 stream
= bt_packet_borrow_stream_const(packet
);
446 case BT_MESSAGE_TYPE_PACKET_END
:
447 packet
= bt_message_packet_end_borrow_packet_const(msg
);
448 stream
= bt_packet_borrow_stream_const(packet
);
450 case BT_MESSAGE_TYPE_EVENT
:
451 event
= bt_message_event_borrow_event_const(msg
);
452 stream
= bt_event_borrow_stream_const(event
);
454 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
455 stream
= bt_message_discarded_events_borrow_stream_const(msg
);
457 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
458 stream
= bt_message_discarded_packets_borrow_stream_const(msg
);
460 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
471 const bt_trace
*borrow_trace(const bt_message
*msg
)
473 const bt_trace
*trace
= NULL
;
474 const bt_stream
*stream
= NULL
;
476 stream
= borrow_stream(msg
);
478 trace
= bt_stream_borrow_trace_const(stream
);
485 int compare_messages_by_trace_name(struct messages_to_compare
*msgs
)
488 const char *left_trace_name
= NULL
, *right_trace_name
= NULL
;
490 if (msgs
->left
.trace
&& !msgs
->right
.trace
) {
495 if (!msgs
->left
.trace
&& msgs
->right
.trace
) {
500 if (!msgs
->left
.trace
&& !msgs
->right
.trace
) {
505 left_trace_name
= bt_trace_get_name(msgs
->left
.trace
);
506 right_trace_name
= bt_trace_get_name(msgs
->right
.trace
);
508 if (left_trace_name
&& !right_trace_name
) {
513 if (!left_trace_name
&& right_trace_name
) {
518 if (!left_trace_name
&& !right_trace_name
) {
523 ret
= strcmp(left_trace_name
, right_trace_name
);
529 int compare_messages_by_trace_uuid(struct messages_to_compare
*msgs
)
532 bt_uuid left_trace_uuid
= NULL
, right_trace_uuid
= NULL
;
534 if (msgs
->left
.trace
&& !msgs
->right
.trace
) {
539 if (!msgs
->left
.trace
&& msgs
->right
.trace
) {
544 if (!msgs
->left
.trace
&& !msgs
->right
.trace
) {
549 left_trace_uuid
= bt_trace_get_uuid(msgs
->left
.trace
);
550 right_trace_uuid
= bt_trace_get_uuid(msgs
->right
.trace
);
552 if (left_trace_uuid
&& !right_trace_uuid
) {
557 if (!left_trace_uuid
&& right_trace_uuid
) {
562 if (!left_trace_uuid
&& !right_trace_uuid
) {
567 ret
= bt_uuid_compare(left_trace_uuid
, right_trace_uuid
);
573 int compare_messages_by_stream_class_id(struct messages_to_compare
*msgs
)
576 uint64_t left_stream_class_id
= 0, right_stream_class_id
= 0;
578 if (msgs
->left
.stream
&& !msgs
->right
.stream
) {
583 if (!msgs
->left
.stream
&& msgs
->right
.stream
) {
588 if (!msgs
->left
.stream
&& !msgs
->right
.stream
) {
593 left_stream_class_id
= bt_stream_class_get_id(
594 bt_stream_borrow_class_const(msgs
->left
.stream
));
596 right_stream_class_id
= bt_stream_class_get_id(
597 bt_stream_borrow_class_const(msgs
->right
.stream
));
599 if (left_stream_class_id
== right_stream_class_id
) {
604 ret
= (left_stream_class_id
< right_stream_class_id
) ? -1 : 1;
611 int compare_messages_by_stream_id(struct messages_to_compare
*msgs
)
614 uint64_t left_stream_id
= 0, right_stream_id
= 0;
616 if (msgs
->left
.stream
&& !msgs
->right
.stream
) {
621 if (!msgs
->left
.stream
&& msgs
->right
.stream
) {
626 if (!msgs
->left
.stream
&& !msgs
->right
.stream
) {
631 left_stream_id
= bt_stream_get_id(msgs
->left
.stream
);
632 right_stream_id
= bt_stream_get_id(msgs
->right
.stream
);
634 if (left_stream_id
== right_stream_id
) {
639 ret
= (left_stream_id
< right_stream_id
) ? -1 : 1;
646 int compare_messages_same_type(struct messages_to_compare
*msgs
)
651 * Both messages are of the same type, we must compare characterics of
652 * the messages such as the attributes of the event in a event message.
654 BT_ASSERT(bt_message_get_type(msgs
->left
.msg
) ==
655 bt_message_get_type(msgs
->right
.msg
));
657 switch (bt_message_get_type(msgs
->left
.msg
)) {
658 case BT_MESSAGE_TYPE_STREAM_BEGINNING
:
660 case BT_MESSAGE_TYPE_STREAM_END
:
662 case BT_MESSAGE_TYPE_PACKET_BEGINNING
:
664 case BT_MESSAGE_TYPE_PACKET_END
:
665 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
671 case BT_MESSAGE_TYPE_EVENT
:
673 const bt_event
*left_event
, *right_event
;
674 left_event
= bt_message_event_borrow_event_const(msgs
->left
.msg
);
675 right_event
= bt_message_event_borrow_event_const(msgs
->right
.msg
);
677 ret
= compare_events(left_event
, right_event
);
682 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
688 case BT_MESSAGE_TYPE_DISCARDED_EVENTS
:
690 const bt_stream_class
*left_stream_class
;
691 bt_property_availability left_event_count_avail
,
692 right_event_count_avail
;
693 uint64_t left_event_count
, right_event_count
;
696 * Compare streams first to check if there is a
697 * mismatch about discarded event related configuration
698 * in the stream class.
700 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
705 left_stream_class
= bt_stream_borrow_class_const(msgs
->left
.stream
);
706 if (bt_stream_class_discarded_events_have_default_clock_snapshots(
707 left_stream_class
)) {
708 const bt_clock_snapshot
*left_beg_cs
=
709 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs
->left
.msg
);
710 const bt_clock_snapshot
*right_beg_cs
=
711 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs
->right
.msg
);
712 const bt_clock_snapshot
*left_end_cs
=
713 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs
->left
.msg
);
714 const bt_clock_snapshot
*right_end_cs
=
715 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs
->right
.msg
);
717 ret
= compare_clock_snapshots_and_clock_classes(
718 left_beg_cs
, right_beg_cs
);
723 ret
= compare_clock_snapshots_and_clock_classes(
724 left_end_cs
, right_end_cs
);
730 left_event_count_avail
=
731 bt_message_discarded_events_get_count(
732 msgs
->left
.msg
, &left_event_count
);
733 right_event_count_avail
=
734 bt_message_discarded_events_get_count(
735 msgs
->right
.msg
, &right_event_count
);
736 if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
737 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
738 ret
= left_event_count
- right_event_count
;
742 } else if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
743 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
746 } else if (left_event_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
747 right_event_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
754 case BT_MESSAGE_TYPE_DISCARDED_PACKETS
:
756 const bt_stream_class
*left_stream_class
;
757 bt_property_availability left_packet_count_avail
,
758 right_packet_count_avail
;
759 uint64_t left_packet_count
, right_packet_count
;
762 * Compare streams first to check if there is a
763 * mismatch about discarded packets related
764 * configuration in the stream class.
766 ret
= compare_streams(msgs
->left
.stream
, msgs
->right
.stream
);
771 left_stream_class
= bt_stream_borrow_class_const(msgs
->left
.stream
);
773 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(
774 left_stream_class
)) {
775 const bt_clock_snapshot
*left_beg_cs
=
776 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs
->left
.msg
);
777 const bt_clock_snapshot
*right_beg_cs
=
778 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs
->right
.msg
);
779 const bt_clock_snapshot
*left_end_cs
=
780 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs
->left
.msg
);
781 const bt_clock_snapshot
*right_end_cs
=
782 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs
->right
.msg
);
784 ret
= compare_clock_snapshots_and_clock_classes(
785 left_beg_cs
, right_beg_cs
);
790 ret
= compare_clock_snapshots_and_clock_classes(
791 left_end_cs
, right_end_cs
);
797 left_packet_count_avail
= bt_message_discarded_packets_get_count(
798 msgs
->left
.msg
, &left_packet_count
);
799 right_packet_count_avail
= bt_message_discarded_packets_get_count(
800 msgs
->right
.msg
, &right_packet_count
);
801 if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
802 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
803 ret
= left_packet_count
- right_packet_count
;
807 } else if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
&&
808 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
) {
811 } else if (left_packet_count_avail
== BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
&&
812 right_packet_count_avail
== BT_PROPERTY_AVAILABILITY_AVAILABLE
) {
819 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY
:
821 const bt_clock_snapshot
*left_cs
=
822 bt_message_message_iterator_inactivity_borrow_default_clock_snapshot_const(msgs
->left
.msg
);
823 const bt_clock_snapshot
*right_cs
=
824 bt_message_message_iterator_inactivity_borrow_default_clock_snapshot_const(msgs
->right
.msg
);
826 ret
= compare_clock_snapshots_and_clock_classes(
843 int common_muxing_compare_messages(const bt_message
*left_msg
,
844 const bt_message
*right_msg
)
847 struct messages_to_compare msgs
;
849 BT_ASSERT(left_msg
!= right_msg
);
851 msgs
.left
.msg
= left_msg
;
852 msgs
.left
.trace
= borrow_trace(left_msg
);
853 msgs
.left
.stream
= borrow_stream(left_msg
);
855 msgs
.right
.msg
= right_msg
;
856 msgs
.right
.trace
= borrow_trace(right_msg
);
857 msgs
.right
.stream
= borrow_stream(right_msg
);
859 /* Same timestamp: compare trace names. */
860 ret
= compare_messages_by_trace_name(&msgs
);
865 /* Same timestamp and trace name: compare trace UUIDs. */
866 ret
= compare_messages_by_trace_uuid(&msgs
);
872 * Same timestamp, trace name, and trace UUID: compare stream class
875 ret
= compare_messages_by_stream_class_id(&msgs
);
881 * Same timestamp, trace name, trace UUID, and stream class ID: compare
884 ret
= compare_messages_by_stream_id(&msgs
);
889 if (bt_message_get_type(msgs
.left
.msg
) !=
890 bt_message_get_type(msgs
.right
.msg
)) {
892 * The messages are of different type, we order (arbitrarily)
893 * in the following way:
894 * SB < PB < EV < DE < MI < PE < DP < SE
896 ret
= compare_messages_by_type(&msgs
);
901 /* The messages are of the same type. */
902 ret
= compare_messages_same_type(&msgs
);