Rename "time" -> "timestamp" (terminology)

This patch renames the "time" concept to "timestamp" throughout.

The term "timestamp" is better to describe what used to be named "time",
for example a packet's beginning and end timestamps, and an event
record's timestamp.

"Time" has many definitions, one of which is duration, whereas the
only definition of "timestamp" in Antidote 10 is:

> a printed or stamped mark indicating a time or date of an event

which is pretty accurate.

Which is also why the timestamp members are named `timestamp_begin`,
`timestamp_end`, and `timestamp` in CTF 1.8.

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

diff --git a/barectf/cgen.py b/barectf/cgen.py
index 2319b9564c62c0fd47e811929d34a3d8ece293ab..d6f6e0bdd9241c5feb03e05e8162b2fbad3b98b8 100644 (file)
--- a/barectf/cgen.py
+++ b/barectf/cgen.py
@@ -508,7 +508,7 @@ class _CodeGen:
         self._serialize_write_magic_statements_templ = self._create_template('serialize-write-magic-statements.j2')
         self._serialize_write_uuid_statements_templ = self._create_template('serialize-write-uuid-statements.j2')
         self._serialize_write_dst_id_statements_templ = self._create_template('serialize-write-dst-id-statements.j2')
-        self._serialize_write_time_statements_templ = self._create_template('serialize-write-time-statements.j2')
+        self._serialize_write_timestamp_statements_templ = self._create_template('serialize-write-timestamp-statements.j2')
         self._serialize_write_packet_size_statements_templ = self._create_template('serialize-write-packet-size-statements.j2')
         self._serialize_write_skip_save_statements_templ = self._create_template('serialize-write-skip-save-statements.j2')
         self._serialize_write_ert_id_statements_templ = self._create_template('serialize-write-ert-id-statements.j2')
