bt_field_type_compare(): deep-compare mapped clock classes

Deep-compare mapped clock classes in bt_field_type_integer_compare()
instead of just comparing the pointers. Given the same contexts, two
integer field types which have equal properties and equal mapped clock
classes (not just equal clock class pointers) are considered equal.

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>

diff --git a/include/babeltrace/ctf-ir/clock-class-internal.h b/include/babeltrace/ctf-ir/clock-class-internal.h
index b984d456fd3d04769d1c05f1caede95ce7826629..d38f140613523c188f976a030dc2676d5a30761d 100644 (file)
--- a/include/babeltrace/ctf-ir/clock-class-internal.h
+++ b/include/babeltrace/ctf-ir/clock-class-internal.h
@@ -66,4 +66,8 @@ void bt_clock_class_serialize(struct bt_clock_class *clock_class,
 BT_HIDDEN
 bt_bool bt_clock_class_is_valid(struct bt_clock_class *clock_class);
 
+BT_HIDDEN
+int bt_clock_class_compare(struct bt_clock_class *clock_class_a,
+               struct bt_clock_class *clock_class_b);
+
 #endif /* BABELTRACE_CTF_IR_CLOCK_CLASS_INTERNAL_H */

diff --git a/lib/ctf-ir/clock-class.c b/lib/ctf-ir/clock-class.c
index 7c28fee843f6271daf4b5c77124d5c8ea9d8ab6f..730f8f34dab53f98f2d677a112ec89d37b79ee8f 100644 (file)
--- a/lib/ctf-ir/clock-class.c
+++ b/lib/ctf-ir/clock-class.c
@@ -859,3 +859,151 @@ struct bt_clock_class *bt_clock_value_get_class(
 end:
        return clock_class;
 }
+
+BT_HIDDEN
+int bt_clock_class_compare(struct bt_clock_class *clock_class_a,
+               struct bt_clock_class *clock_class_b)
+{
+       int ret = 1;
+       assert(clock_class_a);
+       assert(clock_class_b);
+
+       /* Name */
+       if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
+               BT_LOGV("Clock classes differ: different names: "
+                       "cc-a-name=\"%s\", cc-b-name=\"%s\"",
+                       clock_class_a->name->str,
+                       clock_class_b->name->str);
+               goto end;
+       }
+
+       /* Description */
+       if (clock_class_a->description) {
+               if (!clock_class_b->description) {
+                       BT_LOGV_STR("Clock classes differ: clock class A has a "
+                               "description, but clock class B does not.");
+                       goto end;
+               }
+
+               if (strcmp(clock_class_a->name->str, clock_class_b->name->str)
+                               != 0) {
+                       BT_LOGV("Clock classes differ: different descriptions: "
+                               "cc-a-descr=\"%s\", cc-b-descr=\"%s\"",
+                               clock_class_a->description->str,
+                               clock_class_b->description->str);
+                       goto end;
+               }
+       } else {
+               if (clock_class_b->description) {
+                       BT_LOGV_STR("Clock classes differ: clock class A has "
+                               "no description, but clock class B has one.");
+                       goto end;
+               }
+       }
+
+       /* Frequency */
+       if (clock_class_a->frequency != clock_class_b->frequency) {
+               BT_LOGV("Clock classes differ: different frequencies: "
+                       "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
+                       clock_class_a->frequency,
+                       clock_class_b->frequency);
+               goto end;
+       }
+
+       /* Precision */
+       if (clock_class_a->precision != clock_class_b->precision) {
+               BT_LOGV("Clock classes differ: different precisions: "
+                       "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
+                       clock_class_a->precision,
+                       clock_class_b->precision);
+               goto end;
+       }
+
+       /* Offset (seconds) */
+       if (clock_class_a->offset_s != clock_class_b->offset_s) {
+               BT_LOGV("Clock classes differ: different offsets (seconds): "
+                       "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
+                       clock_class_a->offset_s,
+                       clock_class_b->offset_s);
+               goto end;
+       }
+
+       /* Offset (cycles) */
+       if (clock_class_a->offset != clock_class_b->offset) {
+               BT_LOGV("Clock classes differ: different offsets (cycles): "
+                       "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
+                       clock_class_a->offset,
+                       clock_class_b->offset);
+               goto end;
+       }
+
+       /* UUIDs */
+       if (clock_class_a->uuid_set) {
+               if (!clock_class_b->uuid_set) {
+                       BT_LOGV_STR("Clock classes differ: clock class A has a "
+                               "UUID, but clock class B does not.");
+                       goto end;
+               }
+
+               if (memcmp(clock_class_a->uuid, clock_class_b->uuid,
+                               BABELTRACE_UUID_LEN) != 0) {
+                       BT_LOGV("Clock classes differ: different UUIDs: "
+                               "cc-a-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
+                               "cc-b-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
+                               (unsigned int) clock_class_a->uuid[0],
+                               (unsigned int) clock_class_a->uuid[1],
+                               (unsigned int) clock_class_a->uuid[2],
+                               (unsigned int) clock_class_a->uuid[3],
+                               (unsigned int) clock_class_a->uuid[4],
+                               (unsigned int) clock_class_a->uuid[5],
+                               (unsigned int) clock_class_a->uuid[6],
+                               (unsigned int) clock_class_a->uuid[7],
+                               (unsigned int) clock_class_a->uuid[8],
+                               (unsigned int) clock_class_a->uuid[9],
+                               (unsigned int) clock_class_a->uuid[10],
+                               (unsigned int) clock_class_a->uuid[11],
+                               (unsigned int) clock_class_a->uuid[12],
+                               (unsigned int) clock_class_a->uuid[13],
+                               (unsigned int) clock_class_a->uuid[14],
+                               (unsigned int) clock_class_a->uuid[15],
+                               (unsigned int) clock_class_b->uuid[0],
+                               (unsigned int) clock_class_b->uuid[1],
+                               (unsigned int) clock_class_b->uuid[2],
+                               (unsigned int) clock_class_b->uuid[3],
+                               (unsigned int) clock_class_b->uuid[4],
+                               (unsigned int) clock_class_b->uuid[5],
+                               (unsigned int) clock_class_b->uuid[6],
+                               (unsigned int) clock_class_b->uuid[7],
+                               (unsigned int) clock_class_b->uuid[8],
+                               (unsigned int) clock_class_b->uuid[9],
+                               (unsigned int) clock_class_b->uuid[10],
+                               (unsigned int) clock_class_b->uuid[11],
+                               (unsigned int) clock_class_b->uuid[12],
+                               (unsigned int) clock_class_b->uuid[13],
+                               (unsigned int) clock_class_b->uuid[14],
+                               (unsigned int) clock_class_b->uuid[15]);
+                       goto end;
+               }
+       } else {
+               if (clock_class_b->uuid_set) {
+                       BT_LOGV_STR("Clock classes differ: clock class A has "
+                               "no UUID, but clock class B has one.");
+                       goto end;
+               }
+       }
+
+       /* Absolute */
+       if (!!clock_class_a->absolute != !!clock_class_b->absolute) {
+               BT_LOGV("Clock classes differ: one is absolute, the other "
+                       "is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d",
+                       !!clock_class_a->absolute,
+                       !!clock_class_b->absolute);
+               goto end;
+       }
+
+       /* Equal */
+       ret = 0;
+
+end:
+       return ret;
+}

