bt_ctf_clock_class_create(): add a frequency parameter

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 <eeppeliteloop@gmail.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/include/babeltrace/ctf-ir/clock-class.h b/include/babeltrace/ctf-ir/clock-class.h
index c147b371bd5dad3477e3e183f8587f38b4c2d640..1fb918fd011d3e60488e13841b99a394410bc931 100644 (file)
--- 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 aab320f6d59885ca1eaf4a83a529e4d80e132230..7d02a989ec9ddad8b30d80fcc5166d3ed04544bd 100644 (file)
--- 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 04346968f090bb343ac78f1c5ea6aba3480316a8..0549ee0a5b6c7c7556df75acaf3c4db403b9a3bd 100644 (file)
--- 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 b18b747b989f7f6789f06598c74f971df83de6e1..adb1e9c7c86e8ef59d2d5c1e777cb5776a51f8f2 100644 (file)
--- 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 4f0811e35e8b72b45b6aa3487a9ba2aaca10f4a2..aad87b8ac980263e39c578e4dc834155ac07d301 100644 (file)
--- 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 d2d128a88c88f1fe12815ba93405deba2e3a9925..7ff5a0ebdcfa8d6b9cac415b11ee56632cfd5f96 100644 (file)
--- 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 ff568d1657161dd7b82ad7b1bf3c4f8d12e9ce13..ad4dc1918ae872366ee7c88fd4dd26a00de9bf48 100644 (file)
--- 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 76edfd76d058046f6412c9b10a212c26cba8eb7b..df507074f56975a3d269c48e8e1cc0c33accd55e 100644 (file)
--- 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);