@@ -720,7 +720,7 @@ class _CodeGen:
 
                 # packet context operation
                 spec_serialize_write_templates = {
-                    'timestamp_begin': self._serialize_write_time_statements_templ,
+                    'timestamp_begin': self._serialize_write_timestamp_statements_templ,
                     'packet_size': self._serialize_write_packet_size_statements_templ,
                     'timestamp_end': self._serialize_write_skip_save_statements_templ,
                     'events_discarded': self._serialize_write_skip_save_statements_templ,
@@ -735,7 +735,7 @@ class _CodeGen:
 
                 if dst._er_header_ft is not None:
                     spec_serialize_write_templates = {
-                        'timestamp': self._serialize_write_time_statements_templ,
+                        'timestamp': self._serialize_write_timestamp_statements_templ,
                         'id': self._serialize_write_ert_id_statements_templ,
                     }
                     er_header_op = builder.build_for_root_ft(dst._er_header_ft, _RootFtPrefixes.ERH,

diff --git a/barectf/config.py b/barectf/config.py
index cb2c00f22d06cccf4049e36fd4b48e6998b56a76..fec77f4ca070ee0612a6bc3d8675f6217f9d4dea 100644 (file)
--- a/barectf/config.py
+++ b/barectf/config.py
@@ -440,8 +440,8 @@ _OptUIntFt = Optional[UnsignedIntegerFieldType]
 class DataStreamTypePacketFeatures:
     def __init__(self, total_size_field_type: _DefaultableUIntFt = DEFAULT_FIELD_TYPE,
                  content_size_field_type: _DefaultableUIntFt = DEFAULT_FIELD_TYPE,
-                 beginning_time_field_type: _OptDefaultableUIntFt = None,
-                 end_time_field_type: _OptDefaultableUIntFt = None,
+                 beginning_timestamp_field_type: _OptDefaultableUIntFt = None,
+                 end_timestamp_field_type: _OptDefaultableUIntFt = None,
                  discarded_event_records_snapshot_counter_field_type: _OptDefaultableUIntFt = None):
         def get_ft(user_ft: _OptDefaultableUIntFt) -> _OptUIntFt:
             if user_ft == DEFAULT_FIELD_TYPE:
@@ -451,8 +451,8 @@ class DataStreamTypePacketFeatures:
 
         self._total_size_field_type = get_ft(total_size_field_type)
         self._content_size_field_type = get_ft(content_size_field_type)
-        self._beginning_time_field_type = get_ft(beginning_time_field_type)
-        self._end_time_field_type = get_ft(end_time_field_type)
+        self._beginning_timestamp_field_type = get_ft(beginning_timestamp_field_type)
+        self._end_timestamp_field_type = get_ft(end_timestamp_field_type)
         self._discarded_event_records_snapshot_counter_field_type = get_ft(discarded_event_records_snapshot_counter_field_type)
 
     @property
@@ -464,12 +464,12 @@ class DataStreamTypePacketFeatures:
         return self._content_size_field_type
 
     @property
-    def beginning_time_field_type(self) -> _OptUIntFt:
-        return self._beginning_time_field_type
+    def beginning_timestamp_field_type(self) -> _OptUIntFt:
+        return self._beginning_timestamp_field_type
 
     @property
-    def end_time_field_type(self) -> _OptUIntFt:
-        return self._end_time_field_type
+    def end_timestamp_field_type(self) -> _OptUIntFt:
+        return self._end_timestamp_field_type
 
     @property
     def discarded_event_records_snapshot_counter_field_type(self) -> _OptUIntFt:
@@ -478,7 +478,7 @@ class DataStreamTypePacketFeatures:
 
 class DataStreamTypeEventRecordFeatures:
     def __init__(self, type_id_field_type: _OptDefaultableUIntFt = DEFAULT_FIELD_TYPE,
-                 time_field_type: _OptDefaultableUIntFt = None):
+                 timestamp_field_type: _OptDefaultableUIntFt = None):
         def get_ft(user_ft: _OptDefaultableUIntFt) -> _OptUIntFt:
             if user_ft == DEFAULT_FIELD_TYPE:
                 return UnsignedIntegerFieldType(64)
@@ -486,15 +486,15 @@ class DataStreamTypeEventRecordFeatures:
             return typing.cast(_OptUIntFt, user_ft)
 
         self._type_id_field_type = get_ft(type_id_field_type)
-        self._time_field_type = get_ft(time_field_type)
+        self._timestamp_field_type = get_ft(timestamp_field_type)
 
     @property
     def type_id_field_type(self) -> _OptUIntFt:
         return self._type_id_field_type
 
     @property
-    def time_field_type(self) -> _OptUIntFt:
-        return self._time_field_type
+    def timestamp_field_type(self) -> _OptUIntFt:
+        return self._timestamp_field_type
 
 
 class DataStreamTypeFeatures:
@@ -550,20 +550,20 @@ class DataStreamType(_UniqueByName):
             self._features = features
             return None
 
-        er_time_ft = None
-        pkt_beginning_time_ft = None
-        pkt_end_time_ft = None
+        er_ts_ft = None
+        pkt_beginning_ts_ft = None
+        pkt_end_ts_ft = None
 
         if self._default_clock_type is not None:
-            # Automatic time field types because the data stream type
-            # has a default clock type.
-            er_time_ft = DEFAULT_FIELD_TYPE
-            pkt_beginning_time_ft = DEFAULT_FIELD_TYPE
-            pkt_end_time_ft = DEFAULT_FIELD_TYPE
+            # Automatic timestamp field types because the data stream
+            # type has a default clock type.
+            er_ts_ft = DEFAULT_FIELD_TYPE
+            pkt_beginning_ts_ft = DEFAULT_FIELD_TYPE
+            pkt_end_ts_ft = DEFAULT_FIELD_TYPE
 
-        self._features = DataStreamTypeFeatures(DataStreamTypePacketFeatures(beginning_time_field_type=pkt_beginning_time_ft,
-                                                                             end_time_field_type=pkt_end_time_ft),
-                                                DataStreamTypeEventRecordFeatures(time_field_type=er_time_ft))
+        self._features = DataStreamTypeFeatures(DataStreamTypePacketFeatures(beginning_timestamp_field_type=pkt_beginning_ts_ft,
+                                                                             end_timestamp_field_type=pkt_end_ts_ft),
+                                                DataStreamTypeEventRecordFeatures(timestamp_field_type=er_ts_ft))
 
     def _set_ft_mapped_clk_type_name(self, ft: Optional[UnsignedIntegerFieldType]):
         if ft is None:
@@ -597,8 +597,8 @@ class DataStreamType(_UniqueByName):
         ])
 
         add_member_if_exists('timestamp_begin',
-                             self._features.packet_features.beginning_time_field_type, True)
-        add_member_if_exists('timestamp_end', self._features.packet_features.end_time_field_type,
+                             self._features.packet_features.beginning_timestamp_field_type, True)
+        add_member_if_exists('timestamp_end', self._features.packet_features.end_timestamp_field_type,
                              True)
         add_member_if_exists('events_discarded',
                              self._features.packet_features.discarded_event_records_snapshot_counter_field_type)
