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/writer.h>
24 #include <babeltrace/ctf-writer/stream.h>
25 #include <babeltrace/ctf-writer/clock.h>
26 #include <babeltrace/ctf-ir/trace.h>
27 #include <babeltrace/ctf-writer/stream-class.h>
28 #include <babeltrace/ctf-ir/stream.h>
29 #include <babeltrace/ctf-ir/fields.h>
30 #include <babeltrace/ctf-ir/event.h>
31 #include <babeltrace/ctf-ir/event-class.h>
32 #include <babeltrace/object-internal.h>
33 #include <babeltrace/compat/stdlib-internal.h>
40 struct bt_ctf_writer
*writer
;
42 struct bt_stream_class
*sc
;
43 struct bt_event_class
*ec
;
44 struct bt_stream
*stream
;
45 struct bt_event
*event
;
48 const char *user_names
[] = {
57 static const size_t USER_NR_ELEMENTS
= sizeof(struct user
) / sizeof(void *);
60 * Returns a structure containing the following fields:
61 * - uint8_t payload_8;
62 * - uint16_t payload_16;
63 * - uint32_t payload_32;
65 static struct bt_field_type
*create_integer_struct(void)
68 struct bt_field_type
*structure
= NULL
;
69 struct bt_field_type
*ui8
= NULL
, *ui16
= NULL
, *ui32
= NULL
;
71 structure
= bt_field_type_structure_create();
76 ui8
= bt_field_type_integer_create(8);
78 diag("Failed to create uint8_t type");
81 ret
= bt_field_type_structure_add_field(structure
, ui8
,
84 diag("Failed to add uint8_t to structure");
87 ui16
= bt_field_type_integer_create(16);
89 diag("Failed to create uint16_t type");
92 ret
= bt_field_type_structure_add_field(structure
, ui16
,
95 diag("Failed to add uint16_t to structure");
98 ui32
= bt_field_type_integer_create(32);
100 diag("Failed to create uint32_t type");
103 ret
= bt_field_type_structure_add_field(structure
, ui32
,
106 diag("Failed to add uint32_t to structure");
120 * A simple event has the following payload:
121 * - uint8_t payload_8;
122 * - uint16_t payload_16;
123 * - uint32_t payload_32;
125 static struct bt_event_class
*create_simple_event(const char *name
)
128 struct bt_event_class
*event
= NULL
;
129 struct bt_field_type
*payload
= NULL
;
132 event
= bt_event_class_create(name
);
134 diag("Failed to create simple event");
138 payload
= create_integer_struct();
140 diag("Failed to initialize integer structure");
144 ret
= bt_event_class_set_payload_type(event
, payload
);
146 diag("Failed to set simple event payload");
158 * A complex event has the following payload:
159 * - uint8_t payload_8;
160 * - uint16_t payload_16;
161 * - uint32_t payload_32;
162 * - struct payload_struct:
163 * - uint8_t payload_8;
164 * - uint16_t payload_16;
165 * - uint32_t payload_32;
167 static struct bt_event_class
*create_complex_event(const char *name
)
170 struct bt_event_class
*event
= NULL
;
171 struct bt_field_type
*inner
= NULL
, *outer
= NULL
;
174 event
= bt_event_class_create(name
);
176 diag("Failed to create complex event");
180 outer
= create_integer_struct();
182 diag("Failed to initialize integer structure");
186 inner
= create_integer_struct();
188 diag("Failed to initialize integer structure");
192 ret
= bt_field_type_structure_add_field(outer
, inner
,
195 diag("Failed to add inner structure to outer structure");
199 ret
= bt_event_class_set_payload_type(event
, outer
);
201 diag("Failed to set complex event payload");
213 static void set_stream_class_field_types(
214 struct bt_stream_class
*stream_class
)
216 struct bt_field_type
*packet_context_type
;
217 struct bt_field_type
*event_header_type
;
218 struct bt_field_type
*ft
;
221 packet_context_type
= bt_field_type_structure_create();
222 assert(packet_context_type
);
223 ft
= bt_field_type_integer_create(32);
225 ret
= bt_field_type_structure_add_field(packet_context_type
,
229 ft
= bt_field_type_integer_create(32);
231 ret
= bt_field_type_structure_add_field(packet_context_type
,
236 event_header_type
= bt_field_type_structure_create();
237 assert(event_header_type
);
238 ft
= bt_field_type_integer_create(32);
240 ret
= bt_field_type_structure_add_field(event_header_type
,
245 ret
= bt_stream_class_set_packet_context_type(stream_class
,
246 packet_context_type
);
248 ret
= bt_stream_class_set_event_header_type(stream_class
,
252 bt_put(packet_context_type
);
253 bt_put(event_header_type
);
256 static struct bt_stream_class
*create_sc1(void)
259 struct bt_event_class
*ec1
= NULL
, *ec2
= NULL
;
260 struct bt_stream_class
*sc1
= NULL
, *ret_stream
= NULL
;
262 sc1
= bt_stream_class_create_empty("sc1");
264 diag("Failed to create Stream Class");
268 set_stream_class_field_types(sc1
);
269 ec1
= create_complex_event("ec1");
271 diag("Failed to create complex event EC1");
274 ret
= bt_stream_class_add_event_class(sc1
, ec1
);
276 diag("Failed to add EC1 to SC1");
280 ec2
= create_simple_event("ec2");
282 diag("Failed to create simple event EC2");
285 ret
= bt_stream_class_add_event_class(sc1
, ec2
);
287 diag("Failed to add EC1 to SC1");
291 ret_stream
= bt_event_class_get_stream_class(ec1
);
292 ok(ret_stream
== sc1
, "Get parent stream SC1 from EC1");
295 ret_stream
= bt_event_class_get_stream_class(ec2
);
296 ok(ret_stream
== sc1
, "Get parent stream SC1 from EC2");
307 static struct bt_stream_class
*create_sc2(void)
310 struct bt_event_class
*ec3
= NULL
;
311 struct bt_stream_class
*sc2
= NULL
, *ret_stream
= NULL
;
313 sc2
= bt_stream_class_create_empty("sc2");
315 diag("Failed to create Stream Class");
319 set_stream_class_field_types(sc2
);
320 ec3
= create_simple_event("ec3");
322 diag("Failed to create simple event EC3");
325 ret
= bt_stream_class_add_event_class(sc2
, ec3
);
327 diag("Failed to add EC3 to SC2");
331 ret_stream
= bt_event_class_get_stream_class(ec3
);
332 ok(ret_stream
== sc2
, "Get parent stream SC2 from EC3");
342 static void set_trace_packet_header(struct bt_trace
*trace
)
344 struct bt_field_type
*packet_header_type
;
345 struct bt_field_type
*ft
;
348 packet_header_type
= bt_field_type_structure_create();
349 assert(packet_header_type
);
350 ft
= bt_field_type_integer_create(32);
352 ret
= bt_field_type_structure_add_field(packet_header_type
,
357 ret
= bt_trace_set_packet_header_type(trace
,
361 bt_put(packet_header_type
);
364 static struct bt_trace
*create_tc1(void)
367 struct bt_trace
*tc1
= NULL
;
368 struct bt_stream_class
*sc1
= NULL
, *sc2
= NULL
;
370 tc1
= bt_trace_create();
372 diag("bt_trace_create returned NULL");
376 set_trace_packet_header(tc1
);
378 ok(sc1
, "Create SC1");
382 ret
= bt_trace_add_stream_class(tc1
, sc1
);
383 ok(!ret
, "Add SC1 to TC1");
389 ok(sc2
, "Create SC2");
393 ret
= bt_trace_add_stream_class(tc1
, sc2
);
394 ok(!ret
, "Add SC2 to TC1");
407 static void init_weak_refs(struct bt_trace
*tc
,
408 struct bt_trace
**tc1
,
409 struct bt_stream_class
**sc1
,
410 struct bt_stream_class
**sc2
,
411 struct bt_event_class
**ec1
,
412 struct bt_event_class
**ec2
,
413 struct bt_event_class
**ec3
)
416 *sc1
= bt_trace_get_stream_class_by_index(tc
, 0);
417 *sc2
= bt_trace_get_stream_class_by_index(tc
, 1);
418 *ec1
= bt_stream_class_get_event_class_by_index(*sc1
, 0);
419 *ec2
= bt_stream_class_get_event_class_by_index(*sc1
, 1);
420 *ec3
= bt_stream_class_get_event_class_by_index(*sc2
, 0);
428 static void test_example_scenario(void)
431 * Weak pointers to CTF-IR objects are to be used very carefully.
432 * This is NOT a good practice and is strongly discouraged; this
433 * is only done to facilitate the validation of expected reference
434 * counts without affecting them by taking "real" references to the
437 struct bt_trace
*tc1
= NULL
, *weak_tc1
= NULL
;
438 struct bt_stream_class
*weak_sc1
= NULL
, *weak_sc2
= NULL
;
439 struct bt_event_class
*weak_ec1
= NULL
, *weak_ec2
= NULL
,
441 struct user user_a
= { 0 }, user_b
= { 0 }, user_c
= { 0 };
443 /* The only reference which exists at this point is on TC1. */
445 ok(tc1
, "Initialize trace");
450 init_weak_refs(tc1
, &weak_tc1
, &weak_sc1
, &weak_sc2
, &weak_ec1
,
451 &weak_ec2
, &weak_ec3
);
453 ok(bt_object_get_ref_count(weak_sc1
) == 0,
454 "Initial SC1 reference count is 0");
455 ok(bt_object_get_ref_count(weak_sc2
) == 0,
456 "Initial SC2 reference count is 0");
457 ok(bt_object_get_ref_count(weak_ec1
) == 0,
458 "Initial EC1 reference count is 0");
459 ok(bt_object_get_ref_count(weak_ec2
) == 0,
460 "Initial EC2 reference count is 0");
461 ok(bt_object_get_ref_count(weak_ec3
) == 0,
462 "Initial EC3 reference count is 0");
464 /* User A has ownership of the trace. */
465 BT_MOVE(user_a
.tc
, tc1
);
466 ok(bt_object_get_ref_count(user_a
.tc
) == 1,
467 "TC1 reference count is 1");
469 /* User A acquires a reference to SC2 from TC1. */
470 user_a
.sc
= bt_trace_get_stream_class_by_index(user_a
.tc
, 1);
471 ok(user_a
.sc
, "User A acquires SC2 from TC1");
472 ok(bt_object_get_ref_count(weak_tc1
) == 2,
473 "TC1 reference count is 2");
474 ok(bt_object_get_ref_count(weak_sc2
) == 1,
475 "SC2 reference count is 1");
477 /* User A acquires a reference to EC3 from SC2. */
478 user_a
.ec
= bt_stream_class_get_event_class_by_index(user_a
.sc
, 0);
479 ok(user_a
.ec
, "User A acquires EC3 from SC2");
480 ok(bt_object_get_ref_count(weak_tc1
) == 2,
481 "TC1 reference count is 2");
482 ok(bt_object_get_ref_count(weak_sc2
) == 2,
483 "SC2 reference count is 2");
484 ok(bt_object_get_ref_count(weak_ec3
) == 1,
485 "EC3 reference count is 1");
487 /* User A releases its reference to SC2. */
488 diag("User A releases SC2");
491 * We keep the pointer to SC2 around to validate its reference
494 ok(bt_object_get_ref_count(weak_tc1
) == 2,
495 "TC1 reference count is 2");
496 ok(bt_object_get_ref_count(weak_sc2
) == 1,
497 "SC2 reference count is 1");
498 ok(bt_object_get_ref_count(weak_ec3
) == 1,
499 "EC3 reference count is 1");
501 /* User A releases its reference to TC1. */
502 diag("User A releases TC1");
505 * We keep the pointer to TC1 around to validate its reference
508 ok(bt_object_get_ref_count(weak_tc1
) == 1,
509 "TC1 reference count is 1");
510 ok(bt_object_get_ref_count(weak_sc2
) == 1,
511 "SC2 reference count is 1");
512 ok(bt_object_get_ref_count(weak_ec3
) == 1,
513 "EC3 reference count is 1");
515 /* User B acquires a reference to SC1. */
516 diag("User B acquires a reference to SC1");
517 user_b
.sc
= bt_get(weak_sc1
);
518 ok(bt_object_get_ref_count(weak_tc1
) == 2,
519 "TC1 reference count is 2");
520 ok(bt_object_get_ref_count(weak_sc1
) == 1,
521 "SC1 reference count is 1");
523 /* User C acquires a reference to EC1. */
524 diag("User C acquires a reference to EC1");
525 user_c
.ec
= bt_stream_class_get_event_class_by_index(user_b
.sc
, 0);
526 ok(bt_object_get_ref_count(weak_ec1
) == 1,
527 "EC1 reference count is 1");
528 ok(bt_object_get_ref_count(weak_sc1
) == 2,
529 "SC1 reference count is 2");
531 /* User A releases its reference on EC3. */
532 diag("User A releases its reference on EC3");
534 ok(bt_object_get_ref_count(weak_ec3
) == 0,
535 "EC3 reference count is 1");
536 ok(bt_object_get_ref_count(weak_sc2
) == 0,
537 "SC2 reference count is 0");
538 ok(bt_object_get_ref_count(weak_tc1
) == 1,
539 "TC1 reference count is 1");
541 /* User B releases its reference on SC1. */
542 diag("User B releases its reference on SC1");
544 ok(bt_object_get_ref_count(weak_sc1
) == 1,
545 "SC1 reference count is 1");
548 * User C is the sole owner of an object and is keeping the whole
549 * trace hierarchy "alive" by holding a reference to EC1.
551 ok(bt_object_get_ref_count(weak_tc1
) == 1,
552 "TC1 reference count is 1");
553 ok(bt_object_get_ref_count(weak_sc1
) == 1,
554 "SC1 reference count is 1");
555 ok(bt_object_get_ref_count(weak_sc2
) == 0,
556 "SC2 reference count is 0");
557 ok(bt_object_get_ref_count(weak_ec1
) == 1,
558 "EC1 reference count is 1");
559 ok(bt_object_get_ref_count(weak_ec2
) == 0,
560 "EC2 reference count is 0");
561 ok(bt_object_get_ref_count(weak_ec3
) == 0,
562 "EC3 reference count is 0");
564 /* Reclaim last reference held by User C. */
568 static void create_user_full(struct user
*user
)
571 struct bt_field_type
*ft
;
572 struct bt_field
*field
;
573 struct bt_ctf_clock
*clock
;
576 trace_path
= g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL
);
577 if (!bt_mkdtemp(trace_path
)) {
581 user
->writer
= bt_ctf_writer_create(trace_path
);
582 assert(user
->writer
);
583 ret
= bt_ctf_writer_set_byte_order(user
->writer
,
584 BT_BYTE_ORDER_LITTLE_ENDIAN
);
586 user
->tc
= bt_ctf_writer_get_trace(user
->writer
);
588 user
->sc
= bt_stream_class_create("sc");
590 clock
= bt_ctf_clock_create("the_clock");
592 ret
= bt_ctf_writer_add_clock(user
->writer
, clock
);
594 ret
= bt_stream_class_set_clock(user
->sc
, clock
);
597 user
->stream
= bt_ctf_writer_create_stream(user
->writer
, user
->sc
);
598 assert(user
->stream
);
599 user
->ec
= bt_event_class_create("ec");
601 ft
= create_integer_struct();
603 ret
= bt_event_class_set_payload_type(user
->ec
, ft
);
606 ret
= bt_stream_class_add_event_class(user
->sc
, user
->ec
);
608 user
->event
= bt_event_create(user
->ec
);
610 field
= bt_event_get_payload(user
->event
, "payload_8");
612 ret
= bt_field_unsigned_integer_set_value(field
, 10);
615 field
= bt_event_get_payload(user
->event
, "payload_16");
617 ret
= bt_field_unsigned_integer_set_value(field
, 20);
620 field
= bt_event_get_payload(user
->event
, "payload_32");
622 ret
= bt_field_unsigned_integer_set_value(field
, 30);
625 ret
= bt_stream_append_event(user
->stream
, user
->event
);
627 recursive_rmdir(trace_path
);
631 static void test_put_order_swap(size_t *array
, size_t a
, size_t b
)
633 size_t temp
= array
[a
];
639 static void test_put_order_put_objects(size_t *array
, size_t size
)
642 struct user user
= { 0 };
643 void **objects
= (void *) &user
;
645 create_user_full(&user
);
648 for (i
= 0; i
< size
; ++i
) {
649 void *obj
= objects
[array
[i
]];
651 printf("%s", user_names
[array
[i
]]);
662 static void test_put_order_permute(size_t *array
, int k
, size_t size
)
665 test_put_order_put_objects(array
, size
);
669 for (i
= k
- 1; i
>= 0; i
--) {
670 size_t next_k
= k
- 1;
672 test_put_order_swap(array
, i
, next_k
);
673 test_put_order_permute(array
, next_k
, size
);
674 test_put_order_swap(array
, i
, next_k
);
679 static void test_put_order(void)
682 size_t array
[USER_NR_ELEMENTS
];
684 /* Initialize array of indexes */
685 for (i
= 0; i
< USER_NR_ELEMENTS
; ++i
) {
689 test_put_order_permute(array
, USER_NR_ELEMENTS
, USER_NR_ELEMENTS
);
693 * The objective of this test is to implement and expand upon the scenario
694 * described in the reference counting documentation and ensure that any node of
695 * the Trace, Stream Class, Event Class, Stream and Event hiearchy keeps all
696 * other "alive" and reachable.
698 * External tools (e.g. valgrind) should be used to confirm that this
699 * known-good test does not leak memory.
701 int main(int argc
, char **argv
)
703 /* Initialize tap harness before any tests */
704 plan_tests(NR_TESTS
);
706 test_example_scenario();
709 return exit_status();