From 2508b07347ab4dce0a92a7f2a65affcea6f4d91d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 16:37:20 +0200 Subject: [PATCH] Fix lint errors --- tracetools_analysis/analysis/data_model.py | 88 ++++++++++++++----- .../analysis/ros2_processor.py | 57 +++++++----- tracetools_analysis/conversion/ctf.py | 2 +- tracetools_analysis/process.py | 8 +- 4 files changed, 105 insertions(+), 50 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index c6ed69d..6d21bc4 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -14,28 +14,62 @@ class DataModel(): def __init__(self): # Objects (one-time events, usually when something is created) - self._contexts = pd.DataFrame(columns=['context_handle', 'timestamp', 'pid']) + self._contexts = pd.DataFrame(columns=['context_handle', + 'timestamp', + 'pid']) self._contexts.set_index(['context_handle'], inplace=True, drop=True) - self._nodes = pd.DataFrame(columns=['node_handle', 'timestamp', 'tid', 'rmw_handle', 'name', 'namespace']) + self._nodes = pd.DataFrame(columns=['node_handle', + 'timestamp', + 'tid', + 'rmw_handle', + 'name', + 'namespace']) self._nodes.set_index(['node_handle'], inplace=True, drop=True) - self._publishers = pd.DataFrame(columns=['publisher_handle', 'timestamp', 'node_handle', 'rmw_handle', 'topic_name', 'depth']) + self._publishers = pd.DataFrame(columns=['publisher_handle', + 'timestamp', + 'node_handle', + 'rmw_handle', + 'topic_name', + 'depth']) self._publishers.set_index(['publisher_handle'], inplace=True, drop=True) - self._subscriptions = pd.DataFrame(columns=['subscription_handle', 'timestamp', 'node_handle', 'rmw_handle', 'topic_name', 'depth']) + self._subscriptions = pd.DataFrame(columns=['subscription_handle', + 'timestamp', + 'node_handle', + 'rmw_handle', + 'topic_name', + 'depth']) self._subscriptions.set_index(['subscription_handle'], inplace=True, drop=True) - self._services = pd.DataFrame(columns=['service_handle', 'timestamp', 'node_handle', 'rmw_handle', 'service_name']) + self._services = pd.DataFrame(columns=['service_handle', + 'timestamp', + 'node_handle', + 'rmw_handle', + 'service_name']) self._services.set_index(['service_handle'], inplace=True, drop=True) - self._clients = pd.DataFrame(columns=['client_handle', 'timestamp', 'node_handle', 'rmw_handle', 'service_name']) + self._clients = pd.DataFrame(columns=['client_handle', + 'timestamp', + 'node_handle', + 'rmw_handle', + 'service_name']) self._clients.set_index(['client_handle'], inplace=True, drop=True) - self._timers = pd.DataFrame(columns=['timer_handle', 'timestamp', 'period']) + self._timers = pd.DataFrame(columns=['timer_handle', + 'timestamp', + 'period']) self._timers.set_index(['timer_handle'], inplace=True, drop=True) - self._callback_objects = pd.DataFrame(columns=['handle', 'timestamp', 'callback_object']) + self._callback_objects = pd.DataFrame(columns=['handle', + 'timestamp', + 'callback_object']) self._callback_objects.set_index(['handle'], inplace=True, drop=True) - self._callback_symbols = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) + self._callback_symbols = pd.DataFrame(columns=['callback_object', + 'timestamp', + 'symbol']) self._callback_symbols.set_index(['callback_object'], inplace=True, drop=True) # Events (multiple instances, may not have a meaningful index) - self._callbacks_instances = pd.DataFrame(columns=['callback_object', 'timestamp', 'duration', 'intra_process']) + self._callbacks_instances = pd.DataFrame(columns=['callback_object', + 'timestamp', + 'duration', + 'intra_process']) def add_context(self, context_handle, timestamp, pid): self._contexts.loc[context_handle] = [timestamp, pid] @@ -43,31 +77,37 @@ class DataModel(): def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace): self._nodes.loc[node_handle] = [timestamp, tid, rmw_handle, name, namespace] - def add_publisher(self, publisher_handle, timestamp, node_handle, rmw_handle, topic_name, depth): - self._publishers.loc[publisher_handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] + def add_publisher(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth): + self._publishers.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_subscription(self, subscription_handle, timestamp, node_handle, rmw_handle, topic_name, depth): - self._subscriptions.loc[subscription_handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] + def add_subscription(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth): + self._subscriptions.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_service(self, service_handle, timestamp, node_handle, rmw_handle, service_name): - self._services.loc[service_handle] = [timestamp, node_handle, rmw_handle, service_name] + def add_service(self, handle, timestamp, node_handle, rmw_handle, service_name): + self._services.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_client(self, client_handle, timestamp, node_handle, rmw_handle, service_name): - self._clients.loc[client_handle] = [timestamp, node_handle, rmw_handle, service_name] + def add_client(self, handle, timestamp, node_handle, rmw_handle, service_name): + self._clients.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_timer(self, timer_handle, timestamp, period): - self._timers.loc[timer_handle] = [timestamp, period] + def add_timer(self, handle, timestamp, period): + self._timers.loc[handle] = [timestamp, period] def add_callback_object(self, handle, timestamp, callback_object): self._callback_objects.loc[handle] = [timestamp, callback_object] def add_callback_symbol(self, callback_object, timestamp, symbol): self._callback_symbols.loc[callback_object] = [timestamp, symbol] - - def add_callback_instance(self, callback_object, timestamp, duration, intra_process): - self._callbacks_instances = self._callbacks_instances.append({'callback_object': callback_object, 'timestamp': timestamp, 'duration': duration, 'intra_process': intra_process}, ignore_index=True) - def print(self): + def add_callback_instance(self, callback_object, timestamp, duration, intra_process): + data = { + 'callback_object': callback_object, + 'timestamp': timestamp, + 'duration': duration, + 'intra_process': intra_process, + } + self._callbacks_instances = self._callbacks_instances.append(data, ignore_index=True) + + def print_model(self): """Debug method to print every contained df.""" print('====================DATA MODEL====================') print(f'Contexts:\n{self._contexts.to_string()}') diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index cdc957a..6604b85 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -1,8 +1,8 @@ # Process trace events and create ROS model +from .data_model import DataModel from .handler import EventHandler from .lttng_models import get_field -from .data_model import DataModel def ros2_process(events): @@ -68,41 +68,48 @@ class Ros2Processor(EventHandler): # Temporary buffers self._callback_instances = {} - + def get_data_model(self): return self._data def _handle_rcl_init(self, event, metadata): context_handle = get_field(event, 'context_handle') - self._data.add_context(context_handle, metadata.timestamp, metadata.pid) + timestamp = metadata.timestamp + pid = metadata.pid + self._data.add_context(context_handle, timestamp, pid) def _handle_rcl_node_init(self, event, metadata): - node_handle = get_field(event, 'node_handle') + handle = get_field(event, 'node_handle') + timestamp = metadata.timestamp + tid = metadata.tid rmw_handle = get_field(event, 'rmw_handle') name = get_field(event, 'node_name') namespace = get_field(event, 'namespace') - self._data.add_node(node_handle, metadata.timestamp, metadata.tid, rmw_handle, name, namespace) + self._data.add_node(handle, timestamp, tid, rmw_handle, name, namespace) def _handle_rcl_publisher_init(self, event, metadata): - pub_handle = get_field(event, 'publisher_handle') + handle = get_field(event, 'publisher_handle') + timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') rmw_handle = get_field(event, 'rmw_publisher_handle') topic_name = get_field(event, 'topic_name') depth = get_field(event, 'depth') - self._data.add_publisher(pub_handle, metadata.timestamp, node_handle, rmw_handle, topic_name, depth) + self._data.add_publisher(handle, timestamp, node_handle, rmw_handle, topic_name, depth) def _handle_subscription_init(self, event, metadata): - sub_handle = get_field(event, 'subscription_handle') + handle = get_field(event, 'subscription_handle') + timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') rmw_handle = get_field(event, 'rmw_subscription_handle') topic_name = get_field(event, 'topic_name') depth = get_field(event, 'depth') - self._data.add_subscription(sub_handle, metadata.timestamp, node_handle, rmw_handle, topic_name, depth) + self._data.add_subscription(handle, timestamp, node_handle, rmw_handle, topic_name, depth) def _handle_rclcpp_subscription_callback_added(self, event, metadata): - subscription_handle = get_field(event, 'subscription_handle') + handle = get_field(event, 'subscription_handle') + timestamp = metadata.timestamp callback_object = get_field(event, 'callback') - self._data.add_callback_object(subscription_handle, metadata.timestamp, callback_object) + self._data.add_callback_object(handle, timestamp, callback_object) def _handle_rclcpp_subscription_callback_start(self, event, metadata): self.__handle_callback_start(event, metadata) @@ -111,16 +118,18 @@ class Ros2Processor(EventHandler): self.__handle_callback_end(event, metadata) def _handle_rcl_service_init(self, event, metadata): - service_handle = get_field(event, 'service_handle') + handle = get_field(event, 'service_handle') + timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') rmw_handle = get_field(event, 'rmw_service_handle') service_name = get_field(event, 'service_name') - self._data.add_service(service_handle, metadata.timestamp, node_handle, rmw_handle, service_name) + self._data.add_service(handle, timestamp, node_handle, rmw_handle, service_name) def _handle_rclcpp_service_callback_added(self, event, metadata): - service_handle = get_field(event, 'service_handle') + handle = get_field(event, 'service_handle') + timestamp = metadata.timestamp callback_object = get_field(event, 'callback') - self._data.add_callback_object(service_handle, metadata.timestamp, callback_object) + self._data.add_callback_object(handle, timestamp, callback_object) def _handle_rclcpp_service_callback_start(self, event, metadata): self.__handle_callback_start(event, metadata) @@ -129,21 +138,24 @@ class Ros2Processor(EventHandler): self.__handle_callback_end(event, metadata) def _handle_rcl_client_init(self, event, metadata): - client_handle = get_field(event, 'client_handle') + handle = get_field(event, 'client_handle') + timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') rmw_handle = get_field(event, 'rmw_client_handle') service_name = get_field(event, 'service_name') - self._data.add_client(client_handle, metadata.timestamp, node_handle, rmw_handle, service_name) + self._data.add_client(handle, timestamp, node_handle, rmw_handle, service_name) def _handle_rcl_timer_init(self, event, metadata): - timer_handle = get_field(event, 'timer_handle') + handle = get_field(event, 'timer_handle') + timestamp = metadata.timestamp period = get_field(event, 'period') - self._data.add_timer(timer_handle, metadata.timestamp, period) + self._data.add_timer(handle, timestamp, period) def _handle_rclcpp_timer_callback_added(self, event, metadata): - timer_handle = get_field(event, 'timer_handle') + handle = get_field(event, 'timer_handle') + timestamp = metadata.timestamp callback_object = get_field(event, 'callback') - self._data.add_callback_object(timer_handle, metadata.timestamp, callback_object) + self._data.add_callback_object(handle, timestamp, callback_object) def _handle_rclcpp_timer_callback_start(self, event, metadata): self.__handle_callback_start(event, metadata) @@ -153,8 +165,9 @@ class Ros2Processor(EventHandler): def _handle_rclcpp_callback_register(self, event, metadata): callback_object = get_field(event, 'callback') + timestamp = metadata.timestamp symbol = get_field(event, 'symbol') - self._data.add_callback_symbol(callback_object, metadata.timestamp, symbol) + self._data.add_callback_symbol(callback_object, timestamp, symbol) def __handle_callback_start(self, event, metadata): # Add to dict diff --git a/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py index 78ca353..c8cb14c 100644 --- a/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/conversion/ctf.py @@ -40,7 +40,7 @@ def ctf_to_pickle(trace_directory, target): pod = _ctf_event_to_pod(event) target.dump(pod) count_written += 1 - + return count_written diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 8a85096..cba3cc4 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -6,10 +6,11 @@ import pickle import time from tracetools_analysis.analysis import ros2_processor -from tracetools_analysis.analysis import data_model + def parse_args(): - parser = argparse.ArgumentParser(description='Process a pickle file generated from tracing and analyze the data.') + parser = argparse.ArgumentParser(description='Process a pickle file generated ' + 'from tracing and analyze the data.') parser.add_argument('pickle_file', help='the pickle file to import') return parser.parse_args() @@ -27,7 +28,8 @@ def main(): time_diff = time.time() - start_time print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') - p.get_data_model().print() + p.get_data_model().print_model() + def _get_events_from_pickled_file(file): p = pickle.Unpickler(file)