Extract tracetools_trace from tracetools_analysis

analysis/.gitignore

@@ -0,0 +1,5 @@
+*.svg
+*.png
+*.pdf
+.ipynb_checkpoints
+

analysis/lttng_models.py

@@ -1,36 +0,0 @@
-# Model objects for LTTng traces/events
-
-def get_field(event, field_name, default=None):
-    return event.get(field_name, default)
-
-def get_name(event):
-    return get_field(event, '_name')
-
-
-class EventMetadata():
-    def __init__(self, event_name, pid, tid, timestamp, procname):
-        self._event_name = event_name
-        self._pid = pid
-        self._tid = tid
-        self._timestamp = timestamp
-        self._procname = procname
-
-    @property
-    def event_name(self):
-        return self._event_name
-
-    @property
-    def pid(self):
-        return self._pid
-
-    @property
-    def tid(self):
-        return self._tid
-
-    @property
-    def timestamp(self):
-        return self._timestamp
-
-    @property
-    def procname(self):
-        return self._procname

analysis/ros_processor.py

@@ -1,75 +0,0 @@
-# Process trace events and create ROS model
-
-import sys
-from .lttng_models import EventMetadata, get_field, get_name
-
-def ros_process(events):
-    """
-    Process unpickled events and create ROS model
-    :param events (list(dict(str:str:))): the list of events
-    :return the processor object
-    """
-    processor = RosProcessor()
-    processor.process_events(events)
-    return processor
-
-class RosProcessor():
-    """
-    ROS-aware event processing/handling class.
-    Handles a trace's events and builds a model with the data.
-    """
-    def __init__(self):
-        # TODO add other stuff
-        # Instances of callback_start for eventual matching
-        self._callback_starts = {}
-        # Callback instances, callback_address: (end - start, start)
-        self.callbacks_instances = {}
-
-        # Link a ROS trace event to its corresponding handling method
-        self._handler_map = {
-            'ros2:rcl_subscription_init': self._handle_subscription_init,
-            'ros2:rclcpp_subscription_callback_added': self._handle_subscription_callback_added,
-            'ros2:rclcpp_subscription_callback_start': self._handle_subscription_callback_start,
-            'ros2:rclcpp_subscription_callback_end': self._handle_subscription_callback_end,
-        }
-
-    def process_events(self, events):
-        """
-        Process events
-        :param events (list(dict(str:str))): the events to process
-        """
-        for event in events:
-            self._handle(event)
-
-    def _handle(self, event):
-        event_name = get_name(event)
-        handler_function = self._handler_map.get(event_name, None)
-        if handler_function is not None:
-            pid = get_field(event, 'vpid', default=get_field(event, 'pid'))
-            tid = get_field(event, 'vtid', default=get_field(event, 'tid'))
-            timestamp = get_field(event, '_timestamp')
-            procname = get_field(event, 'procname')
-            metadata = EventMetadata(event_name, pid, tid, timestamp, procname)
-            handler_function(event, metadata)
-        else:
-            print(f'unhandled event name: {event_name}', file=sys.stderr)
-
-    def _handle_subscription_init(self, event, metadata):
-        # TODO
-        pass
-
-    def _handle_subscription_callback_added(self, event, metadata):
-        # Add the callback address key and create an empty list
-        callback_addr = get_field(event, 'callback')
-        self.callbacks_instances[callback_addr] = []
-
-    def _handle_subscription_callback_start(self, event, metadata):
-        callback_addr = get_field(event, 'callback')
-        self._callback_starts[callback_addr] = metadata.timestamp
-
-    def _handle_subscription_callback_end(self, event, metadata):
-        callback_addr = get_field(event, 'callback')
-        start_timestamp = self._callback_starts.pop(callback_addr, None)
-        if start_timestamp is not None:
-            duration = metadata.timestamp - start_timestamp
-            self.callbacks_instances[callback_addr].append((duration, start_timestamp))

analysis/to_pandas.py

@@ -1,20 +0,0 @@
-# Convert processor object to pandas dataframe
-
-import pandas as pd
-from .ros_processor import RosProcessor
-
-def callback_durations_to_df(ros_processor):
-    callback_addresses = []
-    durations = []
-    start_timestamps = []
-    for addr in ros_processor.callbacks_instances:
-        for duration, start in ros_processor.callbacks_instances[addr]:
-            callback_addresses.append(addr)
-            durations.append(duration)
-            start_timestamps.append(start)
-
-    return pd.DataFrame(data={
-        'callback_address': callback_addresses,
-        'duration': durations,
-        'start_timestamp': start_timestamps
-    })