@@ -616,8 +616,8 @@ class DataStreamType(_UniqueByName):
         if self._features.event_record_features.type_id_field_type is not None:
             members['id'] = StructureFieldTypeMember(self._features.event_record_features.type_id_field_type)
 
-        if self._features.event_record_features.time_field_type is not None:
-            ft = self._features.event_record_features.time_field_type
+        if self._features.event_record_features.timestamp_field_type is not None:
+            ft = self._features.event_record_features.timestamp_field_type
             self._set_ft_mapped_clk_type_name(ft)
             members['timestamp'] = StructureFieldTypeMember(ft)
 

diff --git a/barectf/config_parse_v2.py b/barectf/config_parse_v2.py
index f7ec4d6ab8edfcd3311fc40109473a3406c415dd..8055f9c76393df4ceb26dc787fc17f14078f711d 100644 (file)
--- a/barectf/config_parse_v2.py
+++ b/barectf/config_parse_v2.py
@@ -332,29 +332,29 @@ class _Parser(config_parse_common._Parser):
 
             v3_pkt_total_size_ft_node = self._conv_ft_node(v2_pkt_ctx_ft_fields_node['packet_size'])
             v3_pkt_content_size_ft_node = self._conv_ft_node(v2_pkt_ctx_ft_fields_node['content_size'])
-            v3_pkt_beg_time_ft_node = self._conv_ft_node_if_exists(v2_pkt_ctx_ft_fields_node,
-                                                                   'timestamp_begin')
-            v3_pkt_end_time_ft_node = self._conv_ft_node_if_exists(v2_pkt_ctx_ft_fields_node,
-                                                                   'timestamp_end')
+            v3_pkt_beg_ts_ft_node = self._conv_ft_node_if_exists(v2_pkt_ctx_ft_fields_node,
+                                                                 'timestamp_begin')
+            v3_pkt_end_ts_ft_node = self._conv_ft_node_if_exists(v2_pkt_ctx_ft_fields_node,
+                                                                 'timestamp_end')
             v3_pkt_disc_er_counter_snap_ft_node = self._conv_ft_node_if_exists(v2_pkt_ctx_ft_fields_node,
                                                                                'events_discarded')
             v3_ert_id_ft_node = self._conv_ft_node_if_exists(v2_er_header_ft_fields_node, 'id')
-            v3_er_time_ft_node = self._conv_ft_node_if_exists(v2_er_header_ft_fields_node,
-                                                              'timestamp')
+            v3_er_ts_ft_node = self._conv_ft_node_if_exists(v2_er_header_ft_fields_node,
+                                                            'timestamp')
             v3_features_node: _MapNode = collections.OrderedDict()
             v3_pkt_node: _MapNode = collections.OrderedDict()
             v3_er_node: _MapNode = collections.OrderedDict()
             v3_pkt_node['total-size-field-type'] = v3_pkt_total_size_ft_node
             v3_pkt_node['content-size-field-type'] = v3_pkt_content_size_ft_node
