4 * CTF IR Reference Count test
6 * Copyright 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; under version 2 of the License.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 #include <babeltrace/ctf-writer/clock.h>
24 #include <babeltrace/ctf-writer/event.h>
25 #include <babeltrace/ctf-writer/fields.h>
26 #include <babeltrace/ctf-writer/stream-class.h>
27 #include <babeltrace/ctf-writer/stream.h>
28 #include <babeltrace/ctf-writer/trace.h>
29 #include <babeltrace/ctf-writer/writer.h>
30 #include <babeltrace/ctf-ir/clock-class.h>
31 #include <babeltrace/ctf-ir/event.h>
32 #include <babeltrace/ctf-ir/event-class.h>
33 #include <babeltrace/ctf-ir/fields.h>
34 #include <babeltrace/ctf-ir/stream-class.h>
35 #include <babeltrace/ctf-ir/stream.h>
36 #include <babeltrace/ctf-ir/trace.h>
37 #include <babeltrace/object-internal.h>
38 #include <babeltrace/compat/stdlib-internal.h>
46 struct bt_stream_class
*sc
;
47 struct bt_event_class
*ec
;
48 struct bt_stream
*stream
;
49 struct bt_event
*event
;
53 struct bt_ctf_writer
*writer
;
54 struct bt_ctf_trace
*tc
;
55 struct bt_ctf_stream_class
*sc
;
56 struct bt_ctf_event_class
*ec
;
57 struct bt_ctf_stream
*stream
;
58 struct bt_ctf_event
*event
;
61 const char *writer_user_names
[] = {
70 static const size_t WRITER_USER_NR_ELEMENTS
=
71 sizeof(struct writer_user
) / sizeof(void *);
74 * Returns a structure containing the following fields:
75 * - uint8_t payload_8;
76 * - uint16_t payload_16;
77 * - uint32_t payload_32;
79 static struct bt_field_type
*create_integer_struct(void)
82 struct bt_field_type
*structure
= NULL
;
83 struct bt_field_type
*ui8
= NULL
, *ui16
= NULL
, *ui32
= NULL
;
85 structure
= bt_field_type_structure_create();
90 ui8
= bt_field_type_integer_create(8);
92 diag("Failed to create uint8_t type");
95 ret
= bt_field_type_structure_add_field(structure
, ui8
,
98 diag("Failed to add uint8_t to structure");
101 ui16
= bt_field_type_integer_create(16);
103 diag("Failed to create uint16_t type");
106 ret
= bt_field_type_structure_add_field(structure
, ui16
,
109 diag("Failed to add uint16_t to structure");
112 ui32
= bt_field_type_integer_create(32);
114 diag("Failed to create uint32_t type");
117 ret
= bt_field_type_structure_add_field(structure
, ui32
,
120 diag("Failed to add uint32_t to structure");
133 static struct bt_ctf_field_type
*create_writer_integer_struct(void)
136 struct bt_ctf_field_type
*structure
= NULL
;
137 struct bt_ctf_field_type
*ui8
= NULL
, *ui16
= NULL
, *ui32
= NULL
;
139 structure
= bt_ctf_field_type_structure_create();
144 ui8
= bt_ctf_field_type_integer_create(8);
146 diag("Failed to create uint8_t type");
149 ret
= bt_ctf_field_type_structure_add_field(structure
, ui8
,
152 diag("Failed to add uint8_t to structure");
155 ui16
= bt_ctf_field_type_integer_create(16);
157 diag("Failed to create uint16_t type");
160 ret
= bt_ctf_field_type_structure_add_field(structure
, ui16
,
163 diag("Failed to add uint16_t to structure");
166 ui32
= bt_ctf_field_type_integer_create(32);
168 diag("Failed to create uint32_t type");
171 ret
= bt_ctf_field_type_structure_add_field(structure
, ui32
,
174 diag("Failed to add uint32_t to structure");
188 * A simple event has the following payload:
189 * - uint8_t payload_8;
190 * - uint16_t payload_16;
191 * - uint32_t payload_32;
193 static struct bt_event_class
*create_simple_event(const char *name
)
196 struct bt_event_class
*event
= NULL
;
197 struct bt_field_type
*payload
= NULL
;
200 event
= bt_event_class_create(name
);
202 diag("Failed to create simple event");
206 payload
= create_integer_struct();
208 diag("Failed to initialize integer structure");
212 ret
= bt_event_class_set_payload_field_type(event
, payload
);
214 diag("Failed to set simple event payload");
226 * A complex event has the following payload:
227 * - uint8_t payload_8;
228 * - uint16_t payload_16;
229 * - uint32_t payload_32;
230 * - struct payload_struct:
231 * - uint8_t payload_8;
232 * - uint16_t payload_16;
233 * - uint32_t payload_32;
235 static struct bt_event_class
*create_complex_event(const char *name
)
238 struct bt_event_class
*event
= NULL
;
239 struct bt_field_type
*inner
= NULL
, *outer
= NULL
;
242 event
= bt_event_class_create(name
);
244 diag("Failed to create complex event");
248 outer
= create_integer_struct();
250 diag("Failed to initialize integer structure");
254 inner
= create_integer_struct();
256 diag("Failed to initialize integer structure");
260 ret
= bt_field_type_structure_add_field(outer
, inner
,
263 diag("Failed to add inner structure to outer structure");
267 ret
= bt_event_class_set_payload_field_type(event
, outer
);
269 diag("Failed to set complex event payload");
281 static void set_stream_class_field_types(
282 struct bt_stream_class
*stream_class
)
284 struct bt_field_type
*packet_context_type
;
285 struct bt_field_type
*event_header_type
;
286 struct bt_field_type
*ft
;
289 packet_context_type
= bt_field_type_structure_create();
290 assert(packet_context_type
);
291 ft
= bt_field_type_integer_create(32);
293 ret
= bt_field_type_structure_add_field(packet_context_type
,
297 ft
= bt_field_type_integer_create(32);
299 ret
= bt_field_type_structure_add_field(packet_context_type
,
304 event_header_type
= bt_field_type_structure_create();
305 assert(event_header_type
);
306 ft
= bt_field_type_integer_create(32);
308 ret
= bt_field_type_structure_add_field(event_header_type
,
313 ret
= bt_stream_class_set_packet_context_field_type(stream_class
,
314 packet_context_type
);
316 ret
= bt_stream_class_set_event_header_field_type(stream_class
,
320 bt_put(packet_context_type
);
321 bt_put(event_header_type
);
324 static struct bt_stream_class
*create_sc1(void)
327 struct bt_event_class
*ec1
= NULL
, *ec2
= NULL
;
328 struct bt_stream_class
*sc1
= NULL
, *ret_stream
= NULL
;
330 sc1
= bt_stream_class_create("sc1");
332 diag("Failed to create Stream Class");
336 set_stream_class_field_types(sc1
);
337 ec1
= create_complex_event("ec1");
339 diag("Failed to create complex event EC1");
342 ret
= bt_stream_class_add_event_class(sc1
, ec1
);
344 diag("Failed to add EC1 to SC1");
348 ec2
= create_simple_event("ec2");
350 diag("Failed to create simple event EC2");
353 ret
= bt_stream_class_add_event_class(sc1
, ec2
);
355 diag("Failed to add EC1 to SC1");
359 ret_stream
= bt_event_class_get_stream_class(ec1
);
360 ok(ret_stream
== sc1
, "Get parent stream SC1 from EC1");
363 ret_stream
= bt_event_class_get_stream_class(ec2
);
364 ok(ret_stream
== sc1
, "Get parent stream SC1 from EC2");
375 static struct bt_stream_class
*create_sc2(void)
378 struct bt_event_class
*ec3
= NULL
;
379 struct bt_stream_class
*sc2
= NULL
, *ret_stream
= NULL
;
381 sc2
= bt_stream_class_create("sc2");
383 diag("Failed to create Stream Class");
387 set_stream_class_field_types(sc2
);
388 ec3
= create_simple_event("ec3");
390 diag("Failed to create simple event EC3");
393 ret
= bt_stream_class_add_event_class(sc2
, ec3
);
395 diag("Failed to add EC3 to SC2");
399 ret_stream
= bt_event_class_get_stream_class(ec3
);
400 ok(ret_stream
== sc2
, "Get parent stream SC2 from EC3");
410 static void set_trace_packet_header(struct bt_trace
*trace
)
412 struct bt_field_type
*packet_header_type
;
413 struct bt_field_type
*ft
;
416 packet_header_type
= bt_field_type_structure_create();
417 assert(packet_header_type
);
418 ft
= bt_field_type_integer_create(32);
420 ret
= bt_field_type_structure_add_field(packet_header_type
,
425 ret
= bt_trace_set_packet_header_field_type(trace
,
429 bt_put(packet_header_type
);
432 static struct bt_trace
*create_tc1(void)
435 struct bt_trace
*tc1
= NULL
;
436 struct bt_stream_class
*sc1
= NULL
, *sc2
= NULL
;
438 tc1
= bt_trace_create();
440 diag("bt_trace_create returned NULL");
444 set_trace_packet_header(tc1
);
446 ok(sc1
, "Create SC1");
450 ret
= bt_trace_add_stream_class(tc1
, sc1
);
451 ok(!ret
, "Add SC1 to TC1");
457 ok(sc2
, "Create SC2");
461 ret
= bt_trace_add_stream_class(tc1
, sc2
);
462 ok(!ret
, "Add SC2 to TC1");
475 static void init_weak_refs(struct bt_trace
*tc
,
476 struct bt_trace
**tc1
,
477 struct bt_stream_class
**sc1
,
478 struct bt_stream_class
**sc2
,
479 struct bt_event_class
**ec1
,
480 struct bt_event_class
**ec2
,
481 struct bt_event_class
**ec3
)
484 *sc1
= bt_trace_get_stream_class_by_index(tc
, 0);
485 *sc2
= bt_trace_get_stream_class_by_index(tc
, 1);
486 *ec1
= bt_stream_class_get_event_class_by_index(*sc1
, 0);
487 *ec2
= bt_stream_class_get_event_class_by_index(*sc1
, 1);
488 *ec3
= bt_stream_class_get_event_class_by_index(*sc2
, 0);
496 static void test_example_scenario(void)
499 * Weak pointers to CTF-IR objects are to be used very carefully.
500 * This is NOT a good practice and is strongly discouraged; this
501 * is only done to facilitate the validation of expected reference
502 * counts without affecting them by taking "real" references to the
505 struct bt_trace
*tc1
= NULL
, *weak_tc1
= NULL
;
506 struct bt_stream_class
*weak_sc1
= NULL
, *weak_sc2
= NULL
;
507 struct bt_event_class
*weak_ec1
= NULL
, *weak_ec2
= NULL
,
509 struct user user_a
= { 0 }, user_b
= { 0 }, user_c
= { 0 };
511 /* The only reference which exists at this point is on TC1. */
513 ok(tc1
, "Initialize trace");
518 init_weak_refs(tc1
, &weak_tc1
, &weak_sc1
, &weak_sc2
, &weak_ec1
,
519 &weak_ec2
, &weak_ec3
);
521 ok(bt_object_get_ref_count(weak_sc1
) == 0,
522 "Initial SC1 reference count is 0");
523 ok(bt_object_get_ref_count(weak_sc2
) == 0,
524 "Initial SC2 reference count is 0");
525 ok(bt_object_get_ref_count(weak_ec1
) == 0,
526 "Initial EC1 reference count is 0");
527 ok(bt_object_get_ref_count(weak_ec2
) == 0,
528 "Initial EC2 reference count is 0");
529 ok(bt_object_get_ref_count(weak_ec3
) == 0,
530 "Initial EC3 reference count is 0");
532 /* User A has ownership of the trace. */
533 BT_MOVE(user_a
.tc
, tc1
);
534 ok(bt_object_get_ref_count(user_a
.tc
) == 1,
535 "TC1 reference count is 1");
537 /* User A acquires a reference to SC2 from TC1. */
538 user_a
.sc
= bt_trace_get_stream_class_by_index(user_a
.tc
, 1);
539 ok(user_a
.sc
, "User A acquires SC2 from TC1");
540 ok(bt_object_get_ref_count(weak_tc1
) == 2,
541 "TC1 reference count is 2");
542 ok(bt_object_get_ref_count(weak_sc2
) == 1,
543 "SC2 reference count is 1");
545 /* User A acquires a reference to EC3 from SC2. */
546 user_a
.ec
= bt_stream_class_get_event_class_by_index(user_a
.sc
, 0);
547 ok(user_a
.ec
, "User A acquires EC3 from SC2");
548 ok(bt_object_get_ref_count(weak_tc1
) == 2,
549 "TC1 reference count is 2");
550 ok(bt_object_get_ref_count(weak_sc2
) == 2,
551 "SC2 reference count is 2");
552 ok(bt_object_get_ref_count(weak_ec3
) == 1,
553 "EC3 reference count is 1");
555 /* User A releases its reference to SC2. */
556 diag("User A releases SC2");
559 * We keep the pointer to SC2 around to validate its reference
562 ok(bt_object_get_ref_count(weak_tc1
) == 2,
563 "TC1 reference count is 2");
564 ok(bt_object_get_ref_count(weak_sc2
) == 1,
565 "SC2 reference count is 1");
566 ok(bt_object_get_ref_count(weak_ec3
) == 1,
567 "EC3 reference count is 1");
569 /* User A releases its reference to TC1. */
570 diag("User A releases TC1");
573 * We keep the pointer to TC1 around to validate its reference
576 ok(bt_object_get_ref_count(weak_tc1
) == 1,
577 "TC1 reference count is 1");
578 ok(bt_object_get_ref_count(weak_sc2
) == 1,
579 "SC2 reference count is 1");
580 ok(bt_object_get_ref_count(weak_ec3
) == 1,
581 "EC3 reference count is 1");
583 /* User B acquires a reference to SC1. */
584 diag("User B acquires a reference to SC1");
585 user_b
.sc
= bt_get(weak_sc1
);
586 ok(bt_object_get_ref_count(weak_tc1
) == 2,
587 "TC1 reference count is 2");
588 ok(bt_object_get_ref_count(weak_sc1
) == 1,
589 "SC1 reference count is 1");
591 /* User C acquires a reference to EC1. */
592 diag("User C acquires a reference to EC1");
593 user_c
.ec
= bt_stream_class_get_event_class_by_index(user_b
.sc
, 0);
594 ok(bt_object_get_ref_count(weak_ec1
) == 1,
595 "EC1 reference count is 1");
596 ok(bt_object_get_ref_count(weak_sc1
) == 2,
597 "SC1 reference count is 2");
599 /* User A releases its reference on EC3. */
600 diag("User A releases its reference on EC3");
602 ok(bt_object_get_ref_count(weak_ec3
) == 0,
603 "EC3 reference count is 1");
604 ok(bt_object_get_ref_count(weak_sc2
) == 0,
605 "SC2 reference count is 0");
606 ok(bt_object_get_ref_count(weak_tc1
) == 1,
607 "TC1 reference count is 1");
609 /* User B releases its reference on SC1. */
610 diag("User B releases its reference on SC1");
612 ok(bt_object_get_ref_count(weak_sc1
) == 1,
613 "SC1 reference count is 1");
616 * User C is the sole owner of an object and is keeping the whole
617 * trace hierarchy "alive" by holding a reference to EC1.
619 ok(bt_object_get_ref_count(weak_tc1
) == 1,
620 "TC1 reference count is 1");
621 ok(bt_object_get_ref_count(weak_sc1
) == 1,
622 "SC1 reference count is 1");
623 ok(bt_object_get_ref_count(weak_sc2
) == 0,
624 "SC2 reference count is 0");
625 ok(bt_object_get_ref_count(weak_ec1
) == 1,
626 "EC1 reference count is 1");
627 ok(bt_object_get_ref_count(weak_ec2
) == 0,
628 "EC2 reference count is 0");
629 ok(bt_object_get_ref_count(weak_ec3
) == 0,
630 "EC3 reference count is 0");
632 /* Reclaim last reference held by User C. */
636 static void create_writer_user_full(struct writer_user
*user
)
639 struct bt_ctf_field_type
*ft
;
640 struct bt_ctf_field
*field
;
641 struct bt_ctf_clock
*clock
;
644 trace_path
= g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL
);
645 if (!bt_mkdtemp(trace_path
)) {
649 user
->writer
= bt_ctf_writer_create(trace_path
);
650 assert(user
->writer
);
651 ret
= bt_ctf_writer_set_byte_order(user
->writer
,
652 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN
);
654 user
->tc
= bt_ctf_writer_get_trace(user
->writer
);
656 user
->sc
= bt_ctf_stream_class_create("sc");
658 clock
= bt_ctf_clock_create("the_clock");
660 ret
= bt_ctf_writer_add_clock(user
->writer
, clock
);
662 ret
= bt_ctf_stream_class_set_clock(user
->sc
, clock
);
665 user
->stream
= bt_ctf_writer_create_stream(user
->writer
, user
->sc
);
666 assert(user
->stream
);
667 user
->ec
= bt_ctf_event_class_create("ec");
669 ft
= create_writer_integer_struct();
671 ret
= bt_ctf_event_class_set_payload_field_type(user
->ec
, ft
);
674 ret
= bt_ctf_stream_class_add_event_class(user
->sc
, user
->ec
);
676 user
->event
= bt_ctf_event_create(user
->ec
);
678 field
= bt_ctf_event_get_payload(user
->event
, "payload_8");
680 ret
= bt_ctf_field_integer_unsigned_set_value(field
, 10);
683 field
= bt_ctf_event_get_payload(user
->event
, "payload_16");
685 ret
= bt_ctf_field_integer_unsigned_set_value(field
, 20);
688 field
= bt_ctf_event_get_payload(user
->event
, "payload_32");
690 ret
= bt_ctf_field_integer_unsigned_set_value(field
, 30);
693 ret
= bt_ctf_stream_append_event(user
->stream
, user
->event
);
695 recursive_rmdir(trace_path
);
699 static void test_put_order_swap(size_t *array
, size_t a
, size_t b
)
701 size_t temp
= array
[a
];
707 static void test_put_order_put_objects(size_t *array
, size_t size
)
710 struct writer_user user
= { 0 };
711 void **objects
= (void *) &user
;
713 create_writer_user_full(&user
);
716 for (i
= 0; i
< size
; ++i
) {
717 void *obj
= objects
[array
[i
]];
719 printf("%s", writer_user_names
[array
[i
]]);
730 static void test_put_order_permute(size_t *array
, int k
, size_t size
)
733 test_put_order_put_objects(array
, size
);
737 for (i
= k
- 1; i
>= 0; i
--) {
738 size_t next_k
= k
- 1;
740 test_put_order_swap(array
, i
, next_k
);
741 test_put_order_permute(array
, next_k
, size
);
742 test_put_order_swap(array
, i
, next_k
);
747 static void test_put_order(void)
750 size_t array
[WRITER_USER_NR_ELEMENTS
];
752 /* Initialize array of indexes */
753 for (i
= 0; i
< WRITER_USER_NR_ELEMENTS
; ++i
) {
757 test_put_order_permute(array
, WRITER_USER_NR_ELEMENTS
,
758 WRITER_USER_NR_ELEMENTS
);
762 * The objective of this test is to implement and expand upon the scenario
763 * described in the reference counting documentation and ensure that any node of
764 * the Trace, Stream Class, Event Class, Stream and Event hiearchy keeps all
765 * other "alive" and reachable.
767 * External tools (e.g. valgrind) should be used to confirm that this
768 * known-good test does not leak memory.
770 int main(int argc
, char **argv
)
772 /* Initialize tap harness before any tests */
773 plan_tests(NR_TESTS
);
775 test_example_scenario();
778 return exit_status();