From f3534905684ef28f99ab7f60d85dbe84a5645297 Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Mon, 19 Jun 2017 19:30:27 -0400 Subject: [PATCH] bt_ctf_clock_class_create(): add a frequency parameter MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit The frequency of a clock class is a mandatory property: CTF 1.8 indicates that it's 1 GHz by default, but it is expected that there's no default frequency in CTF 2. To allow this immediately, add a mandatory frequency parameter to bt_ctf_clock_class_create() so that the user's frequency is set at creation time. To maintain backward compatibility with pre-2.0.0 CTF writer, bt_ctf_clock_create() sets its clock class's frequency to 1 GHz, and so do other parts of the code base. Signed-off-by: Philippe Proulx Signed-off-by: Jérémie Galarneau --- include/babeltrace/ctf-ir/clock-class.h | 3 +- lib/ctf-ir/clock-class.c | 44 ++++++++++++++++--- lib/ctf-writer/clock.c | 4 +- .../ctf/common/metadata/visitor-generate-ir.c | 11 +++-- plugins/libctfcopytrace/ctfcopytrace.c | 16 +------ tests/lib/test_cc_prio_map.c | 6 +-- tests/lib/test_ctf_writer.c | 5 ++- tests/plugins/test-utils-muxer.c | 2 +- 8 files changed, 56 insertions(+), 35 deletions(-) diff --git a/include/babeltrace/ctf-ir/clock-class.h b/include/babeltrace/ctf-ir/clock-class.h index c147b371..1fb918fd 100644 --- a/include/babeltrace/ctf-ir/clock-class.h +++ b/include/babeltrace/ctf-ir/clock-class.h @@ -41,7 +41,8 @@ extern "C" { struct bt_ctf_clock_class; struct bt_ctf_clock_value; -extern struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name); +extern struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name, + uint64_t freq); extern const char *bt_ctf_clock_class_get_name( struct bt_ctf_clock_class *clock_class); extern int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class, diff --git a/lib/ctf-ir/clock-class.c b/lib/ctf-ir/clock-class.c index aab320f6..7d02a989 100644 --- a/lib/ctf-ir/clock-class.c +++ b/lib/ctf-ir/clock-class.c @@ -92,13 +92,38 @@ end: return ret; } -struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name) +static +bool validate_freq(struct bt_ctf_clock_class *clock_class, + const char *name, uint64_t freq) +{ + bool is_valid = true; + + if (freq == -1ULL || freq == 0) { + BT_LOGW("Invalid parameter: frequency is invalid: " + "addr=%p, name=\"%s\", freq=%" PRIu64, + clock_class, name, freq); + is_valid = false; + goto end; + } + +end: + return is_valid; +} + +struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name, + uint64_t freq) { int ret; - struct bt_ctf_clock_class *clock_class; + struct bt_ctf_clock_class *clock_class = NULL; BT_LOGD("Creating default clock class object: name=\"%s\"", name); + + if (!validate_freq(NULL, name, freq)) { + /* validate_freq() logs errors */ + goto error; + } + clock_class = g_new0(struct bt_ctf_clock_class, 1); if (!clock_class) { BT_LOGE_STR("Failed to allocate one clock class."); @@ -106,7 +131,7 @@ struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name) } clock_class->precision = 1; - clock_class->frequency = 1000000000; + clock_class->frequency = freq; bt_object_init(clock_class, bt_ctf_clock_class_destroy); if (name) { @@ -211,15 +236,20 @@ int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class, { int ret = 0; - if (!clock_class || freq == -1ULL) { + if (!clock_class) { BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: " - "addr=%p, name=\"%s\", freq=%" PRIu64, - clock_class, bt_ctf_clock_class_get_name(clock_class), - freq); + "addr=%p, name=\"%s\"", + clock_class, bt_ctf_clock_class_get_name(clock_class)); ret = -1; goto end; } + if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class), + freq)) { + /* validate_freq() logs errors */ + goto end; + } + if (clock_class->frozen) { BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", clock_class, bt_ctf_clock_class_get_name(clock_class)); diff --git a/lib/ctf-writer/clock.c b/lib/ctf-writer/clock.c index 04346968..0549ee0a 100644 --- a/lib/ctf-writer/clock.c +++ b/lib/ctf-writer/clock.c @@ -58,7 +58,9 @@ struct bt_ctf_clock *bt_ctf_clock_create(const char *name) bt_object_init(clock, bt_ctf_clock_destroy); clock->value = 0; - clock->clock_class = bt_ctf_clock_class_create(name); + + /* Pre-2.0.0 backward compatibility: default frequency is 1 GHz */ + clock->clock_class = bt_ctf_clock_class_create(name, 1000000000); if (!clock->clock_class) { goto error; } diff --git a/plugins/ctf/common/metadata/visitor-generate-ir.c b/plugins/ctf/common/metadata/visitor-generate-ir.c index b18b747b..adb1e9c7 100644 --- a/plugins/ctf/common/metadata/visitor-generate-ir.c +++ b/plugins/ctf/common/metadata/visitor-generate-ir.c @@ -3794,17 +3794,14 @@ int auto_map_field_to_trace_clock_class(struct ctx *ctx, * point. Create an implicit one at 1 GHz, * named `default`, and use this clock class. */ - clock_class_to_map_to = bt_ctf_clock_class_create("default"); + clock_class_to_map_to = bt_ctf_clock_class_create("default", + 1000000000); if (!clock_class_to_map_to) { BT_LOGE_STR("Cannot create a clock class."); ret = -1; goto end; } - ret = bt_ctf_clock_class_set_frequency(clock_class_to_map_to, - 1000000000); - assert(ret == 0); - ret = bt_ctf_trace_add_clock_class(ctx->trace, clock_class_to_map_to); if (ret) { @@ -4988,7 +4985,9 @@ int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node) } clock_node->visited = TRUE; - clock = bt_ctf_clock_class_create(NULL); + + /* CTF 1.8's default frequency for a clock class is 1 GHz */ + clock = bt_ctf_clock_class_create(NULL, 1000000000); if (!clock) { _BT_LOGE_NODE(clock_node, "Cannot create default clock class."); diff --git a/plugins/libctfcopytrace/ctfcopytrace.c b/plugins/libctfcopytrace/ctfcopytrace.c index 4f0811e3..aad87b8a 100644 --- a/plugins/libctfcopytrace/ctfcopytrace.c +++ b/plugins/libctfcopytrace/ctfcopytrace.c @@ -58,7 +58,8 @@ struct bt_ctf_clock_class *ctf_copy_clock_class(FILE *err, goto end; } - writer_clock_class = bt_ctf_clock_class_create(name); + writer_clock_class = bt_ctf_clock_class_create(name, + bt_ctf_clock_class_get_frequency(clock_class)); if (!writer_clock_class) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); @@ -76,19 +77,6 @@ struct bt_ctf_clock_class *ctf_copy_clock_class(FILE *err, } } - u64_ret = bt_ctf_clock_class_get_frequency(clock_class); - if (u64_ret == -1ULL) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_destroy; - } - int_ret = bt_ctf_clock_class_set_frequency(writer_clock_class, u64_ret); - if (int_ret != 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_destroy; - } - u64_ret = bt_ctf_clock_class_get_precision(clock_class); if (u64_ret == -1ULL) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, diff --git a/tests/lib/test_cc_prio_map.c b/tests/lib/test_cc_prio_map.c index d2d128a8..7ff5a0eb 100644 --- a/tests/lib/test_cc_prio_map.c +++ b/tests/lib/test_cc_prio_map.c @@ -38,11 +38,11 @@ static void test_clock_class_priority_map(void) cc_prio_map = bt_clock_class_priority_map_create(); ok(cc_prio_map, "bt_clock_class_priority_map_create() succeeds"); - cc1 = bt_ctf_clock_class_create("cc1"); + cc1 = bt_ctf_clock_class_create("cc1", 1); assert(cc1); - cc2 = bt_ctf_clock_class_create("cc2"); + cc2 = bt_ctf_clock_class_create("cc2", 2); assert(cc2); - cc3 = bt_ctf_clock_class_create("cc3"); + cc3 = bt_ctf_clock_class_create("cc3", 3); assert(cc3); ok(!bt_clock_class_priority_map_get_highest_priority_clock_class(NULL), "bt_clock_class_priority_map_get_highest_priority_clock_class() handles NULL"); diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index ff568d16..ad4dc191 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -2501,7 +2501,8 @@ void test_create_writer_vs_non_writer_mode(void) non_writer_stream = bt_ctf_stream_create(non_writer_sc, NULL); assert(non_writer_stream); non_writer_clock_class = - bt_ctf_clock_class_create("non_writer_clock_class"); + bt_ctf_clock_class_create("non_writer_clock_class", + 1000000000); assert(non_writer_clock_class); ret = bt_ctf_trace_add_clock_class(non_writer_trace, non_writer_clock_class); @@ -2698,7 +2699,7 @@ void test_static_trace(void) "bt_ctf_trace_set_is_static() succeeds"); ok(bt_ctf_trace_is_static(trace), "bt_ctf_trace_is_static() returns the expected value"); - clock_class = bt_ctf_clock_class_create("yes"); + clock_class = bt_ctf_clock_class_create("yes", 1000000000); assert(clock_class); stream_class2 = bt_ctf_stream_class_create(NULL); assert(stream_class2); diff --git a/tests/plugins/test-utils-muxer.c b/tests/plugins/test-utils-muxer.c index 76edfd76..df507074 100644 --- a/tests/plugins/test-utils-muxer.c +++ b/tests/plugins/test-utils-muxer.c @@ -335,7 +335,7 @@ void init_static_data(void) assert(ret == 0); ret = bt_ctf_trace_set_packet_header_type(trace, empty_struct_ft); assert(ret == 0); - src_clock_class = bt_ctf_clock_class_create("my-clock"); + src_clock_class = bt_ctf_clock_class_create("my-clock", 1000000000); assert(src_clock_class); ret = bt_ctf_clock_class_set_is_absolute(src_clock_class, 1); assert(ret == 0); -- 2.34.1