-            self._set_v3_feature_ft_if_exists(v3_pkt_node, 'beginning-time-field-type',
-                                              v3_pkt_beg_time_ft_node)
-            self._set_v3_feature_ft_if_exists(v3_pkt_node, 'end-time-field-type',
-                                              v3_pkt_end_time_ft_node)
+            self._set_v3_feature_ft_if_exists(v3_pkt_node, 'beginning-timestamp-field-type',
+                                              v3_pkt_beg_ts_ft_node)
+            self._set_v3_feature_ft_if_exists(v3_pkt_node, 'end-timestamp-field-type',
+                                              v3_pkt_end_ts_ft_node)
             self._set_v3_feature_ft_if_exists(v3_pkt_node,
                                               'discarded-event-records-counter-snapshot-field-type',
                                               v3_pkt_disc_er_counter_snap_ft_node)
             self._set_v3_feature_ft_if_exists(v3_er_node, 'type-id-field-type', v3_ert_id_ft_node)
-            self._set_v3_feature_ft_if_exists(v3_er_node, 'time-field-type', v3_er_time_ft_node)
+            self._set_v3_feature_ft_if_exists(v3_er_node, 'timestamp-field-type', v3_er_ts_ft_node)
             v3_features_node['packet'] = v3_pkt_node
             v3_features_node['event-record'] = v3_er_node
             return v3_features_node

diff --git a/barectf/config_parse_v3.py b/barectf/config_parse_v3.py
index 44091ec8f692b5308b48f42b82cb192cb60f9411..6aea8722abec6310c8fc755b1fd0a11df5970083 100644 (file)
--- a/barectf/config_parse_v3.py
+++ b/barectf/config_parse_v3.py
@@ -433,25 +433,25 @@ class _Parser(barectf_config_parse_common._Parser):
             # create feature field types
             pkt_total_size_ft = barectf_config.DEFAULT_FIELD_TYPE
             pkt_content_size_ft = barectf_config.DEFAULT_FIELD_TYPE
-            pkt_beginning_time_ft = None
-            pkt_end_time_ft = None
+            pkt_beginning_ts_ft = None
+            pkt_end_ts_ft = None
             pkt_discarded_er_counter_snap_ft = None
             ert_id_ft = barectf_config.DEFAULT_FIELD_TYPE
-            ert_time_ft = None
+            ert_ts_ft = None
 
             if def_clk_type is not None:
                 # The data stream type has a default clock type.
-                # Initialize the packet beginning time, packet end time,
-                # and event record time field types to default field
-                # types.
+                # Initialize the packet beginning timestamp, packet end
+                # timestamp, and event record timestamp field types to
+                # default field types.
                 #
                 # This means your data stream type node only needs a
                 # default clock type name to enable those features
                 # automatically. Those features do not add any parameter
                 # to the event tracing functions.
-                pkt_beginning_time_ft = barectf_config.DEFAULT_FIELD_TYPE
-                pkt_end_time_ft = barectf_config.DEFAULT_FIELD_TYPE
-                ert_time_ft = barectf_config.DEFAULT_FIELD_TYPE
+                pkt_beginning_ts_ft = barectf_config.DEFAULT_FIELD_TYPE
+                pkt_end_ts_ft = barectf_config.DEFAULT_FIELD_TYPE
+                ert_ts_ft = barectf_config.DEFAULT_FIELD_TYPE
 
             features_node = dst_node.get('$features')
 
@@ -464,10 +464,11 @@ class _Parser(barectf_config_parse_common._Parser):
                                                          pkt_total_size_ft)
                     pkt_content_size_ft = self._feature_ft(pkt_node, 'content-size-field-type',
                                                            pkt_content_size_ft)
