niklas/tracetools_analysis
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix lint errors

Browse source
This commit is contained in:
Christophe Bedard 2019-06-13 16:37:20 +02:00
parent 5cd1f2f48b
commit 2508b07347
4 changed files with 105 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

88
tracetools_analysis/analysis/data_model.py
View file

@ -14,28 +14,62 @@ class DataModel():
def __init__(self): def __init__(self):
# Objects (one-time events, usually when something is created) # 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._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._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._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._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._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._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._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_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) self._callback_symbols.set_index(['callback_object'], inplace=True, drop=True)
# Events (multiple instances, may not have a meaningful index) # 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): def add_context(self, context_handle, timestamp, pid):
self._contexts.loc[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): def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace):
self._nodes.loc[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): def add_publisher(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth):
self._publishers.loc[publisher_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): def add_subscription(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth):
self._subscriptions.loc[subscription_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): def add_service(self, handle, timestamp, node_handle, rmw_handle, service_name):
self._services.loc[service_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): def add_client(self, handle, timestamp, node_handle, rmw_handle, service_name):
self._clients.loc[client_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): def add_timer(self, handle, timestamp, period):
self._timers.loc[timer_handle] = [timestamp, period] self._timers.loc[handle] = [timestamp, period]
def add_callback_object(self, handle, timestamp, callback_object): def add_callback_object(self, handle, timestamp, callback_object):
self._callback_objects.loc[handle] = [timestamp, callback_object] self._callback_objects.loc[handle] = [timestamp, callback_object]
def add_callback_symbol(self, callback_object, timestamp, symbol): def add_callback_symbol(self, callback_object, timestamp, symbol):
self._callback_symbols.loc[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.""" """Debug method to print every contained df."""
print('====================DATA MODEL====================') print('====================DATA MODEL====================')
print(f'Contexts:\n{self._contexts.to_string()}') print(f'Contexts:\n{self._contexts.to_string()}')

57
tracetools_analysis/analysis/ros2_processor.py
View file

@ -1,8 +1,8 @@
# Process trace events and create ROS model # Process trace events and create ROS model
from .data_model import DataModel
from .handler import EventHandler from .handler import EventHandler
from .lttng_models import get_field from .lttng_models import get_field
from .data_model import DataModel
def ros2_process(events): def ros2_process(events):
@ -68,41 +68,48 @@ class Ros2Processor(EventHandler):
# Temporary buffers # Temporary buffers
self._callback_instances = {} self._callback_instances = {}
def get_data_model(self): def get_data_model(self):
return self._data return self._data
def _handle_rcl_init(self, event, metadata): def _handle_rcl_init(self, event, metadata):
context_handle = get_field(event, 'context_handle') 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): 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') rmw_handle = get_field(event, 'rmw_handle')
name = get_field(event, 'node_name') name = get_field(event, 'node_name')
namespace = get_field(event, 'namespace') 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): 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') node_handle = get_field(event, 'node_handle')
rmw_handle = get_field(event, 'rmw_publisher_handle') rmw_handle = get_field(event, 'rmw_publisher_handle')
topic_name = get_field(event, 'topic_name') topic_name = get_field(event, 'topic_name')
depth = get_field(event, 'depth') 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): 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') node_handle = get_field(event, 'node_handle')
rmw_handle = get_field(event, 'rmw_subscription_handle') rmw_handle = get_field(event, 'rmw_subscription_handle')
topic_name = get_field(event, 'topic_name') topic_name = get_field(event, 'topic_name')
depth = get_field(event, 'depth') 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): 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') 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): def _handle_rclcpp_subscription_callback_start(self, event, metadata):
self.__handle_callback_start(event, metadata) self.__handle_callback_start(event, metadata)
@ -111,16 +118,18 @@ class Ros2Processor(EventHandler):
self.__handle_callback_end(event, metadata) self.__handle_callback_end(event, metadata)
def _handle_rcl_service_init(self, 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') node_handle = get_field(event, 'node_handle')
rmw_handle = get_field(event, 'rmw_service_handle') rmw_handle = get_field(event, 'rmw_service_handle')
service_name = get_field(event, 'service_name') 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): 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') 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): def _handle_rclcpp_service_callback_start(self, event, metadata):
self.__handle_callback_start(event, metadata) self.__handle_callback_start(event, metadata)
@ -129,21 +138,24 @@ class Ros2Processor(EventHandler):
self.__handle_callback_end(event, metadata) self.__handle_callback_end(event, metadata)
def _handle_rcl_client_init(self, 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') node_handle = get_field(event, 'node_handle')
rmw_handle = get_field(event, 'rmw_client_handle') rmw_handle = get_field(event, 'rmw_client_handle')
service_name = get_field(event, 'service_name') 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): 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') 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): 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') 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): def _handle_rclcpp_timer_callback_start(self, event, metadata):
self.__handle_callback_start(event, metadata) self.__handle_callback_start(event, metadata)
@ -153,8 +165,9 @@ class Ros2Processor(EventHandler):
def _handle_rclcpp_callback_register(self, event, metadata): def _handle_rclcpp_callback_register(self, event, metadata):
callback_object = get_field(event, 'callback') callback_object = get_field(event, 'callback')
timestamp = metadata.timestamp
symbol = get_field(event, 'symbol') 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): def __handle_callback_start(self, event, metadata):
# Add to dict # Add to dict

2
tracetools_analysis/conversion/ctf.py
View file

@ -40,7 +40,7 @@ def ctf_to_pickle(trace_directory, target):
pod = _ctf_event_to_pod(event) pod = _ctf_event_to_pod(event)
target.dump(pod) target.dump(pod)
count_written += 1 count_written += 1
return count_written return count_written

8
tracetools_analysis/process.py
View file

@ -6,10 +6,11 @@ import pickle
import time import time
from tracetools_analysis.analysis import ros2_processor from tracetools_analysis.analysis import ros2_processor
from tracetools_analysis.analysis import data_model
def parse_args(): 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', parser.add_argument('pickle_file',
help='the pickle file to import') help='the pickle file to import')
return parser.parse_args() return parser.parse_args()
@ -27,7 +28,8 @@ def main():
time_diff = time.time() - start_time time_diff = time.time() - start_time
print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') 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): def _get_events_from_pickled_file(file):
p = pickle.Unpickler(file) p = pickle.Unpickler(file)