diff --git a/lib/ctf-ir/field-types.c b/lib/ctf-ir/field-types.c
index be3e2d0f5c9c54f13690384a79e739c86ef15665..feb7a62bc506db5b59fa526a6d824314677f1df0 100644 (file)
--- a/lib/ctf-ir/field-types.c
+++ b/lib/ctf-ir/field-types.c
@@ -4743,17 +4743,26 @@ int bt_field_type_integer_compare(struct bt_field_type *type_a,
                goto end;
        }
 
-       /* Mapped clock */
-       if (int_type_a->mapped_clock != int_type_b->mapped_clock) {
-               BT_LOGV("Integer field types differ: different mapped clock classes: "
-                       "ft-a-mapped-clock-class-addr=%p, "
-                       "ft-b-mapped-clock-class-addr=%p, "
-                       "ft-a-mapped-clock-class-name=\"%s\", "
-                       "ft-b-mapped-clock-class-name=\"%s\"",
-                       int_type_a->mapped_clock, int_type_b->mapped_clock,
-                       int_type_a->mapped_clock ? bt_clock_class_get_name(int_type_a->mapped_clock) : "",
-                       int_type_b->mapped_clock ? bt_clock_class_get_name(int_type_b->mapped_clock) : "");
-               goto end;
+       /* Mapped clock class */
+       if (int_type_a->mapped_clock) {
+               if (!int_type_b->mapped_clock) {
+                       BT_LOGV_STR("Integer field types differ: field type A "
+                               "has a mapped clock class, but field type B "
+                               "does not.");
+                       goto end;
+               }
+
+               if (bt_clock_class_compare(int_type_a->mapped_clock,
+                               int_type_b->mapped_clock) != 0) {
+                       BT_LOGV_STR("Integer field types differ: different "
+                               "mapped clock classes.");
+               }
+       } else {
+               if (int_type_b->mapped_clock) {
+                       BT_LOGV_STR("Integer field types differ: field type A "
+                               "has no description, but field type B has one.");
+                       goto end;
+               }
        }
 
        /* Equal */