-                    pkt_beginning_time_ft = self._feature_ft(pkt_node, 'beginning-time-field-type',
-                                                             pkt_beginning_time_ft)
-                    pkt_end_time_ft = self._feature_ft(pkt_node, 'end-time-field-type',
-                                                       pkt_end_time_ft)
+                    pkt_beginning_ts_ft = self._feature_ft(pkt_node,
+                                                           'beginning-timestamp-field-type',
+                                                           pkt_beginning_ts_ft)
+                    pkt_end_ts_ft = self._feature_ft(pkt_node, 'end-timestamp-field-type',
+                                                     pkt_end_ts_ft)
                     pkt_discarded_er_counter_snap_ft = self._feature_ft(pkt_node,
                                                                    'discarded-event-records-counter-snapshot-field-type',
                                                                    pkt_discarded_er_counter_snap_ft)
@@ -478,7 +479,7 @@ class _Parser(barectf_config_parse_common._Parser):
 
                 if er_node is not None:
                     ert_id_ft = self._feature_ft(er_node, type_id_ft_prop_name, ert_id_ft)
-                    ert_time_ft = self._feature_ft(er_node, 'time-field-type', ert_time_ft)
+                    ert_ts_ft = self._feature_ft(er_node, 'timestamp-field-type', ert_ts_ft)
 
             erts_prop_name = 'event-record-types'
             ert_count = len(dst_node[erts_prop_name])
@@ -500,10 +501,10 @@ class _Parser(barectf_config_parse_common._Parser):
 
             pkt_features = barectf_config.DataStreamTypePacketFeatures(pkt_total_size_ft,
                                                                        pkt_content_size_ft,
-                                                                       pkt_beginning_time_ft,
-                                                                       pkt_end_time_ft,
+                                                                       pkt_beginning_ts_ft,
+                                                                       pkt_end_ts_ft,
                                                                        pkt_discarded_er_counter_snap_ft)
-            er_features = barectf_config.DataStreamTypeEventRecordFeatures(ert_id_ft, ert_time_ft)
+            er_features = barectf_config.DataStreamTypeEventRecordFeatures(ert_id_ft, ert_ts_ft)
             features = barectf_config.DataStreamTypeFeatures(pkt_features, er_features)
 
             # create packet context (structure) field type extra members
@@ -536,7 +537,7 @@ class _Parser(barectf_config_parse_common._Parser):
             if er_features.type_id_field_type is not None:
                 er_header_common_ctx_member_count = Count(er_header_common_ctx_member_count + 1)
 
-            if er_features.time_field_type is not None:
+            if er_features.timestamp_field_type is not None:
                 er_header_common_ctx_member_count = Count(er_header_common_ctx_member_count + 1)
 
             er_common_ctx_ft_prop_name = 'event-record-common-context-field-type'
@@ -806,8 +807,8 @@ class _Parser(barectf_config_parse_common._Parser):
                             try:
                                 resolve_ft_alias_from(pkt_node, 'total-size-field-type')
                                 resolve_ft_alias_from(pkt_node, 'content-size-field-type')
-                                resolve_ft_alias_from(pkt_node, 'beginning-time-field-type')
-                                resolve_ft_alias_from(pkt_node, 'end-time-field-type')
+                                resolve_ft_alias_from(pkt_node, 'beginning-timestamp-field-type')
+                                resolve_ft_alias_from(pkt_node, 'end-timestamp-field-type')
                                 resolve_ft_alias_from(pkt_node,
                                                       'discarded-event-records-counter-snapshot-field-type')
                             except _ConfigurationParseError as exc:
@@ -819,7 +820,7 @@ class _Parser(barectf_config_parse_common._Parser):
                         if er_node is not None:
                             try:
                                 resolve_ft_alias_from(er_node, 'type-id-field-type')
-                                resolve_ft_alias_from(er_node, 'time-field-type')
+                                resolve_ft_alias_from(er_node, 'timestamp-field-type')
                             except _ConfigurationParseError as exc:
                                 _append_error_ctx(exc, f'`{er_prop_name}` property')
                     except _ConfigurationParseError as exc:
@@ -884,15 +885,16 @@ class _Parser(barectf_config_parse_common._Parser):
                 if pkt_node is not None:
                     apply_ft_inheritance(pkt_node, 'total-size-field-type')
                     apply_ft_inheritance(pkt_node, 'content-size-field-type')
-                    apply_ft_inheritance(pkt_node, 'beginning-time-field-type')
-                    apply_ft_inheritance(pkt_node, 'end-time-field-type')
-                    apply_ft_inheritance(pkt_node, 'discarded-event-records-counter-snapshot-field-type')
+                    apply_ft_inheritance(pkt_node, 'beginning-timestamp-field-type')
+                    apply_ft_inheritance(pkt_node, 'end-timestamp-field-type')
+                    apply_ft_inheritance(pkt_node,
+                                         'discarded-event-records-counter-snapshot-field-type')
 
                 er_node = features_node.get('event-record')
 
                 if er_node is not None:
                     apply_ft_inheritance(er_node, 'type-id-field-type')
-                    apply_ft_inheritance(er_node, 'time-field-type')
+                    apply_ft_inheritance(er_node, 'timestamp-field-type')
 
             pkt_ctx_ft_extra_members_node = dst_node.get('packet-context-field-type-extra-members')
 
@@ -972,8 +974,8 @@ class _Parser(barectf_config_parse_common._Parser):
                 if pkt_node is not None:
                     normalize_struct_ft_member_nodes(pkt_node, 'total-size-field-type')
                     normalize_struct_ft_member_nodes(pkt_node, 'content-size-field-type')
-                    normalize_struct_ft_member_nodes(pkt_node, 'beginning-time-field-type')
-                    normalize_struct_ft_member_nodes(pkt_node, 'end-time-field-type')
+                    normalize_struct_ft_member_nodes(pkt_node, 'beginning-timestamp-field-type')
+                    normalize_struct_ft_member_nodes(pkt_node, 'end-timestamp-field-type')
                     normalize_struct_ft_member_nodes(pkt_node,
                                                      'discarded-event-records-counter-snapshot-field-type')
 
@@ -981,7 +983,7 @@ class _Parser(barectf_config_parse_common._Parser):
 
                 if er_node is not None:
                     normalize_struct_ft_member_nodes(er_node, 'type-id-field-type')
-                    normalize_struct_ft_member_nodes(er_node, 'time-field-type')
+                    normalize_struct_ft_member_nodes(er_node, 'timestamp-field-type')
 
             pkt_ctx_ft_extra_members_node = dst_node.get('packet-context-field-type-extra-members')
 

diff --git a/barectf/schemas/config/3/config-pre-field-type-expansion.yaml b/barectf/schemas/config/3/config-pre-field-type-expansion.yaml
index 03f3b436547923b1d7ad9dca54a92c0d39c8efc5..2caf07ff30f7298a0e60c814640bdfa730e89082 100644 (file)
--- a/barectf/schemas/config/3/config-pre-field-type-expansion.yaml
+++ b/barectf/schemas/config/3/config-pre-field-type-expansion.yaml
@@ -126,9 +126,9 @@ properties:
                                 $ref: '#/definitions/partial-ft'
                               content-size-field-type:
                                 $ref: '#/definitions/partial-ft'
-                              beginning-time-field-type:
+                              beginning-timestamp-field-type:
                                 $ref: '#/definitions/partial-ft'
-                              end-time-field-type:
+                              end-timestamp-field-type:
                                 $ref: '#/definitions/partial-ft'
                               discarded-event-records-counter-snapshot-field-type:
                                 $ref: '#/definitions/partial-ft'
@@ -141,7 +141,7 @@ properties:
                             properties:
                               type-id-field-type:
                                 $ref: '#/definitions/partial-ft'
-                              time-field-type:
+                              timestamp-field-type:
                                 $ref: '#/definitions/partial-ft'
                           else:
                             type: 'null'

diff --git a/barectf/schemas/config/3/config.yaml b/barectf/schemas/config/3/config.yaml
index d12c57bcd88cfd505d9980ea23bc6f2e634d3313..dd2280bdc1cabc7a7f901c32c3a0a27f1c4ed11c 100644 (file)
--- a/barectf/schemas/config/3/config.yaml
+++ b/barectf/schemas/config/3/config.yaml
@@ -206,9 +206,9 @@ definitions:
                     $ref: '#/definitions/opt-feature-uint-ft'
                   content-size-field-type:
                     $ref: '#/definitions/opt-feature-uint-ft'
-                  beginning-time-field-type:
+                  beginning-timestamp-field-type:
                     $ref: '#/definitions/opt-or-def-feature-uint-ft'
-                  end-time-field-type:
+                  end-timestamp-field-type:
                     $ref: '#/definitions/opt-or-def-feature-uint-ft'
                   discarded-event-records-counter-snapshot-field-type:
                     $ref: '#/definitions/opt-or-def-feature-uint-ft'
@@ -222,7 +222,7 @@ definitions:
                 properties:
                   type-id-field-type:
                     $ref: '#/definitions/opt-or-def-feature-uint-ft'
-                  time-field-type:
+                  timestamp-field-type:
                     $ref: '#/definitions/opt-or-def-feature-uint-ft'
                 additionalProperties: false
               else:

diff --git a/barectf/templates/c/barectf.c.j2 b/barectf/templates/c/barectf.c.j2
index 0146c1f55c44c0a7cd5afceecdac6c4f91c1a848..48af1687f2f9b8b1fdacedbe93199325468fb422 100644 (file)
--- a/barectf/templates/c/barectf.c.j2
+++ b/barectf/templates/c/barectf.c.j2
@@ -466,7 +466,7 @@ static uint32_t _er_size_{{ dst.name }}_{{ ert.name }}(void * const vctx{{ (dst,
        uint32_t er_size;
 
                {% if def_clk_type %}
-       /* Save time */
+       /* Save timestamp */
        sctx->cur_last_event_ts = ctx->cbs.{{ def_clk_type.name }}_clock_get_value(ctx->data);
 
                {% endif %}

diff --git a/barectf/templates/c/barectf.h.j2 b/barectf/templates/c/barectf.h.j2
index 9433395044ba076b3dcd14c63afd00322899caf4..7a2a58bd0dafeff0b8070a0978ef3db99cffd75b 100644 (file)
--- a/barectf/templates/c/barectf.h.j2
+++ b/barectf/templates/c/barectf.h.j2
@@ -132,7 +132,7 @@ struct {{ prefix }}ctx {
        /* Tracing is enabled? */
        volatile int is_tracing_enabled;
 
-       /* Use current/last event record time when opening/closing packets */
+       /* Use current/last event record timestamp when opening/closing packets */
        int use_cur_last_event_ts;
 };
 

diff --git a/barectf/templates/c/serialize-write-time-statements.j2 b/barectf/templates/c/serialize-write-time-statements.j2
deleted file mode 100644 (file)
index ac5c486..0000000
--- a/barectf/templates/c/serialize-write-time-statements.j2
+++ /dev/null
@@ -1,28 +0,0 @@
-{#
- # The MIT License (MIT)
- #
- # Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
- #
- # Permission is hereby granted, free of charge, to any person obtaining
- # a copy of this software and associated documentation files (the
- # "Software"), to deal in the Software without restriction, including
- # without limitation the rights to use, copy, modify, merge, publish,
- # distribute, sublicense, and/or sell copies of the Software, and to
- # permit persons to whom the Software is furnished to do so, subject to
- # the following conditions:
- #
- # The above copyright notice and this permission notice shall be
- # included in all copies or substantial portions of the Software.
- #
- # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- # IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- # CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- #}
-{% set c_type = op.ft | ft_c_type %}
-{% set src = 'ts' %}
-/* Write {{ 'beginning ' if op.top_name == 'timestamp_begin' }}time field */
-{% include 'c/serialize-write-bit-array-statements.j2' %}