From b9e4ce7bfbe000a60e7aa6a355a89e0234634f78 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:17:36 +0200 Subject: [PATCH 01/98] Make package a ROS 2 package --- __init__.py | 2 ++ analysis/__init__.py | 0 conversion/__init__.py | 0 conversion/ctf.py | 3 +++ convert.py | 9 +++++++++ 5 files changed, 14 insertions(+) create mode 100644 __init__.py create mode 100644 analysis/__init__.py create mode 100644 conversion/__init__.py create mode 100644 conversion/ctf.py create mode 100644 convert.py diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..6c918a8 --- /dev/null +++ b/__init__.py @@ -0,0 +1,2 @@ +"""Reading and interpreting of LTTng trace data.""" +__author__ = 'Luetkebohle Ingo (CR/AEX3)' diff --git a/analysis/__init__.py b/analysis/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/conversion/__init__.py b/conversion/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/conversion/ctf.py b/conversion/ctf.py new file mode 100644 index 0000000..e5b233a --- /dev/null +++ b/conversion/ctf.py @@ -0,0 +1,3 @@ + +def ctf_to_pickle(): + print('ctf_to_pickle') diff --git a/convert.py b/convert.py new file mode 100644 index 0000000..3ab6144 --- /dev/null +++ b/convert.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python3 +# Entrypoint/script to convert CTF trace data to a pickle file +# TODO + +from tracetools_analysis.conversion.ctf import * + +def main(): + print('main called') + ctf_to_pickle() From c500876b476059a39d30324a884e91d8ba1121e5 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:18:41 +0200 Subject: [PATCH 02/98] Add basic conversion entrypoint --- conversion/ctf.py | 61 +++++++++++++++++++++++++++++++++++++++++++++-- convert.py | 16 ++++++++++--- 2 files changed, 72 insertions(+), 5 deletions(-) diff --git a/conversion/ctf.py b/conversion/ctf.py index e5b233a..3ddba4e 100644 --- a/conversion/ctf.py +++ b/conversion/ctf.py @@ -1,3 +1,60 @@ +# CTF to pickle conversion -def ctf_to_pickle(): - print('ctf_to_pickle') +import babeltrace +from pickle import Pickler +import time + +# TODO +_IGNORED_FIELDS = [] +_DISCARD = "events_discarded" + +def ctf_to_pickle(trace_directory, target): + """ + Load CTF trace and convert to a pickle file + :param trace_directory (str): the main/top trace directory + :param target (Pickler): the target pickle file to write to + """ + # add traces + tc = babeltrace.TraceCollection() + print(f'Importing {trace_directory}') + tc.add_traces_recursive(trace_directory, 'ctf') + + count = 0 + count_written = 0 + # count_pid_matched = 0 + # traced = set() + + start_time = time.time() + + # PID_KEYS = ['vpid', 'pid'] + for event in tc.events: + count += 1 + # pid = None + # for key in PID_KEYS: + # if key in event.keys(): + # pid = event[key] + # break + + # Write all for now + pod = _ctf_event_to_pod(event) + print(f'dumping pod: {str(pod)}') + target.dump(pod) + count_written += 1 + + print(f'{count_written} events in {time.time() - start_time}') + + +def _ctf_event_to_pod(ctf_event): + """ + Convert name, timestamp, and all other keys except those in IGNORED_FIELDS into a dictionary. + :param ctf_element: The element to convert + :type ctf_element: babeltrace.Element + :return: + :return type: dict + """ + pod = {'_name': ctf_event.name, '_timestamp': ctf_event.timestamp} + if hasattr(ctf_event, _DISCARD) and ctf_event[_DISCARD] > 0: + print(ctf_event[_DISCARD]) + for key in [key for key in ctf_event.keys() if key not in _IGNORED_FIELDS]: + pod[key] = ctf_event[key] + return pod diff --git a/convert.py b/convert.py index 3ab6144..3a41428 100644 --- a/convert.py +++ b/convert.py @@ -2,8 +2,18 @@ # Entrypoint/script to convert CTF trace data to a pickle file # TODO +import sys +from pickle import Pickler from tracetools_analysis.conversion.ctf import * -def main(): - print('main called') - ctf_to_pickle() +def main(argv=sys.argv): + if len(argv) != 3: + print("usage: /trace/directory pickle_target_file") + exit(1) + + trace_directory = sys.argv[1] + pickle_target_file = sys.argv[2] + + with open(pickle_target_file, 'wb') as f: + p = Pickler(f, protocol=4) + ctf_to_pickle(trace_directory, p) From edff371e2ba8adead48e3923aef4910232e6a001 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:19:24 +0200 Subject: [PATCH 03/98] Add trace script to setup/enable tracing through Python bindings --- trace.py | 26 +++++++ tracing/__init__.py | 0 tracing/lttng.py | 178 ++++++++++++++++++++++++++++++++++++++++++++ tracing/names.py | 58 +++++++++++++++ 4 files changed, 262 insertions(+) create mode 100644 trace.py create mode 100644 tracing/__init__.py create mode 100644 tracing/lttng.py create mode 100644 tracing/names.py diff --git a/trace.py b/trace.py new file mode 100644 index 0000000..901073b --- /dev/null +++ b/trace.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +# Entrypoint/script to setup and start an LTTng tracing session +# TODO + +import sys +import time +from tracetools_analysis.tracing.lttng import * + +def main(argv=sys.argv): + if len(argv) != 3: + print("usage: session-name /path") + exit(1) + + session_name = argv[1] + path = argv[2] + # TODO fix kernel tracing + lttng_setup(session_name, path, kernel_events=None) + lttng_start(session_name) + print('tracing session started') + + # TODO integrate this with launch + ROS shutdown + time.sleep(5) + + print('stopping & destroying tracing session') + lttng_stop(session_name) + lttng_destroy(session_name) diff --git a/tracing/__init__.py b/tracing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tracing/lttng.py b/tracing/lttng.py new file mode 100644 index 0000000..6d465dc --- /dev/null +++ b/tracing/lttng.py @@ -0,0 +1,178 @@ +# LTTng tracing interface + +from lttng import * +from .names import DEFAULT_EVENTS_ROS, DEFAULT_EVENTS_KERNEL, DEFAULT_CONTEXT + +def lttng_setup(session_name, path, ros_events=DEFAULT_EVENTS_ROS, kernel_events=DEFAULT_EVENTS_KERNEL, context_names=DEFAULT_CONTEXT): + """ + Setup LTTng session, with events and context + :param session_name (str): the name of the session + :param path (str): the path to write trace data to + :param ros_events (list(str)): list of ROS events to enable + :param kernel_events (list(str)): list of kernel events to enable + :param context_names (list(str)): list of context elements to enable + """ + ust_enabled = ros_events is not None and len(ros_events) > 0 + kernel_enabled = kernel_events is not None and len(kernel_events) > 0 + print(f'UST tracing {f"enabled ({len(ros_events)} events)" if ust_enabled else "disabled"}') + print(f'kernel tracing {f"enabled ({len(kernel_events)} events)" if kernel_enabled else "disabled"}') + + # Domains + if ust_enabled: + domain_ust = Domain() + domain_ust.type = DOMAIN_UST + channel_ust = Channel() + channel_ust.name = 'ros2' + channel_ust.attr.overwrite = 0 + channel_ust.attr.subbuf_size = 4096 + channel_ust.attr.num_subbuf = 8 + channel_ust.attr.switch_timer_interval = 0 + channel_ust.attr.read_timer_interval = 200 + channel_ust.attr.output = EVENT_MMAP + events_list_ust = _create_events(ros_events) + if kernel_enabled: + domain_kernel = Domain() + domain_kernel.type = DOMAIN_KERNEL + channel_kernel = Channel() + channel_kernel.name = 'kchan' + # TODO fix kernel tracing + # channel_kernel.attr.overwrite = 0 + # channel_kernel.attr.subbuf_size = 4096 + # channel_kernel.attr.num_subbuf = 8 + # channel_kernel.attr.switch_timer_interval = 0 + # channel_kernel.attr.read_timer_interval = 200 + # channel_kernel.attr.output = EVENT_MMAP + events_list_kernel = _create_events(kernel_events) + + # Session + _create_session(session_name, path) + + # Handles, channels, events + handle_ust = None + if ust_enabled: + handle_ust = _create_handle(session_name, domain_ust) + _enable_channel(handle_ust, channel_ust) + _enable_events(handle_ust, events_list_ust, channel_ust.name) + handle_kernel = None + if kernel_enabled: + handle_kernel = _create_handle(session_name, domain_kernel) + _enable_channel(handle_kernel, channel_kernel) + _enable_events(handle_kernel, events_list_kernel, channel_kernel.name) + + # Context + context_list = _create_context_list(context_names) + enabled_handles = [h for h in [handle_ust, handle_kernel] if h is not None] + _add_context(enabled_handles, context_list) + +def lttng_start(session_name): + """ + Start LTTng session, and check for errors + """ + result = start(session_name) + if result < 0: + raise RuntimeError(f'failed to start tracing: {strerror(result)}') + +def lttng_stop(session_name): + """ + Stop LTTng session, and check for errors + """ + result = stop(session_name) + if result < 0: + raise RuntimeError(f'failed to stop tracing: {strerror(result)}') + +def lttng_destroy(session_name): + """ + Destroy LTTng session, and check for errors + """ + result = destroy(session_name) + if result < 0: + raise RuntimeError(f'failed to destroy tracing session: {strerror(result)}') + +def _create_events(event_names_list): + """ + Create events list from names + """ + events_list = [] + for event_name in event_names_list: + e = Event() + e.name = event_name + e.type = EVENT_TRACEPOINT + e.loglevel_type = EVENT_LOGLEVEL_ALL + events_list.append(e) + return events_list + +def _create_session(session_name, path): + """ + Create session from name and path, and check for errors + """ + result = create(session_name, path) + LTTNG_ERR_EXIST_SESS = -28 + if result == LTTNG_ERR_EXIST_SESS: + # Sessions seem to persist, so if it already exists, + # just destroy it and try again + lttng_destroy(session_name) + result = create(session_name, path) + if result < 0: + raise RuntimeError(f'session creation failed: {strerror(result)}') + +def _create_handle(session_name, domain): + """ + Create a handle for a given session name and a domain, and check for errors + """ + handle = None + handle = Handle(session_name, domain) + if handle is None: + raise RuntimeError('handle creation failed') + return handle + +def _enable_channel(handle, channel): + """ + Enable channel for a handle, and check for errors + """ + result = enable_channel(handle, channel) + if result < 0: + raise RuntimeError(f'channel enabling failed: {strerror(result)}') + +def _enable_events(handle, events_list, channel_name): + """ + Enable events list for a given handle and channel name, and check for errors + """ + for event in events_list: + result = enable_event(handle, event, channel_name) + if result < 0: + raise RuntimeError(f'event enabling failed: {strerror(result)}') + +context_map = { + 'procname': EVENT_CONTEXT_PROCNAME, + 'pid': EVENT_CONTEXT_PID, + 'vpid': EVENT_CONTEXT_VPID, + 'vtid': EVENT_CONTEXT_VTID, +} +def _context_name_to_type(context_name): + """ + Convert from context name to LTTng enum/constant type + """ + return context_map.get(context_name) + +def _create_context_list(context_names_list): + """ + Create context list from names, and check for errors + """ + context_list = [] + for c in context_names_list: + ec = EventContext() + context_type = _context_name_to_type(c) + if context_type is not None: + ec.ctx = context_type + context_list.append(ec) + return context_list + +def _add_context(handles, context_list): + """ + Add context list to given handles, and check for errors + """ + for handle in handles: + for contex in context_list: + result = add_context(handle, contex, None, None) + if result < 0: + raise RuntimeError(f'failed to add context: {strerror(result)}') diff --git a/tracing/names.py b/tracing/names.py new file mode 100644 index 0000000..93f1bab --- /dev/null +++ b/tracing/names.py @@ -0,0 +1,58 @@ +# Lists of names (events, context) + +DEFAULT_EVENTS_KERNEL=[ + 'block_rq_complete', + 'block_rq_insert', + 'block_rq_issue', + 'block_bio_frontmerge', + 'irq_softirq_entry', + 'irq_softirq_raise' + 'irq_softirq_exit', + 'irq_handler_entry', + 'irq_handler_exit', + 'lttng_statedump_process_state', + 'lttng_statedump_start', + 'lttng_statedump_end', + 'lttng_statedump_network_interface', + 'lttng_statedump_block_device', + 'net_dev_queue', + 'netif_receive_skb', + 'net_if_receive_skb', + 'power_cpu_frequency', + 'sched_switch', + 'sched_waking', + 'sched_pi_setprio', + 'sched_process_fork', + 'sched_process_exit', + 'sched_process_free', + 'sched_wakeup', + 'sched_migrate', + 'sched_migrate_task', + 'timer_hrtimer_start', + 'timer_hrtimer_cancel', + 'timer_hrtimer_expire_entry', + 'timer_hrtimer_expire_exit', +] + +DEFAULT_EVENTS_ROS=[ + 'ros2:rcl_init' + 'ros2:rcl_node_init', + 'ros2:rcl_publisher_init', + 'ros2:rcl_subscription_init', + 'ros2:rclcpp_subscription_callback_added', + 'ros2:rclcpp_subscription_callback_start', + 'ros2:rclcpp_subscription_callback_end', + 'ros2:rcl_service_init', + 'ros2:rclcpp_service_callback_added', + 'ros2:rclcpp_service_callback_start', + 'ros2:rclcpp_service_callback_end', +] + +DEFAULT_CONTEXT=[ + 'procname', + 'perf:thread:instructions', + 'perf:thread:cycles', + 'perf:thread:cpu-cycles', + 'vpid', + 'vtid', +] From af2ebbbf655c45c6a4c6ea7db8f4a4a2a540d2d8 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:19:49 +0200 Subject: [PATCH 04/98] Add more fields to list of ignored fields and order them --- conversion/ctf.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/conversion/ctf.py b/conversion/ctf.py index 3ddba4e..5ae4ca7 100644 --- a/conversion/ctf.py +++ b/conversion/ctf.py @@ -4,9 +4,11 @@ import babeltrace from pickle import Pickler import time -# TODO -_IGNORED_FIELDS = [] -_DISCARD = "events_discarded" +_IGNORED_FIELDS = [ + 'content_size', 'cpu_id', 'events_discarded', 'id', 'packet_size', 'packet_seq_num', + 'stream_id', 'stream_instance_id', 'timestamp_end', 'timestamp_begin', 'magic', 'uuid', 'v' +] +_DISCARD = 'events_discarded' def ctf_to_pickle(trace_directory, target): """ From 9e217e0c56ab510abee573f79bf4197cf79fc6ca Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:20:10 +0200 Subject: [PATCH 05/98] Add comment for ignored fields list --- conversion/ctf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/conversion/ctf.py b/conversion/ctf.py index 5ae4ca7..1edd9f5 100644 --- a/conversion/ctf.py +++ b/conversion/ctf.py @@ -4,6 +4,7 @@ import babeltrace from pickle import Pickler import time +# List of ignored CTF fields _IGNORED_FIELDS = [ 'content_size', 'cpu_id', 'events_discarded', 'id', 'packet_size', 'packet_seq_num', 'stream_id', 'stream_instance_id', 'timestamp_end', 'timestamp_begin', 'magic', 'uuid', 'v' From d1ea1bd9bd3f3639ab34a8409cf2b2ac5b297d45 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:20:36 +0200 Subject: [PATCH 06/98] Add basic events processing entrypoint --- conversion/ros.py | 5 +++++ process.py | 27 +++++++++++++++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 conversion/ros.py create mode 100644 process.py diff --git a/conversion/ros.py b/conversion/ros.py new file mode 100644 index 0000000..b63b75b --- /dev/null +++ b/conversion/ros.py @@ -0,0 +1,5 @@ +# Process trace events and create ROS model + +def ros_import(events): + for event in events: + print(f'event: {str(event)}') diff --git a/process.py b/process.py new file mode 100644 index 0000000..9752a44 --- /dev/null +++ b/process.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +# Entrypoint/script to process events from a pickle file to build a ROS model + +import sys +import pickle +from tracetools_analysis.conversion.ros import * + +def main(argv=sys.argv): + if len(argv) != 2: + print('usage: pickle_file') + exit(1) + + pickle_filename = sys.argv[1] + with open(pickle_filename, 'rb') as f: + events = _get_events_from_pickled_file(f) + print(f'imported {len(events)} events') + ros_import(events) + +def _get_events_from_pickled_file(file): + p = pickle.Unpickler(file) + events = [] + while True: + try: + events.append(p.load()) + except EOFError as _: + break # we're done + return events From e3a1564041ef2a142ff4befd7ac1892016d7b316 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:21:41 +0200 Subject: [PATCH 07/98] Rename ROS processing file and move to analysis submodule --- analysis/ros_processor.py | 92 +++++++++++++++++++++++++++++++++++++++ conversion/ros.py | 5 --- process.py | 4 +- 3 files changed, 94 insertions(+), 7 deletions(-) create mode 100644 analysis/ros_processor.py delete mode 100644 conversion/ros.py diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py new file mode 100644 index 0000000..cbd8d66 --- /dev/null +++ b/analysis/ros_processor.py @@ -0,0 +1,92 @@ +# Process trace events and create ROS model + +def ros_process(events): + """ + Process unpickled events and create ROS model + :param events (list(dict(str:str:))): the list of events + """ + processor = RosProcessor() + for event in events: + print(f'event: {str(event)}') + processor.handle(event) + +# TODO move +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 + + +class RosProcessor(): + def __init__(self): + # TODO add other stuff + self.callbacks = [] + + # 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 handle(self, event): + """ + Handle an event + :param event (dict(str:str)): the event to handle + """ + handler_function = self._handler_map.get(get_name(event), d=None) + if handler_function is not None: + name = get_name(event) + 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(name, pid, tid, timestamp, procname) + handler_function(event, metadata) + + def _handle_subscription_init(self, event, metadata): + # TODO + pass + + def _handle_subscription_callback_added(self, event, metadata): + # TODO + pass + + def _handle_subscription_callback_start(self, event, metadata): + # TODO + pass + + def _handle_subscription_callback_end(self, event, metadata): + # TODO + pass + + +def get_field(event, field_name, default=None): + return event.get(field_name, d=default) + +def get_name(event): + return get_field(event, '_name') diff --git a/conversion/ros.py b/conversion/ros.py deleted file mode 100644 index b63b75b..0000000 --- a/conversion/ros.py +++ /dev/null @@ -1,5 +0,0 @@ -# Process trace events and create ROS model - -def ros_import(events): - for event in events: - print(f'event: {str(event)}') diff --git a/process.py b/process.py index 9752a44..fa576d1 100644 --- a/process.py +++ b/process.py @@ -3,7 +3,7 @@ import sys import pickle -from tracetools_analysis.conversion.ros import * +from tracetools_analysis.analysis.ros import * def main(argv=sys.argv): if len(argv) != 2: @@ -14,7 +14,7 @@ def main(argv=sys.argv): with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) print(f'imported {len(events)} events') - ros_import(events) + ros_process(events) def _get_events_from_pickled_file(file): p = pickle.Unpickler(file) From 9ea97f23ecfabac62692a0d5a69753ae8190dba7 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:22:01 +0200 Subject: [PATCH 08/98] Extract EventMetadata to lttng_models file --- analysis/lttng_models.py | 36 ++++++++++++++++++++++++++++++++++++ analysis/ros_processor.py | 39 ++------------------------------------- 2 files changed, 38 insertions(+), 37 deletions(-) create mode 100644 analysis/lttng_models.py diff --git a/analysis/lttng_models.py b/analysis/lttng_models.py new file mode 100644 index 0000000..7128293 --- /dev/null +++ b/analysis/lttng_models.py @@ -0,0 +1,36 @@ +# Model objects for LTTng traces/events + +def get_field(event, field_name, default=None): + return event.get(field_name, d=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 diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py index cbd8d66..bf45af6 100644 --- a/analysis/ros_processor.py +++ b/analysis/ros_processor.py @@ -1,5 +1,7 @@ # Process trace events and create ROS model +from .lttng_models import EventMetadata, get_field, get_name + def ros_process(events): """ Process unpickled events and create ROS model @@ -10,36 +12,6 @@ def ros_process(events): print(f'event: {str(event)}') processor.handle(event) -# TODO move -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 - - class RosProcessor(): def __init__(self): # TODO add other stuff @@ -83,10 +55,3 @@ class RosProcessor(): def _handle_subscription_callback_end(self, event, metadata): # TODO pass - - -def get_field(event, field_name, default=None): - return event.get(field_name, d=default) - -def get_name(event): - return get_field(event, '_name') From 7e99bcb0ab2619b689928c06dab35fe6538e8e9d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:22:21 +0200 Subject: [PATCH 09/98] Add docstring --- analysis/ros_processor.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py index bf45af6..7a26663 100644 --- a/analysis/ros_processor.py +++ b/analysis/ros_processor.py @@ -13,6 +13,10 @@ def ros_process(events): processor.handle(event) 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 self.callbacks = [] From 02f5eb339a0d7f6ba7daf57cf89a761ef34b8b76 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:22:38 +0200 Subject: [PATCH 10/98] Complete basic callback duration processing --- analysis/lttng_models.py | 2 +- analysis/ros_processor.py | 41 +++++++++++++++++++++++++-------------- analysis/to_pandas.py | 17 ++++++++++++++++ process.py | 10 ++++++++-- 4 files changed, 52 insertions(+), 18 deletions(-) create mode 100644 analysis/to_pandas.py diff --git a/analysis/lttng_models.py b/analysis/lttng_models.py index 7128293..88f7e01 100644 --- a/analysis/lttng_models.py +++ b/analysis/lttng_models.py @@ -1,7 +1,7 @@ # Model objects for LTTng traces/events def get_field(event, field_name, default=None): - return event.get(field_name, d=default) + return event.get(field_name, default) def get_name(event): return get_field(event, '_name') diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py index 7a26663..10ee168 100644 --- a/analysis/ros_processor.py +++ b/analysis/ros_processor.py @@ -6,11 +6,11 @@ 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() - for event in events: - print(f'event: {str(event)}') - processor.handle(event) + processor.process_events(events) + return processor class RosProcessor(): """ @@ -19,7 +19,10 @@ class RosProcessor(): """ def __init__(self): # TODO add other stuff - self.callbacks = [] + # Instances of callback_start for eventual matching + self._callback_starts = {} + # Callback instances, callback_address: end - start + self.callbacks_instances = {} # Link a ROS trace event to its corresponding handling method self._handler_map = { @@ -28,13 +31,17 @@ class RosProcessor(): 'ros2:rclcpp_subscription_callback_start': self._handle_subscription_callback_start, 'ros2:rclcpp_subscription_callback_end': self._handle_subscription_callback_end, } - - def handle(self, event): + + def process_events(self, events): """ - Handle an event - :param event (dict(str:str)): the event to handle + Process events + :param events (list(dict(str:str))): the events to process """ - handler_function = self._handler_map.get(get_name(event), d=None) + for event in events: + self._handle(event) + + def _handle(self, event): + handler_function = self._handler_map.get(get_name(event), None) if handler_function is not None: name = get_name(event) pid = get_field(event, 'vpid', default=get_field(event, 'pid')) @@ -49,13 +56,17 @@ class RosProcessor(): pass def _handle_subscription_callback_added(self, event, metadata): - # TODO - pass + # 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): - # TODO - pass + callback_addr = get_field(event, 'callback') + self._callback_starts[callback_addr] = metadata.timestamp def _handle_subscription_callback_end(self, event, metadata): - # TODO - pass + 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) diff --git a/analysis/to_pandas.py b/analysis/to_pandas.py new file mode 100644 index 0000000..9806759 --- /dev/null +++ b/analysis/to_pandas.py @@ -0,0 +1,17 @@ +# 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 = [] + for addr in ros_processor.callbacks_instances: + for d in ros_processor.callbacks_instances[addr]: + callback_addresses.append(addr) + durations.append(d) + + return pd.DataFrame(data={ + 'callback_address': callback_addresses, + 'duration': durations, + }) diff --git a/process.py b/process.py index fa576d1..76d04a5 100644 --- a/process.py +++ b/process.py @@ -3,7 +3,9 @@ import sys import pickle -from tracetools_analysis.analysis.ros import * +import pandas as pd +from tracetools_analysis.analysis.ros_processor import * +from tracetools_analysis.analysis.to_pandas import * def main(argv=sys.argv): if len(argv) != 2: @@ -14,7 +16,11 @@ def main(argv=sys.argv): with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) print(f'imported {len(events)} events') - ros_process(events) + processor = ros_process(events) + + df = callback_durations_to_df(processor) + print(df.to_string()) + def _get_events_from_pickled_file(file): p = pickle.Unpickler(file) From b51910805cf3c8854b304147f72349f07c690c1e Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:23:03 +0200 Subject: [PATCH 11/98] Improve event handling --- analysis/ros_processor.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py index 10ee168..cf69b6f 100644 --- a/analysis/ros_processor.py +++ b/analysis/ros_processor.py @@ -1,5 +1,6 @@ # Process trace events and create ROS model +import sys from .lttng_models import EventMetadata, get_field, get_name def ros_process(events): @@ -41,15 +42,17 @@ class RosProcessor(): self._handle(event) def _handle(self, event): - handler_function = self._handler_map.get(get_name(event), None) + event_name = get_name(event) + handler_function = self._handler_map.get(event_name, None) if handler_function is not None: - name = get_name(event) 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(name, pid, tid, timestamp, 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 From 93d062d2c498296d3cae4b30d6a07ed558513f87 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:23:24 +0200 Subject: [PATCH 12/98] Improve printed messages for conversion script --- conversion/ctf.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/conversion/ctf.py b/conversion/ctf.py index 1edd9f5..362d019 100644 --- a/conversion/ctf.py +++ b/conversion/ctf.py @@ -19,7 +19,7 @@ def ctf_to_pickle(trace_directory, target): """ # add traces tc = babeltrace.TraceCollection() - print(f'Importing {trace_directory}') + print(f'Importing trace directory: {trace_directory}') tc.add_traces_recursive(trace_directory, 'ctf') count = 0 @@ -40,11 +40,11 @@ def ctf_to_pickle(trace_directory, target): # Write all for now pod = _ctf_event_to_pod(event) - print(f'dumping pod: {str(pod)}') target.dump(pod) count_written += 1 - print(f'{count_written} events in {time.time() - start_time}') + time_diff = time.time() - start_time + print(f'{count_written} events in {time_diff * 1000:.2f} ms') def _ctf_event_to_pod(ctf_event): From 182fc771eeca066df19f296ebc19d9593d1092b1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:23:48 +0200 Subject: [PATCH 13/98] Use enter key to stop tracing instead of sleep() --- trace.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/trace.py b/trace.py index 901073b..cfc0c04 100644 --- a/trace.py +++ b/trace.py @@ -19,7 +19,7 @@ def main(argv=sys.argv): print('tracing session started') # TODO integrate this with launch + ROS shutdown - time.sleep(5) + input('press enter to stop...') print('stopping & destroying tracing session') lttng_stop(session_name) From 031f30460ae75621ab56a3ae4cb3df03efd94d4f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:24:16 +0200 Subject: [PATCH 14/98] Use lttng built from source as a workaround --- trace.py | 7 +++---- tracing/lttng.py | 35 ++++++++++++++++++++--------------- 2 files changed, 23 insertions(+), 19 deletions(-) diff --git a/trace.py b/trace.py index cfc0c04..002c220 100644 --- a/trace.py +++ b/trace.py @@ -12,11 +12,10 @@ def main(argv=sys.argv): exit(1) session_name = argv[1] - path = argv[2] - # TODO fix kernel tracing - lttng_setup(session_name, path, kernel_events=None) + path = argv[2] + '/' + session_name + lttng_setup(session_name, path) lttng_start(session_name) - print('tracing session started') + print(f'tracing session started: {path}') # TODO integrate this with launch + ROS shutdown input('press enter to stop...') diff --git a/tracing/lttng.py b/tracing/lttng.py index 6d465dc..cda2cf4 100644 --- a/tracing/lttng.py +++ b/tracing/lttng.py @@ -1,13 +1,17 @@ # LTTng tracing interface +# Temporary workaround +import sys +sys.path = ['/usr/local/lib/python3.6/site-packages'] + sys.path + from lttng import * from .names import DEFAULT_EVENTS_ROS, DEFAULT_EVENTS_KERNEL, DEFAULT_CONTEXT -def lttng_setup(session_name, path, ros_events=DEFAULT_EVENTS_ROS, kernel_events=DEFAULT_EVENTS_KERNEL, context_names=DEFAULT_CONTEXT): +def lttng_setup(session_name, directory, ros_events=DEFAULT_EVENTS_ROS, kernel_events=DEFAULT_EVENTS_KERNEL, context_names=DEFAULT_CONTEXT): """ Setup LTTng session, with events and context :param session_name (str): the name of the session - :param path (str): the path to write trace data to + :param directory (str): the path of the main directory to write trace data to :param ros_events (list(str)): list of ROS events to enable :param kernel_events (list(str)): list of kernel events to enable :param context_names (list(str)): list of context elements to enable @@ -21,10 +25,11 @@ def lttng_setup(session_name, path, ros_events=DEFAULT_EVENTS_ROS, kernel_events if ust_enabled: domain_ust = Domain() domain_ust.type = DOMAIN_UST + domain_ust.buf_type = BUFFER_PER_UID channel_ust = Channel() channel_ust.name = 'ros2' channel_ust.attr.overwrite = 0 - channel_ust.attr.subbuf_size = 4096 + channel_ust.attr.subbuf_size = 2*4096 channel_ust.attr.num_subbuf = 8 channel_ust.attr.switch_timer_interval = 0 channel_ust.attr.read_timer_interval = 200 @@ -33,19 +38,19 @@ def lttng_setup(session_name, path, ros_events=DEFAULT_EVENTS_ROS, kernel_events if kernel_enabled: domain_kernel = Domain() domain_kernel.type = DOMAIN_KERNEL + domain_kernel.buf_type = BUFFER_GLOBAL channel_kernel = Channel() channel_kernel.name = 'kchan' - # TODO fix kernel tracing - # channel_kernel.attr.overwrite = 0 - # channel_kernel.attr.subbuf_size = 4096 - # channel_kernel.attr.num_subbuf = 8 - # channel_kernel.attr.switch_timer_interval = 0 - # channel_kernel.attr.read_timer_interval = 200 - # channel_kernel.attr.output = EVENT_MMAP + channel_kernel.attr.overwrite = 0 + channel_kernel.attr.subbuf_size = 8*4096 + channel_kernel.attr.num_subbuf = 8 + channel_kernel.attr.switch_timer_interval = 0 + channel_kernel.attr.read_timer_interval = 200 + channel_kernel.attr.output = EVENT_MMAP events_list_kernel = _create_events(kernel_events) # Session - _create_session(session_name, path) + _create_session(session_name, directory) # Handles, channels, events handle_ust = None @@ -101,17 +106,17 @@ def _create_events(event_names_list): events_list.append(e) return events_list -def _create_session(session_name, path): +def _create_session(session_name, directory): """ - Create session from name and path, and check for errors + Create session from name and directory path, and check for errors """ - result = create(session_name, path) + result = create(session_name, directory) LTTNG_ERR_EXIST_SESS = -28 if result == LTTNG_ERR_EXIST_SESS: # Sessions seem to persist, so if it already exists, # just destroy it and try again lttng_destroy(session_name) - result = create(session_name, path) + result = create(session_name, directory) if result < 0: raise RuntimeError(f'session creation failed: {strerror(result)}') From a577710ef1eede03880947a29844aa698dd60a9f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:24:32 +0200 Subject: [PATCH 15/98] Fix lttng error value --- tracing/lttng.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tracing/lttng.py b/tracing/lttng.py index cda2cf4..b790d5b 100644 --- a/tracing/lttng.py +++ b/tracing/lttng.py @@ -111,8 +111,8 @@ def _create_session(session_name, directory): Create session from name and directory path, and check for errors """ result = create(session_name, directory) - LTTNG_ERR_EXIST_SESS = -28 - if result == LTTNG_ERR_EXIST_SESS: + LTTNG_ERR_EXIST_SESS = 28 + if result == -LTTNG_ERR_EXIST_SESS: # Sessions seem to persist, so if it already exists, # just destroy it and try again lttng_destroy(session_name) From 8a69effded1b47e3167af69083189f0e54f423af Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:24:45 +0200 Subject: [PATCH 16/98] Fix UST events list --- tracing/names.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tracing/names.py b/tracing/names.py index 93f1bab..20e1e27 100644 --- a/tracing/names.py +++ b/tracing/names.py @@ -35,7 +35,7 @@ DEFAULT_EVENTS_KERNEL=[ ] DEFAULT_EVENTS_ROS=[ - 'ros2:rcl_init' + 'ros2:rcl_init', 'ros2:rcl_node_init', 'ros2:rcl_publisher_init', 'ros2:rcl_subscription_init', From b3b70aff858660af3958ddb10b5458f9f9209372 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:25:00 +0200 Subject: [PATCH 17/98] Add new tracepoints to list --- tracing/names.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tracing/names.py b/tracing/names.py index 20e1e27..aec29f6 100644 --- a/tracing/names.py +++ b/tracing/names.py @@ -46,6 +46,12 @@ DEFAULT_EVENTS_ROS=[ 'ros2:rclcpp_service_callback_added', 'ros2:rclcpp_service_callback_start', 'ros2:rclcpp_service_callback_end', + 'ros2:rcl_client_init', + 'ros2:rcl_timer_init', + 'ros2:rclcpp_timer_callback_added', + 'ros2:rclcpp_timer_callback_start', + 'ros2:rclcpp_timer_callback_end', + 'ros2:rclcpp_callback_register', ] DEFAULT_CONTEXT=[ From 6aba4109c334763c73069c2f1eb7c86ece7e02a4 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:25:16 +0200 Subject: [PATCH 18/98] Add start time to basic callback analysis --- analysis/ros_processor.py | 4 ++-- analysis/to_pandas.py | 7 +++++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/analysis/ros_processor.py b/analysis/ros_processor.py index cf69b6f..17e436c 100644 --- a/analysis/ros_processor.py +++ b/analysis/ros_processor.py @@ -22,7 +22,7 @@ class RosProcessor(): # TODO add other stuff # Instances of callback_start for eventual matching self._callback_starts = {} - # Callback instances, callback_address: end - start + # Callback instances, callback_address: (end - start, start) self.callbacks_instances = {} # Link a ROS trace event to its corresponding handling method @@ -72,4 +72,4 @@ class RosProcessor(): 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) + self.callbacks_instances[callback_addr].append((duration, start_timestamp)) diff --git a/analysis/to_pandas.py b/analysis/to_pandas.py index 9806759..2496913 100644 --- a/analysis/to_pandas.py +++ b/analysis/to_pandas.py @@ -6,12 +6,15 @@ 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 d in ros_processor.callbacks_instances[addr]: + for duration, start in ros_processor.callbacks_instances[addr]: callback_addresses.append(addr) - durations.append(d) + durations.append(duration) + start_timestamps.append(start) return pd.DataFrame(data={ 'callback_address': callback_addresses, 'duration': durations, + 'start_timestamp': start_timestamps }) From 17fe8d22453c26dbfb9840776fc744e82c8fbd79 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:28:25 +0200 Subject: [PATCH 19/98] Extract tracetools_trace from tracetools_analysis --- analysis/__init__.py => README.md | 0 analysis/.gitignore | 5 + analysis/Callback_duration.ipynb | 506 ++++++++++++++++++ package.xml | 15 + setup.cfg | 4 + setup.py | 21 + test/test_tracepoints.py | 22 + trace.py | 25 - .../__init__.py | 0 .../analysis}/__init__.py | 0 .../analysis}/lttng_models.py | 0 .../analysis}/ros_processor.py | 0 .../analysis}/to_pandas.py | 0 .../conversion}/__init__.py | 0 .../conversion}/ctf.py | 0 convert.py => tracetools_analysis/convert.py | 0 process.py => tracetools_analysis/process.py | 0 tracetools_analysis/test/__init__.py | 0 tracetools_analysis/test/utils.py | 41 ++ tracetools_analysis/tracing/__init__.py | 0 tracing/lttng.py | 183 ------- tracing/names.py | 64 --- 22 files changed, 614 insertions(+), 272 deletions(-) rename analysis/__init__.py => README.md (100%) create mode 100644 analysis/.gitignore create mode 100644 analysis/Callback_duration.ipynb create mode 100644 package.xml create mode 100644 setup.cfg create mode 100644 setup.py create mode 100644 test/test_tracepoints.py delete mode 100644 trace.py rename __init__.py => tracetools_analysis/__init__.py (100%) rename {conversion => tracetools_analysis/analysis}/__init__.py (100%) rename {analysis => tracetools_analysis/analysis}/lttng_models.py (100%) rename {analysis => tracetools_analysis/analysis}/ros_processor.py (100%) rename {analysis => tracetools_analysis/analysis}/to_pandas.py (100%) rename {tracing => tracetools_analysis/conversion}/__init__.py (100%) rename {conversion => tracetools_analysis/conversion}/ctf.py (100%) rename convert.py => tracetools_analysis/convert.py (100%) rename process.py => tracetools_analysis/process.py (100%) create mode 100644 tracetools_analysis/test/__init__.py create mode 100644 tracetools_analysis/test/utils.py create mode 100644 tracetools_analysis/tracing/__init__.py delete mode 100644 tracing/lttng.py delete mode 100644 tracing/names.py diff --git a/analysis/__init__.py b/README.md similarity index 100% rename from analysis/__init__.py rename to README.md diff --git a/analysis/.gitignore b/analysis/.gitignore new file mode 100644 index 0000000..4254a9f --- /dev/null +++ b/analysis/.gitignore @@ -0,0 +1,5 @@ +*.svg +*.png +*.pdf +.ipynb_checkpoints + diff --git a/analysis/Callback_duration.ipynb b/analysis/Callback_duration.ipynb new file mode 100644 index 0000000..0b0c60a --- /dev/null +++ b/analysis/Callback_duration.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/boc7rng/ros2_ws/src/trace_analysis\n" + ] + } + ], + "source": [ + "cd .." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import pickle\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from tracetools_analysis.analysis.ros_processor import *\n", + "from tracetools_analysis.analysis.to_pandas import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def _get_events_from_pickled_file(file):\n", + " p = pickle.Unpickler(file)\n", + " events = []\n", + " while True:\n", + " try:\n", + " events.append(p.load())\n", + " except EOFError as _:\n", + " break # we're done\n", + " return events" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "imported 538 events\n", + " callback_address duration start_timestamp\n", + "0 93936519421304 46536 1558603909545758681\n", + "1 93936519421304 42644 1558603910045393758\n", + "2 93936519421304 40642 1558603910545455527\n", + "3 93936519421304 34351 1558603911045288748\n", + "4 93936519421304 15474 1558603911545113622\n", + "5 93936519421304 14516 1558603912045117407\n", + "6 93936519421304 15022 1558603912545132769\n", + "7 93936519421304 17849 1558603913045117649\n", + "8 93936519421304 33639 1558603913545454326\n", + "9 93936519421304 38705 1558603914045519078\n", + "10 93936519421304 45665 1558603914545563667\n", + "11 93936519421304 16300 1558603915045232751\n", + "12 93936519421304 44290 1558603915545598209\n", + "13 93936519421304 40953 1558603916045634003\n", + "14 93936519421304 40437 1558603916545775210\n", + "15 93936519421304 43514 1558603917045613746\n", + "16 93936519421304 41327 1558603917545655079\n", + "17 93936519421304 43243 1558603918045657305\n", + "18 93936519421304 45381 1558603918545721344\n", + "19 93936519421304 40894 1558603919045631809\n", + "20 93936519421304 16709 1558603919545352510\n", + "21 93936519421304 44631 1558603920045743330\n", + "22 93936519421304 42671 1558603920545693414\n", + "23 93936519421304 18798 1558603921045399520\n", + "24 93936519421304 50378 1558603921545779682\n", + "25 93936519421304 44826 1558603922045805896\n", + "26 93936519421304 46134 1558603922545824280\n", + "27 93936519421304 44522 1558603923045847831\n", + "28 93936519421304 14270 1558603923545505829\n", + "29 93936519421304 13918 1558603924045491763\n", + "30 93936519421304 14463 1558603924545502429\n", + "31 93936519421304 17682 1558603925045543843\n", + "32 93936519421304 26879 1558603925545708575\n", + "33 93936519421304 36173 1558603926045806943\n", + "34 93936519421304 41533 1558603926546234707\n", + "35 93936519421304 25794 1558603927045722181\n", + "36 93936519421304 45037 1558603927545955253\n", + "37 93936519421304 39921 1558603928046166359\n", + "38 93936519421304 41263 1558603928545970799\n", + "39 93936519421304 73371 1558603929046020303\n", + "40 93936519421304 42534 1558603929545989798\n", + "41 93936519421304 45511 1558603930046115729\n", + "42 93936519421304 46377 1558603930546125475\n", + "43 93936519421304 73247 1558603931046047649\n", + "44 93936519421304 41306 1558603931546089400\n", + "45 93936519421304 39673 1558603932046102715\n", + "46 93936519421304 37308 1558603932546129212\n", + "47 93936519421304 41327 1558603933046090242\n", + "48 93936519421304 49285 1558603933546200982\n", + "49 93936519421304 45726 1558603934046331611\n", + "50 93936519421304 39606 1558603934546343976\n", + "51 93936519421304 40593 1558603935046371735\n", + "52 93936519421304 50519 1558603935546249214\n", + "53 93936519421304 45703 1558603936046224927\n", + "54 93936519421304 50288 1558603936546480484\n", + "55 93936519421304 42308 1558603937046393863\n", + "56 93936519421304 42491 1558603937546330509\n", + "57 93936519421304 43766 1558603938046320731\n", + "58 93936519421304 46444 1558603938546360943\n", + "59 93936519421304 29410 1558603939045959016\n", + "60 93936519421304 44811 1558603939546372225\n", + "61 93936519421304 39708 1558603940046562544\n", + "62 93936519421304 40792 1558603940546413237\n", + "63 93936519421304 37603 1558603941046042702\n", + "64 93936519421304 14451 1558603941545987965\n", + "65 93936519421304 14424 1558603942046011217\n", + "66 93936519421304 15951 1558603942546019131\n", + "67 93936519421304 14792 1558603943046109404\n", + "68 93936519421304 37913 1558603943546418653\n", + "69 93936519421304 38945 1558603944046422260\n", + "70 93936519421304 40952 1558603944546439491\n", + "71 93936519421304 13510 1558603945046148320\n", + "72 93936519421304 41646 1558603945546539773\n", + "73 93936519421304 46602 1558603946046632028\n", + "74 93936519421304 41038 1558603946546731148\n", + "75 93936519421304 41533 1558603947046566829\n", + "76 93936519421304 47418 1558603947546626622\n", + "77 93936519421304 43078 1558603948046636479\n", + "78 93936519421304 43149 1558603948546637906\n", + "79 93936519421304 42481 1558603949046776452\n", + "80 93936519421304 41696 1558603949546662572\n", + "81 93936519421304 41706 1558603950046684020\n", + "82 93936519421304 42198 1558603950546700575\n", + "83 93936519421304 14290 1558603951046342966\n", + "84 93936519421304 42322 1558603951546707586\n", + "85 93936519421304 40280 1558603952046689217\n", + "86 93936519421304 41132 1558603952546782491\n", + "87 93936519421304 42066 1558603953046798531\n", + "88 93936519421304 16504 1558603953546422303\n", + "89 93936519421304 14516 1558603954046442355\n", + "90 93936519421304 15630 1558603954546466966\n", + "91 93936519421304 13527 1558603955046470100\n", + "92 93936519421304 14511 1558603955546440759\n", + "93 93936519421304 39238 1558603956046828345\n", + "94 93936519421304 37940 1558603956546838914\n", + "95 93936519421304 16518 1558603957046547999\n", + "96 93936519421304 41208 1558603957546937736\n", + "97 93936519421304 40373 1558603958046863393\n", + "98 93936519421304 38127 1558603958546940643\n", + "99 93936519421304 38474 1558603959047126679\n", + "100 93936519421304 39139 1558603959547102757\n", + "101 93936519421304 40323 1558603960047126635\n", + "102 93936519421304 16657 1558603960546707945\n", + "103 93936519421304 45127 1558603961046972300\n", + "104 93936519421304 44417 1558603961546999678\n", + "105 93936519421304 21051 1558603962046787412\n", + "106 93936519421304 44299 1558603962547207600\n", + "107 93936519421304 37212 1558603963047074876\n", + "108 93936519421304 38362 1558603963547260043\n", + "109 93936519421304 39245 1558603964047095756\n", + "110 93936519421304 56045 1558603964547178016\n", + "111 93936519421304 40006 1558603965047136559\n", + "112 93936519421304 42538 1558603965547151958\n", + "113 93936519421304 44609 1558603966047224174\n", + "114 93936519421304 48076 1558603966547234849\n", + "115 93936519421304 42164 1558603967047241765\n", + "116 93936519421304 41176 1558603967547208465\n", + "117 93936519421304 38144 1558603968047237382\n", + "118 93936519421304 38317 1558603968547285930\n", + "119 93936519421304 15479 1558603969046950867\n", + "120 93936519421304 41306 1558603969547273142\n", + "121 93936530091544 267148 1558603909546131291\n", + "122 93936530091544 97761 1558603910045737303\n", + "123 93936530091544 97809 1558603910545815399\n", + "124 93936530091544 49725 1558603911045613603\n", + "125 93936530091544 37888 1558603911545265209\n", + "126 93936530091544 43729 1558603912045277690\n", + "127 93936530091544 36926 1558603912545282942\n", + "128 93936530091544 40864 1558603913045265744\n", + "129 93936530091544 93892 1558603913545767273\n", + "130 93936530091544 94766 1558603914045872613\n", + "131 93936530091544 101556 1558603914545936238\n", + "132 93936530091544 42827 1558603915045351368\n", + "133 93936530091544 134027 1558603915545967520\n", + "134 93936530091544 122609 1558603916045996843\n", + "135 93936530091544 101338 1558603916546128266\n", + "136 93936530091544 131591 1558603917045975420\n", + "137 93936530091544 129990 1558603917546013749\n", + "138 93936530091544 125478 1558603918046031894\n", + "139 93936530091544 96406 1558603918546151987\n", + "140 93936530091544 103382 1558603919046145092\n", + "141 93936530091544 34949 1558603919545473258\n", + "142 93936530091544 99755 1558603920046133787\n", + "143 93936530091544 123701 1558603920546032014\n", + "144 93936530091544 43341 1558603921045536148\n", + "145 93936530091544 97141 1558603921546228154\n", + "146 93936530091544 101314 1558603922046213861\n", + "147 93936530091544 100021 1558603922546238339\n", + "148 93936530091544 98485 1558603923046252111\n", + "149 93936530091544 36358 1558603923545664217\n", + "150 93936530091544 37462 1558603924045591481\n", + "151 93936530091544 42755 1558603924545662172\n", + "152 93936530091544 43373 1558603925045696142\n", + "153 93936530091544 66858 1558603925546038168\n", + "154 93936530091544 89301 1558603926046114417\n", + "155 93936530091544 104388 1558603926546593680\n", + "156 93936530091544 37373 1558603927045911557\n", + "157 93936530091544 106532 1558603927546392711\n", + "158 93936530091544 99191 1558603928046493304\n", + "159 93936530091544 100249 1558603928546329764\n", + "160 93936530091544 107166 1558603929046390766\n", + "161 93936530091544 98986 1558603929546398370\n", + "162 93936530091544 105290 1558603930046476694\n", + "163 93936530091544 104391 1558603930546491195\n", + "164 93936530091544 106862 1558603931046423935\n", + "165 93936530091544 105452 1558603931546416605\n", + "166 93936530091544 99013 1558603932046433703\n", + "167 93936530091544 97755 1558603932546508764\n", + "168 93936530091544 101510 1558603933046431141\n", + "169 93936530091544 99555 1558603933546599805\n", + "170 93936530091544 97447 1558603934046668635\n", + "171 93936530091544 98156 1558603934546871368\n", + "172 93936530091544 104431 1558603935046685106\n", + "173 93936530091544 102795 1558603935546701962\n", + "174 93936530091544 105646 1558603936046574872\n", + "175 93936530091544 147913 1558603936547116272\n", + "176 93936530091544 97975 1558603937046858038\n", + "177 93936530091544 103066 1558603937546695510\n", + "178 93936530091544 100997 1558603938046688277\n", + "179 93936530091544 101590 1558603938546729109\n", + "180 93936530091544 37705 1558603939046096405\n", + "181 93936530091544 104430 1558603939546742500\n", + "182 93936530091544 98944 1558603940046883130\n", + "183 93936530091544 99031 1558603940546742462\n", + "184 93936530091544 36906 1558603941046247983\n", + "185 93936530091544 36562 1558603941546110263\n", + "186 93936530091544 37467 1558603942046128766\n", + "187 93936530091544 36573 1558603942546200819\n", + "188 93936530091544 37139 1558603943046214573\n", + "189 93936530091544 85759 1558603943546741660\n", + "190 93936530091544 93728 1558603944046743370\n", + "191 93936530091544 96131 1558603944546769949\n", + "192 93936530091544 45694 1558603945046257326\n", + "193 93936530091544 93356 1558603945546899026\n", + "194 93936530091544 101303 1558603946047006070\n", + "195 93936530091544 100325 1558603946547088327\n", + "196 93936530091544 90855 1558603947046926970\n", + "197 93936530091544 104867 1558603947547066806\n", + "198 93936530091544 96389 1558603948046996616\n", + "199 93936530091544 101290 1558603948547002923\n", + "200 93936530091544 101254 1558603949047181160\n", + "201 93936530091544 92851 1558603949547024820\n", + "202 93936530091544 90349 1558603950047043090\n", + "203 93936530091544 97952 1558603950547065751\n", + "204 93936530091544 37623 1558603951046458270\n", + "205 93936530091544 97369 1558603951547064421\n", + "206 93936530091544 102119 1558603952047018825\n", + "207 93936530091544 106770 1558603952547118839\n", + "208 93936530091544 89877 1558603953047329975\n", + "209 93936530091544 40101 1558603953546550638\n", + "210 93936530091544 38863 1558603954046586791\n", + "211 93936530091544 46395 1558603954546637143\n", + "212 93936530091544 42206 1558603955046616386\n", + "213 93936530091544 38081 1558603955546545943\n", + "214 93936530091544 113429 1558603956047384175\n", + "215 93936530091544 100517 1558603956547168577\n", + "216 93936530091544 42406 1558603957046709710\n", + "217 93936530091544 107518 1558603957547326714\n", + "218 93936530091544 100328 1558603958047195769\n", + "219 93936530091544 99632 1558603958547307010\n", + "220 93936530091544 93084 1558603959047486950\n", + "221 93936530091544 97420 1558603959547460243\n", + "222 93936530091544 99150 1558603960047439190\n", + "223 93936530091544 42406 1558603960546836621\n", + "224 93936530091544 105395 1558603961047340642\n", + "225 93936530091544 102526 1558603961547358252\n", + "226 93936530091544 48036 1558603962047014219\n", + "227 93936530091544 97694 1558603962547597928\n", + "228 93936530091544 101910 1558603963047422808\n", + "229 93936530091544 104184 1558603963547603375\n", + "230 93936530091544 111690 1558603964047431055\n", + "231 93936530091544 107106 1558603964547996969\n", + "232 93936530091544 94686 1558603965047483701\n", + "233 93936530091544 99583 1558603965547498718\n", + "234 93936530091544 92317 1558603966047605233\n", + "235 93936530091544 95488 1558603966547610139\n", + "236 93936530091544 99006 1558603967047605713\n", + "237 93936530091544 96187 1558603967547564817\n", + "238 93936530091544 103197 1558603968047723776\n", + "239 93936530091544 107328 1558603968547614374\n", + "240 93936530091544 42354 1558603969047119328\n", + "241 93936530091544 103100 1558603969547648380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_publisher_init\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_service_init\n", + "unhandled event name: ros2:rclcpp_service_callback_added\n", + "unhandled event name: ros2:rcl_publisher_init\n" + ] + } + ], + "source": [ + "pickle_filename = '../../the-pickle-file'\n", + "with open(pickle_filename, 'rb') as f:\n", + " events = _get_events_from_pickled_file(f)\n", + " print(f'imported {len(events)} events')\n", + " processor = ros_process(events)\n", + "\n", + "df = callback_durations_to_df(processor)\n", + "print(df.to_string())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Get a list of callback addresses\n", + "callback_addresses = set(df['callback_address'])\n", + "# Split df\n", + "durations = {}\n", + "for addr in callback_addresses:\n", + " durations[addr] = df.loc[df.loc[:, 'callback_address'] == addr, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "for addr, duration in durations.items():\n", + " ax = duration.plot(x='start_timestamp', y='duration')\n", + " ax.legend([str(addr)])\n", + " ax.set_xlabel('start timestamp')\n", + " ax.set_ylabel('duration (ns)')\n", + " plt.title('Callback durations over time')\n", + " plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAFRpJREFUeJzt3X+Q3Hd93/HnOxbGjs+xJBtfhezkTFHdOGgQ1o1jQofe4do1iMRuahI7niBTJ5omgdKpmFaUmY6bJlORjknINBNQYoLKEM6OA5UHh4Cr+MrAgEECY9kxRsYjwLIixSALn+OUCN79Yz+XrE+32t273du9zz0fMzf7/X72893v+/vWVy/tffeHIjORJC1/PzToAiRJvWGgS1IlDHRJqoSBLkmVMNAlqRIGuiRVwkDXshQRH4yI31iifd0cEZ9ain1Ji2GgS00iYiwiMiJWzY5l5ocz85pB1iV1wkDXihIRZwy6BqlfDHQtCxHxqoj4UkQ8GxF3AmeV8Vsi4jNz5mZEvLwsfzAifj8i/iwingMmI2JLRHw5Ir4bEd+KiNuaNv90uX0mImYi4tVz9xERPxURX4yIE+X2p5rum46I/xYRny21fioiLuhTW6QXMNA19CLiTOB/Ax8C1gJ/AvzrLh7iF4DfBM4FPgM8B7wZWA1sAX4lIq4vc19bbldn5khmfm5OLWuBe4HfBc4H3gPcGxHnz9nfW4ALgTOBd3RRq7RgBrqWgyuBFwG/k5l/l5l3A1/sYvs9mfnZzPxBZv5tZk5n5oGy/hDwEeCfd/hYW4CDmfmhzDyZmR8Bvgr8dNOcP8rMr2Xm88BdwKYuapUWzEDXcvBS4HC+8JvkvtHF9t9qXomIn4yI+yPiryPiBPBvgU4vi7x0nn1/A1jftP5XTct/A4x0Uau0YAa6loMjwPqIiKaxHy23zwE/PDsYEf9onu3nfqXoHwP3ABdn5nnA+4BoMXeup4AfmzP2o8DhNttJfWegazn4HHAS+HcRsSoifha4otz3FeAnImJTRJwF3NbB450LfCcz/zYirqBxzXvWXwM/AF7WYts/A/5JRPxCqeXngcuAj3d9VFKPGegaepn5PeBngVuA48DPAx8t930N+HXg/wAHabzo2c6vAr8eEc8C/4XGde7Zff0NjRdQPxsRz0TElXNq+TbwRmA78G3gPwJvzMynF3GIUk+E/8GFJNXBZ+iSVAkDXZIqYaBLUiUMdEmqxKr2U3rnggsuyLGxsaXcZUvPPfcc55xzzqDLGCh70GAf7MGsYe3D/v37n87Ml7Sb1zbQI+JS4M6moZfReKvX/yrjY8Ah4Ocy8/jpHmtsbIx9+/a12+WSmJ6eZmJiYtBlDJQ9aLAP9mDWsPYhIjr6ZHTbSy6Z+VhmbsrMTcBmGh9l/hiwA9ibmRuAvWVdkjQg3V5Dvwr4emZ+A7gO2F3GdwPXt9xKktR33Qb6jTS+mQ5gNDOPAJTbC3tZmCSpOx1/UrR8J/VTwE9k5tGIeCYzVzfdfzwz18yz3TZgG8Do6Ojmqamp3lS+SDMzM4yMrOwvwbMHDfbBHswa1j5MTk7uz8zxdvO6eZfL64EvZebRsn40ItZl5pGIWAccm2+jzNwF7AIYHx/PYXnBYVhf/FhK9qDBPtiDWcu9D91ccrmJf7jcAo2vH91alrcCe3pVlCSpex0FekT8MHA15Rvuip3A1RFxsNy3s/flSZI61dEll/KVoufPGfs2jXe9SJKGgB/9l6RKLOlH/9WdsR339vXxt288yS3z7OPQzi193a+k/vAZuiRVwkCXpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEga6JFXCQJekShjoklQJA12SKtFRoEfE6oi4OyK+GhGPRsSrI2JtRNwXEQfL7Zp+FytJaq3TZ+jvBf48M/8p8ErgUWAHsDczNwB7y7okaUDaBnpE/AjwWuAOgMz8XmY+A1wH7C7TdgPX96tISVJ7kZmnnxCxCdgF/CWNZ+f7gbcDhzNzddO845l5ymWXiNgGbAMYHR3dPDU11bvqF2FmZoaRkZFBl3FaBw6f6Ovjj54NR58/dXzj+vP6ut9hsxzOhX6zBw3D2ofJycn9mTnebl4ngT4OfB54TWY+EBHvBb4LvK2TQG82Pj6e+/bt6+gA+m16epqJiYlBl3FaYzvu7evjb994ktsPrDpl/NDOLX3d77BZDudCv9mDhmHtQ0R0FOidXEN/EngyMx8o63cDlwNHI2Jd2dk64NhCi5UkLV7bQM/MvwK+FRGXlqGraFx+uQfYWsa2Anv6UqEkqSOn/r49v7cBH46IM4EngLfQ+Mfgroi4Ffgm8Kb+lChJ6kRHgZ6ZDwLzXb+5qrflSJIWyk+KSlIlDHRJqoSBLkmVMNAlqRIGuiRVwkCXpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEga6JFViVSeTIuIQ8CzwfeBkZo5HxFrgTmAMOAT8XGYe70+ZkqR2unmGPpmZmzJzvKzvAPZm5gZgb1mXJA3IYi65XAfsLsu7gesXX44kaaE6DfQEPhUR+yNiWxkbzcwjAOX2wn4UKEnqTGRm+0kRL83MpyLiQuA+4G3APZm5umnO8cxcM8+224BtAKOjo5unpqZ6VvxizMzMMDIyMugyTuvA4RN9ffzRs+Ho86eOb1x/Xl/3O2yWw7nQb/agYVj7MDk5ub/pcndLHQX6CzaIuA2YAX4ZmMjMIxGxDpjOzEtPt+34+Hju27evq/31y/T0NBMTE4Mu47TGdtzb18ffvvEktx849XXxQzu39HW/w2Y5nAv9Zg8ahrUPEdFRoLe95BIR50TEubPLwDXAw8A9wNYybSuwZ+HlSpIWq5O3LY4CH4uI2fl/nJl/HhFfBO6KiFuBbwJv6l+ZkqR22gZ6Zj4BvHKe8W8DV/WjKElS9/ykqCRVwkCXpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEga6JFXCQJekShjoklQJA12SKmGgS1IlDHRJqkTHgR4RZ0TElyPi42X9koh4ICIORsSdEXFm/8qUJLXTzTP0twOPNq2/G/jtzNwAHAdu7WVhkqTudBToEXERsAX4w7IewOuAu8uU3cD1/ShQktSZyMz2kyLuBv47cC7wDuAW4POZ+fJy/8XAJzLzFfNsuw3YBjA6Orp5amqqZ8UvxszMDCMjI4Mu47QOHD7R18cfPRuOPn/q+Mb15/V1v8NmOZwL/WYPGoa1D5OTk/szc7zdvFXtJkTEG4Fjmbk/IiZmh+eZOu+/DJm5C9gFMD4+nhMTE/NNW3LT09MMSy2t3LLj3r4+/vaNJ7n9wKmnwKGbJ/q632GzHM6FfrMHDcu9D20DHXgN8DMR8QbgLOBHgN8BVkfEqsw8CVwEPNW/MiVJ7bS9hp6Z78zMizJzDLgR+IvMvBm4H7ihTNsK7OlblZKkthbzPvT/BPyHiHgcOB+4ozclSZIWopNLLn8vM6eB6bL8BHBF70uSJC2EnxSVpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEga6JFXCQJekShjoklQJA12SKmGgS1IlDHRJqkTbQI+IsyLiCxHxlYh4JCL+axm/JCIeiIiDEXFnRJzZ/3IlSa108gz9/wGvy8xXApuAayPiSuDdwG9n5gbgOHBr/8qUJLXTNtCzYaasvqj8JPA64O4yvhu4vi8VSpI6EpnZflLEGcB+4OXA7wH/A/h8Zr683H8x8InMfMU8224DtgGMjo5unpqaWlChBw6fWNB2rYyeDUefbz9v4/rzerrfbvT6mOdq1YNBHvMgzMzMMDIyMugyBsoeNAxrHyYnJ/dn5ni7eas6ebDM/D6wKSJWAx8Dfny+aS223QXsAhgfH8+JiYlOdnmKW3bcu6DtWtm+8SS3H2h/+IdunujpfrvR62Oeq1UPBnnMgzA9Pc1Cz8ta2IOG5d6Hrt7lkpnPANPAlcDqiJhNg4uAp3pbmiSpG528y+Ul5Zk5EXE28C+AR4H7gRvKtK3Ann4VKUlqr5NLLuuA3eU6+g8Bd2XmxyPiL4GpiPgN4MvAHX2sU5LURttAz8yHgFfNM/4EcEU/ipIkdc9PikpSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEga6JFXCQJekShjoklQJA12SKmGgS1IlDHRJqoSBLkmVMNAlqRIGuiRVwkCXpEq0DfSIuDgi7o+IRyPikYh4exlfGxH3RcTBcrum/+VKklrp5Bn6SWB7Zv44cCXwaxFxGbAD2JuZG4C9ZV2SNCBtAz0zj2Tml8rys8CjwHrgOmB3mbYbuL5fRUqS2ovM7HxyxBjwaeAVwDczc3XTfccz85TLLhGxDdgGMDo6unlqampBhR44fGJB27UyejYcfb79vI3rz+vpfrvR62Oeq1UPBnnMgzAzM8PIyMigyxgoe9AwrH2YnJzcn5nj7eZ1HOgRMQL8X+A3M/OjEfFMJ4HebHx8PPft29fR/uYa23HvgrZrZfvGk9x+YFXbeYd2bunpfrvR62Oeq1UPBnnMgzA9Pc3ExMSgyxgoe9AwrH2IiI4CvaN3uUTEi4A/BT6cmR8tw0cjYl25fx1wbKHFSpIWr5N3uQRwB/BoZr6n6a57gK1leSuwp/flSZI61f6aA7wG+EXgQEQ8WMb+M7ATuCsibgW+CbypPyVKkjrRNtAz8zNAtLj7qt6WI0laKD8pKkmVMNAlqRIGuiRVopMXRbXC9Pv976ez0t4DL/WSz9AlqRIGuiRVwkCXpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEm0DPSI+EBHHIuLhprG1EXFfRBwst2v6W6YkqZ1OnqF/ELh2ztgOYG9mbgD2lnVJ0gC1DfTM/DTwnTnD1wG7y/Ju4Poe1yVJ6lJkZvtJEWPAxzPzFWX9mcxc3XT/8cyc97JLRGwDtgGMjo5unpqaWlChBw6fWNB2rYyeDUefbz9v4/rzerrfbvT6mOfqtAdLaRD9npmZYWRkZMn3O0zsQcOw9mFycnJ/Zo63m7eq34Vk5i5gF8D4+HhOTEws6HFu6fH/RL9940luP9D+8A/dPNHT/Xaj18c8V6c9WEqD6Pf09DQLPS9rYQ8alnsfFvoul6MRsQ6g3B7rXUmSpIVYaKDfA2wty1uBPb0pR5K0UJ28bfEjwOeASyPiyYi4FdgJXB0RB4Gry7okaYDaXkDNzJta3HVVj2uRJC2CnxSVpEoY6JJUCQNdkiphoEtSJQx0SaqEgS5JlTDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqxHD9dzVa8cb6/L80zWf7xpNMLPlepd7zGbokVcJAl6RKGOiSVAkDXZIqYaBLUiUMdEmqhIEuSZUw0CWpEov6YFFEXAu8FzgD+MPM3NmTqobIID7oIqk/2v193r7xJLf04e/8oZ1bev6Y81nwM/SIOAP4PeD1wGXATRFxWa8KkyR1ZzGXXK4AHs/MJzLze8AUcF1vypIkdSsyc2EbRtwAXJuZv1TWfxH4ycx865x524BtZfVS4LGFl9tTFwBPD7qIAbMHDfbBHswa1j78WGa+pN2kxVxDj3nGTvnXITN3AbsWsZ++iIh9mTk+6DoGyR402Ad7MGu592Exl1yeBC5uWr8IeGpx5UiSFmoxgf5FYENEXBIRZwI3Avf0pixJUrcWfMklM09GxFuBT9J42+IHMvORnlXWf0N3GWgA7EGDfbAHs5Z1Hxb8oqgkabj4SVFJqoSBLkmVWPaBHhGHIuJARDwYEfvK2NqIuC8iDpbbNWU8IuJ3I+LxiHgoIi5vepytZf7BiNjaNL65PP7jZdv53q655CLiAxFxLCIebhrr+3G32scgtOjBbRFxuJwPD0bEG5rue2c5nsci4l82jV9bxh6PiB1N45dExAPlWO8sL/4TES8u64+X+8eW5ohPFREXR8T9EfFoRDwSEW8v4yvtXGjVhxV1PpCZy/oHOARcMGfst4AdZXkH8O6y/AbgEzTeQ38l8EAZXws8UW7XlOU15b4vAK8u23wCeP2gj7nU9VrgcuDhpTzuVvsYoh7cBrxjnrmXAV8BXgxcAnydxov5Z5TllwFnljmXlW3uAm4sy+8DfqUs/yrwvrJ8I3DnAHuwDri8LJ8LfK0c60o7F1r1YWWdD4PacQ//IA9xaqA/Bqxr+oN+rCy/H7hp7jzgJuD9TePvL2PrgK82jb9g3qB/gDFeGGZ9P+5W+xiiHrT6C/xO4J1N658sIfVq4JNz55XwehpYVcb/ft7stmV5VZkXgz4fSj17gKtX4rnQog8r6nxY9pdcaHw69VMRsT8aXzMAMJqZRwDK7YVlfD3wraZtnyxjpxt/cp7xYbUUx91qH8PkreVywgeaLgN024PzgWcy8+Sc8Rc8Vrn/RJk/UOVX/VcBD7CCz4U5fYAVdD7UEOivyczLaXzr469FxGtPM7fV1xV0O77crKTj/n3gHwObgCPA7WW8lz0Yuv5ExAjwp8C/z8zvnm7qPGPVnAvz9GFFnQ/LPtAz86lyewz4GI1vgTwaEesAyu2xMr3V1xWcbvyiecaH1VIcd6t9DIXMPJqZ38/MHwB/QON8gO578DSwOiJWzRl/wWOV+88DvtP7o+lMRLyIRoh9ODM/WoZX3LkwXx9W2vmwrAM9Is6JiHNnl4FrgIdpfAXB7Kv0W2lcT6OMv7m80n8lcKL8qvhJ4JqIWFN+JbuGxvWxI8CzEXFleWX/zU2PNYyW4rhb7WMozAZM8a9onA/QqPvG8o6ES4ANNF7sm/crLLJxQfR+4Iay/dx+zvbgBuAvyvwlV/587gAezcz3NN21os6FVn1YaefDwF+8WMwPjVeiv1J+HgHeVcbPB/YCB8vt2jIeNP5Tjq8DB4Dxpsf6N8Dj5ectTePjNE6CrwP/k+F58esjNH6F/DsazxBuXYrjbrWPIerBh8oxPkTjL9q6pvnvKsfzGE3vVqLxzo+vlfveNef8+kLpzZ8ALy7jZ5X1x8v9LxtgD/4ZjV/vHwIeLD9vWIHnQqs+rKjzwY/+S1IllvUlF0nSPzDQJakSBrokVcJAl6RKGOiSVAkDXZIqYaBLUiX+P1e/rh/H+ayrAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "for addr, duration in durations.items():\n", + " duration.hist(column='duration')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/package.xml b/package.xml new file mode 100644 index 0000000..e9f29b9 --- /dev/null +++ b/package.xml @@ -0,0 +1,15 @@ + + + + tracetools_analysis + 0.1.0 + Tools for analysing trace data + + Ingo Luetkebohle + Ingo Luetkebohle + GPLv3 + + + ament_python + + diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..721ff12 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,4 @@ +[develop] +script-dir=$base/lib/tracetools_analysis +[install] +install-scripts=$base/lib/tracetools_analysis diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..d4b8330 --- /dev/null +++ b/setup.py @@ -0,0 +1,21 @@ +from setuptools import setup + +package_name = 'tracetools_analysis' + +setup( + name=package_name, + version='0.1.0', + packages=[package_name], + data_files=[ + ('share/' + package_name, ['package.xml']), + ], + install_requires=['setuptools'], + keywords=['ROS'], + description='Tools for analysing trace data', + entry_points={ + 'console_scripts': [ + f'convert = {package_name}.convert:main', + f'process = {package_name}.process:main', + ], + }, +) diff --git a/test/test_tracepoints.py b/test/test_tracepoints.py new file mode 100644 index 0000000..f79ac3e --- /dev/null +++ b/test/test_tracepoints.py @@ -0,0 +1,22 @@ +# Test tracetools tracepoints + +import unittest +from tracetools_analysis.test.utils import * + +class TestTracepoints(unittest.TestCase): + + def test_something(self): + self.assertTrue(True) + + def test_publisher_creation(self): + session_name = 'test-session' + path = '/tmp' + package_name = '' + executable_name = '' + run_and_trace(package_name, executable_name, session_name, path) + event_names = get_trace_event_names(f'{path}/{session_name}') + self.assertTrue('ros2:rcl_publisher_init' in event_names) + + +if __name__ == '__main__': + unittest.main() diff --git a/trace.py b/trace.py deleted file mode 100644 index 002c220..0000000 --- a/trace.py +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env python3 -# Entrypoint/script to setup and start an LTTng tracing session -# TODO - -import sys -import time -from tracetools_analysis.tracing.lttng import * - -def main(argv=sys.argv): - if len(argv) != 3: - print("usage: session-name /path") - exit(1) - - session_name = argv[1] - path = argv[2] + '/' + session_name - lttng_setup(session_name, path) - lttng_start(session_name) - print(f'tracing session started: {path}') - - # TODO integrate this with launch + ROS shutdown - input('press enter to stop...') - - print('stopping & destroying tracing session') - lttng_stop(session_name) - lttng_destroy(session_name) diff --git a/__init__.py b/tracetools_analysis/__init__.py similarity index 100% rename from __init__.py rename to tracetools_analysis/__init__.py diff --git a/conversion/__init__.py b/tracetools_analysis/analysis/__init__.py similarity index 100% rename from conversion/__init__.py rename to tracetools_analysis/analysis/__init__.py diff --git a/analysis/lttng_models.py b/tracetools_analysis/analysis/lttng_models.py similarity index 100% rename from analysis/lttng_models.py rename to tracetools_analysis/analysis/lttng_models.py diff --git a/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py similarity index 100% rename from analysis/ros_processor.py rename to tracetools_analysis/analysis/ros_processor.py diff --git a/analysis/to_pandas.py b/tracetools_analysis/analysis/to_pandas.py similarity index 100% rename from analysis/to_pandas.py rename to tracetools_analysis/analysis/to_pandas.py diff --git a/tracing/__init__.py b/tracetools_analysis/conversion/__init__.py similarity index 100% rename from tracing/__init__.py rename to tracetools_analysis/conversion/__init__.py diff --git a/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py similarity index 100% rename from conversion/ctf.py rename to tracetools_analysis/conversion/ctf.py diff --git a/convert.py b/tracetools_analysis/convert.py similarity index 100% rename from convert.py rename to tracetools_analysis/convert.py diff --git a/process.py b/tracetools_analysis/process.py similarity index 100% rename from process.py rename to tracetools_analysis/process.py diff --git a/tracetools_analysis/test/__init__.py b/tracetools_analysis/test/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tracetools_analysis/test/utils.py b/tracetools_analysis/test/utils.py new file mode 100644 index 0000000..fc54e91 --- /dev/null +++ b/tracetools_analysis/test/utils.py @@ -0,0 +1,41 @@ +# Utils for tracetools testing + +import subprocess +import babeltrace +from ..trace import * + +def get_trace_event_names(trace_directory): + """ + Get a set of event names in a trace + :param trace_directory (str): the path to the main/top trace directory + :return: event names (set(str)) + """ + tc = babeltrace.TraceCollection() + tc.add_traces_recursive(trace_directory, 'ctf') + + event_names = set() + + for event in tc.events: + event_names.add(event.name) + + return event_names + + +def run_and_trace(package_name, executable_name, session_name, path): + """ + Setup, start tracing, and run a ROS 2 executable + :param package_name (str): the name of the package + :param executable_name (str): the name of the executable to run + :param session_name (str): the name of the session + :param directory (str): the path of the main directory to write trace data to + """ + # Enable all events + lttng_setup(session_name, path) + lttng_start(session_name) + _run(package_name, executable_name) + lttng_stop(session_name) + lttng_destroy(session_name) + + +def _run(package_name, executable_name): + subprocess.check_call(['ros2', 'run', package_name, executable_name]) diff --git a/tracetools_analysis/tracing/__init__.py b/tracetools_analysis/tracing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tracing/lttng.py b/tracing/lttng.py deleted file mode 100644 index b790d5b..0000000 --- a/tracing/lttng.py +++ /dev/null @@ -1,183 +0,0 @@ -# LTTng tracing interface - -# Temporary workaround -import sys -sys.path = ['/usr/local/lib/python3.6/site-packages'] + sys.path - -from lttng import * -from .names import DEFAULT_EVENTS_ROS, DEFAULT_EVENTS_KERNEL, DEFAULT_CONTEXT - -def lttng_setup(session_name, directory, ros_events=DEFAULT_EVENTS_ROS, kernel_events=DEFAULT_EVENTS_KERNEL, context_names=DEFAULT_CONTEXT): - """ - Setup LTTng session, with events and context - :param session_name (str): the name of the session - :param directory (str): the path of the main directory to write trace data to - :param ros_events (list(str)): list of ROS events to enable - :param kernel_events (list(str)): list of kernel events to enable - :param context_names (list(str)): list of context elements to enable - """ - ust_enabled = ros_events is not None and len(ros_events) > 0 - kernel_enabled = kernel_events is not None and len(kernel_events) > 0 - print(f'UST tracing {f"enabled ({len(ros_events)} events)" if ust_enabled else "disabled"}') - print(f'kernel tracing {f"enabled ({len(kernel_events)} events)" if kernel_enabled else "disabled"}') - - # Domains - if ust_enabled: - domain_ust = Domain() - domain_ust.type = DOMAIN_UST - domain_ust.buf_type = BUFFER_PER_UID - channel_ust = Channel() - channel_ust.name = 'ros2' - channel_ust.attr.overwrite = 0 - channel_ust.attr.subbuf_size = 2*4096 - channel_ust.attr.num_subbuf = 8 - channel_ust.attr.switch_timer_interval = 0 - channel_ust.attr.read_timer_interval = 200 - channel_ust.attr.output = EVENT_MMAP - events_list_ust = _create_events(ros_events) - if kernel_enabled: - domain_kernel = Domain() - domain_kernel.type = DOMAIN_KERNEL - domain_kernel.buf_type = BUFFER_GLOBAL - channel_kernel = Channel() - channel_kernel.name = 'kchan' - channel_kernel.attr.overwrite = 0 - channel_kernel.attr.subbuf_size = 8*4096 - channel_kernel.attr.num_subbuf = 8 - channel_kernel.attr.switch_timer_interval = 0 - channel_kernel.attr.read_timer_interval = 200 - channel_kernel.attr.output = EVENT_MMAP - events_list_kernel = _create_events(kernel_events) - - # Session - _create_session(session_name, directory) - - # Handles, channels, events - handle_ust = None - if ust_enabled: - handle_ust = _create_handle(session_name, domain_ust) - _enable_channel(handle_ust, channel_ust) - _enable_events(handle_ust, events_list_ust, channel_ust.name) - handle_kernel = None - if kernel_enabled: - handle_kernel = _create_handle(session_name, domain_kernel) - _enable_channel(handle_kernel, channel_kernel) - _enable_events(handle_kernel, events_list_kernel, channel_kernel.name) - - # Context - context_list = _create_context_list(context_names) - enabled_handles = [h for h in [handle_ust, handle_kernel] if h is not None] - _add_context(enabled_handles, context_list) - -def lttng_start(session_name): - """ - Start LTTng session, and check for errors - """ - result = start(session_name) - if result < 0: - raise RuntimeError(f'failed to start tracing: {strerror(result)}') - -def lttng_stop(session_name): - """ - Stop LTTng session, and check for errors - """ - result = stop(session_name) - if result < 0: - raise RuntimeError(f'failed to stop tracing: {strerror(result)}') - -def lttng_destroy(session_name): - """ - Destroy LTTng session, and check for errors - """ - result = destroy(session_name) - if result < 0: - raise RuntimeError(f'failed to destroy tracing session: {strerror(result)}') - -def _create_events(event_names_list): - """ - Create events list from names - """ - events_list = [] - for event_name in event_names_list: - e = Event() - e.name = event_name - e.type = EVENT_TRACEPOINT - e.loglevel_type = EVENT_LOGLEVEL_ALL - events_list.append(e) - return events_list - -def _create_session(session_name, directory): - """ - Create session from name and directory path, and check for errors - """ - result = create(session_name, directory) - LTTNG_ERR_EXIST_SESS = 28 - if result == -LTTNG_ERR_EXIST_SESS: - # Sessions seem to persist, so if it already exists, - # just destroy it and try again - lttng_destroy(session_name) - result = create(session_name, directory) - if result < 0: - raise RuntimeError(f'session creation failed: {strerror(result)}') - -def _create_handle(session_name, domain): - """ - Create a handle for a given session name and a domain, and check for errors - """ - handle = None - handle = Handle(session_name, domain) - if handle is None: - raise RuntimeError('handle creation failed') - return handle - -def _enable_channel(handle, channel): - """ - Enable channel for a handle, and check for errors - """ - result = enable_channel(handle, channel) - if result < 0: - raise RuntimeError(f'channel enabling failed: {strerror(result)}') - -def _enable_events(handle, events_list, channel_name): - """ - Enable events list for a given handle and channel name, and check for errors - """ - for event in events_list: - result = enable_event(handle, event, channel_name) - if result < 0: - raise RuntimeError(f'event enabling failed: {strerror(result)}') - -context_map = { - 'procname': EVENT_CONTEXT_PROCNAME, - 'pid': EVENT_CONTEXT_PID, - 'vpid': EVENT_CONTEXT_VPID, - 'vtid': EVENT_CONTEXT_VTID, -} -def _context_name_to_type(context_name): - """ - Convert from context name to LTTng enum/constant type - """ - return context_map.get(context_name) - -def _create_context_list(context_names_list): - """ - Create context list from names, and check for errors - """ - context_list = [] - for c in context_names_list: - ec = EventContext() - context_type = _context_name_to_type(c) - if context_type is not None: - ec.ctx = context_type - context_list.append(ec) - return context_list - -def _add_context(handles, context_list): - """ - Add context list to given handles, and check for errors - """ - for handle in handles: - for contex in context_list: - result = add_context(handle, contex, None, None) - if result < 0: - raise RuntimeError(f'failed to add context: {strerror(result)}') diff --git a/tracing/names.py b/tracing/names.py deleted file mode 100644 index aec29f6..0000000 --- a/tracing/names.py +++ /dev/null @@ -1,64 +0,0 @@ -# Lists of names (events, context) - -DEFAULT_EVENTS_KERNEL=[ - 'block_rq_complete', - 'block_rq_insert', - 'block_rq_issue', - 'block_bio_frontmerge', - 'irq_softirq_entry', - 'irq_softirq_raise' - 'irq_softirq_exit', - 'irq_handler_entry', - 'irq_handler_exit', - 'lttng_statedump_process_state', - 'lttng_statedump_start', - 'lttng_statedump_end', - 'lttng_statedump_network_interface', - 'lttng_statedump_block_device', - 'net_dev_queue', - 'netif_receive_skb', - 'net_if_receive_skb', - 'power_cpu_frequency', - 'sched_switch', - 'sched_waking', - 'sched_pi_setprio', - 'sched_process_fork', - 'sched_process_exit', - 'sched_process_free', - 'sched_wakeup', - 'sched_migrate', - 'sched_migrate_task', - 'timer_hrtimer_start', - 'timer_hrtimer_cancel', - 'timer_hrtimer_expire_entry', - 'timer_hrtimer_expire_exit', -] - -DEFAULT_EVENTS_ROS=[ - 'ros2:rcl_init', - 'ros2:rcl_node_init', - 'ros2:rcl_publisher_init', - 'ros2:rcl_subscription_init', - 'ros2:rclcpp_subscription_callback_added', - 'ros2:rclcpp_subscription_callback_start', - 'ros2:rclcpp_subscription_callback_end', - 'ros2:rcl_service_init', - 'ros2:rclcpp_service_callback_added', - 'ros2:rclcpp_service_callback_start', - 'ros2:rclcpp_service_callback_end', - 'ros2:rcl_client_init', - 'ros2:rcl_timer_init', - 'ros2:rclcpp_timer_callback_added', - 'ros2:rclcpp_timer_callback_start', - 'ros2:rclcpp_timer_callback_end', - 'ros2:rclcpp_callback_register', -] - -DEFAULT_CONTEXT=[ - 'procname', - 'perf:thread:instructions', - 'perf:thread:cycles', - 'perf:thread:cpu-cycles', - 'vpid', - 'vtid', -] From 8c664e1bc0959b692f1fe472c2d6f2dd8e253070 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:28:48 +0200 Subject: [PATCH 20/98] Add note about babeltrace dependency --- package.xml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/package.xml b/package.xml index e9f29b9..c52e341 100644 --- a/package.xml +++ b/package.xml @@ -9,6 +9,8 @@ Ingo Luetkebohle GPLv3 + + ament_python From 87c4a46eae4712e4809cb1ccb0b33231aa523b01 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:31:41 +0200 Subject: [PATCH 21/98] Remove run function --- tracetools_analysis/test/utils.py | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/tracetools_analysis/test/utils.py b/tracetools_analysis/test/utils.py index fc54e91..5e04eb9 100644 --- a/tracetools_analysis/test/utils.py +++ b/tracetools_analysis/test/utils.py @@ -19,23 +19,3 @@ def get_trace_event_names(trace_directory): event_names.add(event.name) return event_names - - -def run_and_trace(package_name, executable_name, session_name, path): - """ - Setup, start tracing, and run a ROS 2 executable - :param package_name (str): the name of the package - :param executable_name (str): the name of the executable to run - :param session_name (str): the name of the session - :param directory (str): the path of the main directory to write trace data to - """ - # Enable all events - lttng_setup(session_name, path) - lttng_start(session_name) - _run(package_name, executable_name) - lttng_stop(session_name) - lttng_destroy(session_name) - - -def _run(package_name, executable_name): - subprocess.check_call(['ros2', 'run', package_name, executable_name]) From 574a78627e725593071fb7bc410457a6965592f9 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:32:02 +0200 Subject: [PATCH 22/98] Remove test file --- test/test_tracepoints.py | 22 ---------------------- 1 file changed, 22 deletions(-) delete mode 100644 test/test_tracepoints.py diff --git a/test/test_tracepoints.py b/test/test_tracepoints.py deleted file mode 100644 index f79ac3e..0000000 --- a/test/test_tracepoints.py +++ /dev/null @@ -1,22 +0,0 @@ -# Test tracetools tracepoints - -import unittest -from tracetools_analysis.test.utils import * - -class TestTracepoints(unittest.TestCase): - - def test_something(self): - self.assertTrue(True) - - def test_publisher_creation(self): - session_name = 'test-session' - path = '/tmp' - package_name = '' - executable_name = '' - run_and_trace(package_name, executable_name, session_name, path) - event_names = get_trace_event_names(f'{path}/{session_name}') - self.assertTrue('ros2:rcl_publisher_init' in event_names) - - -if __name__ == '__main__': - unittest.main() From 02a18d10d2ee46151fed55db7331295a636b3cbb Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:32:16 +0200 Subject: [PATCH 23/98] Remove forgotten tracing submodule directory --- tracetools_analysis/tracing/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 tracetools_analysis/tracing/__init__.py diff --git a/tracetools_analysis/tracing/__init__.py b/tracetools_analysis/tracing/__init__.py deleted file mode 100644 index e69de29..0000000 From 7fd90243a55cd50316ff1a8e6cfcd2d3ba86eda0 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:32:40 +0200 Subject: [PATCH 24/98] Add link to rosdep index --- package.xml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/package.xml b/package.xml index c52e341..a5cff84 100644 --- a/package.xml +++ b/package.xml @@ -9,7 +9,9 @@ Ingo Luetkebohle GPLv3 - + ament_python From 7c50f8e333db5516c23ebd007b00006178ac3ca6 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:33:00 +0200 Subject: [PATCH 25/98] Remove import of deleted file --- tracetools_analysis/test/utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tracetools_analysis/test/utils.py b/tracetools_analysis/test/utils.py index 5e04eb9..8b1bb96 100644 --- a/tracetools_analysis/test/utils.py +++ b/tracetools_analysis/test/utils.py @@ -2,7 +2,6 @@ import subprocess import babeltrace -from ..trace import * def get_trace_event_names(trace_directory): """ From 15a209bbab4a18381db02018ec1a728ab837d67d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:35:51 +0200 Subject: [PATCH 26/98] Remove test submodule, move to tracetools_test --- tracetools_analysis/test/__init__.py | 0 tracetools_analysis/test/utils.py | 20 -------------------- 2 files changed, 20 deletions(-) delete mode 100644 tracetools_analysis/test/__init__.py delete mode 100644 tracetools_analysis/test/utils.py diff --git a/tracetools_analysis/test/__init__.py b/tracetools_analysis/test/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tracetools_analysis/test/utils.py b/tracetools_analysis/test/utils.py deleted file mode 100644 index 8b1bb96..0000000 --- a/tracetools_analysis/test/utils.py +++ /dev/null @@ -1,20 +0,0 @@ -# Utils for tracetools testing - -import subprocess -import babeltrace - -def get_trace_event_names(trace_directory): - """ - Get a set of event names in a trace - :param trace_directory (str): the path to the main/top trace directory - :return: event names (set(str)) - """ - tc = babeltrace.TraceCollection() - tc.add_traces_recursive(trace_directory, 'ctf') - - event_names = set() - - for event in tc.events: - event_names.add(event.name) - - return event_names From f0bbf76d2133b73a1caa877009ea7b1d3d6ca5fc Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:36:53 +0200 Subject: [PATCH 27/98] Setup tests for *analysis and *trace packages --- package.xml | 5 +++++ setup.py | 4 +++- test/test_copyright.py | 23 +++++++++++++++++++++++ test/test_flake8.py | 23 +++++++++++++++++++++++ test/test_pep257.py | 23 +++++++++++++++++++++++ 5 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 test/test_copyright.py create mode 100644 test/test_flake8.py create mode 100644 test/test_pep257.py diff --git a/package.xml b/package.xml index a5cff84..f026cab 100644 --- a/package.xml +++ b/package.xml @@ -13,6 +13,11 @@ https://github.com/ros/rosdistro/blob/master/rosdep/python.yaml --> + ament_copyright + ament_flake8 + ament_pep257 + python3-pytest + ament_python diff --git a/setup.py b/setup.py index d4b8330..eab091c 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +from setuptools import find_packages from setuptools import setup package_name = 'tracetools_analysis' @@ -5,7 +6,7 @@ package_name = 'tracetools_analysis' setup( name=package_name, version='0.1.0', - packages=[package_name], + packages=find_packages(exclude=['test']), data_files=[ ('share/' + package_name, ['package.xml']), ], @@ -18,4 +19,5 @@ setup( f'process = {package_name}.process:main', ], }, + tests_require=['pytest'], ) diff --git a/test/test_copyright.py b/test/test_copyright.py new file mode 100644 index 0000000..cf0fae3 --- /dev/null +++ b/test/test_copyright.py @@ -0,0 +1,23 @@ +# Copyright 2017 Open Source Robotics Foundation, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from ament_copyright.main import main +import pytest + + +@pytest.mark.copyright +@pytest.mark.linter +def test_copyright(): + rc = main(argv=['.', 'test']) + assert rc == 0, 'Found errors' diff --git a/test/test_flake8.py b/test/test_flake8.py new file mode 100644 index 0000000..eff8299 --- /dev/null +++ b/test/test_flake8.py @@ -0,0 +1,23 @@ +# Copyright 2017 Open Source Robotics Foundation, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from ament_flake8.main import main +import pytest + + +@pytest.mark.flake8 +@pytest.mark.linter +def test_flake8(): + rc = main(argv=[]) + assert rc == 0, 'Found errors' diff --git a/test/test_pep257.py b/test/test_pep257.py new file mode 100644 index 0000000..3aeb4d3 --- /dev/null +++ b/test/test_pep257.py @@ -0,0 +1,23 @@ +# Copyright 2015 Open Source Robotics Foundation, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from ament_pep257.main import main +import pytest + + +@pytest.mark.linter +@pytest.mark.pep257 +def test_pep257(): + rc = main(argv=[]) + assert rc == 0, 'Found code style errors / warnings' From 30fb7dd8f10bab31dea047b47f9c2fbaaab3adba Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:37:08 +0200 Subject: [PATCH 28/98] Add an exec_depend on python3-babeltrace for *analysis --- package.xml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/package.xml b/package.xml index f026cab..142f3fb 100644 --- a/package.xml +++ b/package.xml @@ -9,9 +9,7 @@ Ingo Luetkebohle GPLv3 - + python3-babeltrace ament_copyright ament_flake8 From 650f7cee376822a0ef8604d353458bf623f35d3f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:37:20 +0200 Subject: [PATCH 29/98] Fix authors/maintainer --- package.xml | 4 ++-- setup.py | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/package.xml b/package.xml index 142f3fb..6d0a77c 100644 --- a/package.xml +++ b/package.xml @@ -4,9 +4,9 @@ tracetools_analysis 0.1.0 Tools for analysing trace data - - Ingo Luetkebohle + Christophe Bedard Ingo Luetkebohle + Christophe Bedard GPLv3 python3-babeltrace diff --git a/setup.py b/setup.py index eab091c..c26bf08 100644 --- a/setup.py +++ b/setup.py @@ -11,6 +11,13 @@ setup( ('share/' + package_name, ['package.xml']), ], install_requires=['setuptools'], + maintainer='Christophe Bedard', + maintainer_email='fixed-term.christophe.bourquebedard@de.bosch.com', + author='Ingo Luetkebohle', + author_email='ingo.luetkebohle@de.bosch.com', + author='Christophe Bedard', + author_email='fixed-term.christophe.bourquebedard@de.bosch.com', + # url='', keywords=['ROS'], description='Tools for analysing trace data', entry_points={ From 205850e0d1b0946b6b7e17c17297b92c7fc1532c Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:37:37 +0200 Subject: [PATCH 30/98] Fix version numbers --- package.xml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/package.xml b/package.xml index 6d0a77c..cdfdf9d 100644 --- a/package.xml +++ b/package.xml @@ -2,7 +2,7 @@ tracetools_analysis - 0.1.0 + 0.0.1 Tools for analysing trace data Christophe Bedard Ingo Luetkebohle diff --git a/setup.py b/setup.py index c26bf08..5fcdad5 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ package_name = 'tracetools_analysis' setup( name=package_name, - version='0.1.0', + version='0.0.1', packages=find_packages(exclude=['test']), data_files=[ ('share/' + package_name, ['package.xml']), From f6b5aaf95cba827d2cbe99c605a1a020706b7527 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:38:45 +0200 Subject: [PATCH 31/98] Fix double author= --- setup.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 5fcdad5..747b42c 100644 --- a/setup.py +++ b/setup.py @@ -13,10 +13,8 @@ setup( install_requires=['setuptools'], maintainer='Christophe Bedard', maintainer_email='fixed-term.christophe.bourquebedard@de.bosch.com', - author='Ingo Luetkebohle', - author_email='ingo.luetkebohle@de.bosch.com', - author='Christophe Bedard', - author_email='fixed-term.christophe.bourquebedard@de.bosch.com', + author='Ingo Luetkebohle, Christophe Bedard', + author_email='ingo.luetkebohle@de.bosch.com, fixed-term.christophe.bourquebedard@de.bosch.com', # url='', keywords=['ROS'], description='Tools for analysing trace data', From 475dbbd1073c948f3f8c8721cc00599d7626058a Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:39:14 +0200 Subject: [PATCH 32/98] Move tag to fix lint error --- package.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.xml b/package.xml index cdfdf9d..c100a91 100644 --- a/package.xml +++ b/package.xml @@ -5,9 +5,9 @@ 0.0.1 Tools for analysing trace data Christophe Bedard + GPLv3 Ingo Luetkebohle Christophe Bedard - GPLv3 python3-babeltrace From 9b36c1513c68d7160f1cafe608ceb8532e7b51b8 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:46:18 +0200 Subject: [PATCH 33/98] Fix lint errors --- tracetools_analysis/analysis/ros_processor.py | 10 ++++++++-- tracetools_analysis/conversion/ctf.py | 4 +++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index 17e436c..601b2da 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -3,9 +3,11 @@ import sys from .lttng_models import EventMetadata, get_field, get_name + def ros_process(events): """ - Process unpickled events and create ROS model + Process unpickled events and create ROS model. + :param events (list(dict(str:str:))): the list of events :return the processor object """ @@ -13,11 +15,14 @@ def ros_process(events): 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 @@ -35,7 +40,8 @@ class RosProcessor(): def process_events(self, events): """ - Process events + Process events. + :param events (list(dict(str:str))): the events to process """ for event in events: diff --git a/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py index 362d019..fd4c28f 100644 --- a/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/conversion/ctf.py @@ -13,7 +13,8 @@ _DISCARD = 'events_discarded' def ctf_to_pickle(trace_directory, target): """ - Load CTF trace and convert to a pickle file + Load CTF trace and convert to a pickle file. + :param trace_directory (str): the main/top trace directory :param target (Pickler): the target pickle file to write to """ @@ -50,6 +51,7 @@ def ctf_to_pickle(trace_directory, target): def _ctf_event_to_pod(ctf_event): """ Convert name, timestamp, and all other keys except those in IGNORED_FIELDS into a dictionary. + :param ctf_element: The element to convert :type ctf_element: babeltrace.Element :return: From d2c31e7de7ae3f282da7108c900dce8902def409 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 6 Jun 2019 09:55:55 +0200 Subject: [PATCH 34/98] Mark license as TODO --- package.xml | 2 +- setup.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/package.xml b/package.xml index c100a91..a23316a 100644 --- a/package.xml +++ b/package.xml @@ -5,7 +5,7 @@ 0.0.1 Tools for analysing trace data Christophe Bedard - GPLv3 + TODO Ingo Luetkebohle Christophe Bedard diff --git a/setup.py b/setup.py index 747b42c..570e7cc 100644 --- a/setup.py +++ b/setup.py @@ -24,5 +24,6 @@ setup( f'process = {package_name}.process:main', ], }, + license='TODO', tests_require=['pytest'], ) From 2450c7bd24cf703b58c78a700a8ddfd3fd28864f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 10:32:00 +0200 Subject: [PATCH 35/98] Add .gitignore for tracetools_analysis --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..eef29c1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*~ +*.pyc + From 699347e4616515bec3d596fc30e314a5c95f38e6 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 10:42:40 +0200 Subject: [PATCH 36/98] Simplify imports --- tracetools_analysis/convert.py | 4 ++-- tracetools_analysis/process.py | 7 +++---- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index 3a41428..049bd16 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -4,7 +4,7 @@ import sys from pickle import Pickler -from tracetools_analysis.conversion.ctf import * +from tracetools_analysis.conversion import ctf def main(argv=sys.argv): if len(argv) != 3: @@ -16,4 +16,4 @@ def main(argv=sys.argv): with open(pickle_target_file, 'wb') as f: p = Pickler(f, protocol=4) - ctf_to_pickle(trace_directory, p) + ctf.ctf_to_pickle(trace_directory, p) diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 76d04a5..546c1ec 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -4,8 +4,7 @@ import sys import pickle import pandas as pd -from tracetools_analysis.analysis.ros_processor import * -from tracetools_analysis.analysis.to_pandas import * +from tracetools_analysis.analysis import ros_processor, to_pandas def main(argv=sys.argv): if len(argv) != 2: @@ -16,9 +15,9 @@ def main(argv=sys.argv): with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) print(f'imported {len(events)} events') - processor = ros_process(events) + processor = ros_processor.ros_process(events) - df = callback_durations_to_df(processor) + df = to_pandas.callback_durations_to_df(processor) print(df.to_string()) From c98d525d4b5cd968fec1b260b2539bb10ff8b0c1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 10:57:28 +0200 Subject: [PATCH 37/98] Extract EventHandler class --- tracetools_analysis/analysis/handler.py | 42 +++++++++++++++++++ tracetools_analysis/analysis/ros_processor.py | 28 ++----------- 2 files changed, 45 insertions(+), 25 deletions(-) create mode 100644 tracetools_analysis/analysis/handler.py diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py new file mode 100644 index 0000000..4b5412d --- /dev/null +++ b/tracetools_analysis/analysis/handler.py @@ -0,0 +1,42 @@ +# Event handler + +import sys +from . import lttng_models + + +class EventHandler(): + """Base event handling class.""" + + def __init__(self, handler_map): + """ + Constructor. + + :param handler_map (map(str: function)): the mapping from event name to handling method + """ + self._handler_map = handler_map + + def process_events(self, events): + """ + Process events by calling their handlers. + + :param events (list(dict(str:str))): the events to process + """ + for event in events: + self._handle(event) + + def _handle(self, event): + event_name = lttng_models.get_name(event) + handler_function = self._handler_map.get(event_name, None) + if handler_function is not None: + pid = lttng_models.get_field(event, + 'vpid', + default=lttng_models.get_field(event, 'pid')) + tid = lttng_models.get_field(event, + 'vtid', + default=lttng_models.get_field(event, 'tid')) + timestamp = lttng_models.get_field(event, '_timestamp') + procname = lttng_models.get_field(event, 'procname') + metadata = lttng_models.EventMetadata(event_name, pid, tid, timestamp, procname) + handler_function(event, metadata) + else: + print(f'unhandled event name: {event_name}', file=sys.stderr) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index 601b2da..abfe5bc 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -1,8 +1,8 @@ # Process trace events and create ROS model import sys -from .lttng_models import EventMetadata, get_field, get_name - +from .lttng_models import get_field +from .handler import EventHandler def ros_process(events): """ @@ -16,7 +16,7 @@ def ros_process(events): return processor -class RosProcessor(): +class RosProcessor(EventHandler): """ ROS-aware event processing/handling class. @@ -38,28 +38,6 @@ class RosProcessor(): '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 From e5b8d1782f46dca1e04c3440c74e6158a1dcb385 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:05:20 +0200 Subject: [PATCH 38/98] Fix lint errors in tracetools_analysis --- tracetools_analysis/analysis/handler.py | 1 + tracetools_analysis/analysis/lttng_models.py | 4 ++++ tracetools_analysis/analysis/ros_processor.py | 4 ++-- tracetools_analysis/analysis/to_pandas.py | 2 +- tracetools_analysis/conversion/ctf.py | 5 +++-- tracetools_analysis/convert.py | 6 ++++-- tracetools_analysis/process.py | 9 +++++---- 7 files changed, 20 insertions(+), 11 deletions(-) diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py index 4b5412d..1308d1e 100644 --- a/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/analysis/handler.py @@ -1,6 +1,7 @@ # Event handler import sys + from . import lttng_models diff --git a/tracetools_analysis/analysis/lttng_models.py b/tracetools_analysis/analysis/lttng_models.py index 88f7e01..d0cb096 100644 --- a/tracetools_analysis/analysis/lttng_models.py +++ b/tracetools_analysis/analysis/lttng_models.py @@ -1,13 +1,17 @@ # 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(): + """Container for event metadata.""" + def __init__(self, event_name, pid, tid, timestamp, procname): self._event_name = event_name self._pid = pid diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index abfe5bc..7c75e37 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -1,8 +1,8 @@ # Process trace events and create ROS model -import sys -from .lttng_models import get_field from .handler import EventHandler +from .lttng_models import get_field + def ros_process(events): """ diff --git a/tracetools_analysis/analysis/to_pandas.py b/tracetools_analysis/analysis/to_pandas.py index 2496913..cbdb224 100644 --- a/tracetools_analysis/analysis/to_pandas.py +++ b/tracetools_analysis/analysis/to_pandas.py @@ -1,7 +1,7 @@ # Convert processor object to pandas dataframe import pandas as pd -from .ros_processor import RosProcessor + def callback_durations_to_df(ros_processor): callback_addresses = [] diff --git a/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py index fd4c28f..741e21c 100644 --- a/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/conversion/ctf.py @@ -1,9 +1,9 @@ # CTF to pickle conversion -import babeltrace -from pickle import Pickler import time +import babeltrace + # List of ignored CTF fields _IGNORED_FIELDS = [ 'content_size', 'cpu_id', 'events_discarded', 'id', 'packet_size', 'packet_seq_num', @@ -11,6 +11,7 @@ _IGNORED_FIELDS = [ ] _DISCARD = 'events_discarded' + def ctf_to_pickle(trace_directory, target): """ Load CTF trace and convert to a pickle file. diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index 049bd16..d3539cc 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -2,13 +2,15 @@ # Entrypoint/script to convert CTF trace data to a pickle file # TODO -import sys from pickle import Pickler +import sys + from tracetools_analysis.conversion import ctf + def main(argv=sys.argv): if len(argv) != 3: - print("usage: /trace/directory pickle_target_file") + print('usage: /trace/directory pickle_target_file') exit(1) trace_directory = sys.argv[1] diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 546c1ec..6335e53 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -1,16 +1,17 @@ #!/usr/bin/env python3 # Entrypoint/script to process events from a pickle file to build a ROS model -import sys import pickle -import pandas as pd +import sys + from tracetools_analysis.analysis import ros_processor, to_pandas + def main(argv=sys.argv): if len(argv) != 2: print('usage: pickle_file') exit(1) - + pickle_filename = sys.argv[1] with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) @@ -27,6 +28,6 @@ def _get_events_from_pickled_file(file): while True: try: events.append(p.load()) - except EOFError as _: + except EOFError: break # we're done return events From 3ea4a1c5bb5c6a37ea3917d3ad00fa4506bfca7e Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:25:32 +0200 Subject: [PATCH 39/98] Use argparse for tracetools_analysis entrypoints --- tracetools_analysis/convert.py | 17 ++++++++++------- tracetools_analysis/process.py | 13 +++++++------ 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index d3539cc..e246b7c 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -2,19 +2,22 @@ # Entrypoint/script to convert CTF trace data to a pickle file # TODO +import argparse from pickle import Pickler -import sys from tracetools_analysis.conversion import ctf -def main(argv=sys.argv): - if len(argv) != 3: - print('usage: /trace/directory pickle_target_file') - exit(1) +def main(): + parser = argparse.ArgumentParser(description='Convert CTF trace data to a pickle file.') + parser.add_argument('trace_directory', + help='the path to the main CTF trace directory') + parser.add_argument('pickle_file', + help='the target pickle file to generate') + args = parser.parse_args() - trace_directory = sys.argv[1] - pickle_target_file = sys.argv[2] + trace_directory = args.trace_directory + pickle_target_file = args.pickle_file with open(pickle_target_file, 'wb') as f: p = Pickler(f, protocol=4) diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 6335e53..5942da4 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -1,18 +1,19 @@ #!/usr/bin/env python3 # Entrypoint/script to process events from a pickle file to build a ROS model +import argparse import pickle -import sys from tracetools_analysis.analysis import ros_processor, to_pandas -def main(argv=sys.argv): - if len(argv) != 2: - print('usage: pickle_file') - exit(1) +def main(): + 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') + args = parser.parse_args() - pickle_filename = sys.argv[1] + pickle_filename = args.pickle_file with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) print(f'imported {len(events)} events') From 0a04d24fd43929d5ec42c5334625a88952a2813c Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:28:09 +0200 Subject: [PATCH 40/98] Extract parse_args methods --- tracetools_analysis/convert.py | 8 ++++++-- tracetools_analysis/process.py | 8 ++++++-- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index e246b7c..20ef8a2 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -8,13 +8,17 @@ from pickle import Pickler from tracetools_analysis.conversion import ctf -def main(): +def parse_args(): parser = argparse.ArgumentParser(description='Convert CTF trace data to a pickle file.') parser.add_argument('trace_directory', help='the path to the main CTF trace directory') parser.add_argument('pickle_file', help='the target pickle file to generate') - args = parser.parse_args() + return parser.parse_args() + + +def main(): + args = parse_args() trace_directory = args.trace_directory pickle_target_file = args.pickle_file diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 5942da4..011488c 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -7,11 +7,15 @@ import pickle from tracetools_analysis.analysis import ros_processor, to_pandas -def main(): +def parse_args(): 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') - args = parser.parse_args() + return parser.parse_args() + + +def main(): + args = parse_args() pickle_filename = args.pickle_file with open(pickle_filename, 'rb') as f: From 637f85e167879d51890ab655cf61932e76d78219 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:28:34 +0200 Subject: [PATCH 41/98] Remove TODO --- tracetools_analysis/convert.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index 20ef8a2..1cd1a5c 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -1,6 +1,5 @@ #!/usr/bin/env python3 # Entrypoint/script to convert CTF trace data to a pickle file -# TODO import argparse from pickle import Pickler From 18616c05e639152eccf8284c44a1f34bd1e58213 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:47:41 +0200 Subject: [PATCH 42/98] Call super() for real --- tracetools_analysis/analysis/ros_processor.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index 7c75e37..df55715 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -18,25 +18,26 @@ def ros_process(events): class RosProcessor(EventHandler): """ - ROS-aware event processing/handling class. + ROS-aware event processing/handling class implementation. 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 = { + 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, } + super().__init__(handler_map) + + # TODO add other stuff + # Instances of callback_start for eventual matching + self._callback_starts = {} + # Callback instances, callback_address: (end - start, start) + self.callbacks_instances = {} def _handle_subscription_init(self, event, metadata): # TODO From 7adcba91eef9bec49270f58f846d6c7d8d346612 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 11:59:16 +0200 Subject: [PATCH 43/98] Add handling methods for other events --- tracetools_analysis/analysis/ros_processor.py | 77 +++++++++++++++++-- 1 file changed, 71 insertions(+), 6 deletions(-) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index df55715..829b9fc 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -26,10 +26,23 @@ class RosProcessor(EventHandler): def __init__(self): # Link a ROS trace event to its corresponding handling method handler_map = { + 'ros2:rcl_init': self._handle_rcl_init, + 'ros2:rcl_node_init': self._handle_rcl_node_init, + 'ros2:rcl_publisher_init': self._handle_rcl_publisher_init, '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, + 'ros2:rclcpp_subscription_callback_added': self._handle_rclcpp_subscription_callback_added, + 'ros2:rclcpp_subscription_callback_start': self._handle_rclcpp_subscription_callback_start, + 'ros2:rclcpp_subscription_callback_end': self._handle_rclcpp_subscription_callback_end, + 'ros2:rcl_service_init': self._handle_rcl_service_init, + 'ros2:rclcpp_service_callback_added': self._handle_rclcpp_service_callback_added, + 'ros2:rclcpp_service_callback_start': self._handle_rclcpp_service_callback_start, + 'ros2:rclcpp_service_callback_end': self._handle_rclcpp_service_callback_end, + 'ros2:rcl_client_init': self._handle_rcl_client_init, + 'ros2:rcl_timer_init': self._handle_rcl_timer_init, + 'ros2:rclcpp_timer_callback_added': self._handle_rclcpp_timer_callback_added, + 'ros2:rclcpp_timer_callback_start': self._handle_rclcpp_timer_callback_start, + 'ros2:rclcpp_timer_callback_end': self._handle_rclcpp_timer_callback_end, + 'ros2:rclcpp_callback_register': self._handle_rclcpp_callback_register, } super().__init__(handler_map) @@ -39,22 +52,74 @@ class RosProcessor(EventHandler): # Callback instances, callback_address: (end - start, start) self.callbacks_instances = {} + def _handle_rcl_init(self, event, metadata): + # TODO + pass + + def _handle_rcl_node_init(self, event, metadata): + # TODO + pass + + def _handle_rcl_publisher_init(self, event, metadata): + # TODO + pass + def _handle_subscription_init(self, event, metadata): # TODO pass - def _handle_subscription_callback_added(self, event, metadata): + def _handle_rclcpp_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): + def _handle_rclcpp_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): + def _handle_rclcpp_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)) + + def _handle_rcl_service_init(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_service_callback_added(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_service_callback_start(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_service_callback_end(self, event, metadata): + # TODO + pass + + def _handle_rcl_client_init(self, event, metadata): + # TODO + pass + + def _handle_rcl_timer_init(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_timer_callback_added(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_timer_callback_start(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_timer_callback_end(self, event, metadata): + # TODO + pass + + def _handle_rclcpp_callback_register(self, event, metadata): + # TODO + pass From a6946e264213752f02ccdc5c540ede327eb2507f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 12:02:03 +0200 Subject: [PATCH 44/98] Remove whitespace --- tracetools_analysis/analysis/ros_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index 829b9fc..c0c5b62 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -55,11 +55,11 @@ class RosProcessor(EventHandler): def _handle_rcl_init(self, event, metadata): # TODO pass - + def _handle_rcl_node_init(self, event, metadata): # TODO pass - + def _handle_rcl_publisher_init(self, event, metadata): # TODO pass From f5f3bfac5fa411c1e2a65f0f8e7e7d05937c70d8 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 12:57:32 +0200 Subject: [PATCH 45/98] Split lines --- tracetools_analysis/analysis/ros_processor.py | 51 ++++++++++++------- 1 file changed, 34 insertions(+), 17 deletions(-) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index c0c5b62..430f6ac 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -26,23 +26,40 @@ class RosProcessor(EventHandler): def __init__(self): # Link a ROS trace event to its corresponding handling method handler_map = { - 'ros2:rcl_init': self._handle_rcl_init, - 'ros2:rcl_node_init': self._handle_rcl_node_init, - 'ros2:rcl_publisher_init': self._handle_rcl_publisher_init, - 'ros2:rcl_subscription_init': self._handle_subscription_init, - 'ros2:rclcpp_subscription_callback_added': self._handle_rclcpp_subscription_callback_added, - 'ros2:rclcpp_subscription_callback_start': self._handle_rclcpp_subscription_callback_start, - 'ros2:rclcpp_subscription_callback_end': self._handle_rclcpp_subscription_callback_end, - 'ros2:rcl_service_init': self._handle_rcl_service_init, - 'ros2:rclcpp_service_callback_added': self._handle_rclcpp_service_callback_added, - 'ros2:rclcpp_service_callback_start': self._handle_rclcpp_service_callback_start, - 'ros2:rclcpp_service_callback_end': self._handle_rclcpp_service_callback_end, - 'ros2:rcl_client_init': self._handle_rcl_client_init, - 'ros2:rcl_timer_init': self._handle_rcl_timer_init, - 'ros2:rclcpp_timer_callback_added': self._handle_rclcpp_timer_callback_added, - 'ros2:rclcpp_timer_callback_start': self._handle_rclcpp_timer_callback_start, - 'ros2:rclcpp_timer_callback_end': self._handle_rclcpp_timer_callback_end, - 'ros2:rclcpp_callback_register': self._handle_rclcpp_callback_register, + 'ros2:rcl_init': + self._handle_rcl_init, + 'ros2:rcl_node_init': + self._handle_rcl_node_init, + 'ros2:rcl_publisher_init': + self._handle_rcl_publisher_init, + 'ros2:rcl_subscription_init': + self._handle_subscription_init, + 'ros2:rclcpp_subscription_callback_added': + self._handle_rclcpp_subscription_callback_added, + 'ros2:rclcpp_subscription_callback_start': + self._handle_rclcpp_subscription_callback_start, + 'ros2:rclcpp_subscription_callback_end': + self._handle_rclcpp_subscription_callback_end, + 'ros2:rcl_service_init': + self._handle_rcl_service_init, + 'ros2:rclcpp_service_callback_added': + self._handle_rclcpp_service_callback_added, + 'ros2:rclcpp_service_callback_start': + self._handle_rclcpp_service_callback_start, + 'ros2:rclcpp_service_callback_end': + self._handle_rclcpp_service_callback_end, + 'ros2:rcl_client_init': + self._handle_rcl_client_init, + 'ros2:rcl_timer_init': + self._handle_rcl_timer_init, + 'ros2:rclcpp_timer_callback_added': + self._handle_rclcpp_timer_callback_added, + 'ros2:rclcpp_timer_callback_start': + self._handle_rclcpp_timer_callback_start, + 'ros2:rclcpp_timer_callback_end': + self._handle_rclcpp_timer_callback_end, + 'ros2:rclcpp_callback_register': + self._handle_rclcpp_callback_register, } super().__init__(handler_map) From 110c8701e5704a568ef53026664cfbab0516b72b Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 13:04:20 +0200 Subject: [PATCH 46/98] Rename method to handle_events --- tracetools_analysis/analysis/handler.py | 4 ++-- tracetools_analysis/analysis/ros_processor.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py index 1308d1e..350d2fe 100644 --- a/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/analysis/handler.py @@ -16,9 +16,9 @@ class EventHandler(): """ self._handler_map = handler_map - def process_events(self, events): + def handle_events(self, events): """ - Process events by calling their handlers. + Handle events by calling their handlers. :param events (list(dict(str:str))): the events to process """ diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/ros_processor.py index 430f6ac..3c47c99 100644 --- a/tracetools_analysis/analysis/ros_processor.py +++ b/tracetools_analysis/analysis/ros_processor.py @@ -12,7 +12,7 @@ def ros_process(events): :return the processor object """ processor = RosProcessor() - processor.process_events(events) + processor.handle_events(events) return processor From 02a20885b5c4506e2674537d7494dd941434e21b Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 13:06:01 +0200 Subject: [PATCH 47/98] Rename ros_processor file to processor --- tracetools_analysis/analysis/{ros_processor.py => processor.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tracetools_analysis/analysis/{ros_processor.py => processor.py} (100%) diff --git a/tracetools_analysis/analysis/ros_processor.py b/tracetools_analysis/analysis/processor.py similarity index 100% rename from tracetools_analysis/analysis/ros_processor.py rename to tracetools_analysis/analysis/processor.py From c493e5d57dda4ad61d72debfdd845ea10141d9b9 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 13:38:35 +0200 Subject: [PATCH 48/98] Add basic DataModel class --- tracetools_analysis/analysis/data_model.py | 24 ++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 tracetools_analysis/analysis/data_model.py diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py new file mode 100644 index 0000000..9885842 --- /dev/null +++ b/tracetools_analysis/analysis/data_model.py @@ -0,0 +1,24 @@ +# Data model + +import pandas as pd + + +class DataModel(): + """ + Container to model processed data. + + Contains data for an analysis to use. + """ + + def __init__(self): + # Objects (one-time events, usually when something is created) + self._contexts = pd.DataFrame(columns=[]) + self._nodes = pd.DataFrame(columns=[]) + self._publishers = pd.DataFrame(columns=[]) + self._subscriptions = pd.DataFrame(columns=[]) + self._services = pd.DataFrame(columns=[]) + self._clients = pd.DataFrame(columns=[]) + self._timers = pd.DataFrame(columns=[]) + + # Events + # TODO From 449ccfe6ec6e9d2a3a324acc0eb3b0a28a2b72a1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 7 Jun 2019 13:54:43 +0200 Subject: [PATCH 49/98] Add print method for debugging --- tracetools_analysis/analysis/data_model.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 9885842..18d283a 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -22,3 +22,16 @@ class DataModel(): # Events # TODO + + + def print(self): + """Debug method to print every contained df.""" + print('====================DATA MODEL====================') + print(f'Contexts:\n{self._contexts.to_string()}') + print(f'Nodes:\n{self._nodes.to_string()}') + print(f'Publishers:\n{self._publishers.to_string()}') + print(f'Subscription:\n{self._subscriptions.to_string()}') + print(f'Services:\n{self._services.to_string()}') + print(f'Clients:\n{self._clients.to_string()}') + print(f'Timers:\n{self._timers.to_string()}') + print('==================================================') From 946f0621cc8041c70e012a537c90a717d4ea6019 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 11:38:17 +0200 Subject: [PATCH 50/98] Add more information to the DataModel docstring --- tracetools_analysis/analysis/data_model.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 18d283a..2f46c54 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -5,9 +5,11 @@ import pandas as pd class DataModel(): """ - Container to model processed data. + Container to model pre-processed data for analysis. - Contains data for an analysis to use. + Contains data for an analysis to use. This is a middleground between trace events data and the + output data of an analysis. This aims to represent the data in a ROS-aware way. + It uses pandas DataFrames directly. """ def __init__(self): From 08ec9c30b2600608d71b3fc1f76824f2fb7fa229 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 13:42:48 +0200 Subject: [PATCH 51/98] Add option for raising exception if event field not found --- tracetools_analysis/analysis/handler.py | 8 ++++++-- tracetools_analysis/analysis/lttng_models.py | 8 ++++++-- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py index 350d2fe..84b1859 100644 --- a/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/analysis/handler.py @@ -31,10 +31,14 @@ class EventHandler(): if handler_function is not None: pid = lttng_models.get_field(event, 'vpid', - default=lttng_models.get_field(event, 'pid')) + default=lttng_models.get_field(event, + 'pid', + raise_if_not_found=False)) tid = lttng_models.get_field(event, 'vtid', - default=lttng_models.get_field(event, 'tid')) + default=lttng_models.get_field(event, + 'tid', + raise_if_not_found=False)) timestamp = lttng_models.get_field(event, '_timestamp') procname = lttng_models.get_field(event, 'procname') metadata = lttng_models.EventMetadata(event_name, pid, tid, timestamp, procname) diff --git a/tracetools_analysis/analysis/lttng_models.py b/tracetools_analysis/analysis/lttng_models.py index d0cb096..7562d2f 100644 --- a/tracetools_analysis/analysis/lttng_models.py +++ b/tracetools_analysis/analysis/lttng_models.py @@ -1,8 +1,12 @@ # Model objects for LTTng traces/events -def get_field(event, field_name, default=None): - return event.get(field_name, default) +def get_field(event, field_name, default=None, raise_if_not_found=True): + field_value = event.get(field_name, default) + # If enabled, raise exception as soon as possible to avoid headaches + if raise_if_not_found and field_value is None: + raise AttributeError(f'event field "{field_name}" not found!') + return field_value def get_name(event): From c88000bede34684982c3d77c5b66dd4372876f8b Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 13:45:29 +0200 Subject: [PATCH 52/98] Implement handlers for one-time events/object creation --- tracetools_analysis/analysis/data_model.py | 31 +++++++++-- tracetools_analysis/analysis/processor.py | 61 ++++++++++++++-------- tracetools_analysis/process.py | 10 ++-- 3 files changed, 70 insertions(+), 32 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 2f46c54..f6a0296 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -14,10 +14,15 @@ class DataModel(): def __init__(self): # Objects (one-time events, usually when something is created) - self._contexts = pd.DataFrame(columns=[]) - self._nodes = pd.DataFrame(columns=[]) - self._publishers = pd.DataFrame(columns=[]) - self._subscriptions = pd.DataFrame(columns=[]) + 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.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.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.set_index(['subscription_handle'], inplace=True, drop=True) + self._services = pd.DataFrame(columns=[]) self._clients = pd.DataFrame(columns=[]) self._timers = pd.DataFrame(columns=[]) @@ -25,15 +30,33 @@ class DataModel(): # Events # TODO + def add_context(self, context_handle, timestamp, pid): + self._contexts.loc[context_handle] = [timestamp, pid] + # self._contexts = self._contexts.append({'context_handle': context_handle, 'timestamp': timestamp, 'pid': pid}, ignore_index=True) + + 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_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 print(self): """Debug method to print every contained df.""" print('====================DATA MODEL====================') print(f'Contexts:\n{self._contexts.to_string()}') + print() print(f'Nodes:\n{self._nodes.to_string()}') + print() print(f'Publishers:\n{self._publishers.to_string()}') + print() print(f'Subscription:\n{self._subscriptions.to_string()}') + print() print(f'Services:\n{self._services.to_string()}') + print() print(f'Clients:\n{self._clients.to_string()}') + print() print(f'Timers:\n{self._timers.to_string()}') print('==================================================') diff --git a/tracetools_analysis/analysis/processor.py b/tracetools_analysis/analysis/processor.py index 3c47c99..d4a49d5 100644 --- a/tracetools_analysis/analysis/processor.py +++ b/tracetools_analysis/analysis/processor.py @@ -2,6 +2,7 @@ from .handler import EventHandler from .lttng_models import get_field +from .data_model import DataModel def ros_process(events): @@ -63,43 +64,59 @@ class RosProcessor(EventHandler): } super().__init__(handler_map) - # TODO add other stuff - # Instances of callback_start for eventual matching - self._callback_starts = {} - # Callback instances, callback_address: (end - start, start) - self.callbacks_instances = {} + self._data = DataModel() + + def get_data_model(self): + return self._data def _handle_rcl_init(self, event, metadata): - # TODO - pass + context_handle = get_field(event, 'context_handle') + self._data.add_context(context_handle, metadata.timestamp, metadata.pid) def _handle_rcl_node_init(self, event, metadata): - # TODO - pass + node_handle = get_field(event, 'node_handle') + 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) def _handle_rcl_publisher_init(self, event, metadata): - # TODO - pass + pub_handle = get_field(event, 'publisher_handle') + 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) def _handle_subscription_init(self, event, metadata): - # TODO - pass + sub_handle = get_field(event, 'subscription_handle') + 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) def _handle_rclcpp_subscription_callback_added(self, event, metadata): + # TODO + pass # Add the callback address key and create an empty list - callback_addr = get_field(event, 'callback') - self.callbacks_instances[callback_addr] = [] + # callback_addr = get_field(event, 'callback') + # self.callbacks_instances[callback_addr] = [] def _handle_rclcpp_subscription_callback_start(self, event, metadata): - callback_addr = get_field(event, 'callback') - self._callback_starts[callback_addr] = metadata.timestamp + # TODO + pass + # callback_addr = get_field(event, 'callback') + # self._callback_starts[callback_addr] = metadata.timestamp def _handle_rclcpp_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)) + # TODO + pass + # 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)) def _handle_rcl_service_init(self, event, metadata): # TODO diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 011488c..1b9d6c9 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -4,8 +4,8 @@ import argparse import pickle -from tracetools_analysis.analysis import ros_processor, to_pandas - +from tracetools_analysis.analysis import processor, to_pandas +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.') @@ -21,11 +21,9 @@ def main(): with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) print(f'imported {len(events)} events') - processor = ros_processor.ros_process(events) - - df = to_pandas.callback_durations_to_df(processor) - print(df.to_string()) + p = processor.ros_process(events) + p.get_data_model().print() def _get_events_from_pickled_file(file): p = pickle.Unpickler(file) From 80a62cd5919b11b1f6aba52e8315b2697acd53bb Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 14:39:37 +0200 Subject: [PATCH 53/98] Implement handling for sub callbacks --- tracetools_analysis/analysis/data_model.py | 26 +++++++++++-- tracetools_analysis/analysis/processor.py | 43 +++++++++++++--------- 2 files changed, 47 insertions(+), 22 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index f6a0296..f5565a8 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -22,17 +22,20 @@ class DataModel(): 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.set_index(['subscription_handle'], inplace=True, drop=True) + self._subscription_callback_objects = pd.DataFrame(columns=['subscription_handle', 'timestamp', 'callback_object']) + self._subscription_callback_objects.set_index(['subscription_handle'], inplace=True, drop=True) + self._callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) + self._callbacks.set_index(['callback_object'], inplace=True, drop=True) self._services = pd.DataFrame(columns=[]) self._clients = pd.DataFrame(columns=[]) self._timers = pd.DataFrame(columns=[]) - # Events - # TODO + # Events (multiple instances, may not have a meaningful index) + self._subscription_callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'duration', 'intra_process']) def add_context(self, context_handle, timestamp, pid): self._contexts.loc[context_handle] = [timestamp, pid] - # self._contexts = self._contexts.append({'context_handle': context_handle, 'timestamp': timestamp, 'pid': pid}, ignore_index=True) def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace): self._nodes.loc[node_handle] = [timestamp, tid, rmw_handle, name, namespace] @@ -43,6 +46,15 @@ class DataModel(): 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_callback_object(self, subscription_handle, timestamp, callback_object): + self._subscription_callback_objects.loc[subscription_handle] = [timestamp, callback_object] + + def add_callback(self, callback_object, timestamp, symbol): + self._callbacks.loc[callback_object] = [timestamp, symbol] + + def add_subscription_callback_instance(self, callback_object, timestamp, duration, intra_process): + self._subscription_callbacks = self._subscription_callbacks.append({'callback_object': callback_object, 'timestamp': timestamp, 'duration': duration, 'intra_process': intra_process}, ignore_index=True) + def print(self): """Debug method to print every contained df.""" print('====================DATA MODEL====================') @@ -52,11 +64,17 @@ class DataModel(): print() print(f'Publishers:\n{self._publishers.to_string()}') print() - print(f'Subscription:\n{self._subscriptions.to_string()}') + print(f'Subscriptions:\n{self._subscriptions.to_string()}') + print() + print(f'Subscription callbacks:\n{self._subscription_callback_objects.to_string()}') + print() + print(f'Subscription callback instances:\n{self._subscription_callbacks.to_string()}') print() print(f'Services:\n{self._services.to_string()}') print() print(f'Clients:\n{self._clients.to_string()}') print() print(f'Timers:\n{self._timers.to_string()}') + print() + print(f'Callbacks:\n{self._callbacks.to_string()}') print('==================================================') diff --git a/tracetools_analysis/analysis/processor.py b/tracetools_analysis/analysis/processor.py index d4a49d5..d8c0b46 100644 --- a/tracetools_analysis/analysis/processor.py +++ b/tracetools_analysis/analysis/processor.py @@ -65,6 +65,9 @@ class RosProcessor(EventHandler): super().__init__(handler_map) self._data = DataModel() + + # Temporary buffers + self._callback_instances = {} def get_data_model(self): return self._data @@ -97,26 +100,29 @@ class RosProcessor(EventHandler): self._data.add_subscription(sub_handle, metadata.timestamp, node_handle, rmw_handle, topic_name, depth) def _handle_rclcpp_subscription_callback_added(self, event, metadata): - # TODO - pass - # Add the callback address key and create an empty list - # callback_addr = get_field(event, 'callback') - # self.callbacks_instances[callback_addr] = [] + subscription_handle = get_field(event, 'subscription_handle') + callback_object = get_field(event, 'callback') + self._data.add_subscription_callback_object(subscription_handle, metadata.timestamp, callback_object) def _handle_rclcpp_subscription_callback_start(self, event, metadata): - # TODO - pass - # callback_addr = get_field(event, 'callback') - # self._callback_starts[callback_addr] = metadata.timestamp + # Add to dict + callback_addr = get_field(event, 'callback') + self._callback_instances[callback_addr] = (event, metadata) def _handle_rclcpp_subscription_callback_end(self, event, metadata): - # TODO - pass - # 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)) + # Fetch from dict + callback_object = get_field(event, 'callback') + (event_start, metadata_start) = self._callback_instances.get(callback_object) + if event_start is not None and metadata_start is not None: + del self._callback_instances[callback_object] + duration = metadata.timestamp - metadata_start.timestamp + is_intra_process = get_field(event_start, 'is_intra_process') + self._data.add_subscription_callback_instance(callback_object, + metadata_start.timestamp, + duration, + bool(is_intra_process)) + else: + print(f'No matching callback start for callback object "{callback_object}"') def _handle_rcl_service_init(self, event, metadata): # TODO @@ -155,5 +161,6 @@ class RosProcessor(EventHandler): pass def _handle_rclcpp_callback_register(self, event, metadata): - # TODO - pass + callback_object = get_field(event, 'callback') + symbol = get_field(event, 'symbol') + self._data.add_callback(callback_object, metadata.timestamp, symbol) From 4efa003be09a9f17fba9e926378bfc8beb35d4c2 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 14:47:45 +0200 Subject: [PATCH 54/98] Make callback objects dataframe generic --- tracetools_analysis/analysis/data_model.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index f5565a8..f61a570 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -22,8 +22,6 @@ class DataModel(): 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.set_index(['subscription_handle'], inplace=True, drop=True) - self._subscription_callback_objects = pd.DataFrame(columns=['subscription_handle', 'timestamp', 'callback_object']) - self._subscription_callback_objects.set_index(['subscription_handle'], inplace=True, drop=True) self._callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) self._callbacks.set_index(['callback_object'], inplace=True, drop=True) @@ -31,6 +29,9 @@ class DataModel(): self._clients = pd.DataFrame(columns=[]) self._timers = pd.DataFrame(columns=[]) + self._callback_objects = pd.DataFrame(columns=['handle', 'timestamp', 'callback_object']) + self._callback_objects.set_index(['handle'], inplace=True, drop=True) + # Events (multiple instances, may not have a meaningful index) self._subscription_callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'duration', 'intra_process']) @@ -47,7 +48,7 @@ class DataModel(): self._subscriptions.loc[subscription_handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] def add_subscription_callback_object(self, subscription_handle, timestamp, callback_object): - self._subscription_callback_objects.loc[subscription_handle] = [timestamp, callback_object] + self._callback_objects.loc[subscription_handle] = [timestamp, callback_object] def add_callback(self, callback_object, timestamp, symbol): self._callbacks.loc[callback_object] = [timestamp, symbol] @@ -66,8 +67,6 @@ class DataModel(): print() print(f'Subscriptions:\n{self._subscriptions.to_string()}') print() - print(f'Subscription callbacks:\n{self._subscription_callback_objects.to_string()}') - print() print(f'Subscription callback instances:\n{self._subscription_callbacks.to_string()}') print() print(f'Services:\n{self._services.to_string()}') @@ -76,5 +75,7 @@ class DataModel(): print() print(f'Timers:\n{self._timers.to_string()}') print() + print(f'Callback objects:\n{self._callback_objects.to_string()}') + print() print(f'Callbacks:\n{self._callbacks.to_string()}') print('==================================================') From 84b50e10e89ac9497f2d1eec5e3c65a3c66201e9 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 14:49:16 +0200 Subject: [PATCH 55/98] Reorder attributes --- tracetools_analysis/analysis/data_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index f61a570..a23aec5 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -22,8 +22,6 @@ class DataModel(): 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.set_index(['subscription_handle'], inplace=True, drop=True) - self._callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) - self._callbacks.set_index(['callback_object'], inplace=True, drop=True) self._services = pd.DataFrame(columns=[]) self._clients = pd.DataFrame(columns=[]) @@ -31,6 +29,8 @@ class DataModel(): self._callback_objects = pd.DataFrame(columns=['handle', 'timestamp', 'callback_object']) self._callback_objects.set_index(['handle'], inplace=True, drop=True) + self._callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) + self._callbacks.set_index(['callback_object'], inplace=True, drop=True) # Events (multiple instances, may not have a meaningful index) self._subscription_callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'duration', 'intra_process']) From a58b4e841d16137eecf4305ceb7b01a1dc6fa459 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 14:51:23 +0200 Subject: [PATCH 56/98] Rename --- tracetools_analysis/analysis/data_model.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index a23aec5..48179c9 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -29,11 +29,11 @@ class DataModel(): self._callback_objects = pd.DataFrame(columns=['handle', 'timestamp', 'callback_object']) self._callback_objects.set_index(['handle'], inplace=True, drop=True) - self._callbacks = pd.DataFrame(columns=['callback_object', 'timestamp', 'symbol']) - self._callbacks.set_index(['callback_object'], inplace=True, drop=True) + 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._subscription_callbacks = 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] @@ -51,10 +51,10 @@ class DataModel(): self._callback_objects.loc[subscription_handle] = [timestamp, callback_object] def add_callback(self, callback_object, timestamp, symbol): - self._callbacks.loc[callback_object] = [timestamp, symbol] + self._callback_symbols.loc[callback_object] = [timestamp, symbol] - def add_subscription_callback_instance(self, callback_object, timestamp, duration, intra_process): - self._subscription_callbacks = self._subscription_callbacks.append({'callback_object': callback_object, 'timestamp': timestamp, 'duration': duration, 'intra_process': intra_process}, ignore_index=True) + 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): """Debug method to print every contained df.""" @@ -67,7 +67,7 @@ class DataModel(): print() print(f'Subscriptions:\n{self._subscriptions.to_string()}') print() - print(f'Subscription callback instances:\n{self._subscription_callbacks.to_string()}') + print(f'Callback instances:\n{self._callbacks_instances.to_string()}') print() print(f'Services:\n{self._services.to_string()}') print() @@ -77,5 +77,5 @@ class DataModel(): print() print(f'Callback objects:\n{self._callback_objects.to_string()}') print() - print(f'Callbacks:\n{self._callbacks.to_string()}') + print(f'Callback symbols:\n{self._callback_symbols.to_string()}') print('==================================================') From 6a8843f0f4485ace32d5f19ca8019f431c64ce6c Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 15:02:30 +0200 Subject: [PATCH 57/98] Make callback instance handling more generic --- tracetools_analysis/analysis/data_model.py | 10 +++--- tracetools_analysis/analysis/processor.py | 42 ++++++++++++---------- 2 files changed, 29 insertions(+), 23 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 48179c9..f6bbe77 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -47,10 +47,10 @@ class DataModel(): 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_callback_object(self, subscription_handle, timestamp, callback_object): - self._callback_objects.loc[subscription_handle] = [timestamp, callback_object] + def add_callback_object(self, handle, timestamp, callback_object): + self._callback_objects.loc[handle] = [timestamp, callback_object] - def add_callback(self, callback_object, timestamp, symbol): + 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): @@ -67,8 +67,6 @@ class DataModel(): print() print(f'Subscriptions:\n{self._subscriptions.to_string()}') print() - print(f'Callback instances:\n{self._callbacks_instances.to_string()}') - print() print(f'Services:\n{self._services.to_string()}') print() print(f'Clients:\n{self._clients.to_string()}') @@ -78,4 +76,6 @@ class DataModel(): print(f'Callback objects:\n{self._callback_objects.to_string()}') print() print(f'Callback symbols:\n{self._callback_symbols.to_string()}') + print() + print(f'Callback instances:\n{self._callbacks_instances.to_string()}') print('==================================================') diff --git a/tracetools_analysis/analysis/processor.py b/tracetools_analysis/analysis/processor.py index d8c0b46..0afb2de 100644 --- a/tracetools_analysis/analysis/processor.py +++ b/tracetools_analysis/analysis/processor.py @@ -102,27 +102,13 @@ class RosProcessor(EventHandler): def _handle_rclcpp_subscription_callback_added(self, event, metadata): subscription_handle = get_field(event, 'subscription_handle') callback_object = get_field(event, 'callback') - self._data.add_subscription_callback_object(subscription_handle, metadata.timestamp, callback_object) + self._data.add_callback_object(subscription_handle, metadata.timestamp, callback_object) def _handle_rclcpp_subscription_callback_start(self, event, metadata): - # Add to dict - callback_addr = get_field(event, 'callback') - self._callback_instances[callback_addr] = (event, metadata) + self.__handle_callback_start(event, metadata) def _handle_rclcpp_subscription_callback_end(self, event, metadata): - # Fetch from dict - callback_object = get_field(event, 'callback') - (event_start, metadata_start) = self._callback_instances.get(callback_object) - if event_start is not None and metadata_start is not None: - del self._callback_instances[callback_object] - duration = metadata.timestamp - metadata_start.timestamp - is_intra_process = get_field(event_start, 'is_intra_process') - self._data.add_subscription_callback_instance(callback_object, - metadata_start.timestamp, - duration, - bool(is_intra_process)) - else: - print(f'No matching callback start for callback object "{callback_object}"') + self.__handle_callback_end(event, metadata) def _handle_rcl_service_init(self, event, metadata): # TODO @@ -163,4 +149,24 @@ class RosProcessor(EventHandler): def _handle_rclcpp_callback_register(self, event, metadata): callback_object = get_field(event, 'callback') symbol = get_field(event, 'symbol') - self._data.add_callback(callback_object, metadata.timestamp, symbol) + self._data.add_callback_symbol(callback_object, metadata.timestamp, symbol) + + def __handle_callback_start(self, event, metadata): + # Add to dict + callback_addr = get_field(event, 'callback') + self._callback_instances[callback_addr] = (event, metadata) + + def __handle_callback_end(self, event, metadata): + # Fetch from dict + callback_object = get_field(event, 'callback') + (event_start, metadata_start) = self._callback_instances.get(callback_object) + if event_start is not None and metadata_start is not None: + del self._callback_instances[callback_object] + duration = metadata.timestamp - metadata_start.timestamp + is_intra_process = get_field(event_start, 'is_intra_process', raise_if_not_found=False) + self._data.add_callback_instance(callback_object, + metadata_start.timestamp, + duration, + bool(is_intra_process)) + else: + print(f'No matching callback start for callback object "{callback_object}"') From 12c2c7bad5c23c1d1c760fd761c999007e39049b Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 15:26:21 +0200 Subject: [PATCH 58/98] Add handling for services, clients, and timers --- tracetools_analysis/analysis/data_model.py | 19 +++++++--- tracetools_analysis/analysis/processor.py | 41 ++++++++++++---------- 2 files changed, 38 insertions(+), 22 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index f6bbe77..c6ed69d 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -22,10 +22,12 @@ class DataModel(): 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.set_index(['subscription_handle'], inplace=True, drop=True) - - self._services = pd.DataFrame(columns=[]) - self._clients = pd.DataFrame(columns=[]) - self._timers = pd.DataFrame(columns=[]) + 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.set_index(['client_handle'], inplace=True, drop=True) + 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.set_index(['handle'], inplace=True, drop=True) @@ -47,6 +49,15 @@ class DataModel(): 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_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_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_timer(self, timer_handle, timestamp, period): + self._timers.loc[timer_handle] = [timestamp, period] + def add_callback_object(self, handle, timestamp, callback_object): self._callback_objects.loc[handle] = [timestamp, callback_object] diff --git a/tracetools_analysis/analysis/processor.py b/tracetools_analysis/analysis/processor.py index 0afb2de..fc285da 100644 --- a/tracetools_analysis/analysis/processor.py +++ b/tracetools_analysis/analysis/processor.py @@ -111,40 +111,45 @@ class RosProcessor(EventHandler): self.__handle_callback_end(event, metadata) def _handle_rcl_service_init(self, event, metadata): - # TODO - pass + service_handle = get_field(event, 'service_handle') + 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) def _handle_rclcpp_service_callback_added(self, event, metadata): - # TODO - pass + service_handle = get_field(event, 'service_handle') + callback_object = get_field(event, 'callback') + self._data.add_callback_object(service_handle, metadata.timestamp, callback_object) def _handle_rclcpp_service_callback_start(self, event, metadata): - # TODO - pass + self.__handle_callback_start(event, metadata) def _handle_rclcpp_service_callback_end(self, event, metadata): - # TODO - pass + self.__handle_callback_end(event, metadata) def _handle_rcl_client_init(self, event, metadata): - # TODO - pass + client_handle = get_field(event, 'client_handle') + 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) def _handle_rcl_timer_init(self, event, metadata): - # TODO - pass + timer_handle = get_field(event, 'timer_handle') + period = get_field(event, 'period') + self._data.add_timer(timer_handle, metadata.timestamp, period) def _handle_rclcpp_timer_callback_added(self, event, metadata): - # TODO - pass + timer_handle = get_field(event, 'timer_handle') + callback_object = get_field(event, 'callback') + self._data.add_callback_object(timer_handle, metadata.timestamp, callback_object) def _handle_rclcpp_timer_callback_start(self, event, metadata): - # TODO - pass + self.__handle_callback_start(event, metadata) def _handle_rclcpp_timer_callback_end(self, event, metadata): - # TODO - pass + self.__handle_callback_end(event, metadata) def _handle_rclcpp_callback_register(self, event, metadata): callback_object = get_field(event, 'callback') From 693d52f0ad2a580192556b223866d57d4d01fbbf Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 16:20:06 +0200 Subject: [PATCH 59/98] Move time-related prints to entrypoint scripts --- tracetools_analysis/conversion/ctf.py | 9 ++------- tracetools_analysis/convert.py | 6 +++++- tracetools_analysis/process.py | 6 +++++- 3 files changed, 12 insertions(+), 9 deletions(-) diff --git a/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py index 741e21c..78ca353 100644 --- a/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/conversion/ctf.py @@ -1,7 +1,5 @@ # CTF to pickle conversion -import time - import babeltrace # List of ignored CTF fields @@ -29,8 +27,6 @@ def ctf_to_pickle(trace_directory, target): # count_pid_matched = 0 # traced = set() - start_time = time.time() - # PID_KEYS = ['vpid', 'pid'] for event in tc.events: count += 1 @@ -44,9 +40,8 @@ def ctf_to_pickle(trace_directory, target): pod = _ctf_event_to_pod(event) target.dump(pod) count_written += 1 - - time_diff = time.time() - start_time - print(f'{count_written} events in {time_diff * 1000:.2f} ms') + + return count_written def _ctf_event_to_pod(ctf_event): diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index 1cd1a5c..e1d149c 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -3,6 +3,7 @@ import argparse from pickle import Pickler +import time from tracetools_analysis.conversion import ctf @@ -22,6 +23,9 @@ def main(): trace_directory = args.trace_directory pickle_target_file = args.pickle_file + start_time = time.time() with open(pickle_target_file, 'wb') as f: p = Pickler(f, protocol=4) - ctf.ctf_to_pickle(trace_directory, p) + count = ctf.ctf_to_pickle(trace_directory, p) + time_diff = time.time() - start_time + print(f'converted {count} events in {time_diff * 1000:.2f} ms') diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 1b9d6c9..ee375a4 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -3,6 +3,7 @@ import argparse import pickle +import time from tracetools_analysis.analysis import processor, to_pandas from tracetools_analysis.analysis import data_model @@ -18,10 +19,13 @@ def main(): args = parse_args() pickle_filename = args.pickle_file + + start_time = time.time() with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) - print(f'imported {len(events)} events') p = processor.ros_process(events) + time_diff = time.time() - start_time + print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') p.get_data_model().print() From 54a2fde9a276590d0eafbdf8163063bbceb2f0a8 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 16:22:00 +0200 Subject: [PATCH 60/98] Rename RosProcessor to Ros2Processor --- .../analysis/{processor.py => ros2_processor.py} | 10 +++++----- tracetools_analysis/process.py | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) rename tracetools_analysis/analysis/{processor.py => ros2_processor.py} (97%) diff --git a/tracetools_analysis/analysis/processor.py b/tracetools_analysis/analysis/ros2_processor.py similarity index 97% rename from tracetools_analysis/analysis/processor.py rename to tracetools_analysis/analysis/ros2_processor.py index fc285da..cdc957a 100644 --- a/tracetools_analysis/analysis/processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -5,21 +5,21 @@ from .lttng_models import get_field from .data_model import DataModel -def ros_process(events): +def ros2_process(events): """ - Process unpickled events and create ROS model. + Process unpickled events and create ROS 2 model. :param events (list(dict(str:str:))): the list of events :return the processor object """ - processor = RosProcessor() + processor = Ros2Processor() processor.handle_events(events) return processor -class RosProcessor(EventHandler): +class Ros2Processor(EventHandler): """ - ROS-aware event processing/handling class implementation. + ROS 2-aware event processing/handling class implementation. Handles a trace's events and builds a model with the data. """ diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index ee375a4..9dbf72d 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -5,7 +5,7 @@ import argparse import pickle import time -from tracetools_analysis.analysis import processor, to_pandas +from tracetools_analysis.analysis import ros2_processor, to_pandas from tracetools_analysis.analysis import data_model def parse_args(): @@ -23,7 +23,7 @@ def main(): start_time = time.time() with open(pickle_filename, 'rb') as f: events = _get_events_from_pickled_file(f) - p = processor.ros_process(events) + p = ros2_processor.ros2_process(events) time_diff = time.time() - start_time print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') From 5cd1f2f48bacb43547ede52f461a55f8781000c1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 16:22:57 +0200 Subject: [PATCH 61/98] Remove outdated file --- tracetools_analysis/analysis/to_pandas.py | 20 -------------------- tracetools_analysis/process.py | 2 +- 2 files changed, 1 insertion(+), 21 deletions(-) delete mode 100644 tracetools_analysis/analysis/to_pandas.py diff --git a/tracetools_analysis/analysis/to_pandas.py b/tracetools_analysis/analysis/to_pandas.py deleted file mode 100644 index cbdb224..0000000 --- a/tracetools_analysis/analysis/to_pandas.py +++ /dev/null @@ -1,20 +0,0 @@ -# Convert processor object to pandas dataframe - -import pandas as pd - - -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 - }) diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 9dbf72d..8a85096 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -5,7 +5,7 @@ import argparse import pickle import time -from tracetools_analysis.analysis import ros2_processor, to_pandas +from tracetools_analysis.analysis import ros2_processor from tracetools_analysis.analysis import data_model def parse_args(): From 2508b07347ab4dce0a92a7f2a65affcea6f4d91d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 13 Jun 2019 16:37:20 +0200 Subject: [PATCH 62/98] 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) From ded341a59be0c3c1efd00d9187a4ee8427cc4c92 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 10:09:55 +0200 Subject: [PATCH 63/98] Handle generic 'callback_start|end' events --- .../analysis/ros2_processor.py | 38 +++---------------- 1 file changed, 6 insertions(+), 32 deletions(-) diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index 6604b85..1664f9f 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -37,30 +37,22 @@ class Ros2Processor(EventHandler): self._handle_subscription_init, 'ros2:rclcpp_subscription_callback_added': self._handle_rclcpp_subscription_callback_added, - 'ros2:rclcpp_subscription_callback_start': - self._handle_rclcpp_subscription_callback_start, - 'ros2:rclcpp_subscription_callback_end': - self._handle_rclcpp_subscription_callback_end, 'ros2:rcl_service_init': self._handle_rcl_service_init, 'ros2:rclcpp_service_callback_added': self._handle_rclcpp_service_callback_added, - 'ros2:rclcpp_service_callback_start': - self._handle_rclcpp_service_callback_start, - 'ros2:rclcpp_service_callback_end': - self._handle_rclcpp_service_callback_end, 'ros2:rcl_client_init': self._handle_rcl_client_init, 'ros2:rcl_timer_init': self._handle_rcl_timer_init, 'ros2:rclcpp_timer_callback_added': self._handle_rclcpp_timer_callback_added, - 'ros2:rclcpp_timer_callback_start': - self._handle_rclcpp_timer_callback_start, - 'ros2:rclcpp_timer_callback_end': - self._handle_rclcpp_timer_callback_end, 'ros2:rclcpp_callback_register': self._handle_rclcpp_callback_register, + 'ros2:callback_start': + self._handle_callback_start, + 'ros2:callback_end': + self._handle_callback_end, } super().__init__(handler_map) @@ -111,12 +103,6 @@ class Ros2Processor(EventHandler): callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rclcpp_subscription_callback_start(self, event, metadata): - self.__handle_callback_start(event, metadata) - - def _handle_rclcpp_subscription_callback_end(self, event, metadata): - self.__handle_callback_end(event, metadata) - def _handle_rcl_service_init(self, event, metadata): handle = get_field(event, 'service_handle') timestamp = metadata.timestamp @@ -131,12 +117,6 @@ class Ros2Processor(EventHandler): callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rclcpp_service_callback_start(self, event, metadata): - self.__handle_callback_start(event, metadata) - - def _handle_rclcpp_service_callback_end(self, event, metadata): - self.__handle_callback_end(event, metadata) - def _handle_rcl_client_init(self, event, metadata): handle = get_field(event, 'client_handle') timestamp = metadata.timestamp @@ -157,24 +137,18 @@ class Ros2Processor(EventHandler): callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rclcpp_timer_callback_start(self, event, metadata): - self.__handle_callback_start(event, metadata) - - def _handle_rclcpp_timer_callback_end(self, event, metadata): - self.__handle_callback_end(event, metadata) - 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, timestamp, symbol) - def __handle_callback_start(self, event, metadata): + def _handle_callback_start(self, event, metadata): # Add to dict callback_addr = get_field(event, 'callback') self._callback_instances[callback_addr] = (event, metadata) - def __handle_callback_end(self, event, metadata): + def _handle_callback_end(self, event, metadata): # Fetch from dict callback_object = get_field(event, 'callback') (event_start, metadata_start) = self._callback_instances.get(callback_object) From dd402ed1ce253c8c56e0f51b0d8f6452b9b4f29d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 11:44:46 +0200 Subject: [PATCH 64/98] Extract pickle-loading function --- tracetools_analysis/analysis/load.py | 20 ++++++++++++++++++++ tracetools_analysis/process.py | 24 ++++++------------------ 2 files changed, 26 insertions(+), 18 deletions(-) create mode 100644 tracetools_analysis/analysis/load.py diff --git a/tracetools_analysis/analysis/load.py b/tracetools_analysis/analysis/load.py new file mode 100644 index 0000000..053d058 --- /dev/null +++ b/tracetools_analysis/analysis/load.py @@ -0,0 +1,20 @@ +import pickle + + +def load_pickle(pickle_file_path): + """ + Load pickle file containing converted trace events. + + :param pickle_file_path (str): the path to the pickle file to load + :return list(dict): the list of events (dicts) read from the file + """ + events = [] + with open(pickle_file_path, 'rb') as f: + p = pickle.Unpickler(f) + while True: + try: + events.append(p.load()) + except EOFError: + break # we're done + + return events diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index cba3cc4..029a476 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -2,9 +2,9 @@ # Entrypoint/script to process events from a pickle file to build a ROS model import argparse -import pickle import time +from tracetools_analysis.analysis import load from tracetools_analysis.analysis import ros2_processor @@ -22,21 +22,9 @@ def main(): pickle_filename = args.pickle_file start_time = time.time() - with open(pickle_filename, 'rb') as f: - events = _get_events_from_pickled_file(f) - p = ros2_processor.ros2_process(events) - time_diff = time.time() - start_time - print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') + events = load.load_pickle(pickle_filename) + processor = ros2_processor.ros2_process(events) + time_diff = time.time() - start_time + print(f'processed {len(events)} events in {time_diff * 1000:.2f} ms') - p.get_data_model().print_model() - - -def _get_events_from_pickled_file(file): - p = pickle.Unpickler(file) - events = [] - while True: - try: - events.append(p.load()) - except EOFError: - break # we're done - return events + processor.get_data_model().print_model() From d28ea625ef64ac96b3ac445ae68e2b8a9639aff0 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 13:25:55 +0200 Subject: [PATCH 65/98] Fix attribute name --- tracetools_analysis/analysis/data_model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 6d21bc4..cb73e44 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -66,7 +66,7 @@ class DataModel(): 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', + self._callback_instances = pd.DataFrame(columns=['callback_object', 'timestamp', 'duration', 'intra_process']) @@ -105,7 +105,7 @@ class DataModel(): 'duration': duration, 'intra_process': intra_process, } - self._callbacks_instances = self._callbacks_instances.append(data, ignore_index=True) + self._callback_instances = self._callback_instances.append(data, ignore_index=True) def print_model(self): """Debug method to print every contained df.""" @@ -128,5 +128,5 @@ class DataModel(): print() print(f'Callback symbols:\n{self._callback_symbols.to_string()}') print() - print(f'Callback instances:\n{self._callbacks_instances.to_string()}') + print(f'Callback instances:\n{self._callback_instances.to_string()}') print('==================================================') From 9e1235d8e58e15a613b70a99f2a83a3374c6d7e5 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 13:28:25 +0200 Subject: [PATCH 66/98] Remove leading underscore from DataModel attributes --- tracetools_analysis/analysis/data_model.py | 136 ++++++++++----------- 1 file changed, 68 insertions(+), 68 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index cb73e44..7707af0 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -14,89 +14,89 @@ 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.set_index(['context_handle'], inplace=True, drop=True) - 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.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.set_index(['subscription_handle'], inplace=True, drop=True) - 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', + 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.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.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.set_index(['subscription_handle'], inplace=True, drop=True) + self.services = pd.DataFrame(columns=['service_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', + self.services.set_index(['service_handle'], inplace=True, drop=True) + self.clients = pd.DataFrame(columns=['client_handle', 'timestamp', - 'period']) - self._timers.set_index(['timer_handle'], inplace=True, drop=True) + '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.set_index(['timer_handle'], inplace=True, drop=True) - 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.set_index(['callback_object'], inplace=True, drop=True) + 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.set_index(['callback_object'], inplace=True, drop=True) # Events (multiple instances, may not have a meaningful index) - self._callback_instances = pd.DataFrame(columns=['callback_object', - 'timestamp', - 'duration', - 'intra_process']) + self.callback_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] + self.contexts.loc[context_handle] = [timestamp, pid] 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, handle, timestamp, node_handle, rmw_handle, topic_name, depth): - self._publishers.loc[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, handle, timestamp, node_handle, rmw_handle, topic_name, depth): - self._subscriptions.loc[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, handle, timestamp, node_handle, rmw_handle, service_name): - self._services.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] + self.services.loc[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] + self.clients.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] def add_timer(self, handle, timestamp, period): - self._timers.loc[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] + 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] + self.callback_symbols.loc[callback_object] = [timestamp, symbol] def add_callback_instance(self, callback_object, timestamp, duration, intra_process): data = { @@ -105,28 +105,28 @@ class DataModel(): 'duration': duration, 'intra_process': intra_process, } - self._callback_instances = self._callback_instances.append(data, ignore_index=True) + self.callback_instances = self.callback_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()}') + print(f'Contexts:\n{self.contexts.to_string()}') print() - print(f'Nodes:\n{self._nodes.to_string()}') + print(f'Nodes:\n{self.nodes.to_string()}') print() - print(f'Publishers:\n{self._publishers.to_string()}') + print(f'Publishers:\n{self.publishers.to_string()}') print() - print(f'Subscriptions:\n{self._subscriptions.to_string()}') + print(f'Subscriptions:\n{self.subscriptions.to_string()}') print() - print(f'Services:\n{self._services.to_string()}') + print(f'Services:\n{self.services.to_string()}') print() - print(f'Clients:\n{self._clients.to_string()}') + print(f'Clients:\n{self.clients.to_string()}') print() - print(f'Timers:\n{self._timers.to_string()}') + print(f'Timers:\n{self.timers.to_string()}') print() - print(f'Callback objects:\n{self._callback_objects.to_string()}') + print(f'Callback objects:\n{self.callback_objects.to_string()}') print() - print(f'Callback symbols:\n{self._callback_symbols.to_string()}') + print(f'Callback symbols:\n{self.callback_symbols.to_string()}') print() - print(f'Callback instances:\n{self._callback_instances.to_string()}') + print(f'Callback instances:\n{self.callback_instances.to_string()}') print('==================================================') From 3fc21e7e940a980d81c34cdccf390240707b517d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 13:30:44 +0200 Subject: [PATCH 67/98] Update and simplify callback_duration analysis notebook --- analysis/Callback_duration.ipynb | 497 +++++-------------------------- 1 file changed, 71 insertions(+), 426 deletions(-) diff --git a/analysis/Callback_duration.ipynb b/analysis/Callback_duration.ipynb index 0b0c60a..d28aa4c 100644 --- a/analysis/Callback_duration.ipynb +++ b/analysis/Callback_duration.ipynb @@ -9,7 +9,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/home/boc7rng/ros2_ws/src/trace_analysis\n" + "/home/boc7rng/ros2_ws/src/tracetools_analysis/tracetools_analysis\n" ] } ], @@ -25,10 +25,9 @@ "source": [ "import sys\n", "import pickle\n", - "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "from tracetools_analysis.analysis.ros_processor import *\n", - "from tracetools_analysis.analysis.to_pandas import *" + "from tracetools_analysis.analysis import load\n", + "from tracetools_analysis.analysis import ros2_processor" ] }, { @@ -37,15 +36,13 @@ "metadata": {}, "outputs": [], "source": [ - "def _get_events_from_pickled_file(file):\n", - " p = pickle.Unpickler(file)\n", - " events = []\n", - " while True:\n", - " try:\n", - " events.append(p.load())\n", - " except EOFError as _:\n", - " break # we're done\n", - " return events" + "# Load an process\n", + "pickle_filename = '../../../the_pickle_file'\n", + "events = load.load_pickle(pickle_filename)\n", + "processor = ros2_processor.ros2_process(events)\n", + "data_model = processor.get_data_model()\n", + "\n", + "#data_model.print_model()" ] }, { @@ -54,424 +51,72 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "imported 538 events\n", - " callback_address duration start_timestamp\n", - "0 93936519421304 46536 1558603909545758681\n", - "1 93936519421304 42644 1558603910045393758\n", - "2 93936519421304 40642 1558603910545455527\n", - "3 93936519421304 34351 1558603911045288748\n", - "4 93936519421304 15474 1558603911545113622\n", - "5 93936519421304 14516 1558603912045117407\n", - "6 93936519421304 15022 1558603912545132769\n", - "7 93936519421304 17849 1558603913045117649\n", - "8 93936519421304 33639 1558603913545454326\n", - "9 93936519421304 38705 1558603914045519078\n", - "10 93936519421304 45665 1558603914545563667\n", - "11 93936519421304 16300 1558603915045232751\n", - "12 93936519421304 44290 1558603915545598209\n", - "13 93936519421304 40953 1558603916045634003\n", - "14 93936519421304 40437 1558603916545775210\n", - "15 93936519421304 43514 1558603917045613746\n", - "16 93936519421304 41327 1558603917545655079\n", - "17 93936519421304 43243 1558603918045657305\n", - "18 93936519421304 45381 1558603918545721344\n", - "19 93936519421304 40894 1558603919045631809\n", - "20 93936519421304 16709 1558603919545352510\n", - "21 93936519421304 44631 1558603920045743330\n", - "22 93936519421304 42671 1558603920545693414\n", - "23 93936519421304 18798 1558603921045399520\n", - "24 93936519421304 50378 1558603921545779682\n", - "25 93936519421304 44826 1558603922045805896\n", - "26 93936519421304 46134 1558603922545824280\n", - "27 93936519421304 44522 1558603923045847831\n", - "28 93936519421304 14270 1558603923545505829\n", - "29 93936519421304 13918 1558603924045491763\n", - "30 93936519421304 14463 1558603924545502429\n", - "31 93936519421304 17682 1558603925045543843\n", - "32 93936519421304 26879 1558603925545708575\n", - "33 93936519421304 36173 1558603926045806943\n", - "34 93936519421304 41533 1558603926546234707\n", - "35 93936519421304 25794 1558603927045722181\n", - "36 93936519421304 45037 1558603927545955253\n", - "37 93936519421304 39921 1558603928046166359\n", - "38 93936519421304 41263 1558603928545970799\n", - "39 93936519421304 73371 1558603929046020303\n", - "40 93936519421304 42534 1558603929545989798\n", - "41 93936519421304 45511 1558603930046115729\n", - "42 93936519421304 46377 1558603930546125475\n", - "43 93936519421304 73247 1558603931046047649\n", - "44 93936519421304 41306 1558603931546089400\n", - "45 93936519421304 39673 1558603932046102715\n", - "46 93936519421304 37308 1558603932546129212\n", - "47 93936519421304 41327 1558603933046090242\n", - "48 93936519421304 49285 1558603933546200982\n", - "49 93936519421304 45726 1558603934046331611\n", - "50 93936519421304 39606 1558603934546343976\n", - "51 93936519421304 40593 1558603935046371735\n", - "52 93936519421304 50519 1558603935546249214\n", - "53 93936519421304 45703 1558603936046224927\n", - "54 93936519421304 50288 1558603936546480484\n", - "55 93936519421304 42308 1558603937046393863\n", - "56 93936519421304 42491 1558603937546330509\n", - "57 93936519421304 43766 1558603938046320731\n", - "58 93936519421304 46444 1558603938546360943\n", - "59 93936519421304 29410 1558603939045959016\n", - "60 93936519421304 44811 1558603939546372225\n", - "61 93936519421304 39708 1558603940046562544\n", - "62 93936519421304 40792 1558603940546413237\n", - "63 93936519421304 37603 1558603941046042702\n", - "64 93936519421304 14451 1558603941545987965\n", - "65 93936519421304 14424 1558603942046011217\n", - "66 93936519421304 15951 1558603942546019131\n", - "67 93936519421304 14792 1558603943046109404\n", - "68 93936519421304 37913 1558603943546418653\n", - "69 93936519421304 38945 1558603944046422260\n", - "70 93936519421304 40952 1558603944546439491\n", - "71 93936519421304 13510 1558603945046148320\n", - "72 93936519421304 41646 1558603945546539773\n", - "73 93936519421304 46602 1558603946046632028\n", - "74 93936519421304 41038 1558603946546731148\n", - "75 93936519421304 41533 1558603947046566829\n", - "76 93936519421304 47418 1558603947546626622\n", - "77 93936519421304 43078 1558603948046636479\n", - "78 93936519421304 43149 1558603948546637906\n", - "79 93936519421304 42481 1558603949046776452\n", - "80 93936519421304 41696 1558603949546662572\n", - "81 93936519421304 41706 1558603950046684020\n", - "82 93936519421304 42198 1558603950546700575\n", - "83 93936519421304 14290 1558603951046342966\n", - "84 93936519421304 42322 1558603951546707586\n", - "85 93936519421304 40280 1558603952046689217\n", - "86 93936519421304 41132 1558603952546782491\n", - "87 93936519421304 42066 1558603953046798531\n", - "88 93936519421304 16504 1558603953546422303\n", - "89 93936519421304 14516 1558603954046442355\n", - "90 93936519421304 15630 1558603954546466966\n", - "91 93936519421304 13527 1558603955046470100\n", - "92 93936519421304 14511 1558603955546440759\n", - "93 93936519421304 39238 1558603956046828345\n", - "94 93936519421304 37940 1558603956546838914\n", - "95 93936519421304 16518 1558603957046547999\n", - "96 93936519421304 41208 1558603957546937736\n", - "97 93936519421304 40373 1558603958046863393\n", - "98 93936519421304 38127 1558603958546940643\n", - "99 93936519421304 38474 1558603959047126679\n", - "100 93936519421304 39139 1558603959547102757\n", - "101 93936519421304 40323 1558603960047126635\n", - "102 93936519421304 16657 1558603960546707945\n", - "103 93936519421304 45127 1558603961046972300\n", - "104 93936519421304 44417 1558603961546999678\n", - "105 93936519421304 21051 1558603962046787412\n", - "106 93936519421304 44299 1558603962547207600\n", - "107 93936519421304 37212 1558603963047074876\n", - "108 93936519421304 38362 1558603963547260043\n", - "109 93936519421304 39245 1558603964047095756\n", - "110 93936519421304 56045 1558603964547178016\n", - "111 93936519421304 40006 1558603965047136559\n", - "112 93936519421304 42538 1558603965547151958\n", - "113 93936519421304 44609 1558603966047224174\n", - "114 93936519421304 48076 1558603966547234849\n", - "115 93936519421304 42164 1558603967047241765\n", - "116 93936519421304 41176 1558603967547208465\n", - "117 93936519421304 38144 1558603968047237382\n", - "118 93936519421304 38317 1558603968547285930\n", - "119 93936519421304 15479 1558603969046950867\n", - "120 93936519421304 41306 1558603969547273142\n", - "121 93936530091544 267148 1558603909546131291\n", - "122 93936530091544 97761 1558603910045737303\n", - "123 93936530091544 97809 1558603910545815399\n", - "124 93936530091544 49725 1558603911045613603\n", - "125 93936530091544 37888 1558603911545265209\n", - "126 93936530091544 43729 1558603912045277690\n", - "127 93936530091544 36926 1558603912545282942\n", - "128 93936530091544 40864 1558603913045265744\n", - "129 93936530091544 93892 1558603913545767273\n", - "130 93936530091544 94766 1558603914045872613\n", - "131 93936530091544 101556 1558603914545936238\n", - "132 93936530091544 42827 1558603915045351368\n", - "133 93936530091544 134027 1558603915545967520\n", - "134 93936530091544 122609 1558603916045996843\n", - "135 93936530091544 101338 1558603916546128266\n", - "136 93936530091544 131591 1558603917045975420\n", - "137 93936530091544 129990 1558603917546013749\n", - "138 93936530091544 125478 1558603918046031894\n", - "139 93936530091544 96406 1558603918546151987\n", - "140 93936530091544 103382 1558603919046145092\n", - "141 93936530091544 34949 1558603919545473258\n", - "142 93936530091544 99755 1558603920046133787\n", - "143 93936530091544 123701 1558603920546032014\n", - "144 93936530091544 43341 1558603921045536148\n", - "145 93936530091544 97141 1558603921546228154\n", - "146 93936530091544 101314 1558603922046213861\n", - "147 93936530091544 100021 1558603922546238339\n", - "148 93936530091544 98485 1558603923046252111\n", - "149 93936530091544 36358 1558603923545664217\n", - "150 93936530091544 37462 1558603924045591481\n", - "151 93936530091544 42755 1558603924545662172\n", - "152 93936530091544 43373 1558603925045696142\n", - "153 93936530091544 66858 1558603925546038168\n", - "154 93936530091544 89301 1558603926046114417\n", - "155 93936530091544 104388 1558603926546593680\n", - "156 93936530091544 37373 1558603927045911557\n", - "157 93936530091544 106532 1558603927546392711\n", - "158 93936530091544 99191 1558603928046493304\n", - "159 93936530091544 100249 1558603928546329764\n", - "160 93936530091544 107166 1558603929046390766\n", - "161 93936530091544 98986 1558603929546398370\n", - "162 93936530091544 105290 1558603930046476694\n", - "163 93936530091544 104391 1558603930546491195\n", - "164 93936530091544 106862 1558603931046423935\n", - "165 93936530091544 105452 1558603931546416605\n", - "166 93936530091544 99013 1558603932046433703\n", - "167 93936530091544 97755 1558603932546508764\n", - "168 93936530091544 101510 1558603933046431141\n", - "169 93936530091544 99555 1558603933546599805\n", - "170 93936530091544 97447 1558603934046668635\n", - "171 93936530091544 98156 1558603934546871368\n", - "172 93936530091544 104431 1558603935046685106\n", - "173 93936530091544 102795 1558603935546701962\n", - "174 93936530091544 105646 1558603936046574872\n", - "175 93936530091544 147913 1558603936547116272\n", - "176 93936530091544 97975 1558603937046858038\n", - "177 93936530091544 103066 1558603937546695510\n", - "178 93936530091544 100997 1558603938046688277\n", - "179 93936530091544 101590 1558603938546729109\n", - "180 93936530091544 37705 1558603939046096405\n", - "181 93936530091544 104430 1558603939546742500\n", - "182 93936530091544 98944 1558603940046883130\n", - "183 93936530091544 99031 1558603940546742462\n", - "184 93936530091544 36906 1558603941046247983\n", - "185 93936530091544 36562 1558603941546110263\n", - "186 93936530091544 37467 1558603942046128766\n", - "187 93936530091544 36573 1558603942546200819\n", - "188 93936530091544 37139 1558603943046214573\n", - "189 93936530091544 85759 1558603943546741660\n", - "190 93936530091544 93728 1558603944046743370\n", - "191 93936530091544 96131 1558603944546769949\n", - "192 93936530091544 45694 1558603945046257326\n", - "193 93936530091544 93356 1558603945546899026\n", - "194 93936530091544 101303 1558603946047006070\n", - "195 93936530091544 100325 1558603946547088327\n", - "196 93936530091544 90855 1558603947046926970\n", - "197 93936530091544 104867 1558603947547066806\n", - "198 93936530091544 96389 1558603948046996616\n", - "199 93936530091544 101290 1558603948547002923\n", - "200 93936530091544 101254 1558603949047181160\n", - "201 93936530091544 92851 1558603949547024820\n", - "202 93936530091544 90349 1558603950047043090\n", - "203 93936530091544 97952 1558603950547065751\n", - "204 93936530091544 37623 1558603951046458270\n", - "205 93936530091544 97369 1558603951547064421\n", - "206 93936530091544 102119 1558603952047018825\n", - "207 93936530091544 106770 1558603952547118839\n", - "208 93936530091544 89877 1558603953047329975\n", - "209 93936530091544 40101 1558603953546550638\n", - "210 93936530091544 38863 1558603954046586791\n", - "211 93936530091544 46395 1558603954546637143\n", - "212 93936530091544 42206 1558603955046616386\n", - "213 93936530091544 38081 1558603955546545943\n", - "214 93936530091544 113429 1558603956047384175\n", - "215 93936530091544 100517 1558603956547168577\n", - "216 93936530091544 42406 1558603957046709710\n", - "217 93936530091544 107518 1558603957547326714\n", - "218 93936530091544 100328 1558603958047195769\n", - "219 93936530091544 99632 1558603958547307010\n", - "220 93936530091544 93084 1558603959047486950\n", - "221 93936530091544 97420 1558603959547460243\n", - "222 93936530091544 99150 1558603960047439190\n", - "223 93936530091544 42406 1558603960546836621\n", - "224 93936530091544 105395 1558603961047340642\n", - "225 93936530091544 102526 1558603961547358252\n", - "226 93936530091544 48036 1558603962047014219\n", - "227 93936530091544 97694 1558603962547597928\n", - "228 93936530091544 101910 1558603963047422808\n", - "229 93936530091544 104184 1558603963547603375\n", - "230 93936530091544 111690 1558603964047431055\n", - "231 93936530091544 107106 1558603964547996969\n", - "232 93936530091544 94686 1558603965047483701\n", - "233 93936530091544 99583 1558603965547498718\n", - "234 93936530091544 92317 1558603966047605233\n", - "235 93936530091544 95488 1558603966547610139\n", - "236 93936530091544 99006 1558603967047605713\n", - "237 93936530091544 96187 1558603967547564817\n", - "238 93936530091544 103197 1558603968047723776\n", - "239 93936530091544 107328 1558603968547614374\n", - "240 93936530091544 42354 1558603969047119328\n", - "241 93936530091544 103100 1558603969547648380\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_publisher_init\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_service_init\n", - "unhandled event name: ros2:rclcpp_service_callback_added\n", - "unhandled event name: ros2:rcl_publisher_init\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "pickle_filename = '../../the-pickle-file'\n", - "with open(pickle_filename, 'rb') as f:\n", - " events = _get_events_from_pickled_file(f)\n", - " print(f'imported {len(events)} events')\n", - " processor = ros_process(events)\n", + "callback_instances = data_model.callback_instances\n", + "callback_symbols = data_model.callback_symbols\n", "\n", - "df = callback_durations_to_df(processor)\n", - "print(df.to_string())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Get a list of callback addresses\n", - "callback_addresses = set(df['callback_address'])\n", - "# Split df\n", - "durations = {}\n", - "for addr in callback_addresses:\n", - " durations[addr] = df.loc[df.loc[:, 'callback_address'] == addr, :]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEWCAYAAACwtjr+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXl8VNXZ+L/PLNkTVkE2QRRUQEFFwK3ihrbVV21d66/SqrWLtravb2tba7W2tvWtVetba+vSutStpVqpdUMlYgFBkB1EAgQSdgLZk8ks5/fHvXdyZzIzmUwyCYHn+/nMJ5Nz7z3n3Dv33uc8y3mOGGNQFEVRlGzi6ekOKIqiKAc/KmwURVGUrKPCRlEURck6KmwURVGUrKPCRlEURck6KmwURVGUrKPCRjlgEBEjIkfb358SkV/Y36eLSGUW2ou2kcGxd4vIX7u6TynaO1NE1ndXewcaInKtiLzd0/1QMkeFjdKliMiXRGSJiNSLyA4ReUNEzujpfvU23IIXwBjzgTHmmJ7sU3chIqPs8/c5ZcaY54wxM3qyX0rnUGGjdBki8t/AQ8AvgcHAEcAfgEt6sl8HGu6X6KGOXotDBxU2SpcgIn2Ae4CbjTEvG2MajDFBY8y/jDHft/eZIiILRaTa1np+LyI5HWjjxyKyV0TKReRaV/nnRWSZiNSKSIWI3B133BkissBut0JEvpKg7mIRmSsiD4uIJNh+pIi8LyJ1IjIHGOja1sbMZ/fxPPv73SIyS0T+KiK1wFdSXQsRmWdXs8LWEK+Kb0NEjhORUvv4NSLyX65tT4nIIyLyb7u/i0TkKHubiMiDIrJbRGpEZKWITEhyvYeKyGwR2SciZSLyNVd5k4j0d+17ov3b+O3/rxeRdSKyX0TeEpGRrn2NiNwsIhuADQmads6/2j7/U0XkKyLyn7g6viUiG+xz/LmIHGVf01oR+Zv73hKRi0RkuX29FojICYnOWckixhj96KfTH+BCIAT4UuxzMjAN8AGjgHXAd13bDXC0/f0p4Bf29+l23Q8AucBZQANwjGv78ViDpxOAXcCl9rYjgDrgGsAPDAAmuduwyxY77SXp+0JX+5+x6/yrq/3KuP3LgfPs73cDQeBSu4/5HbkW8W3Y51EG/BjIAc6x+3OM67z2AVPs+p8DXrS3XQAsBfoCAhwHDElyzu9jaaZ5wCRgD3Cuve094GuufX8D/NH+fqndv+Ps9n8CLIg7tzlAfyA/Qbuj7H18rrKvAP+Jq2M2UAKMBwLAu8BooA+wFphp73sSsBuYCniBmfbvk9vTz82h9FHNRukqBgB7jTGhZDsYY5YaYz40xoSMMeXAn7AER7rcaYwJGGPeB/4NXGnXW2qMWWWMiRhjVgIvuOq9FnjHGPOCsTStKmPMcledQ7Feqn83xvwkUaMicgRwiqv9ecC/OtBvgIXGmH/afWzq5LWYBhQBvzbGtBhj3gNewxKoDi8bYxbbv8dzWMICLKFXDBwLiDFmnTFmR4JzHgGcAdxujGm2r9kTwJftXZ532rM1wavtMoCvA7+y6w5hmVUnubUbe/s+Y0xTmueciPuMMbXGmDXAauBtY8wmY0wN8AZwor3f14A/GWMWGWPCxpinsYTTtE60rXQQFTZKV1EFDExlgxeRsSLymojstM1Jv8RljmqH/caYBtf/W7AEBSIy1TaB7RGRGuAbrnpHABtT1Pt5LE3jjyn2GZqk/Y5Q4f6nk9diKFBhjInE9WeY6/+dru+NWMIJWzD9HngE2CUij4lISZI29hlj6pK0MQs4VUSGYml6BvjA3jYS+J1tsqrG0rIkrn8x1yNDdrm+NyX4v8jVn9uc/th9GoF9/yjdgwobpatYCDRjmVCS8SjwCTDGGFOCZQZq4x9JQj8RKXT9fwSw3f7+PJZJZYQxpg+W4HDqrQCOSlHv48CbwOtx9bvZkaR9hwagwPlHRLzAYXF1xKdX78y12A6MEBH383sEsC2dg40xDxtjTsYyP40Fvp+kjf4iUpyoDWNMNfA2lnb5JeAFY4xzjhXA140xfV2ffGPMAnc3UnUxnfPoABXAvXH9KTDGvNDF7SgpUGGjdAm26eKnwCMicqmIFIiIX0Q+KyL/a+9WDNQC9SJyLPDNDjbzMxHJEZEzgYuAv7vq3WeMaRaRKVgvP4fngPNE5EoR8YnIABGZFFfvLcB64DURyU9wbluAJa72zwAudu3yKZAnVqCCH8tHkdvOubR3LXZh+R8SsQhLwP3AvsbT7f682E6biMgptibot+toBsLx+xljKoAFwK9EJM92qN+AdT0dngeuA75IqwkNLGH/IxEZb7fZR0SuaK9vLvYAEZKff0d5HPiGfd4iIoX2b1Xc7pFKl6HCRukyjDEPAP+N9bLdgzWivAX4p73L/2AJgjqsF8BLHah+J7Afa8T9HPANY8wn9rZvAfeISB2WwPubq09bgc8Bt2GZc5YDE+P6bYCb7P6+KiJ5Cdr/EpaDeR9wF/CM6/gauw9PYI38G4D2JqG2dy3uBp62zT5XxvW3Bfgv4LPAXiwn/nWu65GKEru9/VhmsSrg/iT7XoPlrN8OvALcZYyZ49o+GxgD7DLGrHD17xXgPuBF20S42u5rWhhjGoF7gfn2+XfKt2KMWYLlt/k91nmXYQUcKN2ItGq+iqIoipIdVLNRFEVRso4KG0VRFCXrqLBRFEVRso4KG0VRFCXraBI8m4EDB5pRo0Z1qo6GhgYKC5NN1ehd6LkcmBws53KwnAfouSxdunSvMSZ+XlkbVNjYjBo1iiVLlnSqjtLSUqZPn941Heph9FwOTA6WczlYzgP0XEQkrWwaakZTFEVRso4KG0VRFCXrqLBRFEVRso76bBRFyYhgMEhlZSXNzc0dPrZPnz6sW7cuC73qfg6Vc8nLy2P48OH4/f6M6lZhoyhKRlRWVlJcXMyoUaOQtoubpqSuro7i4oMjD+ahcC7GGKqqqqisrOTII4/MqG41oymKkhHNzc0MGDCgw4JG6X2ICAMGDMhIi3VQYaMoSsaooDl06OxvrcKmk7y7bhd/KC3r6W4oiqIc0Kiw6STvf7qHx+dt6uluKMohy+9+9zsmTJjA+PHjeeihhwC48847OeGEE5g0aRIzZsxg+3ZrUdf9+/dz2WWXccIJJzBlyhRWr14NWCbBKVOmMHHiRMaPH89dd90Vrd8Ywx133MHYsWM57rjjePjhhwFrAmSfPn04/fTTmTRpEvfcc0+7dW3evJmpU6cyZswYrrrqKlpaWgAIBAJcddVVHH300UydOpXy8nIAWlpa+OpXv8rxxx/PxIkTKS0tjdZ1xx13MGLECIqKinDz1FNPcdhhhzFp0iQmTZrEE088EbO9traWYcOGccstt7S5lldddRUTJkzo8G+QDipsOonXI4TCuiaQovQEq1ev5vHHH2fx4sWsWLGC1157jQ0bNvD973+flStXsnz5ci666KKoIPjlL3/JpEmTWLlyJc888wy33norALm5ubz33nusWLGC5cuX8+abb/Lhhx8C1su7oqKCTz75hHXr1nH11VdH2z/zzDOZP38+y5cv56c//Wm7dd1+++1873vfY8OGDfTr148nn3wSgCeffJJ+/fpRVlbG9773PW6//XYAHn/8cQBWrVrFnDlzuO2224hEIgBcfPHFLF68OOF1ueqqq1i+fDnLly/nxhtvjNl25513ctZZZ7U55uWXX85q2h0VNp3E7/UQiqiwUZSeYN26dUybNo2CggJ8Ph9nnXUWr7zyCiUlJdF9Ghoaov6GtWvXcu655wJw7LHHUl5ezq5duxCRqIYQDAYJBoPRYx599FF++tOf4vFYr8tBgwal7FOyuowxvPfee1x++eUAzJw5k3/+01rE9tVXX2XmzJkAXH755bz77rsYY2L6O2jQIPr27RtNqzVt2jSGDBnSoeu1dOlSdu3axYwZM2LK6+vreeCBB/jBD37Qofo6goY+dxKvRwjZIw1FOVT52b/WsHZ7bdr7h8NhvF5vyn3GDS3hrovHp9xnwoQJ3HHHHVRVVZGfn8/rr7/O5MmTAcvM9Mwzz9CnTx/mzp0LwMSJE3n55Zc544wzWLx4MVu2bKGyspLBgwcTDoc5+eSTKSsr4+abb2bq1KkAbNy4kZdeeolXXnmFww47jIcffpgxY8YAsHDhQk477TSGDx/O/fffz/jx46PnF1/X3r176du3Lz6f9dodPnw427ZtA2Dbtm2MGDECAJ/PR58+faiqqmLixIm8+uqrXH311VRUVLB06VIqKiqYMmVKyuvyj3/8g3nz5jF27FgefPBBRowYQSQS4bbbbuPZZ5/l3Xffjdn/zjvv5LbbbiM/Pz9lvZ1BNZtO4veIajaK0kMcd9xx3H777Zx//vlceOGFTJw4Mfoyv/fee6moqODaa6/l97//PQA//OEP2b9/P5MmTeL//u//OPHEE6P7e71eli9fTmVlJYsXL476cwKBAHl5eSxZsoSvfe1rXH/99QCcdNJJbNmyhQULFvDtb3+bSy+9NNqvRHUZ0/Y94WhPybZdf/31DB8+nMmTJ/Pd736X0047LdrfZFx88cWUl5ezcuVKzjvvvKjG9Ic//IHPfe5zUaHmsHz5csrKyrjsssvav+CdwRijH2M4+eSTTSY8NOdTM/L210woHDFz587NqI4DET2XA5MD6VzWrl2b8bG1tbVd2JNWfvSjH5lHHnkkpqy8vNyMHz++zb6RSMSMHDnS1NTUtNl29913m9/85jfGGGOOOeYYs3nz5ugxJSUlMfs65zJy5EizZ8+epHVFIhEzYMAAEwwGjTHGLFiwwMyYMcMYY8yMGTPMggULjDHGBINBM2DAABOJRNrUdeqpp5o1a9bElBUWFra9EDahUCja3y996UtmxIgRZuTIkWbAgAGmuLjY3H777eYPf/iDGTJkiBk5cqQZOnSo8fv95qyzzkpYX6LfHFhi0njHqmbTSXxea2SipjRF6Rl2794NwNatW3n55Ze55ppr2LBhQ3T77NmzOfbYYwGorq6ORoA98cQTfOYzn6GkpIQ9e/ZQXV0NQFNTE++88070mEsvvZT33nsPgPfff5+xY8cCsHPnzqhGsnjxYiKRCAMGDEhal4hw9tlnM2vWLACefvppLrnkEgD+67/+i6effhqAWbNmcc455yAiNDY20tDQAMCcOXPw+XyMGzcu5fXYsWNHzLkfd9xxADz33HNs3bqV8vJy7r//fq677jp+/etf881vfpPt27dTXl7OW2+9xdixY2Oi3roK9dl0Ep/HFjYakaYoPcIXv/hFqqqq8Pv9PPLII/Tr148bb7yR9evX4/F4GDlyJH/84x8BK6Dguuuuw+v1Mm7cuGg02I4dO5g5cybhcJhIJMKVV17JRRddBFimt2uvvZYHH3yQoqKiaCjxrFmzePTRR/F4PBQWFvLiiy8iIinruu+++7j66qv5yU9+woknnsgNN9wAwA033MCXv/xljj76aPr378+LL74IWIL0ggsuwOPxMGzYMJ599tnoef/gBz/g+eefp7GxkeHDh3PjjTdy99138/DDDzN79mx8Ph/9+/fnqaee6pbfoT3EkcyHOpMnTzaZLJ725H828/PX1rLirhksWzT/kF5E6UBFzyU7rFu3Ljpq7iiHQj6x3kh755LoNxeRpcaYye3VrWa0TtKq2agZTVEUJRkqbDqJ47MJa0SaoihKUlTYdBJHswmqsFEOQdQMf+jQ2d86a8JGREaIyFwRWScia0TkVrv8bhHZJiLL7c/nXMf8SETKRGS9iFzgKr/QLisTkR+6yo8UkUUiskFEXhKRHLs81/6/zN4+Klvn6bNnFYc1QEA5xMjLy6OqqkoFziGAsdezycvLy7iObEajhYDbjDEfi0gxsFRE5tjbHjTG3O/eWUTGAVcD44GhwDsiMtbe/AhwPlAJfCQis40xa4H77LpeFJE/AjcAj9p/9xtjjhaRq+39rsrGSTpmtKCGPiuHGMOHD6eyspI9e/Z0+Njm5uZOvbgOJA6Vc3FW6syUrAkbY8wOYIf9vU5E1gHDUhxyCfCiMSYAbBaRMsDJyVBmjNkEICIvApfY9Z0DfMne52ngbixhc4n9HWAW8HsREZOFIVhUs1EzmnKI4ff7M161sbS0lBNPPLGLe9Qz6LmkR7fMs7HNWCcCi4DTgVtE5DpgCZb2sx9LEH3oOqySVuFUEVc+FRgAVBtjQgn2H+YcY4wJiUiNvf/euH7dBNwEMHjw4IwmMn2yy2p+4aLFDPA0ZWUyVE9QX1+v53IAcrCcy8FyHqDnki5ZFzYiUgT8A/iuMaZWRB4Ffg4Y++9vgeuBRMvAGRL7lUyK/WlnW2uBMY8Bj4E1zyaT+Qvhdbtg2RJOPOlk9pUtP2DmQHSWA2k+R2fRcznwOFjOA/Rc0iWr0Wgi4scSNM8ZY14GMMbsMsaEjTER4HFaTWWVgDtD3HBge4ryvUBfEfHFlcfUZW/vA+zr2rOz8DrRaBogoCiKkpRsRqMJ8CSwzhjzgKvcvQDDZcBq+/ts4Go7kuxIYAywGPgIGGNHnuVgBRHMtv0vc4HL7eNnAq+66pppf78ceC8b/hqw1rMB9dkoiqKkIptmtNOBLwOrRGS5XfZj4BoRmYRl1ioHvg5gjFkjIn8D1mJFst1sjAkDiMgtwFuAF/izMWaNXd/twIsi8gtgGZZww/77rB1ksA9LQGUFr2YQUBRFaZdsRqP9h8S+k9dTHHMvcG+C8tcTHWdHqLVZRcgY0wxc0ZH+Zoo/mvVZNRtFUZRkaAaBTuK1Q591iQFFUZTkqLDpJLrEgKIoSvuosOkkPjWjKYqitIsKm07ii5rRVNgoiqIkQ4VNJ9H1bBRFUdpHhU0nUTOaoihK+6iw6SRRM5oGCCiKoiRFhU0naV2pU81oiqIoyVBh00l8mhtNURSlXVTYdBKf5kZTFEVpFxU2nSSq2agZTVEUJSkqbDqJI2zCakZTFEVJigqbThJdz0bNaIqiKElRYdNJRASfRzQaTVEUJQUqbLoAr0d0no2iKEoKVNh0AX6vRzMIKIqipECFTRdgaTZqRlMURUmGCpsuwO8V1WwURVFSoMKmC1CfjaIoSmpU2HQBPo/6bBRFUVKhwqYL8HmFkIY+K4qiJEWFTRfg86jPRlEUJRUqbLoAn8ej0WiKoigpUGHTBfi8olmfFUVRUqDCpgvweUTXs1EURUmBCpsuwOf1qGajKIqSAhU2XYDXIwTVZ6MoipIUFTZdgF99NoqiKClRYdMFeD0eXc9GURQlBSpsugC/rmejKIqSEhU2XYDmRlMURUmNCpsuQNezURRFSY0Kmy7A69EAAUVRlFRkTdiIyAgRmSsi60RkjYjcapf3F5E5IrLB/tvPLhcReVhEykRkpYic5Kprpr3/BhGZ6So/WURW2cc8LCKSqo1s4fNq6LOiKEoqsqnZhIDbjDHHAdOAm0VkHPBD4F1jzBjgXft/gM8CY+zPTcCjYAkO4C5gKjAFuMslPB6193WOu9AuT9ZGVvCpZqMoipKSrAkbY8wOY8zH9vc6YB0wDLgEeNre7WngUvv7JcAzxuJDoK+IDAEuAOYYY/YZY/YDc4AL7W0lxpiFxhgDPBNXV6I2soLP69F0NYqiKCnwdUcjIjIKOBFYBAw2xuwASyCJyCB7t2FAheuwSrssVXllgnJStBHfr5uwNCMGDx5MaWlpRue3a0eA5kCI+vrmjOs40Kivr9dzOQA5WM7lYDkP0HNJl6wLGxEpAv4BfNcYU2u7VRLumqDMZFCeNsaYx4DHACZPnmymT5/ekcOjzKtby+JdFRQV5ZJpHQcapaWlei4HIAfLuRws5wF6LumS1Wg0EfFjCZrnjDEv28W7bBMY9t/ddnklMMJ1+HBgezvlwxOUp2ojK1grdaoZTVEUJRnZjEYT4ElgnTHmAdem2YATUTYTeNVVfp0dlTYNqLFNYW8BM0Sknx0YMAN4y95WJyLT7Laui6srURtZwVqpU6PRFEVRkpFNM9rpwJeBVSKy3C77MfBr4G8icgOwFbjC3vY68DmgDGgEvgpgjNknIj8HPrL3u8cYs8/+/k3gKSAfeMP+kKKNrKDLQiuKoqQma8LGGPMfEvtVAM5NsL8Bbk5S15+BPycoXwJMSFBelaiNbOHzejAGIkYFjqIoSiI0g0AX4PVYMlWjnxVFURKjwqYL8HttYaNuG0VRlISosOkCvB7rMqpmoyiKkhgVNl1AVLNRYaMoipIQFTZdgOOziWhEmqIoSkJU2HQBfjWjKYqipKTd0GcRGQ5cDZwJDAWagNXAv4E3jDGHvFtco9EURVFSk1LYiMhfsJJbvgbch5X2JQ8Yi5XO/w4R+aExZl62O3og49NoNEVRlJS0p9n81hizOkH5auBlEckBjuj6bvUufLYZTV02iqIoiUnps0kkaOwcZSfY21uMMWXZ6lxvwdFsQppBQFEUJSFpBQiISKmIlNirZq4A/iIiD7R33KGCz4lGU1mjKIqSkHSj0foYY2qBLwB/McacDJyXvW71LnxeOxpNfTaKoigJSVfY+Ox1Ya7EChZQXPg0Gk1RFCUl6Qqbe7DWlSkzxnwkIqOBDdnrVu9ChY2iKEpq0lpiwBjzd+Dvrv83AV/MVqd6G06AgC4xoCiKkpi0hI2IHAZ8DRjlPsYYc312utW7cEKfQ+qzURRFSUi6i6e9CnwAvAOEs9ed3olXo9EURVFSkq6wKTDG3J7VnvRi/F7NjaYoipKKdAMEXhORz2W1J70YzY2mKIqSmnSFza1YAqdJRGpFpE5EarPZsd5E60qdKm0URVESkW40WnG2O9KbUZ+NoihKalJqNiIyqp3tYi9BcEijPhtFUZTUtKfZ/EZEPFjRaEuBPVhLDBwNnA2cC9wFVGazkwc66rNRFEVJTUphY4y5QkTGAdcC1wNDgEZgHfA6cK8xpjnrvTzAia7UqfNsFEVREtKuz8YYsxa4oxv60mvxelWzURRFSUW60WhKClpzo6m0URRFSYQKmy5A17NRFEVJjQqbLiAaIKA+G0VRlISkm64GERkGjCQ2Eee8bHSqtyEi+DyiPhtFUZQkpJv1+T7gKmAtrYk4DaDCxsbnVWGjKIqSjHQ1m0uBY4wxgWx2pjfj83iIqNNGURQlIen6bDYB/mx2pLfj8wohlTWKoigJSVezaQSWi8i7QFS7McZ8Jyu96oX4PKIrdSqKoiQhXWEz2/4oSfB5PISNhqMpiqIkIi0zmjHmaeAFrPxoS4Hn7bKkiMifRWS3iKx2ld0tIttEZLn9+Zxr249EpExE1ovIBa7yC+2yMhH5oav8SBFZJCIbROQlEcmxy3Pt/8vs7aPSuxSdw+sRDX1WFEVJQlrCRkSmAxuAR4A/AJ+KyGfaOewp4MIE5Q8aYybZn9ft+scBVwPj7WP+ICJeEfHabX4WGAdcY+8LcJ9d1xhgP3CDXX4DsN8YczTwoL1f1vF7RTMIKIqiJCHdAIHfAjOMMWcZYz4DXID1Ik+KPQdnX5r1XwK8aIwJGGM2A2XAFPtTZozZZIxpAV4ELhERAc4BZtnHP40VMefU5Whds4Bz7f2zitcjmkFAURQlCen6bPzGmPXOP8aYT0Uk0+i0W0TkOmAJcJsxZj8wDPjQtU+lXQZQEVc+FRgAVBtjQgn2H+YcY4wJiUiNvf/e+I6IyE3ATQCDBw+mtLQ0w1OCQFMjgdxIp+o4kKivr9dzOQA5WM7lYDkP0HNJl3SFzRIReRJ41v7/WizfTUd5FPg51oTQn2NpTNcDiTQPQ2LNy6TYn3a2xRYa8xjwGMDkyZPN9OnTU3Q9NX1WfoAEG+hMHQcSpaWlei5dxBMfbGLR5n08ft3kTtfV0+fSVRws5wF6LumSrhntm8Aa4DvArViZBL7R0caMMbuMMWFjTAR4HMtMBpZmMsK163Bge4ryvUBfEfHFlcfUZW/vQ/rmvIzxeT2aQUBJyNIt+1m8Oeu3oKIc0KQbjRYwxjxgjPmCMeYyY8yDmWQTEJEhrn8vA5xItdnA1XYk2ZHAGGAx8BEwxo48y8EKIphtjDHAXOBy+/iZWKuJOnXNtL9fDrxn759VdJ6NkozqxiB1zUG64TZUlAOWlGY0EfmbMeZKEVlFAlOUMeaEFMe+AEwHBopIJdby0dNFZJJdVznwdbueNSLyNyyNKQTcbIwJ2/XcArwFeIE/G2PW2E3cDrwoIr8AlgFP2uVPAs+KSBmWRnN1exehK/B5hJCGPisJqG4KEjHQ0BKmKDft3LeKclDR3p1/q/33oo5WbIy5JkHxkwnKnP3vBe5NUP461hLU8eWbaDXDucubgSs61NkuwOfVaDQlMTWNLQDUNQdV2CiHLCnNaMaYHfbXbxljtrg/wLey373eg5VBoKd7oRyIVDcFAahrDrWzp6IcvKQbIHB+grLPdmVHeju6no2SiEAoTGOLtSpHXXOwh3ujKD1Hez6bb2JpMKNFZKVrUzEwP5sd6234vEJY7WhKHDVNrQKmtkk1G+XQpT0D8vPAG8CvgB+6yuuMMRrL6cLn8ajPRmlDdaNL2KhmoxzCpBQ2xpgaoAa4BkBEBgF5QJGIFBljtma/i70DXalTSYRb2KjPRjmUSTcR58UisgHYDLyPFbb8Rhb71evwqs9GSUC1HYkGKmyUQ5t0AwR+AUwDPjXGHAmci/psYvB7PN2+xMD+hpb2d1J6lOomNaMpCqQvbILGmCrAIyIeY8xcYFIW+9Xr8HazGW13XTOn3PsOb63Z2X2NKh2mxjaj5fg8Go2mHNKkK2yqRaQImAc8JyK/w5rpr9j4Pd27ns3euhZCEcM7a3cl3G6M0ei4A4Dqpha8HmFwSa6a0ZRDmnSFzSVAI/A94E1gI3BxtjrVG/F2czRaIGTN3ViwsSphzq0/zy9nwl1vcf9b69V804NUNwbpm++nT75fhY1ySNOusLFXy3zVGBMxxoSMMU8bYx62zWqKjTXPpvvaC9iJ2LZVN7GlqrHN9jXbawiGI/x+bhln/e9cPtiwp/s6p0SpbgrSp8BPca6f2iYV+sqhS7vCxk6I2SgifbqhP72W7s4g0BwMR7/P39hmXTh21waYMKwPr337DAYW5fK9l1bEREYp3UONrdkU5/lUs1EOadI1ozUDq0SVwJ2TAAAgAElEQVTkSRF52Plks2O9DUfYdFca+YArxfSCsrZK5u66ZgYV5zJhWB8eunoS1Y0t3POvtd3SN6WV6qYW+hbkUJzn1wAB5ZAmXWHzb+BOrACBpa6PYuPzWpeyu/w2jrCZOKIvCzdVEYlreHddgEEluQCMH9qHb00/ipeXbeO9TxIHFCjZwfHZlOSrZqMc2qS7eNrTiT7Z7lxvwuuxVqMOdpPjxjGjnXPMIPY1tPDJzrrotkAoTHVjkEHFedGyW84ZwzGDi/nxy6s1Sq0bqWm0fTZ5fuoCIb32yiFLuhkENovIpvhPtjvXm/B7LWHTXS8TR7M559hBACxw+W321FmLqA62NRuw5nl8+dSR7Kxtjm5Ph0176qnY1zYAQWmfYDhCXSBEv4IcSvKszFD1AdVulEOTdM1ok4FT7M+ZwMPAX7PVqd6I12NdylA3RQkEbM1m5MACRh9WyPyyVmGz2xYmbs0G4PAS6/9dtc1pt/O9l5bzM/X1ZIQTfda3wE9Jnh/QZQaUQ5d0zWhVrs82Y8xDwDlZ7luvwtFsQpHuMaM5mk2uz8PUI/uzrKI6um23LUwOK86NOWZwBsJm894GDdnNkP129oA+djQaaH405dAlrTVqReQk178eLE2nOCs96qU4PptQd5nRgmFEIMfrYfTAIqobg1H/QFSzKYkXNtb/u9I0o9U2B6ltDtEcCre/s9KGmiYr1LxvQQ5ese4PFdzKoUq6C6L/1vU9hJX1+cou700vxu+Y0bpJ2DSHIuT6PIgIRwwoAGDLvgZOKOjL7toAHoEBhbHCZkBRLl6PsKsmPc1m2/4mAJpaVNhkgrO8QN98f7RMNRvlUCUtYWOMOTvbHentRDWbbopGCwTD5Pq8AIwaUAhAeVUjJwzvy+66Zg4rzo32yd3Hw4py0zajVdrCRjWbzIgKmwJ/NCS+LqCajXJo0t6y0P+darsx5oGu7U7vxeftZjOardkAHNHf1mz2NgD2HJu44ACHwSW5aZvRKvdbUWhNLd28dsJBgrO8QN/8HIK2L081G+VQpT3NxvHLHIMViTbb/v9irAmeio2vm6PRmoNh8vyWZpOf4+XwkjzK7Rxpu2oDDO2TWNgMKslja4JcaolwNJtAUDWbTKhpbEEEivN8UWGjPhvlUKW9ZaF/BiAibwMnGWPq7P/vBv6e9d71Inw9EI3maDYAIwcUsKXK0mz21DUzaUTiVHaDS3L5qHxfWm1ENRsVNhlR3RSkT74fj0fI9XjtNW1Us1EOTdKdZ3ME4M7i2AKM6vLe9GJ8UZ9N95nRHM0GLL9NeVUjoXCEqoaWpGa0w0vyqG4MxiTyTIaj2YQiptsyIxxMOKlqHEry/NSqsOlR5n26h3+t2N7T3TgkSTca7VlgsYi8AhjgMkDT1bhwcqN1WzRaMByr2QwsYG99gPKqRoxpG/bsMMiea7OnLsAI29eTjG3VTTHt+b3pjk0UcJYXyIn+X5Ln00mdPcwT/9nM2u01XHTCEESk/QN6gH0NLfQr8B+w/cuUdCd13gt8FdgPVANfNcb8Kpsd6204mk13pqvJ9buETX8rIm3pFstEljxAwCrf2U5EWlPIUN0YZHi/fACag6rZdJSaxpYYzaY4z6eaTQ/T3BJmb31LwjWgDgQ2721g6i/f4U/zDr5sYGkPVY0xHxtjfmd/lmWzU70RXzeHPjcHw+T5Ws1oI+25Nos37wdgUHFizSY6sbMdYbO3yRKaRw8qirandIzqpiB9C9zCRpcZ6Gkc/+OSLft7uCeJeWHxVoJhwwNzPqVsd31Pd6dLUbtIF9Ejoc/+2AABgMXl1to2ycxog4udlDWpw5/3NllCc4wKm4xp47PRZQZ6HEfYOBaAA4lAKMyspZVMG92ffL+XH/5jZZulQ3ozKmy6iGjoc7dFo7VO6gRr1DywKIeKfU2IwMCixMKmb4GfHJ8nmj8tGfGaTW+ISNtbH0g7Q3W2zZ3hiKG2OdZno0tD9zxONowl5W01G2MMj8wtY7vLV9mdzFm7i30NLXzjrKO486JxLNmyn2c/3NJl9TcHw8xesb3HBJgKmy7C283RaM3BCHn+2J9vpJ1JYEBhTlJnvogwuCS3XZ/N3iar/mF9C6Lt9TR76wPc/PzH7K1PrJV9668fc+WfFqYUJI0tIW5+7mMm/uxtfvXGOnbXpZ+UtCPUNQcxhjY+G9VsMuNvSyqY8eD7BDqZzaLJzim4YXd9m2XSd9Y285u31vPgnE871UamvLi4gmF98zlzzGF88aRhnDlmIA++82mXDYx++upqvvPCMlZvr+mS+jqKCpsuwt/N0WjudDUOjintsCTBAQ6Di/PS8tkM65tPfo51XgeCZrN8azX/XrmDvyYY7a3eVsPi8n3sqGmOWdvnvU928fjKAK8u38b6nXVc8ceFvLF6B5NG9OXxeZs44765vL5qR5f3deFGy5zZv9Cl2eT5aQqGD7ow8k176tmZZr69TNhW3cTPZq/h0131nfZjNLWEmTDUmoP28dZY7aYhYN3js1dsbyOIOsKmPfVc/9RHbNqTfl+3VDXwn7K9XHXKCLweQUT4wknDqG4Mst61MGKmvLZyO39bUgn0XBYLFTZdRLdnfY7z2UBrjrRkwQEOg0vy2O3y2SQKaqhqMgzvVxCdy9PdPpvV22q48KF51Loc6o12H15cXNGmz3+ZX05BjpfiPB+vfLwNsBYvu/Ofa5i/PcStLy7ngofmsbWqkSe/cgp/vXEq7902ndEDC/n1G590avS4fmcdp/7qXX7+2lqqG1t4c/UOvvPiMiYMK+Hc4wZF9yvJtxdQ68DDvmDjXs65v7RDy0J0Nzc+s4TvvJCdmCFjDD95ZRXN9pIanXnxGmNoCoaZNro/Po+0MaU1tli/SyAUYdbSyozbWba1mvc+2c1Vj33Ip7va7284Ynj43TI8AldOHhEtP2VUf4C0J2Eno3J/Iz96eVX0vdDQQwv4ZU3YiMifRWS3iKx2lfUXkTkissH+288uFxF5WETKRGSle0kDEZlp779BRGa6yk8WkVX2MQ+LHZSerI1sE13PphtGrcYYO4NAYs2mPWEzqKQ1Geery7cx6Z45baKk9jZFGN4vv8eEzZy1u/hkZx2V+1rt5032y2BnbTPvfbK7ta/1Af61YjtfPGk4F50whDfX7KQhEGL28u1sq27i1pNy+cc3T+NHnz2WV24+nbOPsQTAqIGFfPe8MWzd18gbqzPXbh5+bwNV9S38Zf5mzvzfudz8/DKOH9aH526cRnFebDQaWEs3/HvlDm56Zkk060My1u2oY9PeBh56p2dMO+2xv6GFTXsaWFy+L5pxoiv518odzF2/hx9ccAw5Xk+nhI2zBlT/wlzGDy1JIGyse7wgx8tfP9ySsW/DEVotoQhX/Wkha7fXJt13T12ALz+5iH98XMkNZxzJ4a40U8P7FTC0Tx6LOylsfvTyKoyB31wx0e5f67O8bkct038zlw83VXWqjXTIpmbzFHBhXNkPgXeNMWOAd+3/AT4LjLE/NwGPgiU4gLuAqcAU4C6X8HjU3tc57sJ22sgq2dRsAqEwT83fHH3huxdOc+P4bJy5NMk4vCSPhpYwdc1BHi3dSH0gxN76VrNBfSBEfdC62fNTCBtjDIs2VWUlnHf1Nsuu3BRsHYU5D0lJno/nFm2Nlr+waCst4QgzTxvFF04aTmNLmDdW7+TR9zdy7OHFTDrMy8kj+/H1s46KBjw4nD/ucI4cWMif3t+EMbG/3b6GFp5btCX68kjEpj31vL5qBzeceSRv3PoZph45gHOOHcSzN0ylj8tfA0QXUNu6r5Efv7KKt9fu4rO/+4DnF21lSfk+/jJ/cxsToSNgX/qogrLdnTenZEJzMMyHm6oS3gPLK1sX7fvXilaBvbc+wNtrdvLuul0s3FiV0Yu7urGFn81ew8ThfbjxzNEcNaiITzohbJzggHy/h5NH9mdFZTUtodbBofM7XzPlCMqrGvmPa/XbjtBgt/PC16YhIkkHChX7Gvn8wx/w8db93H/FRO74/Lg2+0w5sj+LN+9rc2+my9rttXywYS/fPudojj3cSnXpFjbVjcHoRPBskzVhY4yZB8SL5EtozTzwNHCpq/wZY/Eh0FdEhgAXAHOMMfuMMfuBOcCF9rYSY8xCY/0Kz8TVlaiNrBL12WQhQOCljyq4+19rWWiPPhxh405XAzD6sEKKc32MPTz1unaOMJq9Ynv04XW/UJ11bNyaTaI1bZ5btJWrHvuQU3/1HnfPXpN2gs90WGULG8eObvXR+v6lqSOZt2EPFfsa2VHTxLMfbuEzYw/j6EFFTB7ZjxH98/nV6+so213PN6cflXImttcj3PSZ0azaVsOCja2ju5ZQhK8/u4Q7XlnNBQ/NY0GSF8+f3t9EjtfD9acfyTGHF/PEzMk8ft1kCnPbJudwhM29/15HfSDEX756CpNG9OXHr6zi8j8u5Gf/WstP/rk65rdobAnj9QgFOT7ue3N9B65g1/Fo6UaufuxDTv75HL7zwrIYX8SKimpE4NjDi3l1uWW+bGoJc8nv53PTs0u54eklXPP4h/w7A7/Yr17/hOqmIL/6wgl4PcKxhxd3SrNx/I75OV5OGdWPQCgS4yx37rUvnDSMgUU5/H5uGSsqqjvsY2sMhKLXZOzgIvYn8P+EwhG++9JymlrCvPKt07n85OEJ6zrlyP7sqQtkPAn16QXl5Pu9XH3KERTkWM+y+/5yTGqFud6Ex3cl3e2zGWyM2QFg/3UM2sOACtd+lXZZqvLKBOWp2sgq3mgGga41o0Uihr/MLwdaHXtOFuZ4zaYkz8+HPz6Xi08YkrJOZw7Ow+9uiJa5hcm2auvGHtYvv1WzCcWeV9nuOn7x77VMG92f88cN5rlFWzj7t6XcPmtlp80pu2ubo6uNukdhTS1hPAIzTxuJAFf9aSGn/fo99tYH+MZnRgNWtN1lk4ZR1dDCEf0L+Pzxqa8FwGUnDmNgUS6PzC2LRjvd+++1fFS+n++cczQ+j4cvPbGIn/xzVcx12lHTxMvLKrnqlBFtluBORIltRvtkZx1fnjaSs48ZxF9vmMof/99JPH7dZG49dwzQVsAW5fr4xlmjmbN2F2+XB3n540reXL0z49FuR4hEDLOWVnLC8D5cPHEo767bxd3/WhvdvryimrGDirlmyhF8srOO9Tvr+P3cDWyrbuLha07k1ZtPZ0ifPF5Ztq1D7S7aVMVLSyq48cwjGTe0BIBjDi9mZ20zNY2ZadKOsMnze6MDMrcZ03kJ9y3I4RtnHcXizfu45JH5TPzZ27y1ZmfCOjfvbeCjnbGab0NLmAK/F49HKMr1J3TIP1q6kaVb9vPzSydw3JCSpH2eeqTlt3FMaa+t3M6NT3+U1Me4eltNdFrD/oYW/rl8G5eeOIw+BX4KcqzBjvv+amhxhE26mcsyJ/stpEeioafJoLxjjYrchGWKY/DgwZSWlna0iigNQav5t5esZ0d5GQPyhaP6dn60sHx3iM17rRfvxyvXULL/U/Y0Wi/+zWWfUtq8ucN17qi3jt9VG2BsPw+f7o/w4ZKPqS+3bocPt1s34KerllG90brUn2zYSKmx5H4wYrhnYTN+Ilx9RBN98wJ85sw8Xt8c5B9LK5i1tII7puUxuk9m5798d+vDuXTFKvL2fmL1Z1OAHA+sX7aIM4f52LA/wKVH+Zk2xEdL5WpK7eHHsGAEn8B5Q0P854N51NfXt/vbnj/c8MInVZxyz5uMG+Dlwx1hLhzl46ScHUw40fDyBh9//XAr76yqYOa4XBpDhvcrQoQjhuP9u9O6d3bbv1uxH07J301p6R4AHKNnw27rJTr3g/kMKrAGEhu3BPCaMGMilfTPE57/pIXnP1kBwC/PyGdoUXbHi2urwmyrbubiIyJMGxCieqiHORv28PqcueT7YMmmRk4c5KNv3WY8Ane8MJ9lu8OcPtRHyf5P2b8fJvUP8/b63fzr7bkU51j3k/Ob7G6MUNVkOG5A670SjBjunN/EwHzhpJydlJbuAqBlj3VfvPjmPI7p3/F7a0ut9ZLduH4dZqd13ZatWke/mjIAVpZb13/Z4g85Okd4cHo+G6oj/HNDC3e9/DH+3fl4bC25KWSYvTHI2+VBwgbG9HuPvrlWnWXlAXwSobS0lIaaZvbWRGLuj03VYR5c1My0IV761mygtLR10BePMYZiP8xeuJa8fWX86INGGoLwf7PeZdKg2Nf32qowv13STHGO8P3JeazYEyIQijDOvyfavt8Dn2zcTKnPEv7LKqxzXrl0MRV5nrSelUzpbmGzS0SGGGN22KYwx8tbCYxw7Tcc2G6XT48rL7XLhyfYP1UbbTDGPAY8BjB58mQzffr0ZLu2SyAUJmfum3ywLcQH20Lk+jysu+dCPJ7kJpx0ePyJD+lXEGF/Y5Dho45i+pmj2bCrDubNY9Lx45k+cWiH66wPhPjRf97CI/D9i0/ia88s4ehjJzB9wuEAbFu0BVau5uwzT2NwSR65777B4GEjmD79OAAeeHs9FXVlPHHdZM4bNzha72VA2e56znvgfWTgaKaffmRG57zy3Q2AZeceedRYpk8bCcBb+1ZSvG8306dPp72f6sKzg/SxU8WUlpbS3m97ljFcuGEvzywo5731uzntqAH8/vop0QSrM86F+WV7ue1vK7jvI2vkmOPz8O1zxnDF+WPTOq/mYJjfrXyf/7lgLJ8/sa3ZpGnVDp5Y9THHnzg5Otr9+/aP6ddSywXnTeeUU1t4473/4B8yhh/MWskxx0/i5JH902o7U2a/tJzi3F1894qzyfN7KT5yH28+upDgYWMZP6Iv9W+V8tkpx3HJ1CP4x7bFzPt0DyV5Ph766vSotjdobC1vPPwB1SWjudj+LZ3f5JrHPmTjnnoW3zE92ubTC8rZ2bCGp756CtOPaTVMHFvTzANL3yV/yFFMP3VUh8/lo/J9sGAhp5w0kZOO6AelbzF05Gimn3UUAGvmlsEn65lxzlnkuKwGx67YzndeWEZ48DjOGTeYmqYgF//ff9i6L8hxQ0pYt6OWCSdOifoDX96xjH5N1UyfPp13q1ezrnp7zP337FMfMbDI8Kebzmrj10vEqRVLWL+rjg9q+hMIN9GvwMeKhhK+O31KdJ+Ne+r5ziPzGTWwkLrmEPcvC+H3eph6ZH++fPGp0f2KP5jDwMFDmD59AgBlH2yCNes4b/qZFOf503pWMqW7zWizASeibCbwqqv8OjsqbRpQY5vA3gJmiEg/OzBgBvCWva1ORKbZUWjXxdWVqI2skuvzct9n8nnj1jP5+lmjCYQi1KdwLKfDuh21zC+r4sYzLRNRfaA1NNNqM7OfryjXR//CHGaMO9yVIcDlJwi0RuWAZXYIuCZ1Li7fx6QRfWMEjYOzamhnwitXbauJ5nBzm60aW8LRPrVHn4L2H2I3IsJZYw/jya+cwqIfncufv3JKVNA4nH70QN787pn8+gvHM+sbp7Lq7hl8L01BA9Z1nP/Dc7gsgaABKLBNGW6belNLOGr+6F+Yw7BiD6MHWoEgbnNIZ1hVWcNF//cBc9fHjsvqmoO8vnoHF00cGvXdnTiiHwOLcnl7zS6WV1jBARPttZMunWQNfL5/wTExZsXjhli+i1fjTGnlextYuKkqJrwdLNNUcZ4vRtCAldevT76fdTsy89u0Bgh4KcjxIhJ7nzYEQvg8EiNoAD434XCG9c3nsXkbAfjZ7DVsq27i+a9N5X9mjI0e667HMUsV5fmobw7FmDz31AcYN7QkLUEDVpDAlqpG/r60khvPHM2XTx1F6ad7otky9je0cMNTH+H3enjqq1P4+zdOpTDXx+66AF85bVRMXQU53qjpDFrfKc49lk2yGfr8ArAQOEZEKkXkBuDXwPkisgE43/4f4HVgE1AGPA58C8AYsw/4OfCR/bnHLgP4JvCEfcxG4A27PFkbWadfnofjhpRw1EDrBZ5papL9DS38c9k2fvzKKvL8Hq6degT5fm/0hnb8CvEBAh3h+a9N5ddfPD768k5kx3VuwHy/N+alXx8I0S/JyzzH58HvlWhETias3lYTnWPQEOcsz+/EOafLoJK8pNe2b0EOV085gsmj+rcJPe8shYl+i0CI/DgB22p77/x8iX8u28blf1zA6m21LNtaHbPtjVU7aQ5GuGJyq3D0eITzxw2mdP1uFm/eR57fwzGDLf/HJZOG8dcbpnLt1JEx9YgIl0waxpIt+2PSCb20xDLLNgcjMT6IhkCIogQ+BBHhmMOLWb8zeShxKtwBAiJCYY4v+rKF5IMZn9fDDWccyUfl+/nVG+t4edk2bjn7aE47amC0n+56GlpCFNq/UVGuj1DERAeIYPle3SHx7THF9tsM7ZPHd849mmumjMAjwvOLt1IfCPGVpz5ie00zj113MiP6FzByQCGzvnEav/7C8cwYf3hMXQU53uhgEuz7y++N+pyzSdbEmTHmmiSbzk2wrwFuTlLPn4E/JyhfAkxIUF6VqI3uxIk6ymSm7prtNVz6yHyCYcOAwhzu+Nxx9C3IoTDXR719kzipYzLVbACOPdwy0zijyqY4R3yOpzXoIc/vodmVJqS+OcTogbEhxG4Kc300Zvgi3FsfYEdNMxOH9+WddbviNJtQ2ppNb8QRIjGaTTDMAFcWAiD6guuMQAd4btEW7nhlNVOO7M+qypo2IeyzllYy+rBCThzRN6b8gvGDeWHx1mjggKMBej3CGWMGJmzrvyYO5TdvrWf2iu3cfPbRhOzAAxEwxnpBOwEUDS2hpA7rYw8v5uWPt2GM6fB6L07otjNgKcr1xQjsxhTtXnXKCB5651P+9P4mjh/Wh1vOORpodazHCy0nc4T7XeAMYGqbgtHydBg3pITPHX84104dSUGOj4IcH+ceO4i/fVTB8q3VrN5Ww6PXnhRjUj28Tx5XTzmiTV0FOb6YAVxDS7hbggNAMwhkhRJbPc5Es9m0p4Fg2PDH/3cSH91xHl+2bdNFuW01m9wuGOUX+J1wyFjNxh0JmZdAsylK8bAU5vgyfhE682vGDyuhIMcX069Gl0npYMQJP43XbOLPuSC3bQhrRzHG8Ni8TZx0RF+eu3Eq/Qpio6aMMSzdup/zjxvc5qV+6lEDKMr1EQhFmBQniJIxon8Bp4zqx1/mb2ZlZTUr9oTZUxfg3GMHRc/ToT6Q/AV4zOHF1AdC0VVkO0LUjGYPWApzvXEafXIzbWGujxvPHE1BjpcHrpwYnergCA13VoiGQKxmE39+dc2tgjUdfF4Pf7j2ZE4/ulWQXzttJFUNLSzcVMX9V5zQRoNJRmFu7LNsmfy6ZwCnwiYLlERninf8ZeA88BNH9I0JLih0jcIc/0l8Is5M8Hk95Pg8NMb5bHJ9rW3n+b0xoc91zSGKU4yGCnK8GZt41tizrScM69PGvtzUEm5jUjqYSKjZJHgBFiYIYe0oS7bsZ0tVI9dOHYnf62mz1k5DS5hwxDCgKKfNsbk+L2fbQmJimsIG4JeXHU+uz8uVf1rIrE9bGFScy+ftMP14AVuY5Hd2JiZmMt+mKYFmE6ORJBDsbr59ztEs+vG5jBncOo+tMKplJjbHxZvZmoNhWsKRDmk2iTjz6IF88aTh/ObyE5L6ABOR748dCDYEwtH7KduosMkCTg6sTDSb+oB1TLxNt9D1YDgmra7yGRTkxI12WkLkxWg2Hprt7S2hCIFQJKFNPVpfbuaazarKGkYNKKAkz9+mXx0JEOiNRDWbltSj7Ty/B490zmcza0klBTleLrQjEOMzUjv3brIR+BdPGkZhjpcpo9KPhhszuJhXbzmdcUNK2NFguGLy8FbTWRIHezxj7Rf9+jRyjsXjnmcDsc8UpNZswPIZxT+XCX02cQEC0DqIdMzWJZ0UNh6P8NsrJ3KFK5daOhTmettM6lTNphdT4sqB1VHqm63ZxwVxJrKi3FZba6ALfDZuCvzeNuaqXG+rZpPv90YFnPNQpTKjFeV6M/bZrNlRw3g7K29+nDnuYBc2eT4rQsp97ZpawtEoNQfHud2QoRmtqSXMv1ft4HPHD4m+FNsIG+elmCRiavoxg1j9swsY1E5qpHgGFuXy/Nem8dUJ1sTJRJpBQ0viAAGrn34GFuWmvW6Rm6YWa3kB57kpjPPZNGXgv8j1efBKqxnNGBNznxbnWtfPeW6ca5zsumabtqbp5IK9q1FhkwUcFbm2qeMvg9pm60GLn59jPRhOgEDno9Hc5Od426RIccsSt8/GeahSRdMUZOizaQlF2La/iaMOs0J7C3O80dxgYOUJy/cfvD4bj0co8Huj1y4YjtASjrQZeIDlt2nM0Iz21pqd1AdCMSlS4s1ozr2byrfQUQe9Q57fy1nD/RTn+ROaBBsC4ZSj7UxXPG2yoxmdfseb0RoyCEAREfJ8rZpZSzhCKGLaaDaOxaIu+vz0zH1cmBM7EKx3+ZeyjQqbLODzeijM8Wam2QQS+0OKcr1dNs8mnvjRTkMgRE4SzabOfmhSmdEKM/TZbK9uImIsZ7LVr1aNyxhDY/Dg1mzA0uYcwR/NQpzgWndGs5m1tJLh/fJjTGDFeb4YH2PUjJaf3RdRa1BE3Aswxf1VkufP6Nlqirt/CnNj79PGQGb3V55XqLPrcYRmYbzPxjGjNSU2k3cXBTleGoPhaGLU9gR7V6LCJkuU5PszyoZc1xxMaKIqzHEFCHSxsMnPaWtGc/tscv1emlqsNuvTGJkV5PoyipTaaptGnImh+S4hGAhFMIaDOkAAHJu6dc6N0flObc853gSULvsbWpi/cS9fOHFYjPbsaDbO5MNW30J2X4pFcWa0YDhCSyiScrQdLxjTpSkYjrEGuK0F4ITWd1y45rs0G+dvgcs8CUSFUdSM1lPCJteHMa1+31Rh5l2NCpssUZzny8iMVh9IPOGrMNd68UYihuZgGJ9H2sxwz5S2jvhQTDRavt8bTf7pPCypNJuiuIc4XaLCxl6Xp9Bl3lbUgRQAACAASURBVHOvNXIwU5DTeu1SnbMVqdfxa7ynPoAxxERUgXW/BsOtkw9bNZvsvhSdl7LzknZMg+1pNpkM5JqDsZOCi3J8tNjCzfG1ZDLKz/NJ1Org/GaOsMz1efB5pFWzaXY0m54zo4HVT2NMTJh2tlFhkyUyVfXrmxM7R90jQGvhtK776QpzfG19NnHRaE4kTzoBAgU5XpqC4Q6vflmxr5Ecr4fB9rLWbo0r1Sj/YMItYJuiwiaBppuh9liXxPHvREc592xtN/kWHH+UM2HZSfFUlC2fjev+ce7hhkAo6mvJRLOxhE2rpgCtc6FExEpZE9VsukeIJyPfCa8PhAmEIkRM92R8BhU2WaMkPzNhY6WySPxyAcvGGgiFuyw4AKyXuvNii0RMwmi0UMQQDEei5oBUL6HCBPNF0mHrvkaG98+Pmnccn40xxjUh7+ANEIDYsPGoSSaJZpNJgICjbcf/fs7Lr87lWyjI8UYnL2YLj0fsc4k1Q6V6ARbn+TOaVpDIjAbWACo+H2BHyPMm0Mxc92lRri+q2dQ1h/AISecRZZtoSqSWUFQAqs+ml1OSoRmtLpBM2DgjwBDNwa7VbBynIbTORXA/6+6loaM+m9wU0Wi5rap6R9i6rzHqr7H65SMcMbSEI60mpW7IjdaTuKOFnN8k0QswPpIqXZL5YuJTLNU2B7vNr1DoCuuPvgBT+Wzs7AUtoY6tHdUUjMSa0VzWAudaZ2JSyve1mskaEmjgRbm+6CCttilIUa4v40i+zuJO9ppIMGYTFTZZIlPNpl0zWsAyo3W1ZtMYZwbIc2k2eTmOsIlQHwji9UjK7AWJUnSkQ1thYwutQPiQ8tlETYeB5Ga0+AjCdKmNzvOIrdPxEzpmntqmUNYj0RzcPr60fDb5sX1NFyt0PoFm0xyKCviCjHw2Ls0mwWJkxXmxmk1PmdAg1mejms1BguXEDHVoNcVgOEJTMJw0QABsYRMMt0mD3hkK/JajNBSORM1VMbnR7LYczaa9kVmiFQHbo6YxSF1zKLGwCYajSyAcCtFoDS2xL67E0WjWfh1drTNZZoCe1Gzc6Y3SeQFmmug2PvS5yGUtaOjEYCbfJ9Tbv0V86LPVTqsWWtvBjM9djfP8NATC3bpKJ6iwyRol+ZYJqCOjT+eBS6XZ1AdCNIciXZKE08H9Unceljx3NFpOqxmtLonm5cZtF04XJxJtRJwZDawRaWMKZ/nBREGOLzq6Tx2NZoWwOmbPdKltDpLj9bTRjNtoNs3BbhuBu9PGpHoGHIozzNDR1BKJaulOu1ab4VbNJqMAAStzdWNLOKHPqSjP7xI2Hcv43NW4/anp+Me6EhU2WSKTByLV7GJ3Wo9AMBzVNroCR5g0tYSjo2l3gECenYOtKRhO6lNyk2gRsPaIn2MDrS/ZhkPIjFaY442G40bDaJNM8oWOJ+O0zDht64vPelHbFOp0/q50KcptNQnGr6WUiEw1m/jQ59bsBaE2IcsdwTE5uzWkeN9QnduM1oOaTYEr/16D+mwODqL50ToQJJBa2LSGiGZNs2kJRx8WtxUj3+2zSRIt5yaTF2EizSbf1a/49PAHK46gdgS/O5dXzH4ZRvzVNiU2jxXl+BDpGc0mkRktlWZTktdxn40xhqb4eTYua0F8yHJHyPe1Chsrc7Q3bsKsz5WuJthtQjwRhS5rQasZTX02vZpo5ucOPBCtD1qCl0Gcz6Zro9HcESp2gEDMEgNWW01By6nYnhktk5Ukt+5rZEBhTkzd0Qcj2LmRZ2/CbYJsbAlT4MrlFbNfhppNbXOI4gRCxOMRinKsmfnGmKRCKRu4fRqNgTAeSb18Ria5B4NhQzhiYgYrbj9oZzRnR3Y02JpNvFZWlOujORghGI50eOG0rsYRtg0Bl8lPNZveTatm0xEzWvLZxfl+bzStfEsXR6MVxJjREgQIuEOfAyGK2nkJRc0THfBXVexrjNFq3P1qCIRpskf5XbGGz4FMqwnS0mwS5UWDxOuopIMlRJJlVLbMPQ0tYSIm+3nRHNyRdU5etFQBKJlkVY9fXgCsJcxzfB7qO+kTjGo2zSE7i3LbjO1gWS7qAz0bjebxCPl+a+JwKjNtVtrullYOQaKrdWai2SR4GbjXTG/ucs2m1Y7bmCj02SVs6pqD7Ws2zjybDmo2R8QLmxiTUmzG3oOV1pVTQymXVMhEewTHjJP4ZefkR2tvLZuupsgVWdeQhuYcv0ZMOjQl8KVYbVs55loDBDKb1Am2OS6QQLOx+7urtpmI6blUNQ5WJKM1cPR7pUsjW1OhwiZLlGSg6kdThKQYzbbOs8lGgEAooc8mVti07zj226t/pqvZhMIRtlU3tRU2fpdJ6RDI+AwuB24gnPDF5VCY4cTZ2iQBAtCq2bS3lk1XU2gnh7R8hu2n+fd6hKJcX0aaTZtVT+2loRtarOkEmWRMiPHZtLRdZdR5nnfUWEtZ92ToM7RmDEm1SF02UGGTJeJDSdOhvbVinAfDyo3WlWY0l+kmYJmr3ANAZzRY1xxqd5XOaF87sMzAjppmwhHTRtjEBwgc7MEBEBua2hRM/uItzFCzsXwGie+vknw/dYFgWmvZdCUFLpNgQyCc1v0Vv9hbeziaTbz52bEWNGawlo2D49+M+mxyE2s226ubgZ7L+OzgZJDvziWhQYVN1sjxecjzezqUCr292fmOIzVbZrRG21xV4PfikbYBAnvqA1Y/0jADFHRgvZVEkWhgr4LokWhkVsFBvHCag3tp6FRmNLdzO10CIWug0p7PprvWsnEoitHm0httdzTzs6PZxA9YnLxljS2Zv3idy1kXCNlZlBP7bLZXO5pNz97HTs7B7lwSGlTYZJWSDiYMdJJwJvNLFNqmg1DEdHm6GrBGf4lGZs48m711LUDqsFSHolxf2okiW4VNfky5yP9v78zD46rOg/97Z0YzkkZeZeziBWyDWYwBQ7xioAICCSlxQkha8vEFSGhIUhpCk7ZpkzRkK23aPG2Sfk/zhQA1pEAIUEIWErYgDMEGjBdsbIMXbCzbWLYlW5IlWdvbP865mitpljuaTcv5PY8ezdx759xz1/e8y3lfr3KleRmMBs2mV8u0ySFT+2wSQikomUoSm7IYnUWrZePh19IyFU7zyFaz8arb9vfZeHnZctFsoiFj2vN8P/377wmX/UetZlPCAAFIHHMxa9mAEzYFJdv8aKnyonnEYxEajpkXfl41mzK/ZjNwZBYKGSeip9kEGZlV+tKuZGJPQyuRkHDiuIoB6zz7crpR/kjCH8nX2pm6mJen9WUzzyaT43+MTbF0tEi1bDz8WtqxJPdfMkwBtSw0mzQBAgnH/uDuLxO8k/D9DNRszHkcKppNRZnPZ+PMaCODbDM/N2eIxKmKRWhoyb+wiViHfqu1mSdL419RFuZgszWjpcn47OGvLJqJPY1tTB1fQTiUbD5JJGHeGwXCptdPlUGzERE7GTK4ZpOpRs2Y8ghdPUp9c/BBRT6I9/PZBDKjVZRl57PpNaP1fW680tCDrdLp4QnqZOHqvT6bo0ND2CS0ueKVhAYnbApKtppNurBUMA+Gl6o8n2Y0SNhxk2k2Zn+hXmETSLPpV2o6HXWNrUyfMFCrAXrnBLR1dI34WjZg536EQxl9NpAI2w1KpsJdXuDA3sa2otSy8eidyGp9NgUJEEgyzwbMwMlLh5TLizceC3OktYPObh3w/JiJufDu0aERIODVQmpxms3IIVufjZkwmd6M5hHL8+TGyrJwQoNI8rBXlIVpOBY8QKAqFjxAYE9DGzMmVCZdlxCC3SO+lo1HZSxMy/FOm6U49bnORqADGaPMvMCBvUfaivpC9O7ro22dHO/qCeizMc9W0KzXqaqeenN8jh3PTbOpikU40NyedB9edobObk2aBLXY9A0QcMJmRJBt+dpUVTo9qnw3cXkeQ5/B+kY6k88TADMi9Ko8p5oH5KcyFqySZHtnN4dajg8IDki0ExlVoc9gTJCeby6dZhPPQqCDr3Bamnk2YDSbYkWiQULYeOa7IOZSz+TX3hmsgFpbmgABVTjc0pGTmTYei1DfdNx+TlLszp7bUpvQwAhDL/XUYHLBDRYnbArI2HJjRgs6+goSIOCRd83GpgxJNZHQPxoLotl48xcyUddoItGmp9JsvNQao2RSJ5iXrWeyTJWuBrLzi4E/HVJ6M9qB5vbiajb2utY3Gc0giBkt22ScvXWaIv19NjYbQR40m0MtnrAc2I53TKWORIOEMOzs1j4D2ELjhE0BGVNeRmd38NFXcwYzmv8hzOekTrDVOr35LCl8NmBCPPuPDpNRGTWle7u60x/7nkbjNE2p2UTDHGntpLtHR4+wiUU4ZANB0pkOvUm+QWlq6yIkpIz28kbdqsV9KUbCIWKRUK9mEzT0GQg8j629s5vyslCfbMzQ95nKxWdTFYv0av7DQbPp/ezMaCODbDI/H+/qpqOrJ0OAgM+MlnfNJuybZzPwYfEETND66b3pVDIU96pryKDZxMK9JqXRECAARhgcbE5tkvEw2mh2ZrSxFWUpr59f4yl2Gvx4LEJ9c/aaTdAAnP7lBfz79chFs/G3k8zp7h3T0BA2/jILzow2Isgm87OXqibdg+YXAvnWbOLRCM3tnXR09SR9WMp9wiZQewFnuNc1thGNhDihKpZ0fWXU2ObN51Gi2UTDvSbIdALWS6gYlEw+Qb+AKba5Jx4L+3weQUKfs0vG2daRStgkluVyf/nPa7L+e+tLHYkGfYWqCxAYIWST+Tld4TSPvma0/F66img4YbpJ8tB5D2rQkZm/PEA69jS2Mn18xQDzRv/9purXSKSPmSNdgECWPptMNWritoAaFP+lGI/6fR5BAgSy9Nl0dvcpCe1RFQt2rjMRz9DOUNJs/ALWhT6PELLJ/BykQqH/xijEPBuvD8nMCbFsNZuAlSTrGtuYPjG5CQ36PhhBfEUjgaCjbS9Sr6cnWABKU4Z5XCGbTRmKlxfNI+7zeQSdZwPBs6q3pZiz1Ndnk1uAQLp2vInQpc74DH3vqRGv2YjILhHZKCLrRWSNXTZRRJ4WkW32/wS7XETkhyKyXUReF5Hzfe3cYLffJiI3+Ja/x7a/3f62JEVQBqPZBA8QyL9m45HMT9Drswk4MkuY0TJoNg2pJ3SafuXHpj6cqAx4zJ6jvy2DX8yjqS11eQEPTxgVXbPJ8qWfdTRaCp9NvjSbTO1UDVEzWjGtBaXUbC5R1fmqusB+/zvgWVWdAzxrvwNcCcyxfzcDPwIjnIDbgcXAIuB2T0DZbW72/e79hT+cgSScmJlHX80Bkh/6hUAs35pNWfoXnBeQEHRklihbnPrYW4530djamXJCJ/SNnBo982zCST/3x5+aPwjN7anLC3j0+haK7LPxO6qDaDaV0TDhkAT32XR2J7UGFCJAIFk7Y4aSGc3Xv6CWinwwlMxoHwLutZ/vBT7sW36fGlYD40XkROB9wNOq2qCqjcDTwPvturGqukrNBJf7fG0VlYSqHyBAIIgZrYCaTWWGF1xFlma03kqSaV6EiTk2qTUbf79Gjc/Gd47TCVh/av4gNLV3ZRxZl8qR7d0voYClv0WyK6CWKkCgMhru9VPlQ7MpLwslzfFXVSIhngx/oFExJ3WWSswq8JSIKPBjVb0TmKKq+wFUdb+ITLbbTgP2+H5bZ5elW16XZPkARORmjAbElClTqK2tzemgWlpaBrRREYFXN++gVuqS/8iydrd5aF5f+wq7osmtfqpKWKBbYdWLK/NaInnPO4mHduumDUyOtPU5ljq7vrF+P7W1hzO219Bu5tes27iZcUe2Jd1mXb0RRAff3kJt41tJt9l2MCGsNq5bw4E3sxeyya7LUGav71q8uurFPrWF/Mey84A5NytfWs3uselfGj2qtBzvouFAHbW19Sm36zhmwo+3bd5A197CvYj6X5MjB01wQCwMzz//fKA2onSxbXcdtbWHMm7b2NTKeGlNeh/EQtDeDZvWv8ahbYO7v3ZtWg9AmfQk3cc7+8212r19K7XN27PeRz453pXw8a17eRWxSPL7K9+UStgsU9V9VqA8LSJb02yb7I2qg1g+cKERcncCLFiwQGtqatJ2OhO1tbX0b2Px26+wp6F1wPL+vPHcdtjyJu+79OK0Yc1VK5+ivbObSy65JKe+9qdxXR33bd4AwIVLF7Fvy2t9+rwntouH3nyDuXNmUVMzJ2N7Te2dUPsU02eeQs1Fs5Nu8/Yf3oa1m1n+3guZlCL0uWpXA7y2CoCaiy5g8pjy7A6M5NdlKHP4tTp+unkDsUiIS/tdZ/+xRLYd4j/WvcyZZ5/HolkT07Z5tLUTnnyKs8+YQ82Fs1Ju99i769hwcB+XLFvCzEnxnI8lFf2vySvtW3nmnR2MqywPfK1O2PAC8XHl1NQszLzxS88wc/pkamrOGbBq3EvP0N50nEsvuoDJYwd3f501byGsqmVCVWXS/stbB/nRhldYtvA8lsyuznof+aSnR5FnnwDgistq+gxaC/mslMSMpqr77P964DGMz+WANYFh/3vDrzpghu/n04F9GZZPT7K8JCydXc2Og8d6J6ylorm9i2g4lHH+TFUskncTGkBFH59N8txo3v6D4M18T2fi2dPQRkVZmOp4NHW/+pjRSm/vLgaevyuTWSeIX8wjURAt/Tkslc/GMxFnM4vf1LTpe+xN7Z3c8+LbvelpPNo6kvts/PvOxSeY6ZpdcEo1/3j1PBbOTD8oKAahkClKaELdixc7VXRhIyJxERnjfQauADYBvwS8iLIbgMft518C19uotCXAUWtuexK4QkQm2MCAK4An7bpmEVlio9Cu97VVdLxRzOqdDWm3M87bADnHYuG8BwdAf59N6kmdQR2cXgqSdKHPXmmBdDe8X8CMltBn75gzCdd4FgECQQuija+IEpLiO7KreoVN8P2OSZJV/e4X3uZbv97Md36zuc/y9s6elILA23euudEgdf/LwiGuW3xyUn9OKaiIRopaywZKY0abAjxmXzAR4AFV/Z2IvAr8XERuAt4BPma3fwL4ALAdaAU+CaCqDSLybeBVu923VNV7o38OWAFUAL+1fyXhrKljGROLsHrnYZafOxWAnQdbqI7HGFeZePAzlRfwiMcigUNds6GPIz5N6HM2L6FMWYn3NLYxI80cG0gEK6RyvI5Egmo23vog2bWDlnq+bslJzJs2rmi1bDy8Y8lmkuHYigjN+xP3V3eP8vM1e4hFQtz/8jvUnD6Zy+dOoau7h47unpSDlXg0kvP9VVEWJiTDJ4glHgsTLvKMkKILG1XdCZybZPlh4LIkyxW4JUVb9wD3JFm+BpiXc2fzQCQcYuGsiazeYZzqh1uO88H/eJFlp07izusX9G6XKeOzR1Usu7IFQfFMCJGQEE3yovEEUDZRSvEkZQYONLVz1ws72bDnKG++28SimRNS/Lpvv0aLCQ18mk2G+yEeIOLPI0iGCoATx1UkLc9daAaj2YwtL+szz+b5t+rZf7SdH1w7nztX7uTLj77OudMv6r2HUpnJqsojOd9fIkI8FinqjPxcqIxGiBR58DaUQp9HLEtmT2TnoWMcaGrnzpU7OdbRzdNbDrD78LHebTLlrUq0Vc3SAjgYvYetIhpOatZaNHMid1x9dkZHtJ/+ZQZUlb96aD0rXtpFR3cPn1hyMp9K46zu069RYkKDhBDJVCwuaP45SITfjxsCobfJ8ARrNokhx5RHaD7e1ZtB4cFX9jCpKsqV807kB9fOp7Wjiy89vKG3wFwqn80JY2JMqkrtNwzK5DExJo3JvZ1iUB2PMjGNr7QQDA8xPMxZOnsSAL/asI97V+3i4tNOYNWOQ6x4aRe3f/AsunuUA83tzJk8JmNbt1xyakH6mMmMEQmH+D+LT8q6TX8lyWe31PPSjsN8c/lZ3HDBzEBthENCLBIaNuaJfOCNwDPZ1KOREGVhCZSM03OkD4UZ7MnwhEy2mo2q0exaO7r5/dZ6Pn3RbKKREKdOHsPX/mQuX/vFJv7f702ocaoBy99ccXqg2kuZWPHJRUNi0mYQ/vmas4u+z+FxZoY5c6eOZUx5hH958k26e5RvLj+LHz67jYfX1PHFy0/jnhd3sftwK7demjmkuFB4L/N8TvKKxxKaTWd3D3c8sYXZJ8QHJbRGk7DxhEyQkgqV0QitAV6UnrkpaLqhYhMfhBmt2mojf/rj1UwbX0F3j3LtwkSA6nWLT2LlWwf56erdQGoz2oR4lAl5GOVn8j8OJVKV9CgkzoxWBMIhYfGsiXR09fCR86Yxa1KcTy2bRcvxLr786Ot8/9m3+Mh50/jI+UnnnhYFz1yVT5tzPBrp9dncv3o3Ow8d46sfODNr53NlNDJqUtWAKfktaYqc+YlHg5UZaGozPsGhGmQRH8T998Fzp3LH1Wejqjyz5QDLTq3uMzdIRPjuNefwR3buzGi6h4YiQ3OYMwK55IzJvLj9ELdeZrSXs6ePY+HMCTyx8V3mTK7iO1fPK2rMe3/CISGaZ3NVZSzMwZbjfP3xTTzyWh3LTq3m0jMmZ/5hP+Kx8LBxvOaDUEiojsd6R+7piMcibH23iSc27qciGuYP2w7x+631dPUol54xmaWnVFPffJyXdhwqekG0bBhbUUZIYGI8uJmvzJp2P75oBpv2NvFH4wZOyJwQj/KDa+dz68/WMbO6cJNUHZkZunffCOPjC0/iqrOn9gl3vu29p/H1xzfxn9edPySirfJtrhpbXkbDsQ5+9uoeLp87hb+/8oxBCdQvv/+MIZFTqpg8/NmlgYTN3KljeXz9Pv7i/rUARMMhlp5STSQkPPjKO6x4aRdgAgP8JqahxriKMn7+maXMnTo269+KCGdPH5dy/eLZ1bz8lffm0j1HHij9G26UEApJH0EDsOzUSTz7pZrSdCgJlWXhvNYk//TFsznvpPHUnD45pyioy86ckrc+DRdmBUwV8/0/m8+3ls9j75E2jrR1cM708b1hxG0d3Wzad5Sp4yuYOq68pJpzEBYMgdn1jsLhhI2jl7+6/LS8Ojmnja9g2vzS+aFGAyJmENN/IAPGRzEU0qM4HOCEjcPHxxYMXTOLw+EY3rhoNIfD4XAUHCdsHA6Hw1FwnLBxOBwOR8FxwsbhcDgcBccJG4fD4XAUHCdsHA6Hw1FwnLBxOBwOR8FxwsbhcDgcBUdMIUyHiBwEdufYzCTgUB66MxRwxzI0GSnHMlKOA9yxnKyqJ2TayAmbPCIia1R1QeYthz7uWIYmI+VYRspxgDuWoDgzmsPhcDgKjhM2DofD4Sg4TtjklztL3YE84o5laDJSjmWkHAe4YwmE89k4HA6Ho+A4zcbhcDgcBccJG4fD4XAUHCds8oCI3CMi9SKyqdR9yRURmSEiz4nIFhF5Q0S+UOo+DRYRKReRV0Rkgz2Wb5a6T7kgImERWScivy51X3JBRHaJyEYRWS8ia0rdn1wQkfEi8oiIbLXPzNJS9ylbROR0ey28vyYRuS3v+3E+m9wRkYuBFuA+VZ1X6v7kgoicCJyoqmtFZAzwGvBhVd1c4q5ljYgIEFfVFhEpA14EvqCqq0vctUEhIl8EFgBjVfWqUvdnsIjILmCBqg77iZAici/wgqreJSJRoFJVj5S6X4NFRMLAXmCxquY6yb0PTrPJA6q6EmgodT/ygaruV9W19nMzsAWYVtpeDQ41tNivZfZvWI6uRGQ68CfAXaXui8MgImOBi4G7AVS1YzgLGstlwI58CxpwwsaRBhGZCZwHvFzangwea3paD9QDT6vqcD2W7wN/C/SUuiN5QIGnROQ1Ebm51J3JgdnAQeC/rHnzLhGJl7pTOXIt8GAhGnbCxpEUEakCHgVuU9WmUvdnsKhqt6rOB6YDi0Rk2Jk5ReQqoF5VXyt1X/LEMlU9H7gSuMWaoYcjEeB84Eeqeh5wDPi70nZp8Fgz4HLg4UK074SNYwDWv/EocL+q/k+p+5MPrHmjFnh/ibsyGJYBy62v42fApSLy36Xt0uBR1X32fz3wGLCotD0aNHVAnU9bfgQjfIYrVwJrVfVAIRp3wsbRB+tUvxvYoqr/Vur+5IKInCAi4+3nCuC9wNbS9ip7VPXvVXW6qs7EmDl+r6r/t8TdGhQiEreBJ1iT0xXAsIziVNV3gT0icrpddBkw7AJpfHycApnQwKiBjhwRkQeBGmCSiNQBt6vq3aXt1aBZBnwC2Gh9HQBfUdUnStinwXIicK+NsAkBP1fVYR02PAKYAjxmxjREgAdU9Xel7VJOfB6435qgdgKfLHF/BoWIVAKXA58p2D5c6LPD4XA4Co0zozkcDoej4Dhh43A4HI6C44SNw+FwOAqOEzYOh8PhKDhO2DgcjiFLNkluReRiEVkrIl0i8tF+624QkW3274Ys9p+yzX7b1YrIm75klpPt8htF5KBv+Z/7fvMvNkHsFhH5oZ12gIhEReROEXnLJvi8xi6PichDIrJdRF62GT4QkUW+9jeIyNW+fXxBRDbZ/WRMrpnhHCbtb1CcsHE4UiAit9mQ0Gx/d6OITA2yzqY4mZtLPzP05SuFartIrCD4RNx3gBuBB/wLRWQicDuwGDOB9HYRmdBvm5kiUhu0zRRcp6rz7V+9b/lDvuV32f1dgJlmcA4wD1gI/LHd/quYjBGnAXOB5+3ym4BGVT0V+Hfgu3b5Jkxi0/mYc/VjEYnYbBmftsd8LnCViMzJcAypzmG6/gbCCRuHIzW3AVkJGzun50YgqbDpv05V/7zAGbWHtbBJluRWRE4Rkd/Z3GoviMgZdttdqvo6A/PHvQ+TF69BVRuBpwkowNK0mSsKlANRIIZJEuvN3P8U8E92/z2+7NgfAu61nx8BLhMRUdVWVe2yy8tJJJs9E1jtW/88cDUM6hym628gnLBxjHrsrPbfWBPEJhH5MxG5FSMUnhOR5+x2PxKRNdKvNo6Y+ixfF5EXMbOwF2Am+q23mQu87T7af501vyyw61tEImbPDAAABQ1JREFU5Lv2BfCMNY/UishOEVlutwmLyL+KyKsi8rqIfMYuP1FEVtp2N4nIRSLyz0CFXXa/3e4Xtv03xJcEM+C+bxSRx+1L6k0Rub2Q1yUNdwKfV9X3AH8N/GeG7acBe3zf6yhMJvP/suf6H/qZmK6x1+oREZkBoKqrgOeA/fbvSVXdIjbjBfBta856WESm9D8OKzyOAtUAIrJYRN4ANgKftes3AReLSLXV0D8AzLBtZXUOU/U3q7Ojqu7P/Y3qP+Aa4Ce+7+Ps/13AJN/yifZ/GJNn7Rzfdn/r264WY9ZItq8+6/zfMaPHK+3nx4CnMCPIc4H1dvnNwNfs5xiwBpgFfAn4qq9/Y+znln77946hAvMyqs5i3zfaF0217/dJjzPP12cmsMl+rgLagPW+vy39tl8BfNT3/W+8c2a//wPwJd+xrsekmWnxtfnJdG0m6eM0+3+MPXfX2+/VQMx+/iwm1RDAqcBv7PFUAasw5Qom2Wtxjd3ui8BP7ec3gOm+fe7wrp9v2ZnAK0C5/X4TsBZYCfx/jPltMOcwaX+zuY4uXY3DYUaD3xOR7wK/VtUXUmz3p1YbiGBS4cwFXrfrHspDPzoAL3XLRuC4qnaKyEbMCxdMLrFzfM7bccAc4FXgHjFJVH+hqutJzq0+B/IM+9vDAfcNxhx1GEBE/ge4ECPwikUIOKLGPxGUOkw6KY/pGCGPqnpmpZnAClWtYRCo6l77v1lEHsD4Se7zzpXlJyT8LFdjTFwtdv+/BZYALwCtGCEIJgPzTb7jmAHUiUgEc+37mBjVaEfHMH6VNWrSZt1t93GHbWMw5zBVf1cGbcCZ0RyjHlV9C3gP5iX7TyLy9f7biMgsjLnhMlU9BzPKK/dtciwPXelUO4zE2MyP2/71kMhjKBjzh+dwnqWqT6nxbVyMqbL4UxG5Pskx1GCSkS5V1XOBdb5jCLJvGFh8rqj5rtSUu3hbRD4GJnGsiJyb4WdPAleIyAQbGHCFXZYXrDN+kv1cBlyFTS4qpvKtx3JMMUIwjvg/tr8twzjbt9hr8CsSwtGf3POXgBdJ91GMlqQiMssKH0TkZOB0jLaNJKLiTgI+Ajw4yHOYtL8BTxHghI3DgZjosFZV/W/geyTSxDdjzCIAYzEC5ai1oV+Zpkn/77JZF4Qngc/ZBx4ROc36nE7GRDD9BDOS9Y6h09sWMxJuVNVWMQ7hJYPY/+UiMtH6oj4M/CGHY8mImCS3q4DTRaRORG4CrgNuEpENGNPSh+y2C8Ukwv0YJiLrDQBVbQC+jdH+XgW+ZZcF2X/SNu06T3uMAU+KyOsYk9RejBYDRpN8w/b1VowpEoyDfwdmgLMB2KCqv7Lrvgx8w7b3CYyJFMx1rRaR7Rjzmlc750Jgg+3PY8BfaCKo4FER2YwRYLeoCZAg23OYob+BcIk4HaMeEXkf8K+YEX0n8DlVXSMinwduAfar6iUisgITPrsTM/L/paquEFNnZoH3gIuZF3EHxi6+VFXbfPvqsw74LfDXdn8tqlplt/sGxt/yPfu9RVWrRCQEfAf4IEbLOYh56X8Y45voxPgerlfVt61pcDnGbv8p4BcYR/ObwAnAN1S1NuC+b8Q4meMYG/4DqtobKOFwpMMJG4fDEQgrbBao6l+Wui+O4YczozkcDoej4DjNxuFwOBwFx2k2DofD4Sg4Ttg4HA6Ho+A4YeNwOByOguOEjcPhcDgKjhM2DofD4Sg4/wuBNtWRDu48LQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "for addr, duration in durations.items():\n", - " ax = duration.plot(x='start_timestamp', y='duration')\n", - " ax.legend([str(addr)])\n", - " ax.set_xlabel('start timestamp')\n", - " ax.set_ylabel('duration (ns)')\n", - " plt.title('Callback durations over time')\n", - " plt.grid()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "for addr, duration in durations.items():\n", - " duration.hist(column='duration')" + "# Get a list of callback objects\n", + "callback_objects = set(callback_instances['callback_object'])\n", + "# Get their symbol\n", + "symbols = {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects}\n", + "\n", + "# Plot durations\n", + "for obj in callback_objects:\n", + " duration_ns = callback_instances.loc[callback_instances.loc[:, 'callback_object'] == obj, :]\n", + " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", + "\n", + " fig = plt.figure(figsize=(12, 6))\n", + " fig.suptitle('TODO', fontsize=20)\n", + "\n", + " ax = fig.add_subplot(1, 2, 1)\n", + " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", + " ax.legend([str(symbols.get(obj, 'unknown'))])\n", + " ax.set_xlabel('start')\n", + " ax.set_ylabel('duration (ms)')\n", + " ax.title.set_text('Callback durations')\n", + " ax.grid()\n", + "\n", + " ax = fig.add_subplot(1, 2, 2)\n", + " duration_ms.hist(column='duration', ax=ax)\n", + " ax.title.set_text('Duration histogram')\n", + "\n", + " plt.show()" ] }, { @@ -498,7 +143,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.6.8" } }, "nbformat": 4, From c4bd35def97f205798cf01ebe95e9f26aab07645 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 14 Jun 2019 14:14:13 +0200 Subject: [PATCH 68/98] Add typing --- tracetools_analysis/analysis/data_model.py | 24 ++++---- tracetools_analysis/analysis/handler.py | 45 +++++++------- tracetools_analysis/analysis/load.py | 8 ++- tracetools_analysis/analysis/lttng_models.py | 9 ++- .../analysis/ros2_processor.py | 58 ++++++++++--------- tracetools_analysis/conversion/ctf.py | 9 ++- 6 files changed, 85 insertions(+), 68 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 7707af0..7eb7ad6 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -12,7 +12,7 @@ class DataModel(): It uses pandas DataFrames directly. """ - def __init__(self): + def __init__(self) -> None: # Objects (one-time events, usually when something is created) self.contexts = pd.DataFrame(columns=['context_handle', 'timestamp', @@ -71,34 +71,34 @@ class DataModel(): 'duration', 'intra_process']) - def add_context(self, context_handle, timestamp, pid): + def add_context(self, context_handle, timestamp, pid) -> None: self.contexts.loc[context_handle] = [timestamp, pid] - def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace): + def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace) -> None: self.nodes.loc[node_handle] = [timestamp, tid, rmw_handle, name, namespace] - def add_publisher(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth): + def add_publisher(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth) -> None: self.publishers.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_subscription(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth): + def add_subscription(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth) -> None: self.subscriptions.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_service(self, handle, timestamp, node_handle, rmw_handle, service_name): + def add_service(self, handle, timestamp, node_handle, rmw_handle, service_name) -> None: self.services.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_client(self, handle, timestamp, node_handle, rmw_handle, service_name): + def add_client(self, handle, timestamp, node_handle, rmw_handle, service_name) -> None: self.clients.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_timer(self, handle, timestamp, period): + def add_timer(self, handle, timestamp, period) -> None: self.timers.loc[handle] = [timestamp, period] - def add_callback_object(self, handle, timestamp, callback_object): + def add_callback_object(self, handle, timestamp, callback_object) -> None: 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) -> None: self.callback_symbols.loc[callback_object] = [timestamp, symbol] - def add_callback_instance(self, callback_object, timestamp, duration, intra_process): + def add_callback_instance(self, callback_object, timestamp, duration, intra_process) -> None: data = { 'callback_object': callback_object, 'timestamp': timestamp, @@ -107,7 +107,7 @@ class DataModel(): } self.callback_instances = self.callback_instances.append(data, ignore_index=True) - def print_model(self): + def print_model(self) -> None: """Debug method to print every contained df.""" print('====================DATA MODEL====================') print(f'Contexts:\n{self.contexts.to_string()}') diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py index 84b1859..98e4b34 100644 --- a/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/analysis/handler.py @@ -1,47 +1,52 @@ # Event handler import sys +from typing import Callable +from typing import Dict +from typing import List -from . import lttng_models +from .lttng_models import EventMetadata +from .lttng_models import get_field +from .lttng_models import get_name class EventHandler(): """Base event handling class.""" - def __init__(self, handler_map): + def __init__(self, handler_map: Dict[str, Callable[[Dict, EventMetadata], None]]) -> None: """ Constructor. - :param handler_map (map(str: function)): the mapping from event name to handling method + :param handler_map: the mapping from event name to handling method """ self._handler_map = handler_map - def handle_events(self, events): + def handle_events(self, events: List[Dict[str, str]]) -> None: """ Handle events by calling their handlers. - :param events (list(dict(str:str))): the events to process + :param events: the events to process """ for event in events: self._handle(event) - def _handle(self, event): - event_name = lttng_models.get_name(event) + def _handle(self, event: Dict[str, str]) -> None: + event_name = get_name(event) handler_function = self._handler_map.get(event_name, None) if handler_function is not None: - pid = lttng_models.get_field(event, - 'vpid', - default=lttng_models.get_field(event, - 'pid', - raise_if_not_found=False)) - tid = lttng_models.get_field(event, - 'vtid', - default=lttng_models.get_field(event, - 'tid', - raise_if_not_found=False)) - timestamp = lttng_models.get_field(event, '_timestamp') - procname = lttng_models.get_field(event, 'procname') - metadata = lttng_models.EventMetadata(event_name, pid, tid, timestamp, procname) + pid = get_field(event, + 'vpid', + default=get_field(event, + 'pid', + raise_if_not_found=False)) + tid = get_field(event, + 'vtid', + default=get_field(event, + 'tid', + raise_if_not_found=False)) + 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) diff --git a/tracetools_analysis/analysis/load.py b/tracetools_analysis/analysis/load.py index 053d058..073b086 100644 --- a/tracetools_analysis/analysis/load.py +++ b/tracetools_analysis/analysis/load.py @@ -1,12 +1,14 @@ import pickle +from typing import Dict +from typing import List -def load_pickle(pickle_file_path): +def load_pickle(pickle_file_path: str) -> List[Dict]: """ Load pickle file containing converted trace events. - :param pickle_file_path (str): the path to the pickle file to load - :return list(dict): the list of events (dicts) read from the file + :param pickle_file_path: the path to the pickle file to load + :return: the list of events read from the file """ events = [] with open(pickle_file_path, 'rb') as f: diff --git a/tracetools_analysis/analysis/lttng_models.py b/tracetools_analysis/analysis/lttng_models.py index 7562d2f..2c54719 100644 --- a/tracetools_analysis/analysis/lttng_models.py +++ b/tracetools_analysis/analysis/lttng_models.py @@ -1,7 +1,10 @@ # Model objects for LTTng traces/events +from typing import Any +from typing import Dict -def get_field(event, field_name, default=None, raise_if_not_found=True): + +def get_field(event: Dict, field_name: str, default=None, raise_if_not_found=True) -> Any: field_value = event.get(field_name, default) # If enabled, raise exception as soon as possible to avoid headaches if raise_if_not_found and field_value is None: @@ -9,14 +12,14 @@ def get_field(event, field_name, default=None, raise_if_not_found=True): return field_value -def get_name(event): +def get_name(event: Dict) -> str: return get_field(event, '_name') class EventMetadata(): """Container for event metadata.""" - def __init__(self, event_name, pid, tid, timestamp, procname): + def __init__(self, event_name, pid, tid, timestamp, procname) -> None: self._event_name = event_name self._pid = pid self._tid = tid diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index 1664f9f..087b2b6 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -1,20 +1,12 @@ # Process trace events and create ROS model +from typing import Dict +from typing import List + from .data_model import DataModel from .handler import EventHandler from .lttng_models import get_field - - -def ros2_process(events): - """ - Process unpickled events and create ROS 2 model. - - :param events (list(dict(str:str:))): the list of events - :return the processor object - """ - processor = Ros2Processor() - processor.handle_events(events) - return processor +from .lttng_models import EventMetadata class Ros2Processor(EventHandler): @@ -24,7 +16,7 @@ class Ros2Processor(EventHandler): Handles a trace's events and builds a model with the data. """ - def __init__(self): + def __init__(self) -> None: # Link a ROS trace event to its corresponding handling method handler_map = { 'ros2:rcl_init': @@ -61,16 +53,16 @@ class Ros2Processor(EventHandler): # Temporary buffers self._callback_instances = {} - def get_data_model(self): + def get_data_model(self) -> DataModel: return self._data - def _handle_rcl_init(self, event, metadata): + def _handle_rcl_init(self, event: Dict, metadata: EventMetadata) -> None: context_handle = get_field(event, 'context_handle') 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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'node_handle') timestamp = metadata.timestamp tid = metadata.tid @@ -79,7 +71,7 @@ class Ros2Processor(EventHandler): namespace = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'publisher_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -88,7 +80,7 @@ class Ros2Processor(EventHandler): depth = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'subscription_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -97,13 +89,13 @@ class Ros2Processor(EventHandler): depth = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'subscription_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rcl_service_init(self, event, metadata): + def _handle_rcl_service_init(self, event: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'service_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -111,13 +103,13 @@ class Ros2Processor(EventHandler): service_name = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'service_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rcl_client_init(self, event, metadata): + def _handle_rcl_client_init(self, event: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'client_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -125,30 +117,30 @@ class Ros2Processor(EventHandler): service_name = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'timer_handle') timestamp = metadata.timestamp period = get_field(event, '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: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'timer_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rclcpp_callback_register(self, event, metadata): + def _handle_rclcpp_callback_register(self, event: Dict, metadata: EventMetadata) -> None: callback_object = get_field(event, 'callback') timestamp = metadata.timestamp symbol = get_field(event, 'symbol') self._data.add_callback_symbol(callback_object, timestamp, symbol) - def _handle_callback_start(self, event, metadata): + def _handle_callback_start(self, event: Dict, metadata: EventMetadata) -> None: # Add to dict callback_addr = get_field(event, 'callback') self._callback_instances[callback_addr] = (event, metadata) - def _handle_callback_end(self, event, metadata): + def _handle_callback_end(self, event: Dict, metadata: EventMetadata) -> None: # Fetch from dict callback_object = get_field(event, 'callback') (event_start, metadata_start) = self._callback_instances.get(callback_object) @@ -162,3 +154,15 @@ class Ros2Processor(EventHandler): bool(is_intra_process)) else: print(f'No matching callback start for callback object "{callback_object}"') + + +def ros2_process(events: List[Dict[str, str]]) -> Ros2Processor: + """ + Process unpickled events and create ROS 2 model. + + :param events: the list of events + :return: the processor object + """ + processor = Ros2Processor() + processor.handle_events(events) + return processor diff --git a/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/conversion/ctf.py index c8cb14c..826231f 100644 --- a/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/conversion/ctf.py @@ -1,5 +1,7 @@ # CTF to pickle conversion +from pickle import Pickler + import babeltrace # List of ignored CTF fields @@ -10,12 +12,13 @@ _IGNORED_FIELDS = [ _DISCARD = 'events_discarded' -def ctf_to_pickle(trace_directory, target): +def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: """ Load CTF trace and convert to a pickle file. - :param trace_directory (str): the main/top trace directory - :param target (Pickler): the target pickle file to write to + :param trace_directory: the main/top trace directory + :param target: the target pickle file to write to + :return: the number of events written """ # add traces tc = babeltrace.TraceCollection() From 34ef92f51a3a4eb6c2ab0952cf318b8a1dbe758d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 17 Jun 2019 09:27:21 +0200 Subject: [PATCH 69/98] Cleanup notebook --- analysis/Callback_duration.ipynb | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/analysis/Callback_duration.ipynb b/analysis/Callback_duration.ipynb index d28aa4c..60eca43 100644 --- a/analysis/Callback_duration.ipynb +++ b/analysis/Callback_duration.ipynb @@ -40,9 +40,7 @@ "pickle_filename = '../../../the_pickle_file'\n", "events = load.load_pickle(pickle_filename)\n", "processor = ros2_processor.ros2_process(events)\n", - "data_model = processor.get_data_model()\n", - "\n", - "#data_model.print_model()" + "data_model = processor.get_data_model()" ] }, { @@ -54,7 +52,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -66,7 +64,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -78,7 +76,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { From 5d43b0b986346ebea756bc8375b38678f58824f7 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 17 Jun 2019 10:47:03 +0200 Subject: [PATCH 70/98] Rename 'depth' to 'queue_depth' --- tracetools_analysis/analysis/ros2_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index 087b2b6..4bfadd1 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -77,7 +77,7 @@ class Ros2Processor(EventHandler): 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') + depth = get_field(event, 'queue_depth') self._data.add_publisher(handle, timestamp, node_handle, rmw_handle, topic_name, depth) def _handle_subscription_init(self, event: Dict, metadata: EventMetadata) -> None: @@ -86,7 +86,7 @@ class Ros2Processor(EventHandler): 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') + depth = get_field(event, 'queue_depth') self._data.add_subscription(handle, timestamp, node_handle, rmw_handle, topic_name, depth) def _handle_rclcpp_subscription_callback_added(self, event: Dict, metadata: EventMetadata) -> None: From 067a714e8332f9ccf2da1f0ee900913de7d4b366 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 17 Jun 2019 10:47:32 +0200 Subject: [PATCH 71/98] Fix indent --- tracetools_analysis/analysis/handler.py | 24 +++++++++++-------- .../analysis/ros2_processor.py | 9 +++---- tracetools_analysis/convert.py | 6 ++--- tracetools_analysis/process.py | 3 +-- 4 files changed, 22 insertions(+), 20 deletions(-) diff --git a/tracetools_analysis/analysis/handler.py b/tracetools_analysis/analysis/handler.py index 98e4b34..ef4298f 100644 --- a/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/analysis/handler.py @@ -34,16 +34,20 @@ class EventHandler(): 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', - raise_if_not_found=False)) - tid = get_field(event, - 'vtid', - default=get_field(event, - 'tid', - raise_if_not_found=False)) + pid = get_field( + event, + 'vpid', + default=get_field( + event, + 'pid', + raise_if_not_found=False)) + tid = get_field( + event, + 'vtid', + default=get_field( + event, + 'tid', + raise_if_not_found=False)) timestamp = get_field(event, '_timestamp') procname = get_field(event, 'procname') metadata = EventMetadata(event_name, pid, tid, timestamp, procname) diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index 4bfadd1..c4f91d7 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -148,10 +148,11 @@ class Ros2Processor(EventHandler): del self._callback_instances[callback_object] duration = metadata.timestamp - metadata_start.timestamp is_intra_process = get_field(event_start, 'is_intra_process', raise_if_not_found=False) - self._data.add_callback_instance(callback_object, - metadata_start.timestamp, - duration, - bool(is_intra_process)) + self._data.add_callback_instance( + callback_object, + metadata_start.timestamp, + duration, + bool(is_intra_process)) else: print(f'No matching callback start for callback object "{callback_object}"') diff --git a/tracetools_analysis/convert.py b/tracetools_analysis/convert.py index e1d149c..2650702 100644 --- a/tracetools_analysis/convert.py +++ b/tracetools_analysis/convert.py @@ -10,10 +10,8 @@ from tracetools_analysis.conversion import ctf def parse_args(): parser = argparse.ArgumentParser(description='Convert CTF trace data to a pickle file.') - parser.add_argument('trace_directory', - help='the path to the main CTF trace directory') - parser.add_argument('pickle_file', - help='the target pickle file to generate') + parser.add_argument('trace_directory', help='the path to the main CTF trace directory') + parser.add_argument('pickle_file', help='the target pickle file to generate') return parser.parse_args() diff --git a/tracetools_analysis/process.py b/tracetools_analysis/process.py index 029a476..53ee3f4 100644 --- a/tracetools_analysis/process.py +++ b/tracetools_analysis/process.py @@ -11,8 +11,7 @@ from tracetools_analysis.analysis import ros2_processor def parse_args(): 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') + parser.add_argument('pickle_file', help='the pickle file to import') return parser.parse_args() From 62fe1696349e8ffd9180ed70f6d1e4a3fface840 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 17 Jun 2019 11:21:33 +0200 Subject: [PATCH 72/98] Add version to rcl_init handling --- tracetools_analysis/analysis/data_model.py | 7 ++++--- tracetools_analysis/analysis/ros2_processor.py | 3 ++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/analysis/data_model.py index 7eb7ad6..30ca49e 100644 --- a/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/analysis/data_model.py @@ -16,7 +16,8 @@ class DataModel(): # Objects (one-time events, usually when something is created) self.contexts = pd.DataFrame(columns=['context_handle', 'timestamp', - 'pid']) + 'pid', + 'version']) self.contexts.set_index(['context_handle'], inplace=True, drop=True) self.nodes = pd.DataFrame(columns=['node_handle', 'timestamp', @@ -71,8 +72,8 @@ class DataModel(): 'duration', 'intra_process']) - def add_context(self, context_handle, timestamp, pid) -> None: - self.contexts.loc[context_handle] = [timestamp, pid] + def add_context(self, context_handle, timestamp, pid, version) -> None: + self.contexts.loc[context_handle] = [timestamp, pid, version] def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace) -> None: self.nodes.loc[node_handle] = [timestamp, tid, rmw_handle, name, namespace] diff --git a/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/analysis/ros2_processor.py index c4f91d7..8110fa7 100644 --- a/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/analysis/ros2_processor.py @@ -60,7 +60,8 @@ class Ros2Processor(EventHandler): context_handle = get_field(event, 'context_handle') timestamp = metadata.timestamp pid = metadata.pid - self._data.add_context(context_handle, timestamp, pid) + version = get_field(event, 'version') + self._data.add_context(context_handle, timestamp, pid, version) def _handle_rcl_node_init(self, event: Dict, metadata: EventMetadata) -> None: handle = get_field(event, 'node_handle') From 352690044bbf1362829d7a933b1bb312e9eb8d70 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 24 Jun 2019 16:06:58 +0200 Subject: [PATCH 73/98] Extract trace reading functions --- tracetools_analysis/package.xml | 2 +- .../tracetools_analysis/analysis/handler.py | 7 ++-- .../analysis/lttng_models.py | 15 --------- .../analysis/ros2_processor.py | 3 +- .../tracetools_analysis/conversion/ctf.py | 33 +++---------------- 5 files changed, 11 insertions(+), 49 deletions(-) diff --git a/tracetools_analysis/package.xml b/tracetools_analysis/package.xml index a23316a..064fa3d 100644 --- a/tracetools_analysis/package.xml +++ b/tracetools_analysis/package.xml @@ -9,7 +9,7 @@ Ingo Luetkebohle Christophe Bedard - python3-babeltrace + tracetools_read ament_copyright ament_flake8 diff --git a/tracetools_analysis/tracetools_analysis/analysis/handler.py b/tracetools_analysis/tracetools_analysis/analysis/handler.py index ef4298f..da7c2de 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/tracetools_analysis/analysis/handler.py @@ -5,9 +5,10 @@ from typing import Callable from typing import Dict from typing import List +from tracetools_read.utils import get_event_name +from tracetools_read.utils import get_field + from .lttng_models import EventMetadata -from .lttng_models import get_field -from .lttng_models import get_name class EventHandler(): @@ -31,7 +32,7 @@ class EventHandler(): self._handle(event) def _handle(self, event: Dict[str, str]) -> None: - event_name = get_name(event) + event_name = get_event_name(event) handler_function = self._handler_map.get(event_name, None) if handler_function is not None: pid = get_field( diff --git a/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py b/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py index 2c54719..62b86ca 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py +++ b/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py @@ -1,20 +1,5 @@ # Model objects for LTTng traces/events -from typing import Any -from typing import Dict - - -def get_field(event: Dict, field_name: str, default=None, raise_if_not_found=True) -> Any: - field_value = event.get(field_name, default) - # If enabled, raise exception as soon as possible to avoid headaches - if raise_if_not_found and field_value is None: - raise AttributeError(f'event field "{field_name}" not found!') - return field_value - - -def get_name(event: Dict) -> str: - return get_field(event, '_name') - class EventMetadata(): """Container for event metadata.""" diff --git a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py index 8110fa7..e9c6eae 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py @@ -3,9 +3,10 @@ from typing import Dict from typing import List +from tracetools_read.utils import get_field + from .data_model import DataModel from .handler import EventHandler -from .lttng_models import get_field from .lttng_models import EventMetadata diff --git a/tracetools_analysis/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/tracetools_analysis/conversion/ctf.py index 826231f..e3b329f 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/tracetools_analysis/conversion/ctf.py @@ -2,14 +2,7 @@ from pickle import Pickler -import babeltrace - -# List of ignored CTF fields -_IGNORED_FIELDS = [ - 'content_size', 'cpu_id', 'events_discarded', 'id', 'packet_size', 'packet_seq_num', - 'stream_id', 'stream_instance_id', 'timestamp_end', 'timestamp_begin', 'magic', 'uuid', 'v' -] -_DISCARD = 'events_discarded' +from tracetools_read import utils def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: @@ -21,9 +14,8 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: :return: the number of events written """ # add traces - tc = babeltrace.TraceCollection() print(f'Importing trace directory: {trace_directory}') - tc.add_traces_recursive(trace_directory, 'ctf') + ctf_events = utils._get_trace_ctf_events(trace_directory) count = 0 count_written = 0 @@ -31,7 +23,7 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: # traced = set() # PID_KEYS = ['vpid', 'pid'] - for event in tc.events: + for event in ctf_events: count += 1 # pid = None # for key in PID_KEYS: @@ -40,25 +32,8 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: # break # Write all for now - pod = _ctf_event_to_pod(event) + pod = utils.event_to_dict(event) target.dump(pod) count_written += 1 return count_written - - -def _ctf_event_to_pod(ctf_event): - """ - Convert name, timestamp, and all other keys except those in IGNORED_FIELDS into a dictionary. - - :param ctf_element: The element to convert - :type ctf_element: babeltrace.Element - :return: - :return type: dict - """ - pod = {'_name': ctf_event.name, '_timestamp': ctf_event.timestamp} - if hasattr(ctf_event, _DISCARD) and ctf_event[_DISCARD] > 0: - print(ctf_event[_DISCARD]) - for key in [key for key in ctf_event.keys() if key not in _IGNORED_FIELDS]: - pod[key] = ctf_event[key] - return pod From 7c7e509d4c394bf3ef6f1bd195e89a040c30637c Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 24 Jun 2019 16:44:03 +0200 Subject: [PATCH 74/98] Add license --- LICENSE | 202 ++++++++++++++++++ tracetools_analysis/package.xml | 3 +- tracetools_analysis/setup.py | 22 +- .../tracetools_analysis/__init__.py | 14 ++ .../tracetools_analysis/analysis/__init__.py | 13 ++ .../analysis/data_model.py | 16 +- .../tracetools_analysis/analysis/handler.py | 16 +- .../tracetools_analysis/analysis/load.py | 16 ++ .../analysis/lttng_models.py | 16 +- .../analysis/ros2_processor.py | 16 +- .../conversion/__init__.py | 13 ++ .../tracetools_analysis/conversion/ctf.py | 16 +- .../tracetools_analysis/convert.py | 16 +- .../tracetools_analysis/process.py | 16 +- 14 files changed, 382 insertions(+), 13 deletions(-) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tracetools_analysis/package.xml b/tracetools_analysis/package.xml index 064fa3d..c07368c 100644 --- a/tracetools_analysis/package.xml +++ b/tracetools_analysis/package.xml @@ -5,7 +5,8 @@ 0.0.1 Tools for analysing trace data Christophe Bedard - TODO + Ingo Lütkebohle + Apache 2.0 Ingo Luetkebohle Christophe Bedard diff --git a/tracetools_analysis/setup.py b/tracetools_analysis/setup.py index 570e7cc..b694047 100644 --- a/tracetools_analysis/setup.py +++ b/tracetools_analysis/setup.py @@ -11,10 +11,22 @@ setup( ('share/' + package_name, ['package.xml']), ], install_requires=['setuptools'], - maintainer='Christophe Bedard', - maintainer_email='fixed-term.christophe.bourquebedard@de.bosch.com', - author='Ingo Luetkebohle, Christophe Bedard', - author_email='ingo.luetkebohle@de.bosch.com, fixed-term.christophe.bourquebedard@de.bosch.com', + maintainer=( + 'Christophe Bedard, ' + 'Ingo Lütkebohle' + ), + maintainer_email=( + 'fixed-term.christophe.bourquebedard@de.bosch.com, ' + 'ingo.luetkebohle@de.bosch.com' + ), + author=( + 'Christophe Bedard, ' + 'Ingo Lütkebohle' + ), + author_email=( + 'fixed-term.christophe.bourquebedard@de.bosch.com, ' + 'ingo.luetkebohle@de.bosch.com' + ), # url='', keywords=['ROS'], description='Tools for analysing trace data', @@ -24,6 +36,6 @@ setup( f'process = {package_name}.process:main', ], }, - license='TODO', + license='Apache 2.0', tests_require=['pytest'], ) diff --git a/tracetools_analysis/tracetools_analysis/__init__.py b/tracetools_analysis/tracetools_analysis/__init__.py index 6c918a8..e4deba3 100644 --- a/tracetools_analysis/tracetools_analysis/__init__.py +++ b/tracetools_analysis/tracetools_analysis/__init__.py @@ -1,2 +1,16 @@ +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + """Reading and interpreting of LTTng trace data.""" __author__ = 'Luetkebohle Ingo (CR/AEX3)' diff --git a/tracetools_analysis/tracetools_analysis/analysis/__init__.py b/tracetools_analysis/tracetools_analysis/analysis/__init__.py index e69de29..4b18865 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/__init__.py +++ b/tracetools_analysis/tracetools_analysis/analysis/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/tracetools_analysis/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/tracetools_analysis/analysis/data_model.py index 30ca49e..1f0bdab 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/tracetools_analysis/analysis/data_model.py @@ -1,4 +1,18 @@ -# Data model +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module for data model.""" import pandas as pd diff --git a/tracetools_analysis/tracetools_analysis/analysis/handler.py b/tracetools_analysis/tracetools_analysis/analysis/handler.py index da7c2de..71de848 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/handler.py +++ b/tracetools_analysis/tracetools_analysis/analysis/handler.py @@ -1,4 +1,18 @@ -# Event handler +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module for event handler.""" import sys from typing import Callable diff --git a/tracetools_analysis/tracetools_analysis/analysis/load.py b/tracetools_analysis/tracetools_analysis/analysis/load.py index 073b086..e79dfa4 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/load.py +++ b/tracetools_analysis/tracetools_analysis/analysis/load.py @@ -1,3 +1,19 @@ +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module for pickle loading.""" + import pickle from typing import Dict from typing import List diff --git a/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py b/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py index 62b86ca..7de325c 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py +++ b/tracetools_analysis/tracetools_analysis/analysis/lttng_models.py @@ -1,4 +1,18 @@ -# Model objects for LTTng traces/events +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module LTTng traces/events models.""" class EventMetadata(): diff --git a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py index e9c6eae..3818ea0 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py @@ -1,4 +1,18 @@ -# Process trace events and create ROS model +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module for trace events processor and ROS model creation.""" from typing import Dict from typing import List diff --git a/tracetools_analysis/tracetools_analysis/conversion/__init__.py b/tracetools_analysis/tracetools_analysis/conversion/__init__.py index e69de29..4b18865 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/__init__.py +++ b/tracetools_analysis/tracetools_analysis/conversion/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/tracetools_analysis/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/tracetools_analysis/conversion/ctf.py index e3b329f..6ba3db9 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/tracetools_analysis/conversion/ctf.py @@ -1,4 +1,18 @@ -# CTF to pickle conversion +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module with CTF to pickle conversion functions.""" from pickle import Pickler diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index 2650702..cbd6ebc 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -1,5 +1,19 @@ #!/usr/bin/env python3 -# Entrypoint/script to convert CTF trace data to a pickle file +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Entrypoint/script to convert CTF trace data to a pickle file.""" import argparse from pickle import Pickler diff --git a/tracetools_analysis/tracetools_analysis/process.py b/tracetools_analysis/tracetools_analysis/process.py index 53ee3f4..e02470e 100644 --- a/tracetools_analysis/tracetools_analysis/process.py +++ b/tracetools_analysis/tracetools_analysis/process.py @@ -1,5 +1,19 @@ #!/usr/bin/env python3 -# Entrypoint/script to process events from a pickle file to build a ROS model +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Entrypoint/script to process events from a pickle file to build a ROS model.""" import argparse import time From 92943a48fb17e12500eac67359046db3b34d442a Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Wed, 26 Jun 2019 09:49:52 +0200 Subject: [PATCH 75/98] Add gitlab-ci config file --- .gitlab-ci.yml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 .gitlab-ci.yml diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..19427a9 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,22 @@ +image: registry.gitlab.com/ros_tracing/ros2_tracing/ci-base:latest + +variables: + DOCKER_DRIVER: overlay2 + PACKAGES_LIST: tracetools_analysis + +before_script: + - git clone https://gitlab.com/ros_tracing/ros2_tracing.git + - apt-get update + - rosdep update + - rosdep install --from-paths . --ignore-src --rosdistro dashing -y --skip-keys "console_bridge fastcdr fastrtps libopensplice67 libopensplice69 rti-connext-dds-5.3.1 urdfdom_headers" + +build: + script: + - colcon build --symlink-install --packages-up-to $PACKAGES_LIST + - colcon test --packages-select $PACKAGES_LIST + artifacts: + paths: + - install + - build/*/test_results/*/*.xunit.xml + reports: + junit: build/*/test_results/*/*.xunit.xml From 81e499eb17e57b71d9ba656197efc93ac1b4011d Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Wed, 26 Jun 2019 09:54:05 +0200 Subject: [PATCH 76/98] Remove rosdep lines --- .gitlab-ci.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 19427a9..e35147e 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -6,9 +6,6 @@ variables: before_script: - git clone https://gitlab.com/ros_tracing/ros2_tracing.git - - apt-get update - - rosdep update - - rosdep install --from-paths . --ignore-src --rosdistro dashing -y --skip-keys "console_bridge fastcdr fastrtps libopensplice67 libopensplice69 rti-connext-dds-5.3.1 urdfdom_headers" build: script: From dabd7eb84fe5731123ffa93bd1fbe579a927581b Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Wed, 26 Jun 2019 10:05:19 +0200 Subject: [PATCH 77/98] Add pytest.xml to report artifacts list --- .gitlab-ci.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e35147e..dc61ed4 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -15,5 +15,8 @@ build: paths: - install - build/*/test_results/*/*.xunit.xml + - build/*/pytest.xml reports: - junit: build/*/test_results/*/*.xunit.xml + junit: + - build/*/test_results/*/*.xunit.xml + - build/*/pytest.xml From 1b7c909fffabc5a14beeec9ba10e6fbf2b232794 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Wed, 26 Jun 2019 10:25:11 +0200 Subject: [PATCH 78/98] Fix lint errors --- .../analysis/data_model.py | 40 ++++++++++---- .../analysis/ros2_processor.py | 52 ++++++++++++++----- 2 files changed, 69 insertions(+), 23 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/tracetools_analysis/analysis/data_model.py index 1f0bdab..09d5f0e 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/tracetools_analysis/analysis/data_model.py @@ -86,34 +86,54 @@ class DataModel(): 'duration', 'intra_process']) - def add_context(self, context_handle, timestamp, pid, version) -> None: + def add_context( + self, context_handle, timestamp, pid, version + ) -> None: self.contexts.loc[context_handle] = [timestamp, pid, version] - def add_node(self, node_handle, timestamp, tid, rmw_handle, name, namespace) -> None: + def add_node( + self, node_handle, timestamp, tid, rmw_handle, name, namespace + ) -> None: self.nodes.loc[node_handle] = [timestamp, tid, rmw_handle, name, namespace] - def add_publisher(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth) -> None: + def add_publisher( + self, handle, timestamp, node_handle, rmw_handle, topic_name, depth + ) -> None: self.publishers.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_subscription(self, handle, timestamp, node_handle, rmw_handle, topic_name, depth) -> None: + def add_subscription( + self, handle, timestamp, node_handle, rmw_handle, topic_name, depth + ) -> None: self.subscriptions.loc[handle] = [timestamp, node_handle, rmw_handle, topic_name, depth] - def add_service(self, handle, timestamp, node_handle, rmw_handle, service_name) -> None: + def add_service( + self, handle, timestamp, node_handle, rmw_handle, service_name + ) -> None: self.services.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_client(self, handle, timestamp, node_handle, rmw_handle, service_name) -> None: + def add_client( + self, handle, timestamp, node_handle, rmw_handle, service_name + ) -> None: self.clients.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] - def add_timer(self, handle, timestamp, period) -> None: + def add_timer( + self, handle, timestamp, period + ) -> None: self.timers.loc[handle] = [timestamp, period] - def add_callback_object(self, handle, timestamp, callback_object) -> None: + def add_callback_object( + self, handle, timestamp, callback_object + ) -> None: self.callback_objects.loc[handle] = [timestamp, callback_object] - def add_callback_symbol(self, callback_object, timestamp, symbol) -> None: + def add_callback_symbol( + self, callback_object, timestamp, symbol + ) -> None: self.callback_symbols.loc[callback_object] = [timestamp, symbol] - def add_callback_instance(self, callback_object, timestamp, duration, intra_process) -> None: + def add_callback_instance( + self, callback_object, timestamp, duration, intra_process + ) -> None: data = { 'callback_object': callback_object, 'timestamp': timestamp, diff --git a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py index 3818ea0..a335faa 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py @@ -71,14 +71,18 @@ class Ros2Processor(EventHandler): def get_data_model(self) -> DataModel: return self._data - def _handle_rcl_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_init( + self, event: Dict, metadata: EventMetadata + ) -> None: context_handle = get_field(event, 'context_handle') timestamp = metadata.timestamp pid = metadata.pid version = get_field(event, 'version') self._data.add_context(context_handle, timestamp, pid, version) - def _handle_rcl_node_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_node_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'node_handle') timestamp = metadata.timestamp tid = metadata.tid @@ -87,7 +91,9 @@ class Ros2Processor(EventHandler): namespace = get_field(event, 'namespace') self._data.add_node(handle, timestamp, tid, rmw_handle, name, namespace) - def _handle_rcl_publisher_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_publisher_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'publisher_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -96,7 +102,9 @@ class Ros2Processor(EventHandler): depth = get_field(event, 'queue_depth') self._data.add_publisher(handle, timestamp, node_handle, rmw_handle, topic_name, depth) - def _handle_subscription_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_subscription_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'subscription_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -105,13 +113,17 @@ class Ros2Processor(EventHandler): depth = get_field(event, 'queue_depth') self._data.add_subscription(handle, timestamp, node_handle, rmw_handle, topic_name, depth) - def _handle_rclcpp_subscription_callback_added(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rclcpp_subscription_callback_added( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'subscription_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rcl_service_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_service_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'service_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -119,13 +131,17 @@ class Ros2Processor(EventHandler): service_name = get_field(event, 'service_name') self._data.add_service(handle, timestamp, node_handle, rmw_handle, service_name) - def _handle_rclcpp_service_callback_added(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rclcpp_service_callback_added( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'service_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rcl_client_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_client_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'client_handle') timestamp = metadata.timestamp node_handle = get_field(event, 'node_handle') @@ -133,30 +149,40 @@ class Ros2Processor(EventHandler): service_name = get_field(event, 'service_name') self._data.add_client(handle, timestamp, node_handle, rmw_handle, service_name) - def _handle_rcl_timer_init(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rcl_timer_init( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'timer_handle') timestamp = metadata.timestamp period = get_field(event, 'period') self._data.add_timer(handle, timestamp, period) - def _handle_rclcpp_timer_callback_added(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rclcpp_timer_callback_added( + self, event: Dict, metadata: EventMetadata + ) -> None: handle = get_field(event, 'timer_handle') timestamp = metadata.timestamp callback_object = get_field(event, 'callback') self._data.add_callback_object(handle, timestamp, callback_object) - def _handle_rclcpp_callback_register(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_rclcpp_callback_register( + self, event: Dict, metadata: EventMetadata + ) -> None: callback_object = get_field(event, 'callback') timestamp = metadata.timestamp symbol = get_field(event, 'symbol') self._data.add_callback_symbol(callback_object, timestamp, symbol) - def _handle_callback_start(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_callback_start( + self, event: Dict, metadata: EventMetadata + ) -> None: # Add to dict callback_addr = get_field(event, 'callback') self._callback_instances[callback_addr] = (event, metadata) - def _handle_callback_end(self, event: Dict, metadata: EventMetadata) -> None: + def _handle_callback_end( + self, event: Dict, metadata: EventMetadata + ) -> None: # Fetch from dict callback_object = get_field(event, 'callback') (event_start, metadata_start) = self._callback_instances.get(callback_object) From 70f51087b9f1003ba0de11e0325ddba3b3dc2c79 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 09:26:16 +0200 Subject: [PATCH 79/98] Move conversion logic to ctf module --- .../tracetools_analysis/conversion/ctf.py | 19 +++++++++++++++++-- .../tracetools_analysis/convert.py | 12 +++++------- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/tracetools_analysis/conversion/ctf.py index 6ba3db9..c2927db 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/tracetools_analysis/conversion/ctf.py @@ -21,9 +21,9 @@ from tracetools_read import utils def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: """ - Load CTF trace and convert to a pickle file. + Load CTF trace, convert events, and dump to a pickle file. - :param trace_directory: the main/top trace directory + :param trace_directory: the trace directory :param target: the target pickle file to write to :return: the number of events written """ @@ -51,3 +51,18 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: count_written += 1 return count_written + + +def convert(trace_directory: str, pickle_target_path: str) -> int: + """ + Convert CTF trace to pickle file. + + :param trace_directory: the trace directory + :param pickle_target_path: the path to the pickle file that will be created + :return: the number of events written to the pickle file + """ + with open(pickle_target_path, 'wb') as f: + p = Pickler(f, protocol=4) + count = ctf_to_pickle(trace_directory, p) + + return count diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index cbd6ebc..d282c55 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -25,7 +25,7 @@ from tracetools_analysis.conversion import ctf def parse_args(): parser = argparse.ArgumentParser(description='Convert CTF trace data to a pickle file.') parser.add_argument('trace_directory', help='the path to the main CTF trace directory') - parser.add_argument('pickle_file', help='the target pickle file to generate') + parser.add_argument('pickle_path', help='the path to the target pickle file to generate') return parser.parse_args() @@ -33,11 +33,9 @@ def main(): args = parse_args() trace_directory = args.trace_directory - pickle_target_file = args.pickle_file + pickle_target_path = args.pickle_path start_time = time.time() - with open(pickle_target_file, 'wb') as f: - p = Pickler(f, protocol=4) - count = ctf.ctf_to_pickle(trace_directory, p) - time_diff = time.time() - start_time - print(f'converted {count} events in {time_diff * 1000:.2f} ms') + count = ctf.convert(trace_directory, pickle_target_path) + time_diff = time.time() - start_time + print(f'converted {count} events in {time_diff * 1000:.2f} ms') From 19450ff028e462a9b7c825d095fa711a4fb20d55 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 09:27:04 +0200 Subject: [PATCH 80/98] Cleanup ctf conversion function --- .../tracetools_analysis/conversion/ctf.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/tracetools_analysis/conversion/ctf.py index c2927db..2f5955e 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/tracetools_analysis/conversion/ctf.py @@ -27,25 +27,15 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: :param target: the target pickle file to write to :return: the number of events written """ - # add traces print(f'Importing trace directory: {trace_directory}') ctf_events = utils._get_trace_ctf_events(trace_directory) count = 0 count_written = 0 - # count_pid_matched = 0 - # traced = set() - # PID_KEYS = ['vpid', 'pid'] for event in ctf_events: count += 1 - # pid = None - # for key in PID_KEYS: - # if key in event.keys(): - # pid = event[key] - # break - # Write all for now pod = utils.event_to_dict(event) target.dump(pod) count_written += 1 From c2195fefb6b6e7d5f475eccec3ae9bc67419ecf9 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 09:48:50 +0200 Subject: [PATCH 81/98] Move print to CLI function --- tracetools_analysis/tracetools_analysis/conversion/ctf.py | 1 - tracetools_analysis/tracetools_analysis/convert.py | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/tracetools_analysis/tracetools_analysis/conversion/ctf.py b/tracetools_analysis/tracetools_analysis/conversion/ctf.py index 2f5955e..a81c523 100644 --- a/tracetools_analysis/tracetools_analysis/conversion/ctf.py +++ b/tracetools_analysis/tracetools_analysis/conversion/ctf.py @@ -27,7 +27,6 @@ def ctf_to_pickle(trace_directory: str, target: Pickler) -> int: :param target: the target pickle file to write to :return: the number of events written """ - print(f'Importing trace directory: {trace_directory}') ctf_events = utils._get_trace_ctf_events(trace_directory) count = 0 diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index d282c55..a08a76b 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -35,6 +35,7 @@ def main(): trace_directory = args.trace_directory pickle_target_path = args.pickle_path + print(f'Importing trace directory: {trace_directory}') start_time = time.time() count = ctf.convert(trace_directory, pickle_target_path) time_diff = time.time() - start_time From a79c1348dfbeda399eb3da2a4403381064567eec Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 10:02:06 +0200 Subject: [PATCH 82/98] Remove unused import --- tracetools_analysis/tracetools_analysis/convert.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index a08a76b..576db4c 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -16,7 +16,6 @@ """Entrypoint/script to convert CTF trace data to a pickle file.""" import argparse -from pickle import Pickler import time from tracetools_analysis.conversion import ctf From 9b48c620eda7b4a85854249eedb7646d9e714d34 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 10:14:53 +0200 Subject: [PATCH 83/98] Update callback duration notebook --- .../analysis/Callback_duration.ipynb | 149 ---------------- .../analysis/callback_duration.ipynb | 163 ++++++++++++++++++ 2 files changed, 163 insertions(+), 149 deletions(-) delete mode 100644 tracetools_analysis/analysis/Callback_duration.ipynb create mode 100644 tracetools_analysis/analysis/callback_duration.ipynb diff --git a/tracetools_analysis/analysis/Callback_duration.ipynb b/tracetools_analysis/analysis/Callback_duration.ipynb deleted file mode 100644 index 60eca43..0000000 --- a/tracetools_analysis/analysis/Callback_duration.ipynb +++ /dev/null @@ -1,149 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/boc7rng/ros2_ws/src/tracetools_analysis/tracetools_analysis\n" - ] - } - ], - "source": [ - "cd .." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import pickle\n", - "import matplotlib.pyplot as plt\n", - "from tracetools_analysis.analysis import load\n", - "from tracetools_analysis.analysis import ros2_processor" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Load an process\n", - "pickle_filename = '../../../the_pickle_file'\n", - "events = load.load_pickle(pickle_filename)\n", - "processor = ros2_processor.ros2_process(events)\n", - "data_model = processor.get_data_model()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "callback_instances = data_model.callback_instances\n", - "callback_symbols = data_model.callback_symbols\n", - "\n", - "# Get a list of callback objects\n", - "callback_objects = set(callback_instances['callback_object'])\n", - "# Get their symbol\n", - "symbols = {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects}\n", - "\n", - "# Plot durations\n", - "for obj in callback_objects:\n", - " duration_ns = callback_instances.loc[callback_instances.loc[:, 'callback_object'] == obj, :]\n", - " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", - "\n", - " fig = plt.figure(figsize=(12, 6))\n", - " fig.suptitle('TODO', fontsize=20)\n", - "\n", - " ax = fig.add_subplot(1, 2, 1)\n", - " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", - " ax.legend([str(symbols.get(obj, 'unknown'))])\n", - " ax.set_xlabel('start')\n", - " ax.set_ylabel('duration (ms)')\n", - " ax.title.set_text('Callback durations')\n", - " ax.grid()\n", - "\n", - " ax = fig.add_subplot(1, 2, 2)\n", - " duration_ms.hist(column='duration', ax=ax)\n", - " ax.title.set_text('Duration histogram')\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb new file mode 100644 index 0000000..46c4486 --- /dev/null +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -0,0 +1,163 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "trace_directory = '/tmp/session-composed/ust'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "# Assuming a workspace with:\n", + "# src/tracetools_analysis/\n", + "# src/ros2/ros2_tracing/tracetools_read/\n", + "sys.path.insert(0, '../')\n", + "sys.path.insert(0, '../../../ros2/ros2_tracing/tracetools_read/')\n", + "import os\n", + "import pickle\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from tracetools_analysis.analysis import load\n", + "from tracetools_analysis.analysis import ros2_processor\n", + "from tracetools_analysis.conversion import ctf" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "156 events\n" + ] + } + ], + "source": [ + "# Convert\n", + "pickle_filename = 'pickle'\n", + "pickle_path = os.path.join(trace_directory, pickle_filename)\n", + "count = ctf.convert(trace_directory, pickle_path)\n", + "print(f'{count} events')\n", + "\n", + "# Process\n", + "events = load.load_pickle(pickle_path)\n", + "processor = ros2_processor.ros2_process(events)\n", + "data_model = processor.get_data_model()\n", + "#data_model.print_model()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "callback_instances = data_model.callback_instances\n", + "callback_symbols = data_model.callback_symbols\n", + "\n", + "# Get a list of callback objects\n", + "callback_objects = set(callback_instances['callback_object'])\n", + "# Get their symbol\n", + "symbols = {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects}\n", + "\n", + "# Plot durations\n", + "for obj in callback_objects:\n", + " duration_ns = callback_instances.loc[callback_instances.loc[:, 'callback_object'] == obj, :]\n", + " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", + "\n", + " fig = plt.figure(figsize=(12, 6))\n", + " fig.suptitle('TODO', fontsize=20)\n", + "\n", + " ax = fig.add_subplot(1, 2, 1)\n", + " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", + " ax.legend([str(symbols.get(obj, 'unknown'))])\n", + " ax.set_xlabel('start')\n", + " ax.set_ylabel('duration (ms)')\n", + " ax.title.set_text('Callback durations')\n", + " ax.grid()\n", + "\n", + " ax = fig.add_subplot(1, 2, 2)\n", + " duration_ms.hist(column='duration', ax=ax)\n", + " ax.title.set_text('Duration histogram')\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 87396b2710cefe67205c7eff4933e6e810276864 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 10:35:46 +0200 Subject: [PATCH 84/98] Make --pickle-path arg optional --- .../tracetools_analysis/convert.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index 576db4c..2268101 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -16,16 +16,25 @@ """Entrypoint/script to convert CTF trace data to a pickle file.""" import argparse +import os import time from tracetools_analysis.conversion import ctf def parse_args(): - parser = argparse.ArgumentParser(description='Convert CTF trace data to a pickle file.') - parser.add_argument('trace_directory', help='the path to the main CTF trace directory') - parser.add_argument('pickle_path', help='the path to the target pickle file to generate') - return parser.parse_args() + parser = argparse.ArgumentParser( + description='Convert CTF trace data to a pickle file.') + parser.add_argument( + 'trace_directory', help='the path to the main CTF trace directory') + parser.add_argument( + '--pickle-path', '-p', + help='the path to the target pickle file to generate (default: $trace_directory/pickle)') + args = parser.parse_args() + if args.pickle_path is None: + args.pickle_path = os.path.join(args.trace_directory, 'pickle') + print(args.pickle_path) + return args def main(): From 5cafa62b9f0ba4dc27f3995eb790ed276586d2a1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 10:38:52 +0200 Subject: [PATCH 85/98] Move pickle file path print to main --- tracetools_analysis/tracetools_analysis/convert.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/convert.py b/tracetools_analysis/tracetools_analysis/convert.py index 2268101..b1ffa42 100644 --- a/tracetools_analysis/tracetools_analysis/convert.py +++ b/tracetools_analysis/tracetools_analysis/convert.py @@ -33,7 +33,6 @@ def parse_args(): args = parser.parse_args() if args.pickle_path is None: args.pickle_path = os.path.join(args.trace_directory, 'pickle') - print(args.pickle_path) return args @@ -43,8 +42,9 @@ def main(): trace_directory = args.trace_directory pickle_target_path = args.pickle_path - print(f'Importing trace directory: {trace_directory}') + print(f'importing trace directory: {trace_directory}') start_time = time.time() count = ctf.convert(trace_directory, pickle_target_path) time_diff = time.time() - start_time print(f'converted {count} events in {time_diff * 1000:.2f} ms') + print(f'pickle written to: {pickle_target_path}') From 25dc4ac97e88f88df8e186258b509a78d2a935a1 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 11:31:34 +0200 Subject: [PATCH 86/98] Add data model utility class --- .../analysis/callback_duration.ipynb | 21 +++---- .../tracetools_analysis/analysis/utils.py | 62 +++++++++++++++++++ 2 files changed, 71 insertions(+), 12 deletions(-) create mode 100644 tracetools_analysis/tracetools_analysis/analysis/utils.py diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb index 46c4486..a71c620 100644 --- a/tracetools_analysis/analysis/callback_duration.ipynb +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -27,6 +27,7 @@ "\n", "from tracetools_analysis.analysis import load\n", "from tracetools_analysis.analysis import ros2_processor\n", + "from tracetools_analysis.analysis import utils\n", "from tracetools_analysis.conversion import ctf" ] }, @@ -66,7 +67,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -78,7 +79,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAukAAAGeCAYAAAApC5/vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3Xt8nHWZ9/HPlTTTNpO0zaQ0gbbQKj0IdilLxDMERBce5LDP4wHEFXxcux5QnpVFQV3Eirso6rqu7D501+OCuIKLgICg0pEH5VgsZ5rUUmhampQ2bTNJm+P1/HHfE4YwSWbSuWcm6ff9es0rM/fh97tm2tc9V3753dfP3B0RERERESkfFaUOQEREREREXklJuoiIiIhImVGSLiIiIiJSZpSki4iIiIiUGSXpIiIiIiJlRkm6iIiIiEiZUZIuIiIiIlJmlKSLiJSAmXmejwtGnF9nZpeb2UNm1mlmvWa2xcx+ZmbvHKPfzSPa7TeznWb2hJn9p5m918xi48RebWZ/a2b3mtlLYd8vmtlt4flWoI9JROSgZVrMSESk+Mzsiiyb/w8wG/hnYPeIfb9w9/XhuScAPwfmAs8A9wBdwBLgNKAauA74a3fvHdHvZuCIjD4qgFnAMuDtQBxoBf7K3R/MEvfRwG3AYuB54C5gJ3A4cDowB/g18D53H/keREQkR0rSRUTKREYCvdjdN49yzFHAQ8BMgqT+u55xITezhcAvgD8Hvu/uH8m1DzObDXwF+BSwB3iTuz+bsb8ReBQ4FPhH4HJ3H8jYnwB+AvwFQaJ+qrsP5fkxiIgImu4iIjLZfIdgtPvr7v4vPmKkxd23AO8GOoH/bWZvzbVhd9/j7p8Gfkwwon/ViEOuJEjQf+run89M0MPzdwH/C9gEvBM4N693JiIiw5Ski4hMEma2GHgH0At8fbTj3P1F4D/Cl6sm0NWXw5/vNrNZYd8zgQ+G21eP0Xc38M0D6FtERFCSLiIymbwt/LnO3TvHOfbX4c+cR9LT3H0T0AZUAseFm5uA6cA2d38mx77fZGaV+fYvIiJK0kVEJpNDw59bcjg2fcxhE+xra/jzkAPoOwbUT7B/EZGDmpJ0EZHJI13aMJc7/vM5NpfzJ9qeqhOIiEyAknQRkcnjxfDn4Tkcu2DEOflKj8DvmEDfC8OffcCuCfYvInJQU5IuIjJ53Bf+PM7M5oxz7Cnhz9/n24mZHUmQ5A8A68LNDxPcsHqYmb0ux74fcPfBfPsXEREl6SIik0Z4Q+daghs4LxntODNrAP46fLlmAl1dHv68zd27wr73EdRAB/jiGH3PBD5zAH2LiAhK0kVEJpuLgB7gc2b28ZE7zWw+8EsgAfzA3XMeSTezWWb2HeCvCFYjvXTEIV8E2oEPmNlXzGzaiPPrgJuAI4HfADfk/K5EROQVtOKoiEiZyGXF0fC4kwiS4QTwFMHoehdBcnw6UA1cD3zE3XtH6eOfCRJxA2YBy4ATCBZKagE+6O4PZ+n7z4BbwzY2A78imHd+eNh3HUGC/l53353vZyAiIgEl6SIiZSLXJD08th74FMHqokuAGQQ3ed4P/Lu73z1OH2kDBAn+VmA9cAtwq7v3jdF3HPgb4H8CRwE1BIn6IwSrld44ciVUERHJj5J0EREREZEyoznpIiIiIiJlRkm6iIiIiEiZUZIuIiIiIlJmlKSLiIiIiJQZJekiIiIiImVGSbqIiIiISJlRki4iIiIiUmaUpIuIiIiIlBkl6SIiIiIiZUZJuoiIiIhImVGSLiIiIiJSZpSkS9kwMzezI8PnPzSzK8PnzWbWFkF/w31M4NwrzOy6Qsc0Rn9vN7MNxepPRKQcmdmdZnZ+BO2O+X1gZikze02h+xUZi5J0KSgz+4CZPRJe0F4ML6hvK3Vck03mLywA7v7/3H1ZKWMSkYOXmW02s31m1mVmu83sD2b2MTOLLI/INhji7qe5+4+i6nM07l7j7pvGOiaqASU5eClJl4Ixs88A3wb+AWgADgf+FTirlHGVGzObVuoYREQm4Ax3rwWOAK4CPgd8byIN6TqYPzOrLHUMUlxK0qUgzGw2sBr4pLv/t7t3u3u/u9/m7peExxxvZveHozAvmtl3zSyWRx+fN7OXwhGd8zK2n25mfzSzvWa2xcyuGHHe28JRn93h/guytF1rZmvN7DtmZln2Lzaz34WjSL8G5mbse9XoSRjjKeHzK8zsJjO7zsz2AheM9VmY2b1hM4+Ff5F4/8g+zOx1ZpYMz3/KzM7M2PdDM7vGzG4P433QzF4b7jMz+ycz6zCzPWb2uJm9Ptd/AxERd9/j7rcC7wfOT19DwmvSX6ePM7MLzOy+jNduZp80s1agNdz2z+F1ea+ZrTOzt4fbTwU+D7w/vA4+NrIPM6swsy+a2fPhNe3H4XcRZrYo7O98M3sh/O74wjhvrS7bdTMj9vR0zP9hZk+Hx201s78zszhwJ3BYGG/KzA4zs+lm9m0z2xY+vm1m0zPa/Wz4HbDNzP7aXj3t89/M7A4z6wZOGuv7LuM9fzjc12nBXzveEF7rd5vZd/P715ZSUpIuhfJmYAZw8xjHDAJ/S5Dgvhl4B/CJHNtvDM+bD5wPrDGz9PSPbuBDwBzgdODjZnY2gJkdTnDh/BfgEGAlsD6zYTOrB34L/N7dP+3unqX/nwDrwhi+EsaQj7OAm8IYr2eMz8LdTwjPOSb8E+t/jYi3CrgNuBuYB3wKuD7j8wA4F/gyUAdsBL4abn8XcAKwNIzl/cDOPN+LiAju/hDQBrw9j9POBt4IHBW+fpjgupwguM7eaGYz3P1XBH+V/a/wOnhMlrYuCB8nAa8BaoCRSejbgGUE19jLzex1Y8Q22nVzpO8BfxP+VeH1wD3u3g2cBmwL461x923AF4A3he/xGOB44Isw/IvIZ4BTgCOBE7P09YEwjlrgPsb4vsvwRmAJwfX922EMpwBHA+8zs2z9SBlSki6FUg+85O4Dox3g7uvc/QF3H3D3zcC1ZL8ojebv3b3X3X8H3A68L2w36e5PuPuQuz8O3JDR7nnAb9z9hnBkf6e7ZybphwG/A2509y9m6zRM9N+Q0f+9BElyPu5391+EMe47wM/iTQRfRle5e5+73wP8kuALJu2/3f2h8N/jeoIvCIB+gov9csDc/Rl3fzHP9yIikraNIMHO1T+6+y533wfg7teF1+UBd/8mMJ0gqc7FecC33H2Tu6eAy4Bz7JVTab4cXnMfAx4jSJRHM9p1c6R+4Cgzm+Xune7+6Dgxrnb3DnffQfBLwF+F+94H/MDdn3L3nnDfSLe4++/D747943zfpX0lPPZugqT+hrD/rcD/A44dI14pI0rSpVB2AnNtjHmGZrbUzH5pZtstmPbxD2RMGxlHZzhSkfY8QYKNmb3RgqkqO8xsD/CxjHYXAn8ao93TgZnA/x3jmMNG6T8fWzJfHOBncRiwxd2HRsQzP+P19oznPQRJPWFC/13gGqDdzNaY2az83oqIyLD5wK48jh95LbzYzJ4Jp9/tBmaT37Uw81r8PDCN4J6otKzXwlHkeuz/Av4H8LwF0yDfnGeMh2Xsy/w8XvHZZNs2zvddWnvG831ZXo/1GUgZUZIuhXI/sJ/gT5mj+TfgWWCJu88imG/4qvnfo6gL5/ylHU4wggPBn0hvBRa6+2yChDvd7hbgtYzu34FfAXeMaD/Ti6P0n9YNVKdfWHBzzyEj2hg5heZAPottwEJ7ZVWFw4GtuZzs7t9x9+MI/vS5FLgkx35FRIaZ2RsIkvT0vPNXXAsJpimONHwtDOeff45gRLnO3ecAe3j5Wpht6mGmbQQ3saYdDgzwyqS04Nz9YXc/i2C64S+An6V35Rhj+rvrRWBBxr6F2bob8Xqs7zuZYpSkS0G4+x7gcuAaMzvbzKrNrMrMTjOzr4eH1QJ7gZSZLQc+nmc3XzazWHhhfzdwY0a7u9x9v5kdTzCHL+164BQze5+ZTTOzejMb+SfMC4ENwC/NbGaW9/Y88EhG/28Dzsg4pAWYEd7QU0Uw33D6yHZGGO+zaCeYY5nNgwRfhp8NP+PmMJ6fjtMn4Q1Ebwzj7Cb4xWpwvPNERNLMbJaZvZvgmnOduz8R7loP/M/w+n8k8JFxmqolSKp3ANPM7HIg8y977cAiG73M4w3A31pwY38NL89hH3Xa5YEKvwPOM7PZ7t5PcB1PX0PbgXoLb17NiPGLZnaImc0l+J5Ml5X8GfBhCwoBVIf7xjPW951MMUrSpWDc/VsEN8F8keCiu4UgAf5FeMjfEVxQughGsP8rSzOj2Q50EoxAXA98zN2fDfd9AlhtZl0EF7n0qAbu/gLBnyUvJviT7HpGzEkMbxRdFcZ7i5nNyNL/BwhuxtkFfAn4ccb5e8IY/oNgNLub4GaqsYz3WVwB/Ci8G/99I+LtA84kuEnpJYIylx/K+DzGMivsr5Pgz647gW/kcJ6IyG3hdXYLwc2I3wI+nLH/n4A+gmT1RwTX6rHcRXBjfwvB9Wg/r5zekR6I2Wlm2eZ9fx/4T+Be4Lnw/E/l8X4m6q+AzeFUxY8BHwQIr8E3AJvCa/dhwJUEgzyPA08Aj4bbcPc7ge8AawluVL0/bL93jL5H/b6TqceyF7IQERERkWIJK888CUyP8q8BMnloJF1ERESkBMzsL8MpNHXA14DblKBLmpJ0ERERkdL4G4LpoX8imNue771aMoVpuouIiIiISJnRSLqIiIiISJmJNEk3s1PNbIOZbTSzS7Ps/5iZPWFm683sPjM7KmPfZeF5G8zsL3JtU0RERERksotsuku4oEsL8E6CcnQPA+e6+9MZx8xy973h8zOBT7j7qWGyfgNwPMGKXL8hWHSF8drMZu7cub5o0aICvruxdXd3E4+Pti5O6ZRjXOUYEyiufCmu3Kxbt+4ldx+50JUUwHjX+XL6v6BYslMsoyuneBRLdulYCnqdd/dIHsCbgbsyXl8GXDbG8ecCd2Y7lqCW6pvzbTP9OO6447yY1q5dW9T+clWOcZVjTO6KK1+KKzfAIx7RNfdgf4x3nS+n/wuKJTvFMrpyikexZJeOpZDX+WkFyfSzm88rFyVoI1gM5hXM7JMEC+DEgJMzzn1gxLnzw+fjthm2u4pggRoaGhpIJpN5v4GJSqVSRe0vV+UYVznGBIorX4pLRESksKJM0i3LtlfNrXH3awiWkv8AwUqV549xbrY59Fnn67j7GmANQFNTkzc3N+cWdQEkk0mK2V+uyjGucowJFFe+FJeIiEhhRZmktwELM14vIFjSfTQ/Bf4th3PzaVNEREREZNKJMkl/GFhiZouBrcA5wAcyDzCzJe7eGr48HUg/vxX4iZl9i+DG0SXAQwQj7GO2KSIHrr+/n7a2Nvbv35/T8bNnz+aZZ56JOKr8lSquGTNmsGDBAqqqqoret4iITA2RJenuPmBmFxLc9FkJfN/dnzKz1QST6m8FLjSzU4B+oJNgqgvhcT8DngYGgE+6+yBAtjajeg8iB6u2tjZqa2tZtGgRZtlmn71SV1cXtbW1RYgsP6WIy93ZuXMnbW1tLF68uKh9i4jI1BHlSDrufgdwx4htl2c8v2iMc78KfDWXNkWksPbv359zgi6vZGbU19ezY8eOUociIiKTmFYcFZGslKBPnD47ERE5UErSRURERETKjJJ0ESlLmzdvZubMmaxcuRKAmpqagrR7xRVX8I1vfGPc4y644AJuuummMY+55JJLaGxszKk9ERGRfEQ6J11E5EC89rWvZf369aUOY1RXX3112SxJLSIiU4uSdBEZ05dve4qnt+0d85jBwUEqKytzbvOow2bxpTOOnlA8qVSKs846i87OTvr7+7nyyis566yz2Lx5M6eeeipve9vbeOCBBzjmmGN4//vfz9e+9jU6Ojq4/vrrOf744wF47LHHOPnkk9myZQuf/exn+ehHP4q786lPfYp77rmHxYsXE6zuHFi9ejW33XYb+/bt4y1veQvXXnut5p0XgZn9LfDXBIvWPQF82N1zqwsqIjLJabpLFk9u3cNDz+0qdRgiksWMGTO4+eabefTRR1m7di0XX3zxcEK9ceNGLrroIh5//HGeffZZbrzxRu677z6+8Y1v8A//8A/DbTz++OPcfvvt3H///axevZpt27Zx8803s2HDBp544gn+/d//nT/84Q/Dx1944YU8/PDDPPnkk+zbt49f/vKXRX/fBxszmw98Gmhy99cTlN09p7RRiYgUj0bSs/j2b1rYuns/d1709lKHIlJyuYx4F7Meubvz+c9/nnvvvZeKigq2bt1Ke3s7AIsXL2bFihUAHH300ZxwwgmYGStWrGDz5s3DbZx11lnMnDmTmTNnctJJJ/HQQw9x7733cu6551JZWclhhx3GySefPHz82rVr+frXv05PTw+7du3i6KOP5owzzijK+z3ITQNmmlk/UI1WmBaRg4iS9CzqqmM8uXXsP++LSGlcf/317Nixg3Xr1lFVVcWiRYuGV0adPn368HEVFRXDrysqKhgYGBjeN3KqSvp1tiks+/fv5xOf+ASPPPIICxcu5Iorrsh5JVaZOHffambfAF4A9gF3u/vdmceY2SpgFUBDQwPJZHLU9lKpVNb9T2zdU7igx7Bi/uxxYykFxZJdOcUC5RWPYskuiliUpGeRqImxq7sPd9e8U5Eys2fPHubNm0dVVRVr167l+eefz7uNW265hcsuu4zu7m6SySRXXXUVg4ODXHvttXzoQx+io6ODtWvX8oEPfGA4IZ87dy6pVIqbbrqJ97znPYV+WzKCmdUBZwGLgd3AjWb2QXe/Ln2Mu68B1gA0NTV5c3PzqO0lk0my7b/g0tsLGvdoNp/3ct+jxVIKiiW7cooFyisexZJdFLEoSc8iUR2jb3CI7r5BaqbrIxIpJ+eddx5nnHEGTU1NrFy5kuXLl+fdxvHHH8/pp5/OCy+8wN///d9z2GGH8Zd/+Zfcc889rFixgqVLl3LiiScCMGfOHD760Y+yYsUKFi1axBve8IZCvyXJ7hTgOXffAWBm/w28BbhuzLNERKYIZaBZJOIxADq7+5Ski5SJVCoFBCPa999/f9ZjnnzyyeHnP/zhD+nq6gJg0aJFw/uuuOKKrOeaGd/97nez7rvyyiu58sorJxq6TMwLwJvMrJpguss7gEdKG5KISPGouksW6SR9Z3dfiSMROXhVVlayZ8+e4cWMytEll1zCddddp1rpEXD3B4GbgEcJyi9WEE5tERE5GGiYOIu6jJF0ESmNhQsXsmXLllKHMaarr76aq6++utRhTFnu/iXgS6WOQ0SkFDSSnkW9RtJFXrGYj+RHn52IiBwoJelZaCRdDnYzZsxg586dSjYnwN3ZuXMnM2bMKHUoIiIyiWm6Sxa106dRVWns6lGSLgenBQsW0NbWxo4dO3I6fv/+/WWZlJYqrhkzZrBgwYKi9ysiIlOHkvQszIy66hi7UkrS5eBUVVXF4sWLcz4+mUxy7LHHRhjRxJRrXCIiIuPRdJdRJOIxjaSLiIiISEkoSR9FIh6sOioiIiIiUmxK0kdRF4/pxlERERERKQkl6aOoj8dUglFERERESkJJ+ijqqmPs2dfPwOBQqUMRERERkYOMkvRR1NcEtdJ37+svcSQiIiIicrBRkj6KuuogSdfNoyIiIiJSbErSR5GIK0kXERERkdJQkj4KJekiIiIiUipK0kehJF1ERERESkVJ+ijSc9JVK11EREREik1J+ihi0yqonT5NtdJFREREpOiUpI+hLh6js0dJuoiIiIgUl5L0MSTiMc1JFxEREZGiizRJN7NTzWyDmW00s0uz7P+MmT1tZo+b2W/N7Ihw+0lmtj7jsd/Mzg73/dDMnsvYtzKq+JWki4iIiEgpRJakm1klcA1wGnAUcK6ZHTXisD8CTe7+Z8BNwNcB3H2tu69095XAyUAPcHfGeZek97v7+qjeQyIe042jIiIiIlJ0UY6kHw9sdPdN7t4H/BQ4K/OAMBnvCV8+ACzI0s57gDszjiuaRDzGzu4+3L3YXYuIiIjIQWxahG3PB7ZkvG4D3jjG8R8B7syy/RzgWyO2fdXMLgd+C1zq7r0jTzKzVcAqgIaGBpLJZO6Rhzq399E7MMTdv00yfZrlfF4qlZpQf1Erx7jKMSZQXPlSXCIiIoUVZZKeLavNOiRtZh8EmoATR2w/FFgB3JWx+TJgOxAD1gCfA1a/qiP3NeF+mpqavLm5Oe830BHfwo0tj3PUn7+RhYnqnM9LJpNMpL+olWNc5RgTKK58KS4REZHCinK6SxuwMOP1AmDbyIPM7BTgC8CZWUbE3wfc7O796Q3u/qIHeoEfEEyriURduOqoyjCKiIiISDFFmaQ/DCwxs8VmFiOYtnJr5gFmdixwLUGC3pGljXOBG0acc2j404CzgScjiB0I5qQDqvAiIiIiIkUV2XQXdx8wswsJpqpUAt9396fMbDXwiLvfClwN1AA3Bjk3L7j7mQBmtohgJP53I5q+3swOIZhOsx74WFTvQUm6iIiIiJRClHPScfc7gDtGbLs84/kpY5y7meDm05HbTy5giGNKVCtJFxEREZHi04qjY5g1cxqVFaYkXURERESKSkn6GMyMuuqYbhwVERERkaJSkj6O+nhMI+kiIiIiUlRK0sdRF69Ski4iUmRmtszM1mc89prZ/yl1XCIixRLpjaNTQSIeY8P2rlKHISJyUHH3DcBKADOrBLYCN5c0KBGRItJI+jgSmu4iIlJq7wD+5O7PlzoQEZFi0Uj6OBLVMXbv62dwyKmssFKHIyJyMDqHEQvbAZjZKmAVQENDA8lkctQGUqlU1v0XrxgoVIxjyux7tFhKQbFkV06xQHnFo1iyiyIWJenjSMRjuMOeff3DixuJiEhxhCtWnwlcNnKfu68B1gA0NTV5c3PzqO0kk0my7b/g0tsLFOnYNp/3ct+jxVIKiiW7cooFyisexZJdFLFouss46oZXHe0tcSQiIgel04BH3b291IGIiBSTkvRxJIaT9P4SRyIiclA6lyxTXUREpjol6eNIaCRdRKQkzKwaeCfw36WORUSk2DQnfRwaSRcRKQ137wHqSx2HiEgpaCR9HHXVQZLe2aMyjCIiIiJSHErSxzGjqpJ4rJKdKSXpIiIiIlIcStJzUBePaSRdRERERIpGSXoO6uMxdmrVUREREREpEiXpOaiLx+hUki4iIiIiRaIkPQeJeIxdStJFREREpEiUpOcgUa0kXURERESKR0l6DhI1Mfb1D7Kvb7DUoYiIiIjIQUBJeg4SYa30XarwIiIiIiJFoCQ9B3XhqqO6eVREREREikFJeg7qwyRdZRhFREREpBiUpOdAI+kiIiIiUkxK0nOQHklXhRcRERERKQYl6TmYNaOKClOSLiIiIiLFoSQ9BxUVRl11TNVdRERERKQolKTnKBGPsSulJF1EREREoqckPUd1cY2ki4iIiEhxKEnPUX08puouIiIiIlIUkSbpZnaqmW0ws41mdmmW/Z8xs6fN7HEz+62ZHZGxb9DM1oePWzO2LzazB82s1cz+y8xiUb6HtLp4TDeOioiIiEhRRJakm1klcA1wGnAUcK6ZHTXisD8CTe7+Z8BNwNcz9u1z95Xh48yM7V8D/sndlwCdwEeieg+ZEtUxOnv6GBryYnQnIiIiIgexKEfSjwc2uvsmd+8DfgqclXmAu691957w5QPAgrEaNDMDTiZI6AF+BJxd0KhHkYjHGHLYs6+/GN2JiIiIyEFsWoRtzwe2ZLxuA944xvEfAe7MeD3DzB4BBoCr3P0XQD2w290HMtqcn60xM1sFrAJoaGggmUxO5D0M274t6PJXa+/j0Jqxf7dJpVIH3F8UyjGucowJFFe+FJeIiEhhRZmkW5ZtWeeKmNkHgSbgxIzNh7v7NjN7DXCPmT0B7M21TXdfA6wBaGpq8ubm5jxCf7WKlh2sefwhlrx+JU2LEmMem0wmOdD+olCOcZVjTKC48qW4RERECivK6S5twMKM1wuAbSMPMrNTgC8AZ7p7b3q7u28Lf24CksCxwEvAHDNL/3KRtc0oJOLB/ak7dfOoiIiIiEQsyiT9YWBJWI0lBpwD3Jp5gJkdC1xLkKB3ZGyvM7Pp4fO5wFuBp93dgbXAe8JDzwduifA9DKsLk3SVYRQRERGRqEWWpIfzxi8E7gKeAX7m7k+Z2WozS1druRqoAW4cUWrxdcAjZvYYQVJ+lbs/He77HPAZM9tIMEf9e1G9h0yJao2ki4iIiEhxRDknHXe/A7hjxLbLM56fMsp5fwBWjLJvE0HlmKKaGatkZlWlRtJFREREJHJacTQPiXiMXT1K0kVEREQkWkrS85DQqqMiIiIiUgRK0vNQF49puouIiIiIRE5Jeh7q4zHdOCoiUiRmNsfMbjKzZ83sGTN7c6ljEhEplkhvHJ1q6qo1ki4iUkT/DPzK3d8TlvKtLnVAIiLFopH0PNTXxOjuG2R//2CpQxERmdLMbBZwAmGZXXfvc/fdpY1KRKR4NJKeh7qwVnpnTx+Hzp5Z4mhERKa01wA7gB+Y2THAOuAid+9OH2Bmq4BVAA0NDSSTyVEbS6VSWfdfvGKgoEGPJrPv0WIpBcWSXTnFAuUVj2LJLopYlKTnIRGvAmBXt5J0EZGITQP+HPiUuz9oZv8MXAr8ffoAd18DrAFoamry5ubmURtLJpNk23/BpbcXNOjRbD7v5b5Hi6UUFEt25RQLlFc8iiW7KGLRdJc8JOLTAVSGUUQkem1Am7s/GL6+iSBpFxE5KChJz0PmSLqIiETH3bcDW8xsWbjpHcDTJQxJRKSoNN0lD+mRdFV4EREpik8B14eVXTYBHy5xPCIiRaMkPQ+zZ1ZhppF0EZFicPf1QFOp4xARKQVNd8lDZYUxZ2YVu3qUpIuIiIhIdJSk5ykRj2kkXUREREQipSQ9T0rSRURERCRqStLzlIjH6OzuL3UYIiIiIjKFKUnPUyIeY6dG0kVEREQkQkrS85SIx+js6cPdSx2KiIiIiExRStLzVFcdY3DI2btvoNShiIiIiMgUpSQ9T4l4DEBlGEVEREQkMkrS8zScpGteuoiIiIhEREl6npSki4iIiEjUlKTnKZ2kdypJFxEREZGIKEnPUzpJVxlGEREREYmKkvQ8zaw2qh/wAAAgAElEQVSqZPq0Cjp146iIiIiIRERJep7MjPp4jJ0pJekiIiIiEg0l6RNQFy5oJCIiIiISBSXpE5CIx1TdRUREREQioyR9ApSki4iIiEiUlKRPQF11TCUYRURERCQykSbpZnaqmW0ws41mdmmW/Z8xs6fN7HEz+62ZHRFuX2lm95vZU+G+92ec80Mze87M1oePlVG+h2zq4zG6egfoHRgsdtciIiIichCILEk3s0rgGuA04CjgXDM7asRhfwSa3P3PgJuAr4fbe4APufvRwKnAt81sTsZ5l7j7yvCxPqr3MJq6sFb67p7+YnctIiIiIgeBKEfSjwc2uvsmd+8DfgqclXmAu691957w5QPAgnB7i7u3hs+3AR3AIRHGmpf6MEnXvHQRERERiUKUSfp8YEvG67Zw22g+Atw5cqOZHQ/EgD9lbP5qOA3mn8xseiGCzUedknQRERERidC0CNu2LNs864FmHwSagBNHbD8U+E/gfHcfCjdfBmwnSNzXAJ8DVmdpcxWwCqChoYFkMjmhN5HN1q4glPseXk9/26s/wlQqVdD+CqUc4yrHmEBx5UtxiYiIFFaUSXobsDDj9QJg28iDzOwU4AvAie7em7F9FnA78EV3fyC93d1fDJ/2mtkPgL/L1rm7ryFI4mlqavLm5uYDejOZXkr18oXf/4bGI46k+S2LXrU/mUxSyP4KpRzjKseYQHHlS3GJiIgUVpTTXR4GlpjZYjOLAecAt2YeYGbHAtcCZ7p7R8b2GHAz8GN3v3HEOYeGPw04G3gywveQ1ZyZVYCmu4iIiIhINCIbSXf3ATO7ELgLqAS+7+5Pmdlq4BF3vxW4GqgBbgxybl5w9zOB9wEnAPVmdkHY5AVhJZfrzewQguk064GPRfUeRjOtsoI51VV09ihJFxEREZHCi3K6C+5+B3DHiG2XZzw/ZZTzrgOuG2XfyYWMcaIS1TF2aiRdRERERCKgFUcnqC6uVUdFREREJBpK0icoEY9pTrqIiIiIRCLS6S5TWaI6xmNbdpc6DBGRKcvMNgNdwCAw4O5NpY1IRKR4lKRPUKImRmdPH+5OeNOriIgU3knu/lKpgxARKba8pruYWdzMKqMKZjJJVMfoH3S6egdKHYqIiIiITDFjJulmVmFmHzCz282sA3gWeNHMnjKzq81sSXHCLD918RiAbh4VEYmOA3eb2bpwFWkRkYPGeNNd1gK/AS4DnnT3IQAzSwAnAVeZ2c1hycSDSn2YpO/s7uOI+niJoxERmZLe6u7bzGwe8Gsze9bd703vDBP3VQANDQ0kk8lRG0qlUln3X7yiOH8Nzex7tFhKQbFkV06xQHnFo1iyiyKW8ZL0U9y9f+RGd98F/Bz4uZlVFTSiSUIj6SIi0XL3beHPDjO7GTgeuDdj/xpgDUBTU5M3NzeP2lYymSTb/gsuvb2gMY9m83kv9z1aLKWgWLIrp1igvOJRLNlFEcuY013SCbqZvdbMpofPm83s02Y2J/OYg016JF1lGEVECi+8B6o2/Rx4F/BkaaMSESmeXG8c/TkwaGZHAt8DFgM/iSyqSaBOSbqISJQagPvM7DHgIeB2d/9ViWMSESmaXEswDrn7gJn9JfBtd/8XM/tjlIGVu3isklhlBbt6lKSLiBSau28Cjil1HCIipZLrSHq/mZ0LnA/8Mtx2UM5FTzOzYNXRVPGS9I6u/XSr5KOIiIjIlJdrkv5h4M3AV939OTNbDBx0FV1GqosHCxoVy3v+7X7+8c5nitafiIiIiJRGTtNd3P1p4NMZr58DrooqqMmiPh4r2pz03T19vLCrh8e27ClKfyIiIiJSOjmNpJvZu83sj2a2y8z2mlmXme2NOrhyV1fEJL2lPRX+7GJwyIvSp4iIiIiURq7TXb5NMB+93t1nuXutu8+KMK5JoZgj6S3tXQD0Dgzx/M7uovQpIiIiIqWRa5K+hWDFUQ3hZqirjrF3/wD9g0OR97WxIzX8fMP2rsj7ExEREZHSybUE42eBO8zsd0BveqO7fyuSqCaJRDwocNPZ08e82hmR9tXS3sXyxlo2tHfx7PYuTltxaKT9iYiIiEjp5DqS/lWgB5gB1GY8DmqJ+HQAOrujX3S1pT3FivmzWVQf10i6iIiIyBSX60h6wt3fFWkkk1BdOJK+s7uXKH9n6ezu46VUL0saaujaPzA8P11EREREpqZcR9J/Y2ZK0keoL9JIejopX9JQy9LGWjbv7GZ//2CkfYqIiIhI6eSapH8S+JWZ7VMJxpelR9J3dfeOc+SBaQ1vGl3aUMvyxlqGHFrbU+OcJSIiIiKTVa6LGR3088+zqauOAbAr4pH01vYuaqZP47DZM9jfH/xTPLt9LysWzI60XxEREREpjTFH0s1s0Tj7zcwWFDKgyaSqsoJZM6bR2RNtrfSW9hRHzqvBzFhUH2f6tArdPCoiIiIyhY03kn61mVUAtwDrgB0EFV6OBE4C3gF8CWiLMshylojH2BnxgkatHV2ctGweAJUVxpKGGjbo5lERERGRKWvMJN3d32tmRwHnAf8bOJSgFOMzwB3AV919f+RRlrFEPEZnhEn6ru4+Xkr1sbTh5RlHSxtqua/1pcj6FBEREZHSGndOurs/DXyhCLFMSol4jK27o/s9pXW4skvN8LbljbX896Nb6ezuoy4ei6xvERERESmNXKu7yCjqqqMdSW/JqOyStqxxFgDPal66iIiIyJSkJP0AJWpi7Oruw90jaT9d2eXQ2TOGty1vDBL2DdsP+iqYIiIiIlOSkvQDlKiO0Tc4RHdfNIsLtbR3DVd2SZtXO5051VVsUK10ERERkSkppzrpAGY2Hzgi8xx3vzeKoCaTRDgnvLO7j5rpOX+cOdvYkeLk5fNesc3MWNZQq5F0ERERkSkqp5F0M/sa8Hvgi8Al4ePvcjjvVDPbYGYbzezSLPs/Y2ZPm9njZvZbMzsiY9/5ZtYaPs7P2H6cmT0RtvkdyxxiLoF0kh5FGcZslV3SljXW0tKeimyajYiIiIiUTq5Dv2cDy9y9N9eGzawSuAZ4J0Ed9YfN7NawWkzaH4Emd+8xs48DXwfeb2YJgvrrTYAD68JzO4F/A1YBDxCUgTwVuDPXuAqtLmMkvdBahiu7ZE/SU70DtHXuY2GiuuB9i4iIiEjp5DonfRNQlWfbxwMb3X2Tu/cBPwXOyjzA3de6e0/48gEgvXrpXwC/dvddYWL+a+BUMzsUmOXu93swhPxjgl8gSqY+wpH0dPnFpRnlF9NevnlUFV5EREREpppcR9J7gPVm9ltgeDTd3T89xjnzgS0Zr9uAN45x/Ed4eUQ827nzw0dblu2vYmarCEbcaWhoIJlMjtH1xPX0B9NNHn78GeZ2bQQglUoVpL+1T/cycxo8++gDbBgxq2ffQNDvnfc/xrSO3GqlFyquQirHmEBx5UtxiYiIFFauSfqt4SMf2eaKZ51AbWYfJJjacuI45+bcpruvAdYANDU1eXNz8zjhToy7U5W8k8ShC2luXg5AMpmkEP3935b7WX7YECed9Nas++c/cg/91XU0Nx+bU3uFiquQyjEmUFz5UlwiIiKFlVOS7u4/MrMYsDTctMHd+8c5rQ1YmPF6AbBt5EFmdgrBiqYnZsx5bwOaR5ybDLcvGLH9VW0Wk5lRVx1jVyqK6S4pTnldw6j7lzXWarqLiIiIyBSUa3WXZqCV4EbQfwVazOyEcU57GFhiZovDBP8cRozGm9mxwLXAme7ekbHrLuBdZlZnZnXAu4C73P1FoMvM3hRWdfkQcEsu7yFKiXiMXT2FTdJ3pnrZ2d3Hkizz0dOWNdbypx0p+gaGCtq3iIiIiJRWrtNdvgm8y903AJjZUuAG4LjRTnD3ATO7kCDhrgS+7+5Pmdlq4BF3vxW4GqgBbgwrKb7g7me6+y4z+wpBog+w2t13hc8/DvwQmEkwh71klV3SEvFg1dFCagkXKspWfjFteWMtA0POppdSLG+cVdD+RURERKR0ck3Sq9IJOoC7t5jZuNVe3P0OgjKJmdsuz3h+yhjnfh/4fpbtjwCvzzHuoqiLx3hmW2EXFtrYkS6/OPZIOgQVXpSki4iIiEwduSbpj5jZ94D/DF+fB6yLJqTJpz6C6S4t7Slqp0+jcdaMUY95zdwaplWY5qWLiIiITDG51kn/OPAU8GngIuBp4GNRBTXZ1FXH2N3Tz8Bg4eaGt7R3saShhrEWVI1Nq+C1h9QoSReRKcnMKs3sj2b2y1LHIiJSbLlWd+kFvhU+ZIREuKDR7n39zK2ZXpA2WztSvOuo0Su7pC1trOXR5zsL0qeISJm5CHgG0Hw+ETnojDmSbmY/C38+YWaPj3wUJ8Tyl07SC3Xz6EupXnZ197FkjJtG05Y31rJ19z669o9XEVNEZPIwswXA6cB/lDoWEZFSGG8k/aLw57ujDmQyK3SS3hpWdlkyb/SbRtOWhYl8S3sXxx2RKEj/IiJl4NvAZ4FRRyvyWVl6tNVnL14xcIBh5iaz73JaCVexZFdOsUB5xaNYsosiljGT9LAuOcAn3P1zmfvM7GvA51591sEnnaR3FipJDyu7jFV+Me3lCi8pJekiMiWY2buBDndfF67TkVU+K0uPtvrsBZfefoDR5mbzeS/3XU4r4SqW7MopFiiveBRLdlHEkuuNo+/Msu20QgYymaWT9J0FStJb2ruonTGNhlnjz29fUDeTeKySDdsLWwJSRKSE3gqcaWabgZ8CJ5vZdaUNSUSkuMabk/5xM3sCWDZiPvpzgOakh+ZUByXjCzWS3tKeYmlD7ZiVXdLMjKWNtTyrCi8iMkW4+2XuvsDdFxGsVn2Pu3+wxGGJiBTVeHPSf0Kwouc/ApdmbO/KWAH0oDd9WiW106cVbCR9Y46VXdKWN9Zy55PbcfecEnsRERERKW9jjqS7+x533+zu57r788A+wIEaMzu8KBFOEnXxGJ0FWNAon8ouacsaatnd009HV+8B9y8iUk7cPenuKl4gIgednOakm9kZZtYKPAf8DthMMMIuoUQ8VpDqLi3t6ZtGx6/skrasMSghrCkvIiIiIlNDrjeOXgm8CWhx98XAO4DfRxbVJFSoJD1dfjGXyi5py8MKLy1K0kVERESmhFyT9H533wlUmFmFu68FVkYY16STiMcKcuNoS3sXs2ZMY15t7iuX1sVjzKudrpF0ERERkSlivBtH03abWQ1wL3C9mXUAxVkBYpJIxGPs7O7D3Q+ondaOFEtyrOySaVljLRvaVYZRREREZCrIdST9LKAH+FvgV8CfgDOiCmoyqquO0TswxL7+wQm34e60tnflNR89bVlDLa3tKQaHDuyXBBEREREpvXFH0s2sErjF3U8BhoAfRR7VJFQfLmh0IPPSX0r10dnTz5J5uc9HT1vWWEvvwBCbd3bz2kPyT/JFREREpHyMO5Lu7oNAj5nNLkI8k1ZdAZL01uHKLvkn6cvDCi+6eVRERERk8st1Tvp+4Akz+zXQnd7o7p+OJKpJKFGAJH0i5RfTljTUYBaUYTxtxaETjkFERERESi/XJP328CGjyEzSExNso7UjxawZ0zgkj8ouaTOqKllUH2eDRtJFREREJr2cknR31zz0cSSqC5Ckt6dYOoHKLmnLGmrZ0K4kXURERGSyy3XF0efMbNPIR9TBTSazZk6jssLo7JnYdBd3p6WjiyUTmI+etqyxls07u9nXN/EKMyIiIiJSerlOd2nKeD4DeC9MeMB4SjIz6qrDVUfzn63CjlQvu3v6JzQfPW15Yy3usLEjxYoFus9XREREZLLKaSTd3XdmPLa6+7eBkyOObdKpj8cmfOPoxvYUMLHKLmnLGoNzn92uRY1EREREJrOcRtLN7M8zXlYQjKxPPJucouriVRNO0tOVXZbMm/hI+hH1caZPq9DNoyIiIiKTXK7TXb6Z8XwA2Ay8r+DRTHKJeGzCCXJLR4rZM6smVNklrbLCWNJQo5tHRURERCa5XKu7nBR1IFNBIh6js6cfqMr73Nb2LpY21Ey4skvasoZZ3Nu644DaEBEREZHSGjNJN7PPjLXf3b9V2HAmt0R1jM6ePoY81z9QBNydlvYUp//ZgS9CtLyxlp8/2haUggxrt4uIiIjI5DLejaO14aMJ+DgwP3x8DDgq2tAmn0Q8hjt09+d33o5UL3v29bP0AOajp6VvHtW8dBEREZHJa8whX3f/MoCZ3Q38ubt3ha+vAG6MPLpJpi4cue7q87zOaw0ruxxIjfS05cNJ+l7e/Nr6A25PRERERIovpxKMwOFAZtmSPmBRwaOZ5BITTNKHK7scQI30tENqpzOnuko3j4qIiIhMYrkm6f8JPGRmV5jZl4AHgR+Nd5KZnWpmG8xso5ldmmX/CWb2qJkNmNl7MrafZGbrMx77zezscN8PwxVQ0/tW5vgeIjfxJD3FnOoqDqmZeGWXNDNjWUMtz2q6i4iIiMiklWt1l6+a2Z3A28NNH3b3P451jplVAtcA7wTagIfN7FZ3fzrjsBeAC4C/G9HfWmBl2E4C2AjcnXHIJe5+Uy6xF1M6SU/15zvdpYul82oPuLJL2vLGWm5a18bQkFNRUZg2RURERKR4ci5D4u6PAo/m0fbxwEZ33wRgZj8FzgKGk3R33xzuGxqjnfcAd7p7Tx59l0Rddf4j6e5Oa0eKdxegskvassZZdPcNsnX3PhYmqgvWroiIiIgUR361AvMzH9iS8boNeOME2jkHGFnq8atmdjnwW+BSd+8deZKZrQJWATQ0NJBMJifQdf5mVMKu7r6c+9u9f4g9+/ph73aSyZ0FiaGncxCAm37zB46d9/I/cSqVKtrnkKtyjAkUV74Ul4iISGFFmaRnm2eR1zwQMzsUWAHclbH5MmA7EAPWAJ8DVr+qI/c14X6ampq8ubk5n64nbO6D97CfPnLt777WlyD5IKe/9VjecuTcgsRw3P5+rnzwbmKHLKK5+cjh7clkMue4iqUcYwLFlS/FJSIiUli53jg6EW3AwozXC4BtebbxPuBmdx+uPO7uL3qgF/gBwbSaslEfj9HVN/5xaS9Xdjnw8otptTOqmD9npm4eFREREZmkokzSHwaWmNliM4sRTFu5Nc82zgVuyNwQjq5jwV2WZwNPFiDWgqmLx0jlMSe9tSNFXXUVc2sKuzro8sZaNmzfW9A2RURERKQ4IkvS3X0AuJBgqsozwM/c/SkzW21mZwKY2RvMrA14L3CtmT2VPt/MFhGMxP9uRNPXm9kTwBPAXODKqN7DRCTisbxuHG1t72JJQ+Equ6Qta6xl045u+gbGuidXRERERMpRlHPScfc7gDtGbLs84/nDBNNgsp27meDm05HbTy5slIWVqI7RlWMJRnenpb2LM445rOBxLGusZWDI2fRSiuWNswrevoiIiIhEJ8rpLgeluniMvkHY1zc47rEdXb3s3T/A0gLOR09LJ+YbNC9dREREZNJRkl5g9eGCRrt6xr979OWbRmsKHsfiuXGmVZhuHhWRScnMZpjZQ2b2mJk9ZWZfLnVMIiLFpCS9wOrCJL2ze/wkvbU9BRDJSHpsWgWvPaRGI+kiMln1Aie7+zEEK1CfamZvKnFMIiJFoyS9wIZH0nNJ0ju6SMRjzK2ZHkksyxprlaSLyKQUltpNhS+rwkdea22IiExmkd44ejCqyyNJb2lPceS8wk91SVvWWMutj22ja38/tTOqIutHRCQKZlYJrAOOBK5x9wdH7M95ZenRVp+9eMVA4QIew79cf8vw84aZr3xdSCvmz87r+HJalVexjK6c4lEs2UURi5L0AktU55akpyu7nLWy8JVd0pY3BtNoWtq7OO6IRGT9iIhEwd0HgZVmNge42cxe7+5PZuzPeWXp0VafveDS2wsc9fguXjHAN5+I5ut383nNeR1fTqvyKpbRlVM8iiW7KGLRdJcCmz2zCmP8JL19by9dEVV2SUu3rZtHRWQyc/fdQBI4tcShiIgUjZL0AquoMGpi41d3ae0IK7vMiy5JX1A3k5rp0zQvXUQmHTM7JBxBx8xmAqcAz5Y2KhGR4tF0lwjUxmzc6i4tw5VdopuTbmYsbajRSLqITEaHAj8K56VXEKxa/csSxyQiUjRK0iNQW2XsHCdJb20PKrvUR1TZJW1Z4yzufPJF3FUUQUQmD3d/HDi21HGIiJSKprtEILeR9C6WRFjZJW15Yy27e/rp6OqNvC8RERERKQwl6RGoidmYN466O60dqUhvGk1b1qibR0VEREQmGyXpEaitMjp7+hgayj7F5OXKLtGPpC8LfxHYsH1v5H2JiIiISGEoSY9AbcwYcti7vz/r/pb2YFT7yAgru6TVxWPMq52ukXQRERGRSURJegRqYgYw6s2j6SS9GCPpEEx5SfcpIiIiIuVPSXoEZgWLjo5682hre4r6IlR2SVveWEtre4ohVXgRERERmRSUpEegpmrskfTWji6WFGkUHYIyjL0DQ7R3K0kXERERmQyUpEegNpzukm0k3d1pbS9OZZe09M2jbamhovUpIiIiIhOnJD0C6Tnpu3penaRv37ufrt6BotRIT1vSUEOFQVuXknQRERGRyUBJegSmVxozqyrZlXp1kt7SngJgSRFH0mdUVbKoPq6RdBEREZFJQkl6RBLxWNaR9Nbhyi7FS9IhqPCikXQRERGRyUFJekQS8VjWVUdb21PMrYmRiMeKGs+yxlo6epx9fYNF7VdERERE8qckPSJ18VjWG0dbOrpYUoRFjEZa3liLE1SWEREREZHypiQ9IvVZpru4OxvbU0Utv5iWnl6jlUdFREREyp+S9IjUVcdedePoi3vCyi5Fno8OcER9nFgFbFCSLiIiIlL2lKRHpL4mRnffIPv7X54D3toRVHZZWsTyi2mVFcZhNRW0tCtJFxERESl3StIjUlcd3BjamTHlpVSVXdIW1FZououIiIjIJKAkPSKJeBXAKyq8tLR3MbdmOnVFruyStqCmgh1dvVmrzoiIiIhI+VCSHpFEfDoAnd39w9ta2lNFXWl0pAW1wUqoz27fW7IYRERERGR8StIjkh5J39ndC4SVXTpSLC1BZZe0BTXBP7duHhUREREpb5Em6WZ2qpltMLONZnZplv0nmNmjZjZgZu8ZsW/QzNaHj1szti82swfNrNXM/svMSjN3ZBwvj6QHU0te3LOfVIkqu6TNnm7UVVfp5lERERGRMhdZkm5mlcA1wGnAUcC5ZnbUiMNeAC4AfpKliX3uvjJ8nJmx/WvAP7n7EqAT+EjBgy+A2TOrMHt5TnpLiW8aBTAzljXW6uZRERERkTIX5Uj68cBGd9/k7n3AT4GzMg9w983u/jgwlEuDZmbAycBN4aYfAWcXLuTCqaww5sysGl7QqLU9KL9YyjnpAMsbZ9GyvYuhIS9pHCIiIiIyuiiT9PnAlozXbeG2XM0ws0fM7AEzSyfi9cBudx+YYJtFlYjHXjGSXsrKLmlLG2rp7htk6+59JY1DREREREY3LcK2Lcu2fIZvD3f3bWb2GuAeM3sCyFaWJGubZrYKWAXQ0NBAMpnMo+sDk0qlSCaTVA7sY9PWfSSTSdZt3MchMYoaR7a4ejpbAbjpN3/g2HlR/vPnJv1ZlRvFlR/FJSIiUlhRZmltwMKM1wuAbbme7O7bwp+bzCwJHAv8HJhjZtPC0fRR23T3NcAagKamJm9ubp7AW5iYZDJJc3MzN2x5hM0v9XDiiW+n/Z67eG/TQpqbjy5aHNniOufNb+PKB+8idsgimpuPLFksmTEV898mV4orP4pLRESksKKc7vIwsCSsxhIDzgFuHeccAMyszsymh8/nAm8FnnZ3B9YC6Uow5wO3FDzyAknEY+zs7mPbnv109w2ypITlF9Nqpk9jQd1M3TwqIiIiUsYiS9LDke4LgbuAZ4CfuftTZrbazM4EMLM3mFkb8F7gWjN7Kjz9dcAjZvYYQVJ+lbs/He77HPAZM9tIMEf9e1G9hwNVVx2js6ePlu2lr+ySaXljLRu0oJGIiIhI2Yp0UrK73wHcMWLb5RnPHyaYsjLyvD8AK0ZpcxNB5Ziyl4jHGBxy1j3fCZS+skvassZakht20DcwRGya1rMSERERKTfK0CKUCCu5PPjcTg6pnc6c6vJYd2lpQy0DQ86fdqRKHYqIiIiIZKEkPULpJP2xLXtYWgbz0dOWN84CYIPmpYtImTKzhWa21syeMbOnzOyiUsckIlJMStIjlE7S+waHWDKvPOajA7zmkDjVsUp+dP9mevoGxj1eRKQEBoCL3f11wJuAT2ZZtVpEZMpSkh6huozpLeVy0yhAVWUF33zvMTy2ZTerfryO/f2DpQ5JROT/t3ff4VnV9//Hn+/ssPcKK2wZyh5OEC3gHmgFHFj5Wa2zTqzWttrWOuu2+lUcFdy7TlTQYmXJStgbwh6ySUjI5/fHOdEbTCDJPc5N8npc133lzpmvnHPu+37n3J9zPgdwzq1zzs3wn+/EuwFB3HZeJyISacH3ZlOB1a32c5EeD7dfDDWkS2MeGHoMt7w1m+tem8nTI7qTnKj/2UQk/phZS7y+MqYcNLzUndaV1LHVzV1i/21iw/TorfeJsWW7K3HD9LLPU6RLRs1yzVeSeOp8LJ6yQHzlUZbiRSOLivQoSk9OJDUpgbyCQtrFUXOXIkN7NGV3XgF/+nAut741m0cu7EpCQnEdxYqIBMPMquF1ZHejc+6Ae8eWpdO6kjq2Gjn64wimLZ2buxTwcFZ8fPyGk2XFiP4RzRJPnY/FUxaIrzzKUrxoZImPd4kKysyoWzWFgkJHzSrJQccp1mXHtmRXXgEPfr6QqqlJ/PWczpipUBeR4JlZMl6BPtY5927QeUREYklFepQ1qplGjfT4LNCLXDOgDbvyCnhm4lKqpSUxenAHFeoiEijz3oReAOY75x4JOo+ISKypSI+yxy7qdkS09b5tUHt25Rbw7DfLqJGWzDUD2gQdSUQqt+OAS4AsM5vlD/uD30meiEiFpyI9yprVqWYd8ngAACAASURBVBJ0hFIxM/5yVid2FzV9SUlk5HGZQccSkUrKOTcJ0Fd6IlJpqUiXnyQkGA8MPZrd+wr480fzqJqaxAU9mwUdS0RERKTSif92GBJTSYkJPD6sGye0rcft78zhk6x1QUcSERERqXRUpMsvpCYl8uwlPejevDY3vD6TCQs3Bh1JREREpFJRkS7FqpKSxJjLe9G+UXWu+vcPTF62JehIIiIiIpWGinQpUY20ZF6+vDdNa6cz6uXpzMnZFnQkERERkUpBRbocUt1qqYwd1ZfaVZO5dMxUFq7fGXQkqUQmL9vCgvU7Dj+hiIhIBaMiXQ6rUc00xl7Rl5TEBC5+YQorNu8OOpJUAht35nL5i9O48fVZOOeCjiMiIhJTKtKlVJrXrcLYUX0o2F/IiOensG773qAjSQX39ISl7M3fz4L1O5mxSk2tRESkclGRLqXWtmF1XvlNH3bszWfE81PYvCsv6EhSQa3ZtpdxU1Zx5jFNqJaaxNgpK4OOJCIiElMq0qVMujStyZjLe7F2214ueWEq2/fkBx1JKqAnvloMwOghHTinWxM+nrOObXv2BZxKREQkdlSkS5n1almHZy/pyZKNO7n8panszisIOpJUIMs37+atH3IY3qc5GbXSGd67BXkFhbwzY03Q0URERGJGRbqUy0nt6vPEsG7MWr2NK/89ndz8/UFHkgri0S8XkZxo/G5AawA6NqlB9+a1GDtlpS4gFRGRSkNFupTb4M6NeXDoMXy3ZAv3f7Yg6DhSASxcv5MPZ69l5LGZNKie9tPw4X1asGzTbiYv2xpgOhERkdhRkS5hOb9HUy7p24KX/7eC2at1Bw4Jz8NfLKRaShJXndTqgOFnHN2YGmlJjJu6KqBkIiIisaUiXcJ26+D21KuWyh3vZlGwvzDoOHKEmr16G1/M28CoE1pRq0rKAePSkhMZ2qMZn2Wv012FRESkUlCRLmGrkZbMPWd3Yt66HYz5bnnQceQI9dAXC6ldJZnfHN+y2PHD+zQjf7/jrek5sQ0mIiISABXpEhGDOjXilKMa8sj4RazeuifoOHKEmbJsC/9dvJmrTmpN9bTkYqdp06A6fTLr8NrUVRQW6gJSERGp2FSkS0SYGfec3YlEM+56P1t34ZBSc87x0BcLqV89lUv7tTzktCP6tmDV1j1MWrI5NuFEREQCoiJdIqZJrXRuGdSebxZt4sPZa4OOI0eIbxZtYtqKH7nu5DakpyQectpBnRpSt2qKeiAVEZEKT0W6RNSl/VpyTNOa3PufeeohUg7LOcfDXywio1Y6F/VqftjpU5MSGdqzKV/O38iGHbkxSCgiIhIMFekSUYkJxn3nHc2Pe/K57xPdO10O7fO568las50bTmlLSlLp3o6G927O/kLHG9NWRzmdiIhIcKJapJvZYDNbaGZLzGx0MeNPNLMZZlZgZkNDhnc1s+/NbK6ZzTGzX4eMe8nMlpvZLP/RNZp/g5RdxyY1GHVCJm9MX83kZVuCjhNX1m7by+tTV7ErryDoKIHbX+h4ZPwiWtWvynndMko9X4u6VTmhbT1em7pKt/wUEZEKK2pFupklAk8BQ4COwDAz63jQZKuAkcC4g4bvAS51znUCBgOPmlmtkPG3Oue6+o9ZUfkDJCw3DmxHszrp/OG9LHLz9wcdJy4s27SL85/5H6PfzeK4f3zNY18uZvve/KBjBeaj2WtZtGEXvz+lHUmJZXsrGtGnOeu25zJx4aYopRMREQlWNM+k9waWOOeWOef2Aa8DZ4dO4Jxb4ZybAxQeNHyRc26x/3wtsBGoH8WsEmHpKYn89ZwuLNu0m6cnLg06TuAWrN/Bhc9OZl9BIU8M60bvzDr888tFHP+Pr3nw8wVs3V252u/n7y/kn18u4qjGNTi9S+Myzz/wqIY0qJ6qHkhFRKTCSorisjOA0EajOUCfsi7EzHoDKUBopfc3M7sb+AoY7Zz7RReEZnYlcCVAw4YNmThxYllXXW67du2K6fpKK4hcfRsn8tTXi2mUl0OTar/8n7AybKtl2/fz8PRcUhKMW3ulUf3HRYxoDifUSuOjZfk8PWEpz3+7lAHNkhmcmUSt1JL/d64o22vi6nxWbtnHDd1T+fbbb8q1zr4NCvlowUbe/vRr6qUXv83idXuJiIgcTjSLdCtmWJlunm1mjYF/A5c554rOtt8BrMcr3J8Dbgfu+cWKnHvOH0/Pnj1d//79y7LqsEycOJFYrq+0gsjVuWceAx/+hvdy0njjyn4kJBx4WFT0bTV1+VYeeWkadaqnM25UX5rVqXLA+EuBJRt38tSEpXwwaw0TcvYzrHdzfntSKxrXTI9arkgrS67c/P3c8dBEujarxY0XHItZcW8Vh9e2617+c//XrEjIYGj/9mHnEhERiSfRbO6SAzQL+b0pUOqbZ5tZDeBj4C7n3OSi4c65dc6TB7yI16xG4lS9aqncedpRTFvxI29Mr1x34/h20SYuHTOFBjVSefO3/X5RoBdp06A6//x1V76+uT9nd23Cq5NXctIDE/nDe1kVsvfWcVNWsW57LrcOal/uAh0go1Y6A9o34I3pq8nXBaQiIlLBRLNInwa0NbNMM0sBLgI+LM2M/vTvAa845946aFxj/6cB5wDZEU0tEXdBz6b0bVWHv38yn407K8e9rb+Yu55RL0+nZd2qvPnbfsWeFT9Yy3pVeWDoMUy4pT8X9GzK29NzGPDQRG59azbLN++OQero27OvgKcnLqFfq7oc16Ze2Msb0bc5m3bm8eW8DRFIJyIiEj+iVqQ75wqAa4HPgfnAm865uWZ2j5mdBWBmvcwsB7gAeNbM5vqzXwicCIws5laLY80sC8gC6gF/jdbfIJFhZvz93C7kFRRyz0fzgo4TdR/MWsPVY2dwVJMavH5lX+pVSy3T/M3qVOFv53bh29sGcEm/Fnw4ey0DH57IDa/PZM2uI/uM8YvfrWDzrn3cMqj45illdVK7BmTUSmfsFF1AKiIiFUs026TjnPsE+OSgYXeHPJ+G1wzm4PleBV4tYZknRzimxECr+tW4dkAbHhm/iPO7b2RAhwZBR4qKN6atYvS7WfRuWYcXRvaiWmr5X2KNaqbxpzM78bv+bXh+0jL+/f1KPty3n0nbfuDak9vQqUnNCCaPvu1783n2m6Wc3KEBPVrUjsgyExOMYb2b8dAXi1ixeTct61WNyHJFRESCph5HJWauOqk1bRtU4673s9ldATvzGTNpObe/k8WJbevz0uW9wyrQQ9WvnsodQ47iu9tP5ozWyUxavJnTH5/EqJenkb1me0TWEQvP/3cZO3ILuPlX7SK63At7NiMpwXhNt2OsUMxsjJltNDM1aRSRSklFusRMSlICfz+vC2u27eWf4xcFHSeinpqwhHv+M49BnRry3KU9SE9JjPg6aldN4fy2KUwafTI3n9qO6St/5Lxn/se8tTsivq5I27IrjzGTlnN6l8YR/wagQY00Tu3YkDenryavQB1nVSAv4XVmJyJSKalIl5jq1bIOw/s0Z8x3y4+os8Alcc7xwGcLePDzhZzbLYOnhncnNSnyBXqomunJXDewLV/edBK10pO5dtyMuP9m4pmJS9mbv5/fnxrZs+hFRvRpwY978vkse31Uli+x55z7FtgadA4RkaBEtU26SHFuH9yB8fM2MPrdOfy+U5lunR9XCgsd9/xnHi/9bwXD+zTnr2d3/sV94KOpXrVUHruoGyOen8wfP8jmkQu7Hn6mAKzfnssrk1dybremtGlQLSrrOLZ1XVrUrcLYKas4u2tGVNYh8acsndaV1LHVzV1i/w9uw/Rg1luccLJEuqOweOh8LMs/edQwHZ4Y+0HU1tMlo2zfKMbDtikSD1nicT9FY7uoSJeYq5mezJ/P7MQ142YwvloKA4MOVA77Cx13vDuHN6fnMOr4TO48/aiw7vldXv1a1+X6gW159MvFHNu6HkN7/OI67MA98fVinHPceErbqK0jIcEY3rs59326gMUbdtK2YfWorUviR1k6rSupY6uRoz+OUrqS3dylgIez4uPjN5wsK0b0j2iWeOh8rOh4iPY+Kuu2i4dtUyQessTjforGdlFzFwnEaV0acXKHBry7ZN8R12FP/v5CbnxjFm9Oz+H6gW0DK9CLXHdyW/q2qsMf389mycadgeUozqote3hj2mp+3atZiZ05RcrQHk1JSUzQ7RhFRKRCUJEugTAz7jm7Ewbc/UE2zh0ZzV5y8/dz9asz+Gj2Wu4Y0oGbTm0XaIEO3m0IH7uoG1VSErlm7Exy8+Pn4slHv1pEYoJx3cnRO4tepG61VIZ0acQ7M3LYuy9+toGIiEh5qEiXwDStXYXz2qYwYeEmPs5aF3Scw9qzr4BRL0/ny/kbuPfsTvz2pNZBR/pJwxppPHzhMSzcsJO/xEmHUUs27uT9mWu4tF8LGtZIi8k6h/duzs7cAv4zZ21M1ifRY2avAd8D7c0sx8yuCDqTiEgsqUiXQJ3SPIkuGTX584fz2L4nP+g4JdqRm8+lL0zlf0s389AFx3BJv5ZBR/qF/u0bcNVJrXlt6io+mh18kfrI+EWkJydydf82MVtn78w6tGlQTU1eKgDn3DDnXGPnXLJzrqlz7oWgM4mIxJKKdAlUYoJx33ld2Lo7j398tiDoOAfYs6+AeWt38PGcdVz8/BRmrd7GE8O6x+XFmUVu/lU7ujevxR3vZrFyy+7AcmSv2c4nWeu54vhM6lRNidl6zYwRfZoza/U25q498m/xKSIilVd8XF4ulVrnjJpccXwm//ff5ZzbLYPemXVitu78/YWs3rqH5Zt3H/BYsGYPWz/7/Kfp0pMTee7SHpzcoWHMspVHcmICjw/rxumPT+LacTN5++p+Ub9ve3Ee/mIhNdOTGXViq5iv+7xuTbn/swWMm7KKU2vHfPUiIiIRoSJd4sLvT23HJ1nr+cN7Wfz5zE6kJieQlpRIWnICqUU/kxNJTUogNSmhTBdrFhY6NuzMZfmm3Sw7qBhftXUP+wt/vmi1ZnoyrepX5ag6ifTr3IrMetXIrFeVzHpVo9KLaDQ0rV2FB4YezW///QP/+HQBfzqzU0zX/8PKrUxYuInbBrenRlpyTNcNULNKMmcc3YT3Z67h+BNTY75+ERGRSFCRLnGhSkoSfz23M795aRoXvzDlkNOa4RfrXvGe5hfvacmJpCUlkuoX9gkGq7buYeWWPewNueNJWnICLetW5ajG1TmtS6OfCvFW9apS22+a4d3vNPp3JImWQZ0aMfLYlrz43Qr6tqrLoE6NYrLexRt2cutbc6hXLZWRx7aMyTqLM6JPc97+IYfJawsYElgKERGR8lORLnFjQPsGTLylPxt25JGbv5+8gkJy8/cf8DyvoJC8/P3kFv2eX0huwYHT7MwtYFN+HoXO0bR2FY5rU++nIjyzflUaVk+Lac+gQbnjtA5MX7mV296eQ+eMmmTUSo/q+t6dkcOd72VTJSWRp0Z0p0pKcG8vXZvVomPjGkzM2YVzLvDbZIqIiJSVinSJKy3qVqVF3apBx6gQUpMSeXJYd854YhLXvzaT16/sS3Ji5K8Vz83fz5jsPL7NmU3vzDo8MaxbzG65WBIzY3if5tz1fjazc7bTtVmtQPOIiIiUle7uIlKBtaxXlb+f14UfVv7II+MXRXz5yzbt4pynvuPbnAJ+178140b1CbxAL3JOtwzSEmHs5JVBRxERESkzFekiFdxZxzRhWO9mPDNxKd8s2hSx5X40ey1nPjGJDTtyualHKrcN7kBSFM7Ul1e11CT6Nkniozlr2b43fu/BLyIiUpz4+UQVkai5+4xOtG9YnZvemMWGHblhLSs3fz93vZ/Fda/NpH2j6nx8/QkcXT8+W84NaJZEbn4h783IicjynHMs3bSLcVNWkb1G92EXEZHoic9PVhGJqPSURJ4c3o2znvyOG1+fxauj+pBYjotnV27ZzTXjZpC9Zgf/74RMbhvcgeTEBCLfkCYyWtRI5JhmtRg7ZRWXHduyzBeQFhY6FqzfydTlW5i6YitTl29l8659AFw/sC2dM2pGI7aIiIiKdJHKom3D6txzdidufXsOT369hBtOKdstJj/LXsetb83BDP7v0p6c2jG+O3YqMqJPc257ew7TVvx42I6y8vcXMnftDq8oX+4V5TtyCwDIqJXOiW3r0zuzDr0z65BZTxc4i4hI9KhIF6lEhvZoyvdLt/DYV4vonVmHfq3rHnaefQWF3PfpfF78bgXHNK3Jk8O706xOlRikjYwzj27Cvf+Zx7gpK39RpOfm72dOznamLt/ClOVb+WHlj+zZ591Tv1W9qpzWpfFPRXnT2kfO3ywiIkc+FekilYiZce85nZm1ehs3vD6TT284gbrVSu6VM+fHPVwzbiazV29j5LEt+cNpR5GSdGRdypKeksj53Zsybsoqbhm0hxWb9zDFL8pnrd7GvoJCADo0qs7QHk3pk1mXXpm1aVA9Pu5SIyIilZOKdJFKpmpqEk8M78a5T/+Pm96czYsjexXbudOX8zZw81uzKSx0PD2iO6d1aRxA2sgY0ac5L/1vBcffPwGAxASjc5MaXNavBb0z69KrZW1qVUkJOKWIiMjPVKSLVEKdmtTkj2d05I/vZ/Pcf5dx1UmtfxqXv7+Qhz5fyLPfLqNj4xo8PaI7LY/w9tdtG1bntsHt2Z1XQO/MuvRoUZtqqXr7ExGR+KVPKZFK6uI+zfl+6WYe+nwhvVrWoUeL2qzbvpdrx83kh5U/MqJPc/54RkfSkhODjhoRv+vfJugIIiIipaYiXaSSMjPuO+9ostb8l+tfm8noIR24+4Ns8goKeeyirpzdNSPoiCIiIpXWkXUFmIhEVM30ZJ4Y1p0NO3K57rWZNKiexofXHq8CXUREJGA6ky5SyXVtVouHLjiG+et2cOMp7UhPqRjNW0RERI5kKtJFhHO6ZXBON509FxERiRdq7iIiIiIiEmeiWqSb2WAzW2hmS8xsdDHjTzSzGWZWYGZDDxp3mZkt9h+XhQzvYWZZ/jIfN7Nf3uBZREREROQIFrUi3cwSgaeAIUBHYJiZdTxoslXASGDcQfPWAf4E9AF6A38ys9r+6GeAK4G2/mNwlP4EEREREZFARPNMem9giXNumXNuH/A6cHboBM65Fc65OUDhQfMOAsY757Y6534ExgODzawxUMM5971zzgGvAOdE8W8QEREREYm5aF44mgGsDvk9B+/MeHnnzfAfOcUM/wUzuxLvjDsNGzZk4sSJpVx1+Hbt2hXT9ZVWPOaKx0ygXGWlXCIiIpEVzSK9uLbiLsx5S71M59xzwHMAPXv2dP379y/lqsM3ceJEYrm+0orHXPGYCZSrrJRLREQksqLZ3CUHaBbye1NgbZjz5vjPy7NMEREREZEjQjSL9GlAWzPLNLMU4CLgw1LO+znwKzOr7V8w+ivgc+fcOmCnmfX17+pyKfBBNMKLiIiIiAQlakW6c64AuBav4J4PvOmcm2tm95jZWQBm1svMcoALgGfNbK4/71bgXrxCfxpwjz8M4GrgeWAJsBT4NFp/g4iIiIhIEKLa46hz7hPgk4OG3R3yfBoHNl8JnW4MMKaY4dOBzpFNKiIiIiISP9TjqIiIxKXDdYgnIlKRqUgXEZG4U8oO8UREKiwV6SIiEo8O2yGeiEhFZl7HnRWbmW0CVsZwlfWAzTFcX2nFY654zATKVVbKVTotnHP1gw5xJDCzocBg59wo//dLgD7OuWtDpvmp0zqgPbDwEIuMp2NBWYqnLCWLpzzKUryiLBF7n4/qhaPxItYfimY23TnXM5brLI14zBWPmUC5ykq5JAoO23ldaKd1h11YHB0LylI8ZSlZPOVRluJFI4uau4iISDwKp0M8EZEjnop0ERGJR+F0iCcicsSrFM1dAlCqr18DEI+54jETKFdZKZdElHOuwMyKOsRLBMY45+aGsch4OhaUpXjKUrJ4yqMsxYt4lkpx4aiIiIiIyJFEzV1EREREROKMinQRERERkTijIr0UzKy9mc0KeewwsxvNrI6ZjTezxf7P2v70ZmaP+11ZzzGz7iHLusyffrGZXRaBbL83s7lmlm1mr5lZmn+h1RR/HW/4F11hZqn+70v88S1DlnOHP3yhmQ0KM9MNfp65ZnajPyyQbWVmY8xso5llhwyLWBYz62FmWf48j5tZcbeNK02mC/ztVWhmPQ+avth9YyV0mV7S/i9nrgfNbIG/Pd4zs1pxkuteP9MsM/vCzJr4w2OyDyVYJR1jIeNPNLMZZlZg3v3WQ8dF9DgobxYz62pm3/uv+zlm9uuQcS+Z2XL7+TOna4y2zf6QdX4YMry8r93ybpsBduBnbq6ZnRPOtilFlpvMbJ6/L74ysxYh42J9zBSbJRrHTJjbJdbHS0nbJYjj5Sp/388ys0kW0huylfGz8ZCcc3qU4YF3AdN6oAXwADDaHz4auN9/fhrwKd59fvsCU/zhdYBl/s/a/vPaYWTJAJYD6f7vbwIj/Z8X+cP+BVztP/8d8C//+UXAG/7zjsBsIBXIBJYCieXM1BnIBqrgXZj8JdA2qG0FnAh0B7JDhkUsCzAV6OfP8ykwpJyZjsLrjGUi0DNkeLH7xn8sBVoBKf40HUOOg1/s/3Lm+hWQ5D+/P2RbBZ2rRsjz6/n5uI7JPtQjuMehjrGQaVoCRwOvAENDhkf6tRxOlnZAW/95E2AdUMv//aXQaWOxbfxxu0pYbplfu+FmOWifbQWqlHfblDLLgJB1XM3Pn49BHDMlZYnoMRNOloCOlxKzBHC8hH4GnQV85j8v82fjoR46k152A4GlzrmVeF1Uv+wPfxk4x39+NvCK80wGaplZY2AQMN45t9U59yMwHhgcZp4kIN3MkvAK43XAycDbJeQqyvs2MND/z/9s4HXnXJ5zbjmwBK9L7vI4CpjsnNvjnCsAvgHOJaBt5Zz7Fu8FGyoiWfxxNZxz3zvv1flKyLLKlMk5N985V1xviSXtm2K7TPf3Z0n7vzy5vvD3I8BkvHtVx0OuHSG/VuXnTm5isg8lUMUeY6ETOOdWOOfmAIUHzRvp46DcWZxzi5xzi/3na4GNQLgd74WzbYoVxms3UlmGAp865/aUJm8YWSaErCP0vS6IY6bYLFE4ZsLZLsWK8vFSmiyxOl4O9RlU6s/GwwVRkV52FwGv+c8bOufWAfg/G/jDM4DVIfPk+MNKGl4uzrk1wEPAKrzifDvwA7AtpLAKXcdP6/fHbwfqRjhXNnCimdU1syp4ZzabEfC2OkiksmT4z6ORsUhZM9Wl5P0frt/gnS2Ki1xm9jczWw2MAO4uZ65Y7EOJrHDeGyJ9HETkfcrMeuOdXVsaMvhv/tf6/zSz1FIuKtw8aWY23cwmFzUXoPyv3Ui9h4d+5hYp67Ypa5YrKN17XSyOmdAsP4nQMRNuliCPl2K3CzE8XszsGjNbivft/PWHmbdcrwcV6WXgt6s6C3jrcJMWM8wdYnh589TG+08sE++rr6rAkEOsI+q5nHPz8ZpFjAc+w/tKp+AQs8RkW5VSWbPEImNcZDKzO/H249h4yeWcu9M518zPdG285JKoC2efRfo4CPv48c/I/hu43DlXdEb5DqAD0Avv6/vbS7u4MPM0d1635sOBR82sdRjLjNS26YJ3r/wi5dk2pc5iZhcDPYEHDzNv1LdLMVmKhkfqmAk3SyDHy2G2S8yOF+fcU8651v4y7zrMvOXaLirSy2YIMMM5t8H/fYN/UBQdHBv94SV1Zx3pbq5PAZY75zY55/KBd4Fj8b7iL+qoKnQdP63fH18TrxlBRHM5515wznV3zp3oL38xwW+rUJHKksOBX7dFo9vysmbaTMn7v1zMu1DqDGCE/7VuXOQKMQ44v5y5YrEPJbLCeW+I9HEQ1vuUmdUAPgbu8ptnAd43fH6TrTzgRUrf/DCsPH4TCpxzy/Cuj+lG+V+7kXgPvxB4z/98K8pYnm1TqixmdgpwJ3CWv/xDzRvVY6aELJE+ZsLKEsTxUlIWX0yPlxCv83OTnsjWNK4Mjekr+8PfEZeH/P4gB16A+ID//HQOvHhtqvv5gobleBef1Paf1wkjTx9gLl5bdMNr+3Ud3pn+0Is2fuc/v4YDLxx903/eiQMvdFhGOS8c9ZfXwP/ZHFjg/62BbSu8i5NCLzqMWBa8rsv78vOFQ6eVJ1PI8IkceOFosfsG71qEZf6wootQOvnzFLv/y7mtBgPzgPoHTRd0rrYhz68D3o71PtQjmMehjrFipn2JX144GrHjIMwsKcBXwI3FTNvY/2nAo8A/YrBtagOp/vN6eCdXii76LvNrN5wsIcMnAwPC3TalyYJXYC4NfW8J6pg5RJaIHjNhZon58VJSloCOl9DPoDOB6f7zMn82HjLL4SbQ46edUAXYAtQMGVbXf8Es9n8WvXANeMo/mLI4sOj6Dd6FBEsIKfjDyPUXvEI4G+/rr1S8q4en+ut4K+SFlOb/vsQf3ypkOXf6eRcS5t0tgP/iFXazgYFBbiu8tmnrgHy8/2SviGQWvK/csv15ngSvF99yZDrXf54HbAA+P9y+wWvvv8gfd2fI8GL3fzlzLcFrRzfLf/wrTnK942/3OcBHQEYs96EewT6KO8aAe/DOroH31XYOsBvvfXtutI6D8mYBLvaP6Vkhj67+uK/94zcbeBWoFu1tg/ctbBbe+3YWcEXIMsv72g1nP7UE1gAJBy2zXNumFFm+xHvvLdoXHwZ4zBSbJRrHTBhZgjheDrWPYn28PIZ3knQWMIGQgpsyfjYe6mH+jCIiIiIiEifUJl1EREREJM6oSBcRERERiTMq0kVERERE4oyKdBERERGROKMiXUQiwswuMLO5ZlZoZj0PMd0KM8sys1lmNv2gcdeZ2UJ/OQ/4w+qa2QQz22VmTx40fYqZPWdmi8xsgZmd7w+/yczm+b3MfWVmLfzhLczsB3/dc83sKn94FTP72F/GXDP7Ryn+3g5m9r2Z5ZnZLiIC3AAABNtJREFULSHDm/l55/vLuqEs21FERAS8+zaKiM/MbgSec87tKeN8I4EvnN+5Q0VnZv2Bkc65kSGDs4HzgGdLsYgBzrnNBy1zAF4Pukc75/LMrIE/Khf4I9DZf4S6E9jonGtnZgl49zQGmIl3+8U9ZnY1XrfNv8a7leOx/vKrAdlm9iGwDXjIOTfB71n4KzMb4pwrrtvpIlvxuoI+56DhBcDNzrkZZlYd+MHMxjvn5pViu4iIiAA6ky5ysBvx7olfamaWCIwEmkQj0JHCOTffObcwjEVcjdfRRJ6/vI3+z93OuUl4xfrBfgPc509XWFT4O+cmhPyjNRm/Z0Dn3D73cy91qfjvgc65Pc65CUXTADOK5jGz+mb2jplN8x/HFeVzzk3Du29x6HZY55yb4T/fCcwHMsLYLiIiUgmpSJdKy8yq+k0cZptZtpn9Ca/QnmBmE/xpnjGz6X6zhb+EzLvCzO42s0nAMLxOLcb6zSjSA/mDjhwO+MJvdnJlyPB2wAlmNsXMvjGzXodaiJnV8p/ea2YzzOwtM2tYzKRX4PUGWDRfMzObg9dJ0/0Hf/vhL/dMvI6uwOu04p/OuV7A+cDzpf1DzawlXi95U0o7j4iICKi5i1Rug4G1zrnTAcysJnA5BzbFuNM5t9U/W/6VmR3tnJvjj8t1zh3vzzsKuMU5N50KzMym4J2BrgbUMbNZ/qjbnXOfl3Ixxznn1vrNWcab2QLn3Ld470e18brZ7gW8aWatXMk9riXhne3+zjl3k5ndBDwEXBKS92K8f6BOKhrmnFsNHG1mTYD3zext59wGf/okvB5OH3fOLfNnOQXoaGZFi6hhZtX9s+Ql8pvTvIPXhfeOUm4bERERQGfSpXLLAk4xs/vN7ATn3PZiprnQzGbgtXHuBHQMGfdGLELGE+dcH+dcV2AUXpfMXf1HaQt0is5c+81Z3gN6+6NygHedZypQCNQ7xKK2AHv8ZYDX/XT3opFmdgpem/WzQpq4HJxjLnBCyODngMXOuUdDhiUA/UL+1oxSFOjJeAX6WOfcu4eaVkREpDgq0qXScs4tAnrgFev3mdndoePNLBO4BRjonDsa+BhIC5lkd6yyVhR+E6PqRc+BX+FdcArwPnCyP64dkAJsLm45AP4Z9o+A/v6ggcA8f/5ueBewnlXUtt0f3rSoOZKZ1QaOAxb6v/8VqIl3XUKoL4BrQ5bR9TB/owEvAPOdc48caloREZGSqEiXSstv7rDHOfcqXjOJ7sBOoLo/SQ28Qny739Z5yCEWFzpfpWRm55pZDtAP+NjMPveHNzGzT/zJGgKTzGw2MBX42Dn3mT9uDNDKzLKB14HLipq6mNkK4BFgpJnlmFnRNxq3A3/225hfAtzsD38Qr0nOW/51Ah/6w48Cpvjr/wbvji5ZZtYU76x7R2CGP88of57rgZ7+7RznAUW3bWzk/703AXf5uWrgFf6XACf7y5llZqeFvYFFRKRSsZKbe4pUbGY2CK+YK8S7Q8fVeAXmNcA659wAM3sJ6AMsA/Lwmni85BeNPYvarpt3f+6/A3vxmkbsjfGfIyIiIhWIinQRERERkTij5i4iIiIiInFGRbqIiIiISJxRkS4iIiIiEmdUpIuIiIiIxBkV6SIiIiIicUZFuoiIiIhInFGRLiIiIiISZ/4/L+4MrAerYmcAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -90,7 +91,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -100,17 +101,13 @@ } ], "source": [ - "callback_instances = data_model.callback_instances\n", - "callback_symbols = data_model.callback_symbols\n", + "data_util = utils.DataModelUtil(data_model)\n", "\n", - "# Get a list of callback objects\n", - "callback_objects = set(callback_instances['callback_object'])\n", - "# Get their symbol\n", - "symbols = {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects}\n", + "callback_symbols = data_util.get_callback_symbols()\n", "\n", "# Plot durations\n", - "for obj in callback_objects:\n", - " duration_ns = callback_instances.loc[callback_instances.loc[:, 'callback_object'] == obj, :]\n", + "for obj, symbol in callback_symbols.items():\n", + " duration_ns = data_util.get_callback_durations(obj)\n", " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", "\n", " fig = plt.figure(figsize=(12, 6))\n", @@ -118,7 +115,7 @@ "\n", " ax = fig.add_subplot(1, 2, 1)\n", " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", - " ax.legend([str(symbols.get(obj, 'unknown'))])\n", + " ax.legend([str(symbol)])\n", " ax.set_xlabel('start')\n", " ax.set_ylabel('duration (ms)')\n", " ax.title.set_text('Callback durations')\n", diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py new file mode 100644 index 0000000..0085380 --- /dev/null +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -0,0 +1,62 @@ +# Copyright 2019 Robert Bosch GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Module for data model utility class.""" + +from typing import Mapping +from pandas import DataFrame + +from .data_model import DataModel + + +class DataModelUtil(): + """ + Data model utility class. + + Provides functions to get info on a data model. + """ + + def __init__(self, data_model: DataModel) -> None: + """ + Constructor. + + :param data_model: the data model object to use + """ + self._data = data_model + + def get_callback_symbols(self) -> Mapping[int, str]: + """ + Get mappings between a callback object and its resolved symbol. + + :return: the map + """ + callback_instances = self._data.callback_instances + callback_symbols = self._data.callback_symbols + + # Get a list of callback objects + callback_objects = set(callback_instances['callback_object']) + # Get their symbol + return {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects} + + def get_callback_durations(self, callback_obj: int) -> DataFrame: + """ + Get durations of callback instances for a given callback object. + + :param callback_obj: a callback object value + :return: a dataframe containing the durations of all callback instances for that object + """ + return self._data.callback_instances.loc[ + self._data.callback_instances.loc[:, 'callback_object'] == callback_obj, + : + ] From 579e064b54609b5b7c5e5f73aa0d4b3bb0a83a45 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 12:48:56 +0200 Subject: [PATCH 87/98] Fix lint --- tracetools_analysis/tracetools_analysis/analysis/utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py index 0085380..801116b 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/utils.py +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -15,6 +15,7 @@ """Module for data model utility class.""" from typing import Mapping + from pandas import DataFrame from .data_model import DataModel From a816736c4301809c8eb2cf120d9e92e8a0346a36 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 14:55:54 +0200 Subject: [PATCH 88/98] Add util methods to get information on a callback object --- .../analysis/data_model.py | 13 +- .../analysis/ros2_processor.py | 3 +- .../tracetools_analysis/analysis/utils.py | 145 +++++++++++++++++- 3 files changed, 156 insertions(+), 5 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/tracetools_analysis/analysis/data_model.py index 09d5f0e..d3cefcf 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/tracetools_analysis/analysis/data_model.py @@ -68,7 +68,8 @@ class DataModel(): self.clients.set_index(['client_handle'], inplace=True, drop=True) self.timers = pd.DataFrame(columns=['timer_handle', 'timestamp', - 'period']) + 'period', + 'tid']) self.timers.set_index(['timer_handle'], inplace=True, drop=True) self.callback_objects = pd.DataFrame(columns=['handle', @@ -117,9 +118,9 @@ class DataModel(): self.clients.loc[handle] = [timestamp, node_handle, rmw_handle, service_name] def add_timer( - self, handle, timestamp, period + self, handle, timestamp, period, tid ) -> None: - self.timers.loc[handle] = [timestamp, period] + self.timers.loc[handle] = [timestamp, period, tid] def add_callback_object( self, handle, timestamp, callback_object @@ -165,3 +166,9 @@ class DataModel(): print() print(f'Callback instances:\n{self.callback_instances.to_string()}') print('==================================================') + + timers_info = self.timers.merge(self.nodes, on='tid', right_index=True) + print(timers_info.to_string()) + print() + subscriptions_info = self.subscriptions.merge(self.nodes, left_on='node_handle', right_index=True) + print(subscriptions_info.to_string()) diff --git a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py index a335faa..47b6dea 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py +++ b/tracetools_analysis/tracetools_analysis/analysis/ros2_processor.py @@ -155,7 +155,8 @@ class Ros2Processor(EventHandler): handle = get_field(event, 'timer_handle') timestamp = metadata.timestamp period = get_field(event, 'period') - self._data.add_timer(handle, timestamp, period) + tid = metadata.tid + self._data.add_timer(handle, timestamp, period, tid) def _handle_rclcpp_timer_callback_added( self, event: Dict, metadata: EventMetadata diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py index 801116b..15ec3c8 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/utils.py +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -14,7 +14,9 @@ """Module for data model utility class.""" +from typing import Any from typing import Mapping +from typing import Union from pandas import DataFrame @@ -54,10 +56,151 @@ class DataModelUtil(): """ Get durations of callback instances for a given callback object. - :param callback_obj: a callback object value + :param callback_obj: the callback object value :return: a dataframe containing the durations of all callback instances for that object """ return self._data.callback_instances.loc[ self._data.callback_instances.loc[:, 'callback_object'] == callback_obj, : ] + + def get_callback_owner_info(self, callback_obj: int) -> Union[str, None]: + """ + Get information about the owner of a callback. + + Depending on the type of callback, it will give different kinds of info: + * subscription: node name, topic name + * timer: tid, period of timer + * service/client: node name, service name + + :param callback_obj: the callback object value + :return: information about the owner of the callback, or `None` if it fails + """ + # Get handle corresponding to callback object + handle = self._data.callback_objects.loc[ + self._data.callback_objects['callback_object'] == callback_obj + ].index.values.astype(int)[0] + + type_name = None + info = None + # Check if it's a timer first (since it's slightly different than the others) + if handle in self._data.timers.index: + type_name = 'Timer' + info = self.get_timer_handle_info(handle) + elif handle in self._data.publishers.index: + type_name = 'Publisher' + info = self.get_publisher_handle_info(handle) + elif handle in self._data.subscriptions.index: + type_name = 'Subscription' + info = self.get_subscription_handle_info(handle) + elif handle in self._data.services.index: + type_name = 'Service' + info = self.get_subscription_handle_info(handle) + elif handle in self._data.clients.index: + type_name = 'Client' + info = self.get_client_handle_info(handle) + + if info is not None: + info = f'{type_name} -- {self.format_info_dict(info)}' + return info + + def get_timer_handle_info(self, timer_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about the owner of a timer. + + :param timer_handle: the timer handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + timers_info = self._data.timers.merge(self._data.nodes, on='tid', right_index=True) + if timer_handle not in timers_info.index: + return None + + tid = timers_info.loc[timer_handle, 'tid'] + period_ns = timers_info.loc[timer_handle, 'period'] + period_ms = period_ns / 1000000.0 + return {'tid': tid, 'period': f'{period_ms} ms'} + + def get_publisher_handle_info(self, publisher_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about a publisher handle. + + :param publisher_handle: the publisher handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + if publisher_handle not in self._data.publishers.index: + return None + + node_handle = self._data.publishers.loc[publisher_handle, 'node_handle'] + node_handle_info = self.get_node_handle_info(node_handle) + topic_name = self._data.publishers.loc[publisher_handle, 'topic_name'] + publisher_info = {'topic': topic_name} + return {**node_handle_info, **publisher_info} + + def get_subscription_handle_info(self, subscription_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about a subscription handle. + + :param subscription_handle: the subscription handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + subscriptions_info = self._data.subscriptions.merge( + self._data.nodes, + left_on='node_handle', + right_index=True) + if subscription_handle not in self._data.subscriptions.index: + return None + + node_handle = subscriptions_info.loc[subscription_handle, 'node_handle'] + node_handle_info = self.get_node_handle_info(node_handle) + topic_name = subscriptions_info.loc[subscription_handle, 'topic_name'] + subscription_info = {'topic': topic_name} + return {**node_handle_info, **subscription_info} + + def get_service_handle_info(self, service_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about a service handle. + + :param service_handle: the service handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + if service_handle not in self._data.services: + return None + + node_handle = self._data.services.loc[service_handle, 'node_handle'] + node_handle_info = self.get_node_handle_info(node_handle) + service_name = self._data.services.loc[service_handle, 'service_name'] + service_info = {'service': service_name} + return {**node_handle_info, **service_info} + + def get_client_handle_info(self, client_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about a client handle. + + :param client_handle: the client handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + if client_handle not in self._data.clients: + return None + + node_handle = self._data.clients.loc[client_handle, 'node_handle'] + node_handle_info = self.get_node_handle_info(node_handle) + service_name = self._data.clients.loc[client_handle, 'service_name'] + service_info = {'service': service_name} + return {**node_handle_info, **service_info} + + def get_node_handle_info(self, node_handle: int) -> Union[Mapping[str, Any], None]: + """ + Get information about a node handle. + + :param node_handle: the node handle value + :return: a dictionary with name:value info, or `None` if it fails + """ + if node_handle not in self._data.nodes.index: + return None + + node_name = self._data.nodes.loc[node_handle, 'name'] + tid = self._data.nodes.loc[node_handle, 'tid'] + return {'node': node_name, 'tid': tid} + + def format_info_dict(self, info_dict: Mapping[str, Any]) -> str: + return ', '.join([f'{key}: {val}' for key, val in info_dict.items()]) From d39ffc11f358635b5c5783eed9470ef20d4faf07 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 15:01:44 +0200 Subject: [PATCH 89/98] Remove merge between timer and nodes --- .../tracetools_analysis/analysis/utils.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py index 15ec3c8..e0d3a8c 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/utils.py +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -111,14 +111,14 @@ class DataModelUtil(): :param timer_handle: the timer handle value :return: a dictionary with name:value info, or `None` if it fails """ - timers_info = self._data.timers.merge(self._data.nodes, on='tid', right_index=True) - if timer_handle not in timers_info.index: + # TODO find a way to link a timer to a specific node + if timer_handle not in self._data.timers.index: return None - tid = timers_info.loc[timer_handle, 'tid'] - period_ns = timers_info.loc[timer_handle, 'period'] + tid = self._data.timers.loc[timer_handle, 'tid'] + period_ns = self._data.timers.loc[timer_handle, 'period'] period_ms = period_ns / 1000000.0 - return {'tid': tid, 'period': f'{period_ms} ms'} + return {'tid': tid, 'period': f'{period_ms:.0f} ms'} def get_publisher_handle_info(self, publisher_handle: int) -> Union[Mapping[str, Any], None]: """ From 31e6c026b749eeddcfbf8141422f0ba1cb03e133 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 15:02:44 +0200 Subject: [PATCH 90/98] Update callback_duration notebook --- .../analysis/callback_duration.ipynb | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb index a71c620..f29c3c8 100644 --- a/tracetools_analysis/analysis/callback_duration.ipynb +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -65,9 +65,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -77,9 +77,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -89,9 +89,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtoAAAGeCAYAAACqz6bUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3XmYZGV59/Hv3ctM98D0sCijbM64BxxBGVASxXYNRhGNiiwquOESlyjRYGIMojEq4hb1jRh3UKMYIwpxidAQFFlFEAFFHGAYBGTpnp7pnqnuvt8/qqqnp+mluqdOVc/U93NdfXUtp85zV8F1+jdP3ec8kZlIkiRJqq+2ZhcgSZIk7YgM2pIkSVIBDNqSJElSAQzakiRJUgEM2pIkSVIBDNqSJElSAQzakiRJUgEM2pJUoIjIOf6cMOn1u0bEeyPisoi4LyI2RcRtEfGtiHj2DOOumbTfUkTcExHXRsTXIuKlEbFoltqXRMTbI+KiiPhTZew7IuL7lddHnT4mSdohhQvWSFJxIuKUKR7+W2AZ8Eng/knP/XdmXl157WHAd4AHAdcD5wPrgUcBzwWWAGcCr83MTZPGXQM8bMIYbUAP8BjgqcBOwO+AV2TmpVPUvT/wfWAlcAvwI+AeYF/gecAuwE+AozJz8nuQJGHQlqSGmxCCV2bmmmm22Q+4DOimHMw/nRMO2BGxD/DfwBOBL2bma2odIyKWAe8H3gL0A0/OzBsmPP8Q4CrgocC/Au/NzJEJz+8GfB34S8ph+/DMHJvjxyBJOzxbRyRpYfoU5Vnnj2Tmv+WkWZHMvA14PnAf8OqI+Itad5yZ/Zn5VuCrlGfWPzRpkw9QDtnfzMx/mBiyK6+/F3gxcDPwbOCYOb0zSWoRBm1JWmAiYiXwTGAT8JHptsvMO4D/qNw9cR5Dva/y+/kR0VMZuxt4eeXxU2cYewNw+jaMLUk7PIO2JC08T6n8vjIz75tl259Uftc8o12VmTcDa4F24KDKw6uBxcC6zLy+xrGfHBHtcx1fknZ0Bm1JWngeWvl9Ww3bVrfZc55j3V75/eBtGHsRsPs8x5ekHZZBW5IWnupl82o5W30u29by+vnuzzPrJWkSg7YkLTx3VH7vW8O2e096zVxVZ8LvnsfY+1R+bwbunef4krTDMmhL0sJzceX3QRGxyyzbPqvy+2dzHSQiHkk5qI8AV1YevpzySZh7RsSf1Tj2LzJzdK7jS9KOzqAtSQtM5STFCyiflPjO6baLiOXAayt3z5jHUO+t/P5+Zq6vjD1E+RrZAO+ZYexu4B3bMLYk7fAM2pK0ML0N2Aj8fUS8cfKTEbEX8ANgN+BLmVnzjHZE9ETEp4BXUF418uRJm7wHuBM4NiLeHxEdk16/K3A28Ejgf4Fv1PyuJKmFuDKkJDVYLStDVrZ7OuVAuxtwHeVZ7vWUA+7zKC/BfhbwmhqWYA+2LMF+GOXFcH4LvDwzL59i7McD51T2sQb4IeU+7OoS7LtSDtkvdQl2SZqaQVuSGqzWoF3ZdnfKS6U/H3gU0EX5xMVLgM9n5o9nGaNqhHJIvx24GvgecE5mbp5h7J2A1wN/DewH7Ew5bF9BeVXJb09esVKStIVBW5IkSSqAPdqSJElSAQzakiRJUgEM2pIkSVIBDNqSJElSAQzakiRJUgEM2pIkSVIBDNqSJElSAQzakiRJUgEM2pIkSVIBDNqSJElSAQzakiRJUgEM2mq4iMiIeGTl9pcj4gOV270RsbaA8cbHmMdrT4mIM+td0wzjPTUibmzUeJK0EEXE/0TE8QXsd8a/BxExGBEPr/e4al0Gbc1LRBwbEVdUDkp3VA6KT2l2Xdubif/oAMjM/8vMxzSzJkmtKyLWRMRQRKyPiPsj4ucR8YaIKCwvTDWhkZnPzcyvFDXmdDJz58y8eaZtipoU0o7JoK05i4h3AJ8APggsB/YFPgsc2cy6FpqI6Gh2DZI0D0dk5lLgYcCHgL8HvjCfHXkcnLuIaG92Daofg7bmJCKWAacCf5OZ/5WZGzKzlJnfz8x3VrY5JCIuqcyG3BERn46IRXMY4x8i4k+VmZXjJjz+vIj4ZUQMRMRtEXHKpNc9pTL7cn/l+ROm2PfSiLggIj4VETHF8ysj4sLKbM5PgAdNeO4BsxiVGp9VuX1KRJwdEWdGxABwwkyfRURcVNnNryrfDLxs8hgR8WcR0Vd5/XUR8YIJz305Ij4TEedW6r00Ih5ReS4i4uMRcVdE9EfENRHxuFr/G0hSZvZn5jnAy4Djq8eQyjHptdXtIuKEiLh4wv2MiL+JiN8Bv6s89snKcXkgIq6MiKdWHj8c+AfgZZXj4K8mjxERbRHxnoi4pXJM+2rlbxERsaIy3vERcWvlb8c/zvLWdp3quDmh9mpr419FxG8q290eEX8XETsB/wPsWal3MCL2jIjFEfGJiFhX+flERCyesN93Vf4GrIuI18YDWyj/X0ScFxEbgKfP9Pduwnt+VeW5+6L8rcPBlWP9/RHx6bn911ZRDNqaq0OBLuC7M2wzCrydckg9FHgm8KYa9/+Qyuv2Ao4HzoiIaivFBuCVwC7A84A3RsQLASJiX8oHv38DHgwcCFw9cccRsTvwU+BnmfnWzMwpxv86cGWlhvdXapiLI4GzKzWexQyfRWYeVnnNAZWvK/9zUr2dwPeBHwN7AG8BzprweQAcA7wP2BW4CfiXyuPPAQ4DHl2p5WXAPXN8L5JEZl4GrAWeOoeXvRB4ErBf5f7llI/Lu1E+zn47Iroy84eUvx39z8px8IAp9nVC5efpwMOBnYHJQfIpwGMoH2PfGxF/NkNt0x03J/sC8PrK7P7jgPMzcwPwXGBdpd6dM3Md8I/Akyvv8QDgEOA9MP6PiXcAzwIeCTxtirGOrdSxFLiYGf7eTfAk4FGUj++fqNTwLGB/4KiImGocNZhBW3O1O/CnzByZboPMvDIzf5GZI5m5BvgcUx9YpvNPmbkpMy8EzgWOquy3LzOvzcyxzLwG+MaE/R4H/G9mfqMyw35PZk4M2nsCFwLfzsz3TDVoJawfPGH8iygH3bm4JDP/u1Lj0DZ+Fk+m/AflQ5m5OTPPB35A+Y9E1X9l5mWV/x5nUT7IA5QoH7AfC0RmXp+Zd8zxvUhS1TrKIblW/5qZ92bmEEBmnlk5Lo9k5unAYsrBuBbHAR/LzJszcxB4N3B0bN2W8r7KMfdXwK8oh93pTHfcnKwE7BcRPZl5X2ZeNUuNp2bmXZl5N+Ug/4rKc0cBX8rM6zJzY+W5yb6XmT+r/O0YnuXvXdX7K9v+mHIw/0Zl/NuB/wOeMEO9ahCDtubqHuBBMUPfXUQ8OiJ+EBF/jHILxQeZ0IIxi/sqMwZVt1AOyUTEk6Lc9nF3RPQDb5iw332A38+w3+cB3cC/z7DNntOMPxe3TbyzjZ/FnsBtmTk2qZ69Jtz/44TbGykHcyqh/NPAZ4A7I+KMiOiZ21uRpHF7AffOYfvJx8KTIuL6Sivb/cAy5nYsnHgsvgXooHyOUNWUx8Jp1Lrti4G/Am6JckvhoXOscc8Jz038PLb6bKZ6bJa/d1V3Trg9NMX9mT4DNYhBW3N1CTBM+WvB6fw/4AbgUZnZQ7n/7gH90NPYtdIDV7Uv5ZkUKH/deA6wT2Yuoxyaq/u9DXgE0/s88EPgvEn7n+iOacav2gAsqd6J8gkrD560j8ntKNvyWawD9omtz/bfF7i9lhdn5qcy8yDKXyM+GnhnjeNK0riIOJhy0K72YW91LKTc8jfZ+LGw0o/995RndnfNzF2AfrYcC6dq45toHeUTM6v2BUbYOljWXWZenplHUm7d+2/gW9Wnaqyx+rfrDmDvCc/tM9Vwk+7P9PdO2xGDtuYkM/uB9wKfiYgXRsSSiOiMiOdGxEcqmy0FBoDBiHgs8MY5DvO+iFhUOTg/H/j2hP3em5nDEXEI5Z62qrOAZ0XEURHRERG7R8TkrwPfDNwI/CAiuqd4b7cAV0wY/ynAERM2+S3QVTlJpZNy/93iyfuZZLbP4k7KPYdTuZTyH7R3VT7j3ko935xlTConxTypUucGyv84Gp3tdZJUFRE9EfF8ysecMzPz2spTVwN/XTn+PxJ4zSy7Wko5GN8NdETEe4GJ37DdCayI6S8h+A3g7VE+WX1ntvR0T9vCuK0qfwOOi4hlmVmifByvHkPvBHaPygmZE2p8T0Q8OCIeRPnvZPWShd8CXhXlk9uXVJ6bzUx/77QdMWhrzjLzY5RP7HgP5QPnbZRD7H9XNvk7ygeF9ZRnkv9zit1M54/AfZRnAs4C3pCZN1SeexNwakSsp3ygqs4ukJm3Uv6K7yTKX29ezaQevcrJjydW6v1eRHRNMf6xlE8wuRf4Z+CrE17fX6nhPyjPKm+gfILQTGb7LE4BvlI5S/yoSfVuBl5A+cSbP1G+hOIrJ3weM+mpjHcf5a8w7wE+WsPrJOn7lePsbZRPsPsY8KoJz38c2Ew5cH6F8rF6Jj+ifLL6bykfj4bZulWiOplyT0RM1Qf9ReBrwEXAHyqvf8sc3s98vQJYU2n7ewPwcoDKMfgbwM2VY/eewAcoT9RcA1wLXFV5jMz8H+BTwAWUT768pLL/TTOMPe3fO21fYuoLL0iSJKneKldE+TWwuMhZeS0MzmhLkiQVKCJeVGlH2RX4MPB9Q3ZrMGhLkiQV6/WUWy1/T7nXe67nLmk7ZeuIJEmSVABntCVJkqQCGLQlSZKkAky7ut/25kEPelCuWLGiYeNt2LCBnXaabt2T5rGuubGu2i3EmmBh1nXllVf+KTMnL2akOtiWY/1C/H9lLqy/uay/uRZa/bUe53eYoL1ixQquuOKKho3X19dHb29vw8arlXXNjXXVbiHWBAuzroi4ZfatNB/bcqxfiP+vzIX1N5f1N9dCq7/W47ytI5IkSVIBDNqSJElSAQzakiRJUgF2mB5tSXNTKpVYu3Ytw8PDNW2/bNkyrr/++oKrmrtm1tXV1cXee+9NZ2dnU8aXJC1sBm2pRa1du5alS5eyYsUKImLW7devX8/SpUsbUNncNKuuzOSee+5h7dq1rFy5suHjS5IWPltHpBY1PDzM7rvvXlPI1gNFBLvvvnvN3whIklqPQVtqYYbsbePnJ0maiUFbkiRJKoBBW1LTrFmzhu7ubg488EAAdt5557rs95RTTuGjH/3orNudcMIJnH322TNu8853vpOHPOQhNe1PkqSJPBlSUlM94hGP4Oqrr252GdM67bTTFtSyv5Kk7YdBWxLv+/51/GbdwIzbjI6O0t7eXvM+99uzh38+Yv951TM4OMiRRx7JfffdR6lU4gMf+ABHHnkka9as4fDDD+cpT3kKv/jFLzjggAN42ctexoc//GHuuusuzjrrLA455BAAfvWrX/GMZzyD2267jXe961287nWvIzN5y1vewvnnn8/KlSvJzPExTz31VL7//e8zNDTEn//5n/O5z33OHuw6iYgvAs8H7srMx0167u+A04AHZ+afmlGfJBXF1hHVZNPIKGv+tKHZZahFdHV18d3vfperrrqKCy64gJNOOmk8FN9000287W1v45prruGGG27g29/+NhdffDEf/ehH+eAHPzi+j2uuuYZzzz2XSy65hFNPPZV169bx3e9+lxtvvJFrr72Wz3/+8/z85z8f3/7Nb34zl19+Ob/+9a8ZGhriBz/4QcPf9w7sy8Dhkx+MiH2AZwO3NrogSWoEZ7RVk29fsZb3/+A3/PK9z2bJIv+32dHUMvPcyOtVZyb/8A//wEUXXURbWxu33347d955JwArV65k1apVAOy///4cdthhRASrVq1izZo14/s48sgj6e7upru7m6c//elcdtllXHTRRRxzzDG0t7ez55578oxnPGN8+wsuuICPfOQjbNy4kXvvvZf999+fI444oiHvd0eXmRdFxIopnvo48C7gew0tSJIaxMSkmqy7f4hNI2Pct7Fk0FbhzjrrLO6++26uvPJKOjs7WbFixfj1qhcvXjy+XVtb2/j9trY2RkZGxp+b3PZRvT9VO8jw8DBvetObuOKKK9hnn3045ZRTvD52wSLiBcDtmfmr2Vp0IuJE4ESA5cuX09fXN6exrr29H4Dl3fBvZxWb6VfttaywfQ8ODs75vS8k1t9c1t8cJibVpH+oVP69scReu3Q3uRrt6Pr7+9ljjz3o7Ozkggsu4JZbbpnzPr73ve/x7ne/mw0bNtDX18eHPvQhRkdH+dznPscrX/lK7rrrLi644AKOPfbY8VD9oAc9iMHBQc4++2xe8pKX1PttqSIilgD/CDynlu0z8wzgDIDVq1dnb2/vnMY74eRzAThp1QinX1vsn701x/UWtu++vj7m+t4XEutvLutvDoO2ajIwXJ4prAZuqUjHHXccRxxxBKtXr+bAAw/ksY997Jz3ccghh/C85z2PW2+9lX/6p39izz335EUvehHnn38+q1at4tGPfjRPe9rTANhll1143etex6pVq1ixYgUHH3xwvd+StvYIYCVQnc3eG7gqIg7JzD82tTJJqiODtmoyPqNt0FaBBgcHgfLM8iWXXDLlNr/+9a/Hb3/5y19m/fr1AKxYsWL8uVNOOWXK10YEn/70p6d87gMf+AAf+MAH5lu65iAzrwX2qN6PiDXAaq86ImlH41VHVJNqwB4YNmirftrb2+nv7x9fsGYheuc738mZZ57ptbS3QUR8A7gEeExErI2I1zS7JklqBGe0VZOBatB2Rlt1tM8++3Dbbbc1u4wZnXbaaZx22mnNLmO7lpnHzPL8igaVIkkN5Yy2ajJg68gOaeKCLZo7Pz9J0kwM2ppVZtqjvQPq6urinnvuMSzOU2Zyzz330NXV1exSJEkLlK0jmtXGzaOMjJXDmEF7x7H33nuzdu1a7r777pq2Hx4eXpChspl1dXV1sffeezdlbEnSwmfQ1qwmhmt7tHccnZ2drFy5subt+/r6eMITnlBgRfOzUOuSJMnWEc1q4pVGnNGWJEmqjUFbs+rfWA7XuyzpNGhLkiTVyKCtWVXD9T67LqF/aKTJ1UiSJG0fDNqaVTVo77vbEgaGSl6lQpIkqQYGbc1qYLg8i73PbkvYPDrGppGxJlckSZK08Bm0Nav+oRIRsNeu3eP3JUmSNDODtmY1MFRi58Ud7LqkEzBoS5Ik1cKgrVn1D5VY1t1JT5dBW5IkqVYGbc1qoBK0l3VXgvZGg7YkSdJsDNqaVf9QiZ6uLUF74gI2kiRJmppBW7PqnzyjbeuIJEnSrAoN2hFxeETcGBE3RcTJUzx/WERcFREjEfGSKZ7viYjbI+LTRdapmVWD9tKujvH7kiRJmllhQTsi2oHPAM8F9gOOiYj9Jm12K3AC8PVpdvN+4MKialRtBoZLLFvSSUd7Gzsv7jBoS5Ik1aDIGe1DgJsy8+bM3Ax8Ezhy4gaZuSYzrwEesAJKRBwELAd+XGCNmsWmkVGGS2P0VGazl3V3GrQlSZJqUGTQ3gu4bcL9tZXHZhURbcDpwDsLqEtzUA3V1f7snu5OBoZGmlmSJEnSdqGjwH3HFI9lja99E3BeZt4WMdVuKgNEnAicCLB8+XL6+vrmWuO8DQ4ONnS8WtW7rnWD5S8bbv/DTfRtWkNuGuLWP859jFb5vOplIda1EGuChVuXJElFBu21wD4T7u8NrKvxtYcCT42INwE7A4siYjAztzqhMjPPAM4AWL16dfb29m5z0bXq6+ujkePVqt51XXnLfXDxz3nyQY+n9zF78I3brmDNnzbS23tYU+uqF+uq3UKsCRZuXZIkFRm0LwceFRErgduBo4Fja3lhZh5XvR0RJwCrJ4dsNcZApXWkp9o60mWPtiRJUi0K69HOzBHgzcCPgOuBb2XmdRFxakS8ACAiDo6ItcBLgc9FxHVF1aP5mdyj7cmQkiRJtSlyRpvMPA84b9Jj751w+3LKLSUz7ePLwJcLKE81mCpoD5VG2TwyxqIO1zuSJEmajklJMxpvHemqBO0lLsMuSZJUC4O2ZtQ/VKK7s3189tpl2CVJkmpj0NaMqsuvV/UYtCVJkmpi0NaMHhC0uwzakiRJtTBoa0YDw1sH7ertAYO2JEnSjAzamlH/0Ag93VsuTmPQliRJqo1BWzMaGCqN92WDJ0NKkiTVyqCtGU3u0V7U0UZ3Z7tBW5IkaRYGbU1rZHSMwU0jWwVtgJ7uDoO2JEnSLAzamtb64RFgy5VGqlyGXZIkaXYGbU1r8vLrVcu6OxkYGmlGSZIkSdsNg7amVV1mfaqg7Yy2pFpFxBcj4q6I+PWEx06LiBsi4pqI+G5E7NLMGiWpCAZtTWt8RnvJ5B5tg7akOfkycPikx34CPC4zHw/8Fnh3o4uSpKIZtDWtapie3KPd09XpdbQl1SwzLwLunfTYjzOz2oP2C2DvhhcmSQUzaGtaM/Vor980wuhYNqMsSTueVwP/0+wiJKneOmbfRK2qesLjVEEbYP1wiV2WLGp4XZJ2HBHxj8AIcNYM25wInAiwfPly+vr65jTGSavKx7Ll3VtuF2Wutc3F4OBgofsvmvU3l/U3h0Fb0+ofKrGovY2uzq2/+Ji4OqRBW9J8RcTxwPOBZ2bmtF+RZeYZwBkAq1evzt7e3jmNc8LJ5wLlkH36tcX+2VtzXG9h++7r62Ou730hsf7msv7mMGhrWv1DJXq6O4iIrR53GXZJ2yoiDgf+HnhaZm5sdj2SVAR7tDWtgaESPZPaRoDxxwzakmoREd8ALgEeExFrI+I1wKeBpcBPIuLqiPj3phYpSQVwRlvTGhguPaA/G5zRljQ3mXnMFA9/oeGFSFKDOaOtafUPlR5waT/YErRdHVKSJGl6Bm1Nq3/IGW1JkqT5MmhrWtMF7a7ONha1txm0JUmSZmDQ1pQyk4FpgnZE0NPdYdCWJEmagUFbUxrcNMJYQk/31OfL9nS7DLskSdJMDNqa0nTLr1ct6+5kYNigLUmSNB2DtqZUS9C2dUSSJGl6Bm1NqXrpvqkWrAGDtiRJ0mwM2ppSNURPdR3t6uMGbUmSpOkZtDWlgVp6tIdKjI1lI8uSJEnabhi0NaXxHu0l0wftsYTBza4OKUmSNBWDtqY0MFyiLWDnRVNf3m/LMuy2j0iSJE3FoK0p9Q+VWNrVSVtbTPl8j8uwS5IkzcigrSlNt/x61TKDtiRJ0owM2prSbEG7umKkrSOSJElTM2hrSgPOaEuSJG0Tg7am1D9UGp+1nsqWkyG96ogkSdJUDNqaUv/QyIwz2jsv7qC9LZzRliRJmoZBWw+QmQwMlaZdfh0gIujp6jBoS5IkTcOgrQfYNDLG5tGxGWe0oXyJP4O2JEnS1AzaeoBqeO7pmjloLzNoS5IkTcugrQcYX359lhntZd2dDAwbtCVJkqZi0NYD1Bq0bR2RJEmankFbDzAwlxltg7YkSdKUDNp6gPEe7dlmtLvKM9qZ2YiyJEmStiuFBu2IODwiboyImyLi5CmePywiroqIkYh4yYTHD4yISyLiuoi4JiJeVmSd2tpcerRLo8lQabQRZUmSJG1XCgvaEdEOfAZ4LrAfcExE7Ddps1uBE4CvT3p8I/DKzNwfOBz4RETsUlSt2tqWq45MvzIkuDqkJEnSTIqc0T4EuCkzb87MzcA3gSMnbpCZazLzGmBs0uO/zczfVW6vA+4CHlxgrZpgYGiEnRa109E+8/8e1aDtCZGSJEkPNPOU5bbZC7htwv21wJPmupOIOARYBPx+iudOBE4EWL58OX19ffMqdD4GBwcbOl6t6lHXjX/YxOK2sVn3s+ZP5ZaRvp9fxh27tRdeVxGsq3YLsSZYuHVJklRk0I4pHpvTWXMR8VDga8DxmTk2+fnMPAM4A2D16tXZ29s7jzLnp6+vj0aOV6t61HXmLVewx9hGensPm3G73dbez2lX/IyHP/Zx9O63vPC6imBdtVuINcHCrUuSpCJbR9YC+0y4vzewrtYXR0QPcC7wnsz8RZ1r0wwGhkqznggJto5IkiTNpMigfTnwqIhYGRGLgKOBc2p5YWX77wJfzcxvF1ijpjAwXJr10n4w8WRIg7YkSdJkhQXtzBwB3gz8CLge+FZmXhcRp0bECwAi4uCIWAu8FPhcRFxXeflRwGHACRFxdeXnwKJq1db6a5zRXtrljLYkSdJ0iuzRJjPPA86b9Nh7J9y+nHJLyeTXnQmcWWRtml6tQbu9LVja1WHQliRJmoIrQ2orpdExNm4erSloQ3l1SFtHJEmSHsigra0M1LhYTdWy7k5ntCVJkqZg0NZWxpdfX1LbjLZBW9JsIuKLEXFXRPx6wmO7RcRPIuJ3ld+7NrNGSSqCQVtbGQ/aNbaOLOvuZGDYoC1pRl8GDp/02MnATzPzUcBPK/claYdi0NZWBoZHgLkFbWe0Jc0kMy8C7p308JHAVyq3vwK8sKFFSVIDFHrVEW1/+sd7tGsM2ksM2pLmZXlm3gGQmXdExB7TbRgRJwInAixfvpy+vr45DXTSqvIEwvLuLbeLMtfa5mJwcLDQ/RfN+pvL+pvDoK2tzLV1pKerg+HSGJtGRlnc0V5kaZJaVGaeAZwBsHr16uzt7Z3T6084+VygHLJPv7bYP3trjustbN99fX3M9b0vJNbfXNbfHLaOaCvjVx2ZQ+sIuGiNpDm7MyIeClD5fVeT65GkujNoaysDQyUWd7TR1Vnb7HTP+DLsxX4dK2mHcw5wfOX28cD3mliLJBXCoK2t9A+Vap7NBme0Jc0uIr4BXAI8JiLWRsRrgA8Bz46I3wHPrtyXpB2KPdraSq3Lr1ctG5/RNmhLmlpmHjPNU89saCGS1GDOaGsrcw3aPc5oS5IkTcmgra0MDM9vRtugLUmStDWDtrbSP1Sip6v2jiJbRyRJkqZm0NZW+jfObUa7s72NJYvandGWJEmaxKCtcWNjyfpNI3MK2uAy7JIkSVMxaGvc+k0jZNa+WE1VT5dBW5IkaTKDtsbNdVXIKme0JUmSHsigrXHVsDzX1pGe7k4Ghl0ZUpIkaSKDtsbNN2gv6+70qiOSJEmTGLQ1bmAbgratI5IkSVszaGtc/zx7tHu6OxjcNMLI6FgRZUmSJG2XDNoaty2tI4B92pIkSRMYtDWuf6hEe1uw06L2Ob3O1SElSZIeyKCtcQPD5eXXI2KMcC1bAAAgAElEQVROr6sGbfu0JUmStjBoa1z/0NxXhQSDtiRJ0lQM2hrXP1SaV9DuMWhLkiQ9gEFb4/qHSnO+4gg4oy1JkjQVg7bGrTdoS5Ik1Y1BW+Pm2zrS1dnOoo42BoYN2pIkSVUGbQGQmfMO2uAy7JIkSZPNKWhHxE4RMbeLLGu7sHHzKCNjuU1B29YRSZKkLWYM2hHRFhHHRsS5EXEXcANwR0RcFxGnRcSjGlOmilZt++jpml/Q7unqMGhLkiRNMNuM9gXAI4B3Aw/JzH0ycw/gqcAvgA9FxMsLrlENMN/l16uc0ZYkSdpaxyzPPyszH5CeMvNe4DvAdyJifslMC0r/xm0P2r+/e0M9S5IkSdquzTijXQ3ZEfGIiFhcud0bEW+NiF0mbqPtmzPakiRJ9VXryZDfAUYj4pHAF4CVwNcLq0oNNzA8AkBP92xfckxtWXcnA8MlxsaynmVJkiRtt2oN2mOZOQK8CPhEZr4deGhxZanRtnVGu6e7k0xYv2mknmVJkiRtt2oN2qWIOAY4HvhB5TF7s3cg1aC9dL5XHakEdK+lLUmSVFZr0H4VcCjwL5n5h4hYCZxZXFlqtIGhEku7Omhvi3m93mXYJUmStlZTQ25m/gZ464T7fwA+VFRRaryBodK8r6ENW4K2M9qSJEllNc1oR8TzI+KXEXFvRAxExPqIGCi6ODXOtiy/Ds5oS5IkTVbrJSY+Afw1cG1melmJHdC2Bu0eg7YkSdJWau3Rvg34tSF7xzUw7Iy2JElSPdU6o/0u4LyIuBDYVH0wMz9WSFVquP6h0ryvoQ2w06J22tuCgWGDtiRJEtQ+o/0vwEagC1g64WdGEXF4RNwYETdFxMlTPH9YRFwVESMR8ZJJzx0fEb+r/BxfY52ap21tHYkIV4eUJEmaoNYpzN0y8zlz2XFEtAOfAZ4NrAUuj4hzKlcwqboVOAH4u0mv3Q34Z2A1kMCVldfeN5caVJtNI6MMl8a2KWhDdRl2F6yRVLuIeDvwWsrH+muBV2XmcHOrkqT6qHVG+38jYk5BGzgEuCkzb87MzcA3gSMnbpCZazLzGmBs0mv/EvhJZt5bCdc/AQ6f4/iq0UAlHG9r0O7p6nBGW1LNImIvypeOXZ2ZjwPagaObW5Uk1U+tM9p/A7wrIjYBJSCAzMyeGV6zF+WTKKvWAk+qcbypXrvX5I0i4kTgRIDly5fT19dX4+633eDgYEPHq9V86lo3WP53zto/3ETfpjXzHnt0aJi163PK8Xekz6sRFmJdC7EmWLh1qWYdQHdElIAlwLom1yNJdVPrgjWz9mNPYaolBmu9aklNr83MM4AzAFavXp29vb01F7et+vr6aOR4tZpPXVfech9c/HOefNDj6X3MHvMe++x1V/GbdQNTjr8jfV6NsBDrWog1wcKtS7PLzNsj4qOU2wiHgB9n5o8nb7etkyonrSp/a7e8e8vtohT5j77t/R+V1t9c1t8cMwbtiFiRmWtmeD6AvTJz7RRPrwX2mXB/b2qfqVgL9E56bV+Nr9UcVVdzrE+Ptq0jkmoTEbtSbilcCdwPfDsiXp6ZZ07cblsnVU44+VygHLJPv3b+V1eqxZrjegvb9/b+j0rrby7rb47ZerRPi4jvRMQrI2L/iNgjIvaNiGdExPuBnwF/Ns1rLwceFRErI2IR5b67c2qs60fAcyJi18qB+DmVx1SA6iX56hW0vdy6pBo9C/hDZt6dmSXgv4A/b3JNklQ3M/7TPjNfGhH7AccBrwYeSvkyf9cD5wH/Mt3Z4Zk5EhFvphyQ24EvZuZ1EXEqcEVmnhMRBwPfBXYFjoiI92Xm/pl5byXIX17Z3amZee+2v11NpToL3dO1jSdDdncyMpZs3DzKTouLnTWStEO4FXhyRCyh3DryTOCK5pYkSfUzaxqqXI7vH+ez88w8j3Ign/jYeyfcvpxyW8hUr/0i8MX5jKu56d9YvxltKAd3g7ak2WTmpRFxNnAVMAL8kkqLiCTtCExDon+oRHdnO4s6ar3a49SqQXtguMSedNejNEk7uMz8Z8rrJkjSDmfbkpV2CAPD27b8etX4jPZGT4iUJEkyaGubl1+vmtg6IkmS1OpqnsasrOD1sImvycyLiihKjVWvoF09mdKgLUmSVGPQjogPAy8DfgOMVh5OwKC9A+gfGmGvXbq2eT/OaEuSJG1R64z2C4HHZOamIotRcwwMlfizh8xn8c+tLe3qIGLLAjiSJEmtrNYe7ZuBbe8t0II0MFSipw6tI21twdLFHQwMF7vEsSRJ0vag1hntjcDVEfFTYHxWOzPfWkhVapjRsWT9ppG69GgDLFviMuySJElQe9A+h9qXT9d2pNrmUbeg3W3QliRJghqDdmZ+JSIWAY+uPHRjZpqmdgADw5Xl1+sUtHu6DNqSJElQY492RPQCvwM+A3wW+G1EHFZgXWqQfme0JUmSClFr68jpwHMy80aAiHg08A3goKIKU2MUEbS96ogkSVLtVx3prIZsgMz8LV6FZIfgjLYkSVIxap3RviIivgB8rXL/OODKYkpSIw0MlS/F19Nd8yKhM+rp7mTTyBjDpVG6Otvrsk9JkqTtUa3p6o3A3wBvBYLyipCfLaooNU69Z7SrJ1UODJUM2pIkqaXVetWRTcDHKj/agfQPlehsD7rrFIonLsO+R8+2L+suSZK0vZoxaEfEtzLzqIi4FsjJz2fm4wurTA3RP1RiWXcnEVGX/VWDdvWygZIkSa1qthntt1V+P7/oQtQcA8Mlerrqd17rxBltSZKkVjbjVUcy847KzTdl5i0Tf4A3FV+eijYwVKrbYjVg0JYkSaqq9fJ+z57isefWsxA1R7V1pF56uspfkvRvNGhLkqTWNluP9hspz1w/PCKumfDUUuBnRRamxugfKrFi953qtr+e8RntkbrtU5IkaXs0W4/214H/Af4VOHnC4+sz897CqlLDlFtH6nMNbYDO9jZ2WtTuyZCSJKnlzZiwMrMf6AeOAYiIPYAuYOeI2Dkzby2+RBUlMxkYHqlr6wi4OqQkSRLU2KMdEUdExO+APwAXAmsoz3RrOza4aYTRsax70O4xaEuSJNV8MuQHgCcDv83MlcAzsUd7u1fvVSGrDNqSJEm1B+1SZt4DtEVEW2ZeABxYYF1qgIHKCYv1vI42lIP7gEFbkiS1uFrPgrs/InYGLgLOioi7AC8rsZ0rakZ7WXcn1xm0JUlSi6t1RvtIYCPwduCHwO+BI4oqSo1RDdr1XLAGPBlSkiQJapjRjoh24HuZ+SxgDPhK4VWpIQYKnNHesHmU0ugYne21/ltOkiRpxzJrCsrMUWBjRCxrQD1qoOq1rus9o11dHdI+bUmS1Mpq7dEeBq6NiJ8AG6oPZuZbC6lKDdE/VCICli6u34I1AMuWVFeHLLH7zovrum9JkqTtRa0J69zKj3Yg/UMlero6aWuLuu53WfeWoC1JktSqagramWlf9g6o3suvV1WD9sCwF6aRJEmtq6aUFRF/AHLy45n58LpXpIbpHyrV/URIcEZbkiQJam8dWT3hdhfwUmC3+pejRioqaPcYtCVJkmq7jnZm3jPh5/bM/ATwjIJrU8EKC9qVlSa96ogkSWpltbaOPHHC3TbKM9xLC6lIDTMwPFL35dcBujrbWdzR5oy2pFlFxC7AfwCPo9yi+OrMvKS5VUlSfdTaOnL6hNsjwBrgqLpXo4YqakYbyn3azmhLqsEngR9m5ksiYhGwpNkFSVK91HrVkacXXYgaa7g0yuaRsbovVlPlMuySZhMRPcBhwAkAmbkZ2NzMmiSpnmYM2hHxjpmez8yP1bccNUp/QcuvVxm0JdXg4cDdwJci4gDgSuBtmblh5pdJ0vZhthntah/2Y4CDgXMq948ALiqqKBWv2tZR1Ix2T3cndw4MF7JvSTuMDuCJwFsy89KI+CRwMvBPEzeKiBOBEwGWL19OX1/fnAY5aVX5mv7Lu7fcLspca5uLwcHBQvdfNOtvLutvjhmDdma+DyAifgw8MTPXV+6fAny78OpUmEbMaP/2zvWF7FvSDmMtsDYzL63cP5ty0N5KZp4BnAGwevXq7O3tndMgJ5xcXtj4pFUjnH5t/RfpmmjNcb2F7buvr4+5vveFxPqby/qbo6bL+wH7snXf3GZgRd2rUcM0Imh7MqSkmWTmH4HbIuIxlYeeCfymiSVJUl3V+k/7rwGXRcR3KV9+6UWAy7Jvx4oO2j3dnazfNMLYWNLWFoWMIWmH8BbgrMoVR24GXtXkeiSpbmq96si/RMT/AE+tPPSqzPxlcWWpaOM92l3FfI26rLuTTFg/PMKyJcWEeUnbv8y8mq1XH5akHUatrSNk5lWZ+cnKT00hOyIOj4gbI+KmiHhA311ELI6I/6w8f2lErKg83hkRX4mIayPi+oh4d611qjb9Q+UTggo7GbIS4L3yiCRJalU1B+25ioh24DPAc4H9gGMiYr9Jm70GuC8zHwl8HPhw5fGXAoszcxVwEPD6aghXffQPldhpUTud7cX8L1BtSTFoS5KkVlVY0AYOAW7KzJsrixB8Ezhy0jZHsqXX+2zgmRERlPvAd4qIDqCb8smXAwXW2nKKXBUStgTtgWGDtiRJak1FXudoL+C2CffXAk+abpvMHImIfmB3yqH7SOAOysvxvj0z7508wLZeW3VbLNTrOdZa181rh2kbHSvsPdy2fgyAn19xNaW1Hdv959VoC7GuhVgTLNy6JEkqMmhPdamJrHGbQ4BRYE9gV+D/IuJ/M/PmrTbcxmurbouFej3HWuv67I2XsOdO0Nt7aCF13NE/xD/97Hz2fvij6T1k3+3+82q0hVjXQqwJFm5dkiQV2TqyFthnwv29gXXTbVNpE1kG3AscC/wwM0uZeRfwMzwrva4GCm4d6emyR1uSJLW2IoP25cCjImJl5fqoR7NlCfeqc4DjK7dfApyfmQncCjwjynYCngzcUGCtLafoHu0li9rpaAuDtiRJalmFBe3MHAHeDPwIuB74VmZeFxGnRsQLKpt9Adg9Im4C3sGWpXc/A+wM/JpyYP9SZl5TVK2taGCoND7rXISIcHVISZLU0ors0SYzzwPOm/TYeyfcHqZ8Kb/Jrxuc6nHVR2l0jA2bRwud0YbylUec0ZYkSa2qyNYRLVAD48uvF/rvLHoM2pIkqYUZtFtQNfwWvTR6j60jkiSphRm0W9DAcGX59QJ7tMHWEUmS1NoM2i1ofEa78B7tDoO2JElqWQbtFtS4oN3JwPAI5Ss2SpIktRaDdguqBu2eBgTt0bFkw+bRQseRJElaiAzaLWiggTPa4OqQkiSpNRm0W9DAUIlFHW10dbYXOs74MuwbDdqSJKn1GLRbUNHLr1c5oy1JklqZQbsF9Q+V6OkqdrEa2NIDPjBs0JYkSa3HoN2CBoad0ZYkSSqaQbsFNax1pLLypKtDSpKkVmTQbkGNCto7L+ogwhltSZLUmgzaLah/Y6nwa2gDtLUFPV0uwy5JklqTQbvFjI0l6zeNNGRGGyqrQxq0JUlSCzJot5j1m0bILH6xmqpl3c5oS5Kk1mTQbjEDDVp+vcqgLUmSWpVBu8VUQ2911cai9XR3GLQlSVJLMmi3mOqMdmNbR0YaMpYkSdJCYtBuMf0NDto93Z2uDClJklqSQbvFjAftJY2b0d48Msbm0WzIeJIkSQuFQbvFVGeXe7o6GjJedeZ8Q8mgLUmSWotBu8X0D5Vobwt2XtyYoF096XKj3SOSJKnFGLRbTP9QiZ6uDiKiIeONz2iPOKMtSZJai0G7xfQPNW5VSNgStDfaOiJJklqMQbvFDAyVGrZYDdijLUmSWpdBu8X0D5WaNKPdsCElSZIWBIN2i2n0jPbSytVN7NGWNJ2IaI+IX0bED5pdiyTVk0G7xTR6RrujvY2dF3fYOiJpJm8Drm92EZJUbwbtFpKZDAyXxi+51yjLujttHZE0pYjYG3ge8B/NrkWS6q0xF1PWgjBUGqU0mg2d0YbyMuwbRzY3dExJ241PAO8Clk63QUScCJwIsHz5cvr6+uY0wEmrRgBY3r3ldlHmWttcDA4OFrr/oll/c1l/cxi0W8j48usNDtrLuju49z5bRyRtLSKeD9yVmVdGRO9022XmGcAZAKtXr87e3mk3ndIJJ58LlEP26dcW+2dvzXG9he27r6+Pub73hcT6m8v6m8PWkRbSrKDd09XpdbQlTeUvgBdExBrgm8AzIuLM5pYkSfVj0G4hA0Plr0x7uhv7Rcay7k422KMtaZLMfHdm7p2ZK4CjgfMz8+VNLkuS6sag3UKa1zrS6eX9JElSy7FHu4U0M2hvHoXNI2Ms6vDfdpIeKDP7gL4mlyFJdWXqaSHVoN3wy/stKY83MGz/iCRJah0G7RYyUA3aTZjRhi1BX5IkqRUYtFtI/1CJpYs7aG+Lho5bnUE3aEuSpFZi0G4hA0Olhs9mw5YZdIO2JElqJQbtFtLfpKBdbR0ZMGhLkqQWYtBuIQPDJZY1+BraYNCWJEmtyaDdQvqHSg2/tB9sWSDH1hFJktRKDNotpFlBe3FHO4vaDNqSJKm1FBq0I+LwiLgxIm6KiJOneH5xRPxn5flLI2LFhOceHxGXRMR1EXFtRHQVWWsr6B8qNfwa2lVLOsOgLUmSWkphQTsi2oHPAM8F9gOOiYj9Jm32GuC+zHwk8HHgw5XXdgBnAm/IzP2BXsCUtg02jYwyXBpryow2wE6dMDA00pSxJUmSmqHIGe1DgJsy8+bM3Ax8Ezhy0jZHAl+p3D4beGZEBPAc4JrM/BVAZt6TmaMF1rrDq4bc6iqNjbaTM9qSJKnFFBm09wJum3B/beWxKbfJzBGgH9gdeDSQEfGjiLgqIt5VYJ0toRpymzWjvaTDoC1JklpLkdd6m2r5waxxmw7gKcDBwEbgpxFxZWb+dKsXR5wInAiwfPly+vr6trXmmg0ODjZ0vFpNV9dN95W/EFjzu+vpu/93Da4KFjHCbfetX3Cf2fb237GZFmJNsHDrkiSpyKC9Fthnwv29gXXTbLO20pe9DLi38viFmfkngIg4D3gisFXQzswzgDMAVq9enb29vfV/F9Po6+ujkePVarq68sa74NLLecohB3HQw3ZteF1nXf8jNg+w4D6z7e2/YzMtxJpg4dYlSVKRrSOXA4+KiJURsQg4Gjhn0jbnAMdXbr8EOD8zE/gR8PiIWFIJ4E8DflNgrTu8gQXQOrJ+0wijY5O/1JAkSdoxFTajnZkjEfFmyqG5HfhiZl4XEacCV2TmOcAXgK9FxE2UZ7KPrrz2voj4GOWwnsB5mXluUbW2gmb3aO/UWe4SWj9cYpcli5pSgyRJUiMVuh53Zp4HnDfpsfdOuD0MvHSa155J+RJ/qoP+jeWg3dOEJdihfHk/KAd+g7YkSWoFrgzZIgaGS3R1trG4o70p4y+pzGh75RFJktQqDNotolnLr1ct6TBoS5Kk1mLQbhHNDtrVHm1Xh5QkSa3CoN0i+odK9HQ1M2hvqUOSJKkVGLRbxMDQSHNbR+zRliRJLcag3SKa3TqyqA06212GXZIktQ6DdosYGCrR08SgHREs6+40aEuSpJZh0G4Bo2PJ+k0jTQ3aAD3dneMrVEqSJO3oDNotYP1wc1eFrFrW3cnAsEFbkiS1BoN2C2j28utVto5IkqRWYtBuAdVw29PVnOXXqwzakiSplRi0W0B1kZhmz2j3dBm0JUlS6zBot4Dx1pElzW8dGRgqMTaWTa1DkiSpEQzaLWAh9WiPJWzY7DLskiRpx2fQbgFberSbH7TB1SElSVJrMGi3gIHhEh1twZJF7U2to8egLUmSWohBuwVUl1+PiKbW0dPdMV6PJEnSjs6g3QKqQbvZqjW4OqQkSWoFBu0WMDBUYumCCtqeDCkJImKfiLggIq6PiOsi4m3NrkmS6qm5K5ioIQaGSixbsqjZZXgypKTJRoCTMvOqiFgKXBkRP8nM3zS7MEmqB2e0W8BCaR3ZeXEHbWHQllSWmXdk5lWV2+uB64G9mluVJNWPM9otoBy0m/+fOiLocRl2SVOIiBXAE4BLp3juROBEgOXLl9PX1zenfZ+0qtyutrx7y+2izLW2uRgcHCx0/0Wz/uay/uZofvpSoTKTgeGRpl9Du2qZQVvSJBGxM/Ad4G8zc2Dy85l5BnAGwOrVq7O3t3dO+z/h5HOBcsg+/dpi/+ytOa63sH339fUx1/e+kFh/c1l/c9g6soPbsHmU0bFcEK0jUFmGfdigLaksIjoph+yzMvO/ml2PJNWTQXuB2TwyxoW/vZuR0bG67G+hLL9e5Yy2pKooX9z/C8D1mfmxZtcjSfVm0F5ANo+M8aazruL4L17Gm7/+SzaPbHvY7t+4sIK2PdqSJvgL4BXAMyLi6srPXzW7KEmqF4P2ArFpZJQ3nnkl/3v9nfzVqofww+v+yOu/dgXDpdFt2m811PYslKDd1emCNZIAyMyLMzMy8/GZeWDl57xm1yVJ9WLQXgCGS6O84WtX8tMb7uL9L3wcnz3uID74olX0/fZuXvOVy9m4ef5nyVf7oRfKjHa1dSQzm12KJElSoQzaTTZcGuX1X7uSC268mw++aBWvePLDADj2Sfvy0ZccwCW/v4cTvng56+d5AuFC7NEujSbDpfr0oA+XRrl/4+a67EuSJKmeDNpNNFwa5XVfvYILf3s3H/rrVRz7pH23ev7FB+3Nvx3zRK669T5e/oXLxvut52JggbWO1HN1yJ///k8862MXcui/ns9n+25i08i2tdlIkiTVk0G7SYY2l0P2xTf9iY+8+PEcfci+U273vMc/lP/38oO4ft0Ax3z+F9wzuGlO4/QPlYiApYsXxiXT6xG0N24e4ZRzruPYz19KZ3sbf/HIB/GRH97I4Z/4P/puvKtepUqSJG0Tg3YTDG0e5bVfvXw8ZB918D4zbv/s/Zbz+eNX8/u7Bzn6jF9w18BwzWMNDJVYuriDtrbY1rLroqeyQuV8g/aVt9zLX33y//jyz9dwwp+v4Ly3PpX/OH41X3n1IQRwwpcu53VfvYLb7t1Yx6olSZLmrmWD9uhY8o7/vJpf3HxPQ8fduHmEV3/5cn7++3v46EsO4KWrZw7ZVU979IP58qsO4fb7hzjqc5ew7v6hml7XP1Ri2ZKF0TYC85/RHi6N8q/nXc9L/v0SRsaSb7zuyZzygv3pXtQOlD+fH/7tYfz94Y/lZzeVW0o+/pPfbvNVWyRJkuarZYP2uvuHuPQP93L0Gb/gb866irX3FT8DunHzCK/60uVc+od7+NhRB/Dig/ae0+sPfcTufO01T+Kewc0c9blLuPWe2WvuHyotmBMhYX5B+5q193PEv13M5y66maMP3pcf/u1hHPqI3R+w3aKONt7Y+wh+etLTeM7+D+GTP/0dz/rYhfz4uj96lRNJktRwLRu099ltCf/7jqfx9mc9mp/ecCfPPP1CPvbjG7fpUnoz2bBphBO+dDmXr7mXj7/sQF70hLmF7KqDHrYrX3/dkxncNMJRn7uE3989OOP2/UMleroWXtCu5Vram0fG+NiPb+RFn/0564dH+MqrD+Ff/3oVO8/Sb/7QZd382zFP4BuvezJLFrVz4teu5IQvXc4f/rShLu9BkiSpFi0btAG6F7Xztmc9ivNP6uUv938Inzr/Jp55+oV87+rb6zoDOrhphBO+dBlX3nIfnzz6CRx54F7btL9Vey/jmyc+mZGxMV72uUu44Y8D0247MDyyoGa0l3bVNqN9/R0DvPAzP+NT59/ECw/cix+9/TCe9ugHz2msQx+xO+e+9an80/P346pb7uMvP34RH/nhDYX9Y0qSJGmilg7aVXvu0s2njnkC337Doey20yLe9s2reem/X8K1a/u3ed/rh0sc/8XLuOrW+/nU0U/giAP2rEPF8NiH9PDNEw+lvS04+oxf8Ovbp651obWOtLcFS7s6pg3aI6NjfOaCm3jBpy/mrvWb+PwrV3P6UQfM+z10trfxmqes5Kd/9zSOOGBPPtv3e555+oX84Jp1tpNIkqRCGbQnOHjFbpzz5qfw4RevYs09G3jBZy7m78++hrvXz+2SelUDlZD9q9vu59PHPIHnPf6hda33kXvszLdefyg7LergmM//gqtuve8B2yy0oA3TL8N+013refG/X8JpP7qRv9z/Ifz47Yfx7P2W12XMPZZ2cfpRB3D2Gw5l1yWLePPXf8mxn7+U29fXZ+EcSZKkyQzak7S3BS87eF/O/7teXvuUlXznqrU8/aN9nHHR79k8UnsoGxgu8covXMY1a/v59LFP5Lmr6huyqx62+0586w2HsvtOi3jFf1zKDfduucrGcGmUzSNjC2axmqrqMuxVo2PJ5y+6mb/61MXces8GPn3sE/j0sU9kt50W1X3s1St24/tveQrvf+Hj+M0dA7z350N84Ae/mffKm5IkSdMxaE+jp6uTf3zefvzo7YdxyMrd+OB5N/CXn7iI82+4c9aWg/6hEq/4wmVct66fzx73RA5/3EMKrXWvXbr51usPZc9duvnYFcNc9Nu7gYW3KuT/b+/O46Sq7ryPf77dDQ1Nr7I00M1qkEVsVhF3FEchcRCNmWiMisbxifOYxKh5dEaTqJksOo5GH/OMw4yOGpO4gygaRQVmVFzY933tBlmlsUEQ5Pf8cU9j0XZDL7UBv/frVa++de6tW9+6dfvWqVvnnlOtoGUzdoSK7ZqtO7ls7DR+/doizurRljd+ehYXlsWneU1dMjPElUO7MPnWYZxZksVj763inPun8tLM8qO6Ocn7K7bw909N5+bnZvP0B2tYtGEHX+5P7ev9/Isvmb56G89NX1evXnScc865I0l6DBeYxo5vm8vjY05m8pJN/OrVhVz7xHTOPqEtF7Sr/ex25a69XPn4hyzasIN/u2IQ58Wp6cPhtMtvwTPXD2X0Q+9w3ZPT+X9XDKRL6xyAtGs6UtCyGSs2V/HHaav5zWuLycoU//qdflwysM0NN0AAABgPSURBVAQpeQPrHNeqOWP6ZvPTi07hFxMWcPNzc/jt64vpWNiS9vnZtM9vQXFBC9rntzhoulWajLJZXx+t2sYDk5bwwcpttMnNBoyXZlYAkJudxYDOhQzsXMSgLkX071yYsF5q9n65nyWffMac8u3MXVfJnPLtLNtUdVBlf1CXIkYPKOHCkzpQlIBfNJxzzrlkOrJqDCl0Ts92nH58G56atpqH3lrGu8v2sdwW8pPzehyoyG7f9QXff+xDln5SxaPfH8Tw3smpZFdrnZvN7UNaMHZpc3749AyuPq0rAPkt0uttLmjZjGWbqvj5yws4s0cb7ru0jA4FLVOWp1+nQsbdcBrjZlUwbeVWNu7YzcrNO3l/+VY+2/P1HkrysrMOVLqL81vQviD7wHSHgpYUF2TTplV2ykfjnLHmUx6ctJR3l2+hTW42v/zbPlw+pDPZWRms2/Y5M9ZuY8aaT5mxZjv/951l7DeQoGdxHgNCxXtQlyK6ts5p8Beg/fuNlVuqmLOukrnl25lTXsnCDTsONL8qzGlGWWkhf9OnmLLSQjod15LJizczblY5Px8/n3teWcDZJ7TjkoElnNurHS2aZSZiEznnnHMJlV41sDTXPCuD687szugBJdzyxBT+6/1VjJ9dwa3n9+SCE4u58rGPWL6pin+/chDn9GqXkoytmomnfzCEa5/4mMfeXQWk3xntHsW55DTP5M5v9eHyIZ2Seha7LhkZ4tuDSr82iNDOPfv4ZMduNlbu5pMdu2tM72H58i1srtrztSYYWRnipNICRvcv4cKyDrTOzU7aa5m9bjsPTlrK1KWbad2qOXd+qzdXnNLlwCiaAJ1b59C5dc6B/tw/272XOesqo4r32k95dc56/vLRWiA68z+wcxFFX35BTpdtlJUWHFTxNTPKP/2cueXVlertzK/YQVX4kpLTPJO+JQVcfWoXykoL6Rcq1jXf917t8/nh2d1ZtOEzxs0q5+XZ63lr0UbysrP45kkdGD2ghFO6HZfyLzDOOedcfXlFuxHa5GZzTd9sfnbxUO55ZSH/NG4ed72yAICxVw1iWM/UVLKr5bVoxpPXDuG6J6fz/oqtoblA+rj29G5cc3o3Mo+AClOr7CyOb5vL8W1z61zmy/3Glqo9fBIq4Bt37Gb99t1MWbKJX05YwD2vLuSsHm0YPaCE8/u0P6jCG0/zKyp5cNJS3l68iaKcZtw+shdXndqFnOaH/zfPa9GMM3q04YwebYDojPTyzVXhjPenzFzzKSu37OX5pdPIyhAndsynb0kBFds/Z155JVt3fgFA88wMenfI4+IBJZSVFtCvUyHHt82t93stiT4d8+nTsQ+3j+zNtBVbGTerglfnrufZ6evoUNCCi/qXcPGAEnq2z2v8xnLOOeeSwCvaTdC3pIBn/9dQJs7bwJPvr+ZH5/bgrAYOqpIoOc2z+K9rTmZ+xQ46HZeT6jgHOdrOSGZmiOLQdKRfTPntI3uxaMMOxs+uYMLs9fzkmdnkNM9kxIntGT2ghNOOb01WZtOvR160YQe/f2spbyzYSEHLZvzsgp5cfVrXw46geSgZGeKE4jxOKM7j8iGdAZjw5mRySvswY21U+X559npKCltybq92lHUqpF9pAT3b55GdFZ8vEpkZOlD5/+fRfZm0aCPjZ1XwH/+zkkenrqB3h3wuGVBCm93eRaNzzh1tut4+8aD7t5y0jzE1yuJl9e++lZD1QoIr2pJGAA8BmcB/mtnvaszPBp4CBgFbge+a2eqY+Z2BhcBdZnZ/IrM2liQuLOuY8J4yGiM7K5NBXYpSHeOY1rtDPr075HPbBb34aPU2xs+qYOK8Dbw0q4I2udmM6teR0QM6clJJQYOb0Czd+BkPvbWMifM2kJedxU3n9eDaM7ol7GLG/OZiWJ/ipF3gG6tl80xG9evIqH4d2VK1h1fnrGfc7PX8+rVFCHix/ENGDyhhRN/2TfqC4ZxzzsVTwj6RJGUCfwD+BigHPpY0wcwWxiz2A+BTM/uGpMuAe4Hvxsx/EHg9URmdS5aMDDG0e2uGdm/NXaNOZMqSTYybVcHTH6zh8fdW0b1tK0b3L2F0/xI6tz70LxArNlfx0FvLeGXuenKaZfKjc7/BdWd0pyAnvdriJ0qb3GzGnN6NMad3Y+XmKh4a/z6ztu3i1ufncOf4eQzvVczJXYs4qbSQEzvm+4WUzjnnUiaRp36GAMvNbCWApGeAi4jOUFe7CLgrTL8APCJJZmaSRgMrgZ0JzOhc0rVolsmIvh0Y0bcDlbv28tr8DYyfVcEDk5bywKSlDOxcyIm5eynb+cVBg/as3rKTh99exvjZFWRnZfLDs4/n78/snpCBfY4U3dvmcnGP5vz+7LOZuXY742dV8MaCT5g4bwMQNT/p0S6XfqWFnFRaQFmcm7c455xzh5LIinYJsC7mfjlwSl3LmNk+SZVAa0mfA7cRnQ2/ta4nkHQ9cD1AcXExU6ZMiVv4w6mqqkrq89WX52qYdMjVAbihJ/xd55Z8sGEf09ZXMnOt8edFk+jbJpMh7TNZvG0/763fR5bg/C7N+Ga3ZuRnf8Lcjz9JWs502Fa1qaqqYurUqQAML4RzT8tk+56WrKrcz6od+1lduYuJcz7j2enR4ShT0Ckvg64FGXTLz6BbQQYdczPIOsquHXDOOZd6iaxo1/apVXMYurqWuRt40MyqDtVu1czGAmMBBg8ebMOGDWtc0kaYMmUKyXy++vJcDZNuub4d/v7xlXcoz+rAy7PW8x/zdtM8K4OrT+vKDcOOp11ei5RkS7dtVa0+uczsQA8pc8ormVexnRnllUxZF/WWkp2VQZ+O+ZSVFHBSaSFlpQUN6i3FOeecq00iK9rlQKeY+6XA+jqWKZeUBRQA24jOfF8q6T6gENgvabeZPZLAvM6ljU55GVw5rDe3XdCLOeXb6VjYkuL81FSwjwaSKC3KobQoh5EndQCiyvearbuYW1HJvPLtzC2v5IUZ5Tw5bQ0Q9f99Ysd8Hr58QEoHVHLOOXfkSmRF+2Ogh6RuQAVwGfC9GstMAK4GpgGXAu+YmQFnVi8g6S6gyivZ7liUkSEGdPaeYxJBEl3btKJrm1aM6hf1GvTlfmPVlqow+E4lC9ZXUpRz7LaBd8451zQJq2iHNtc3Am8Qde/3uJktkHQPMN3MJgCPAX+UtJzoTPZlicrjnHOHk5khvtEuj2+0y+OSgaWHf4Bzzjl3CAntcNbMXgNeq1H2i5jp3cB3DrOOuxISzjnnnHPOuQRq+rB0zjnnnHPOua/xirZzzjnnnHMJ4BVt55xzzjnnEsAr2s4555xzziWAV7Sdc84555xLAK9oO+ecc845lwBe0XbOOeeccy4BvKLtnHPOOedcAnhF2znnnHPOuQTwirZzzrmUkTRC0hJJyyXdnuo8zjkXT17Rds45lxKSMoE/ACOBPsDlkvqkNpVzzsWPV7Sdc86lyhBguZmtNLMvgGeAi1KcyTnn4kZmluoMcSFpM7AmiU/ZBtiSxOerL8/VMJ6r/tIxE6Rnri5m1jbVIdKdpEuBEWZ2Xbh/JXCKmd1YY7nrgevD3Z7AkkY+ZTruKw3h+VPL86dWuuWv13E+KxlJkiHZH2qSppvZ4GQ+Z314robxXPWXjpkgfXO5elEtZV87+2NmY4GxTX6yI3xf8fyp5flT60jN701HnHPOpUo50CnmfimwPkVZnHMu7ryi7ZxzLlU+BnpI6iapOXAZMCHFmZxzLm6OmqYjKdDknzETxHM1jOeqv3TMBOmbyx2Gme2TdCPwBpAJPG5mCxL4lEf6vuL5U8vzp9YRmf+ouRjSOeecc865dOJNR5xzzjnnnEsAr2g755xzzjmXAF7RjiGpp6TZMbcdkm6SdJykSZKWhb9FYXlJejgMHTxX0sCYdV0dll8m6eom5vqppAWS5kv6i6QW4eKhD8P6nw0XEiEpO9xfHuZ3jVnPP4byJZIuaEqmsL6fhEwLJN0UypK+rSQ9LmmTpPkxZXHLIWmQpHnhMQ9Lqq1Lsvrm+k7YXvslDa6xfK3vT11DVNe1DzQy179IWhy2yThJhWmS61ch02xJb0rqGMqT9j66I0Nd+2PM/DqPjWF+Z0lVkm5NVuYaz9/o/JLKJE0Lx5Z5klokM3vI0Kj8kppJejLkXiTpH5OdPeQ4XP6zJM2UtE9R/++x8+L2ed9Yjc0vqX/MvjNX0neTm/xAjkZv/zA/X1KFpEeSk7gBzMxvtdyILsz5BOgC3AfcHspvB+4N098EXifqC3Yo8GEoPw5YGf4WhemiRuYoAVYBLcP954Ax4e9loexR4IYw/Q/Ao2H6MuDZMN0HmANkA92AFUBmE7ZPX2A+kEN0Ue1bQI9UbCvgLGAgMD+mLG45gI+AU8NjXgdGNiFXb6IBN6YAg2PKa31/wm0F0B1oHpbpE7MvfG0faGSu84GsMH1vzPZKda78mOkf89W+nbT30W/pfzvU/hizTK3Hxpj5LwLPA7ceSfmJjr9zgX7hfmuacGxPQf7vAc+E6RxgNdA1DfN3BcqAp4BLY8rj9nmfovwnAD3CdEdgA1B4pOSPmf8Q8GfgkWRmr8/Nz2jXbTiwwszWEA0J/GQofxIYHaYvAp6yyAdAoaQOwAXAJDPbZmafApOAEU3IkgW0lJRFdCDaAJwLvFBHpuqsLwDDw5m7i4gOZnvMbBWwnGj448bqDXxgZrvMbB8wFbiYFGwrM/tvYFuN4rjkCPPyzWyaRf/NT8Wsq8G5zGyRmdU2ql1d70+tQ1SH97SufaAxud4M7yPAB0T9GadDrh0xd1vx1WAmSXsf3RGhPkO513VsRNJoogpSIns8OZSm5D8fmGtmcwDMbKuZfZmk3NWakt+AVuHzrSXwBbCD5DpsfjNbbWZzgf01Hhvvz/vGaHR+M1tqZsvC9HpgE5DsUW2bsv2RNAgoBt5MRtiG8op23S4D/hKmi81sA0D42y6UlwDrYh5THsrqKm8wM6sA7gfWElWwK4EZwPaYilHs+g88d5hfSXSGI26ZgvnAWZJaS8ohOsPYiRRuqxrilaMkTMc7X00NzdWauveBprqW6IxvWuSS9GtJ64ArgF80Mley3keXGvU5jtR6bJTUCrgNuDsJOevS6PxEZyRN0hvhp/X/k4S8NTUl/wvATqLPt7XA/WZW88RJojXlcyhRn2ENEZcMkoYQnVFeEadc9dXo/JIygH8FfpaAXHHhFe1aKGpTOoroZ8RDLlpLmR2ivDFZioi+2XUj+lmnFTDyEOtPeCaIzswSNTGYBPyV6KeefYd4SFJy1UNDcyQrX1rkknQH0fv4p3TJZWZ3mFmnkOnGdMnl0kp93t+6lrkbeNDMquKeqv6akj8LOIPoi+gZwMWShsc33mE1Jf8Q4Euiz7duwC2Susc33mE15fiQDseWJmcIv/r9EbjGzL521jjBmpL/H4DXzGzdYZdMEa9o124kMNPMNob7G8NOWL0zbgrldQ0fHM9hhc8DVpnZZjPbC7wEnEb0U3n1gEOx6z/w3GF+AdHP8XEf6tjMHjOzgWZ2VniOZaR2W8WKV45yvmpGEc98NTU01xbq3gcaJVzEcyFwRWhekRa5YvwZ+HYjcyXrfXSpUZ/jSF3HxlOA+yStBm4C/knRIDrJ1JT85cBUM9tiZruA14iudUimpuT/HvBXM9trZpuA94DBJFdTPocS9RnWEE3KICkfmAjcGZriJVtT8p8K3Bj+f+8HrpL0u/jGaxqvaNfucr5qNgLRkMDVVxJfDbwcU36VIkOBytBM4Q3gfElF4Yz0+aGsMdYCQyXlhPZsw4GFwGSg+srbmpmqs14KvBMqTROAy8KV392ILlz8qJGZAJDULvztDFxCtM1Sua1ixSVHmPeZpKFh+18Vs654quv9qXWI6vCe1rUPNJikEUQ/n48KH9bpkqtHzN1RwOKYXOn4PrrUqM9Q7rUeG83sTDPramZdgd8DvzGzZPdc0Oj8RPt8WfiMyALOJvqMSKam5F8LnBv+l1sRXdy8mOSqT/66JOozrCEanT8sP47ompfD/YqfKI3Ob2ZXmFnn8P97K9Hr+FqvJSllaXBFZjrdiC423AoUxJS1Bt4mOmP7NnBcKBfwB6L2TPM4uBeJa4kuHFtO9FNMUzLdTXTgmU/000420dW5H4X1Pw9kh2VbhPvLw/zuMeu5I2RdQhx6XAD+h+iAPgcYnqptRVTB3wDsJfpm/IN45iA6uzI/POYRwoiqjcx1cZjeA2wkqgQe8v0hav++NMy7I6a81n2gkbmWE7WRmx1uj6ZJrhfDtp8LvAKUJPt99NuRcattfwTuIfryCIc4Nsas4y5S0OtIU/MD3ye6kHM+cN+RlB/IDeULiD5Pfpam+U8Ox6WdRHWEBTGPjdvnfbLzh31nL18d+2cD/Y+U/DXWMYY07HXEh2B3zjnnnHMuAbzpiHPOOeeccwngFW3nnHPOOecSwCvazjnnnHPOJYBXtJ1zzjnnnEsAr2g75+pN0nckLZC0X1Kdfd1KWi1pnqTZkqbXmPcjSUvCeu4LZa0lTZZUJemRGss3lzRW0lJJiyV9O5TfLGmhpLmS3pbUJZR3kTQjPPcCST8M5TmSJoZ1LKhPX6uSekmaJmmPpFtjyjuFvIvCun7SkO3onHPu2JB1+EWcO/pIugkYawf3GV2fx40B3jSzo36wE0nDgDFmNiameD5Rn+n/Xo9VnGNmW2qs8xyikU7LzGxPdV/swG7g50DfcIt1B7DJzE5QNNzucaF8FlG3frsk3QDcB3yXqIvA08L6c4H5kiYA24mGd54c+mp9W9JIM3udum0DfgyMrlG+D7jFzGZKygNmSJpkZsnuv9g551wa8zPa7lh1E1Gf6fUmKZOon86OiQh0JDCzRWa2pAmruAH4nZntCevbFP7uNLN3iSrcNV0L/DYst7+68m5mk2O+KH1AGPnRzL6oXj9Rn/MZoXyXmU2uXgaYWf0YSW0lvSjp43A7vTqfmX1M1M9s7HbYYGYzw/RnwCKgpAnbxTnn3FHIK9ruqCepVWgyMEfSfEm/JKosT5Y0OSzzb5Kmh2YAd8c8drWkX0h6l2jE0MHAn0KzhJYpeUFHBgPeDE04ro8pPwE4U9KHkqZKOvlQK5FUGCZ/JWmmpOclFdey6A+A12Me10nSXKJBeO6t+QtEWO/fEg1mBPAQ8KCZnUw0zPt/1veFSuoKDAA+rO9jnHPOHRu86Yg7FowA1pvZtwAkFQDXcHDThjvMbFs4a/22pDIzmxvm7TazM8JjryMaOW46RylJHxKdCc4FjpM0O8y6zczqO7Tw6Wa2PjQNmSRpsZn9N9Exp4homOWTgeckdbe6R87KIjrr/J6Z3SzpZuB+4MqYvN8n+gJ0dnWZma0jGpa6IzBe0gtmtjEsn0U0CuXDZrYyPOQ8oI+k6lXkS8oLZ6vrFJqmvAjcZGY76rltnHPOHSP8jLY7FswDzpN0r6QzzayylmX+TtJMona/JwJ9YuY9m4yQ6cLMTjGz/sB1wAQz6x9u9a1kU30GOTQNGQcMCbPKgZcs8hGwH2hziFVtBXaFdUA0VPPA6pmSziNqwz0qprlIzRwLgDNjiscCy8zs9zFlGcCpMa+1pB6V7GZElew/mdlLh1rWOefcsckr2u6oZ2ZLgUFEFe7fSvpF7HxJ3YBbgeFmVgZMBFrELLIzWVmPBqGpTl71NHA+0UWUAOOBc8O8E4DmwJba1gMQznS/AgwLRcOBheHxA4guyhxV3dY7lJdWN+uRVAScDiwJ9/8ZKCBqox/rTeDGmHX0P8xrFPAYsMjMHjjUss45545dXtF2R73QfGCXmT1N1OxgIPAZkBcWySeqTFeG9r8jD7G62McdcyRdLKkcOBWYKOmNUN5R0mthsWLgXUlzgI+AiWb21zDvcaC7pPnAM8DV1c1GJK0GHgDGSCqXVP2rwm3AXaHN9ZXALaH8X4iatzwf2sxPCOW9gQ/D808l6mlknqRSorPffYCZ4THXhcf8GBgcugpcCFR3Cdg+vN6bgTtDrnyiyvuVwLlhPbMlfbPJG9g559xRRXU3jXTu6CDpAqJK2X6i3iNuIKoo/m9gg5mdI+kJ4BRgJbCHqMnEE6HyN7i6LbeiPpx/A3xO1NTg8yS/HOecc84dIbyi7ZxzzjnnXAJ40xHnnHPOOecSwCvazjnnnHPOJYBXtJ1zzjnnnEsAr2g755xzzjmXAF7Rds4555xzLgG8ou2cc84551wCeEXbOeecc865BPj/+hFHglSmYcMAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -107,11 +107,15 @@ "\n", "# Plot durations\n", "for obj, symbol in callback_symbols.items():\n", + " owner_info = data_util.get_callback_owner_info(obj)\n", + " if owner_info is None:\n", + " owner_info = '[unknown]'\n", + "\n", " duration_ns = data_util.get_callback_durations(obj)\n", " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", "\n", " fig = plt.figure(figsize=(12, 6))\n", - " fig.suptitle('TODO', fontsize=20)\n", + " fig.suptitle(owner_info, fontsize=20)\n", "\n", " ax = fig.add_subplot(1, 2, 1)\n", " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", From fcecda6cc6657aaec74faff591f6e84a199036cd Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 15:10:09 +0200 Subject: [PATCH 91/98] Remove debug code --- .../tracetools_analysis/analysis/data_model.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/data_model.py b/tracetools_analysis/tracetools_analysis/analysis/data_model.py index d3cefcf..d9814f1 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/data_model.py +++ b/tracetools_analysis/tracetools_analysis/analysis/data_model.py @@ -166,9 +166,3 @@ class DataModel(): print() print(f'Callback instances:\n{self.callback_instances.to_string()}') print('==================================================') - - timers_info = self.timers.merge(self.nodes, on='tid', right_index=True) - print(timers_info.to_string()) - print() - subscriptions_info = self.subscriptions.merge(self.nodes, left_on='node_handle', right_index=True) - print(subscriptions_info.to_string()) From 24ca3269a2e9dda1d0218194e7334d1a0198aa8f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Thu, 27 Jun 2019 15:12:55 +0200 Subject: [PATCH 92/98] Format --- .../tracetools_analysis/analysis/utils.py | 38 +++++++++++++------ 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py index e0d3a8c..adda780 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/utils.py +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -52,7 +52,9 @@ class DataModelUtil(): # Get their symbol return {obj: callback_symbols.loc[obj, 'symbol'] for obj in callback_objects} - def get_callback_durations(self, callback_obj: int) -> DataFrame: + def get_callback_durations( + self, callback_obj: int + ) -> DataFrame: """ Get durations of callback instances for a given callback object. @@ -64,7 +66,9 @@ class DataModelUtil(): : ] - def get_callback_owner_info(self, callback_obj: int) -> Union[str, None]: + def get_callback_owner_info( + self, callback_obj: int + ) -> Union[str, None]: """ Get information about the owner of a callback. @@ -104,7 +108,9 @@ class DataModelUtil(): info = f'{type_name} -- {self.format_info_dict(info)}' return info - def get_timer_handle_info(self, timer_handle: int) -> Union[Mapping[str, Any], None]: + def get_timer_handle_info( + self, timer_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about the owner of a timer. @@ -120,7 +126,9 @@ class DataModelUtil(): period_ms = period_ns / 1000000.0 return {'tid': tid, 'period': f'{period_ms:.0f} ms'} - def get_publisher_handle_info(self, publisher_handle: int) -> Union[Mapping[str, Any], None]: + def get_publisher_handle_info( + self, publisher_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about a publisher handle. @@ -129,14 +137,16 @@ class DataModelUtil(): """ if publisher_handle not in self._data.publishers.index: return None - + node_handle = self._data.publishers.loc[publisher_handle, 'node_handle'] node_handle_info = self.get_node_handle_info(node_handle) topic_name = self._data.publishers.loc[publisher_handle, 'topic_name'] publisher_info = {'topic': topic_name} return {**node_handle_info, **publisher_info} - def get_subscription_handle_info(self, subscription_handle: int) -> Union[Mapping[str, Any], None]: + def get_subscription_handle_info( + self, subscription_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about a subscription handle. @@ -156,7 +166,9 @@ class DataModelUtil(): subscription_info = {'topic': topic_name} return {**node_handle_info, **subscription_info} - def get_service_handle_info(self, service_handle: int) -> Union[Mapping[str, Any], None]: + def get_service_handle_info( + self, service_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about a service handle. @@ -165,14 +177,16 @@ class DataModelUtil(): """ if service_handle not in self._data.services: return None - + node_handle = self._data.services.loc[service_handle, 'node_handle'] node_handle_info = self.get_node_handle_info(node_handle) service_name = self._data.services.loc[service_handle, 'service_name'] service_info = {'service': service_name} return {**node_handle_info, **service_info} - def get_client_handle_info(self, client_handle: int) -> Union[Mapping[str, Any], None]: + def get_client_handle_info( + self, client_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about a client handle. @@ -181,14 +195,16 @@ class DataModelUtil(): """ if client_handle not in self._data.clients: return None - + node_handle = self._data.clients.loc[client_handle, 'node_handle'] node_handle_info = self.get_node_handle_info(node_handle) service_name = self._data.clients.loc[client_handle, 'service_name'] service_info = {'service': service_name} return {**node_handle_info, **service_info} - def get_node_handle_info(self, node_handle: int) -> Union[Mapping[str, Any], None]: + def get_node_handle_info( + self, node_handle: int + ) -> Union[Mapping[str, Any], None]: """ Get information about a node handle. From ca810a0114496a79695abf88fe39833e4c405e66 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 28 Jun 2019 09:52:58 +0200 Subject: [PATCH 93/98] Use pingpong example --- .../analysis/callback_duration.ipynb | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb index f29c3c8..6d71525 100644 --- a/tracetools_analysis/analysis/callback_duration.ipynb +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "outputs": [], "source": [ - "trace_directory = '/tmp/session-composed/ust'" + "trace_directory = '/tmp/session-pingpong/ust'" ] }, { @@ -40,7 +40,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "156 events\n" + "550 events\n" ] } ], @@ -65,9 +65,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -77,9 +77,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAukAAAGeCAYAAAApC5/vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3XmcXFWZ//HPN0tn6XSgO0AHCJKIgQhGQSMug9Agw8AoRGccFXAEfo6MC+qog8K4IaKiOMq4zYAjogOiwoiAgBukZUBQtrCTBCGYsCSQBdLZl+f3x7kVKpVb1VWdWjqd7/v1qld13e0899bte58699xzFRGYmZmZmdngMazVAZiZmZmZ2ZacpJuZmZmZDTJO0s3MzMzMBhkn6WZmZmZmg4yTdDMzMzOzQcZJupmZmZnZIOMk3aom6WJJIWlyq2OpRNLkLM6Lm1BWSOptdDk7uh15O0vqldS0vnKbVd5AjieS5kua37CgrGmavV9vDySdlf1P9LQ6FhscnKQPEZKGS3qvpN9LWippvaTFku6V9N+Sjmt1jNsjJwVmAzPYE47smHmipP+T9LSkVZLmSvqBpAMqzDdS0ocl/VHSc5JWZvP9SNKuRdNJ0tGSviVptqRlktZImiPpfEndVcZ5qKSN2bY8p07rvl1UuDSSpO5su34z+3xytk1ObnFoTSHpYElflnR9tv+HpIWtjsu2NKLVAdi2kzQc+CVwNLAcuBZYCHQB+wAnANOAq1sVY5M9AbwUeK4JZb0UWNWEcsyGmjOBc0n/r63wY+DtpGPlz4EVwHTgJOAEScdExI3FM0jqAq4HDgbuAi4C1gF7AUcC3cAz2eSjsmnXATcBvwOGA0cAHwHeKekNETGvXICSOoAfko4x47Z9lQeVdwNjW1j+TFJF5ZUtjKHUt4GfAH9pQlknkPbD9cBDpH3XBhkn6UPD8aQE/R7gsIjYIjmVNBZ4TSsCa4WIWA883KSymlKO2VATEU8BT7WibEmvJiXoDwAHR8SqonGnkJLvTwM3lsz6I1KC/oGI+M+SZYotr05vzJbx3YhYVjTdMOC7wD8DXweOrRDqfwA7AV8GvljDKg56EdGMRLSStwJLSD+gBoWIeBZ4tknFXUz6AfhARKxz06PByc1dhobXZ+8XlyboABGxKiJmFQ+rdCm6ijbdwyR9TNLD2eXbhZK+IWl8zrJeLumyrNnIWknPSLoru9w7smTa4ZLeJ+mW7DLyakmPZM11pubFLumE7LJzX6FZSrn4iy7xvri/+LNlB7A3sHc2X5QuV2XaSkvaKbuUOCcrY5mkX0s6Mmfanmw5Z0k6UNK1kpZnl99/L+n1pfM000Djq2UbZNO3SfqMpD9n+8pjks6RNKpCbCMkfUDSbZKez2K6W9JpWTJUj/UPpfazu0i6UNJTWXwPZAld3jzDsn359mzfXJn9/f5ycUl6p6Q7s/1+saT/kbRHP7H9jaTrJD2bxfRnSedJ2rke6z5Q2f/i57KPs4r/f4qmyW1yoeS0bPuukfSEpG9L2qmOIb44e7+hOEHPXJW971o8UNIRwJuAK0oTdIBINhZ9Xh8RXyxO0LPhm4Czs4895QKUNBM4Bfgw8GS/a1Sl7Ds4Kfv4WNF3M79kuqlKTXiekLRO0pPZ56k5yyw+Jp+U/Q8W9uOLJE3Mmadsm3RJR0m6Jpt/raQFkq4qd+yoVbYvHQFcExEbs2P4D7LRP9CWx/vJxfNVe0wrOW6+TtLvlM5rK7J5ZuTMU+m8PC3bloVz6WKlplrvH8g2iIjZEXF3RKwbyPzWHK5JHxqWZO/7Nqm8bwCHAj8jndD+BvgX4A2SDomINZASdOCPQJCa2jwGjAdeAnyAVMu0Ppu2jdRM50hgAelS9PPAZFKNx81A6WXhjwN/DVwDzCLVONUr/vnA57PhAOcXzT+70sKzBOkWYH/g9mzeXUg1d7+R9P6IuCBn1hnAJ4Bbgf8GXgT8PXCDpAMjYk6V69coVcdX6zaQJNL3MRP4M+mybxvw/0hNELai9CPvGtL3N4e0z6wBDge+Rbp69I8l81xMSlBOiYiLa1j3wvqsA64ARgNvAy6StCkiflgy/f+QLicvIG2rIO3H3wUOAU4sieujpFrV5aTa2uXZev2BMs22JH2WtI8uJTV3Wwy8HPhX4G8lvS4inq9hHevpfOAtwGGk2rr5Nc77YVIt+4WkY8RM0vfZRvoOtpAlmHsDUyKimrIeyN6PkDQmIlYXjXtz9v67knlOyN4vVmpP/mZgN+Bp4DcRUUuzncI6bMgbKWk34HvALyLiEtW3nfTnSd/NK0g19cuz4YX3wpWG3wEdpGP3g6QmkycCMyW9MSLuyFn2R4GjgJ8CvyLt66cAPZJeExHP5MyzBUmfBz4L9AG/IP0P7UGqjHoXRd9LllwfBhweEb1VrX3yJtK+9PPs88Wk9Z9JOicUH+OXZ2UN9Lj+GlLTrt8B3yGd//4OOFTSURHxf/0FK+lNwOWkJlS/Ai4jHZNeQTomb/Wj0YaIiPBrO38BB5EO+ptIycHfAXv3M89ZpMShJ2fc5GzcxSXDL86GP1u8fNIVmf/Nxn2maPi/Z8Nm5pTRCQwr+vwlXkjmR5VMOwrYNSf2lcBBjYo/GzcfmF9hOwbQWzLsgmz4BYCKhk8lJVxrgclFw3uy6QM4uWRZ/5wN/24L96+a4xvANjghm/5WYHTR8C5S0p63nQv7wbeA4UXDhwPfz9v3ivaBk2tY/8K6/3dJOfuTkqwHS6Y/Ppv+LmBc0fB24I5s3Akl++taUrJdvE2K98soKePwbPgfgJ1Lxp2cjfvGAL/v3tLyBricwvfTU2Z84bsoXufXZ8MeAbqKho/O9o0g5/+R9H+6xbKqiO/r2TyPk5Knc0k/+taTkqD2kunvyab/KOnYE0WvdcCnayj7k9l8l5UZ/wvScaq75Ds9Z1u/l3LbvmicSG2UAzixZNw7suEPs+Xxu/Bdr6PkmEyqFAng+/3tZ6QEP4BHgT1zYpuUt4xy+1iF9b+c9COg+FhT2MYnl5lnW47rp5Usa2Y2fF6Z7dhTNGyXbPnrSM1ZK26TbdgnAlhYj2X5Vb9XywPwq05fZPo1/1TJiWMJ6aaYY3Om3+pgUDRuMpWT3M/kzPNiUhvMx4qGFZL0o/qJfTiptmIVsEcV61qIPTcJqVf82fD51JCkAyNJJ/AVFCUZReO/kM3z2aJhhYP5zTnTjyQlDXe0cN+qKb4BboPfZsMOz5n+5JztPIyUxDwFjMiZZ2fSj9aflQzfnVQjuFMN6x/Z+ozPGff7bHxHzrpstd8Db8zG3Vg07FPZsM9X2C+jZPiV2TwHlIn5bmDxAL/v3tLyBricwv9pT5nxhf/HyUXDvpcNO6XCfrjV/yPpBvlpwMgaY/xn0nGn+Lh5B3B0zrSF4+sG0tWOl5Cu3r0VWESVP/6AV2dlPg/skzP+/2XLenvO/0AzkvS/ysb9ocy8/5eNPzTnu/5+zvQ7kY7vqymqgMnbz0g/kgJ4a5Xr8aLsex9bw7qPJh2bLi8ZXtjGW32HbNtxfYtEvHT9KUq88/5nSFeMA/iPenz3FbaLk/RB+HJzlyEiIn4m6UpSDdshpNr1Q0iXNd8i6Uekg0/Uobjf55T/qKQFwGRJO0fEctIlz48Av5B0Bely3y0R8eeS2aeRDuR/jIha2l7+aWDhVx3/QEwj9VhwS0QszRl/I6mZz0E547a6fBwR6yUtIl156Jeks3IGXxwR87NL5pNLxvVG9ZeJq41vINvglaSk+uac6fPi2xeYQDoBfjq1ltnKalLvO8XxDvRmxXmR33RkQfa+M+kEDi+sS2/O9L8nJd2l614Yt4Wi/XLvklGvI/04+gdJ/5BTThuwq6QJEbEkZ/xgVXZbkJLD3OYhOceUirLmVf/BC83uLiElkgeSan6vl3RaRHynaLbh2fvdwElFx9IrJW0gXQU8k5QAlyt3X1IiOhJ4Z2ncWfvn80kJ5M9qWac6KnwHpTfNUjS8cI4pvekybx9+TtJsUrOUl1K5ueBrScnir6oJNAZ28+lRpJ5yaunVZVuO6/8X6T6EUr2kbXIQ+ft7wWuz9+urjtaGDCfpQ0ikXk1+k70KXTP+PamngneTDkq/qENRi8oMf5qUTOwELI+IP0l6A6mm8G1k7YMlzSHVGl6WzVe4ya3WrtiernH6gqriH+CyC+3iyyWCheF5N/aVK3MDLyQI/flczrBe0hWBk0knhbzx1ag2voFsg52Apdk+XCrve56QvU8lf50L6tVtXaV1h63Xf2nk3JAVERskPUtqy1w8PfS/XxabQDp+V1p3SOu/PSXpZbdFpBv86rUuJwEfIl2NO7do+M2SjiU1tzhX0g8joi8bt4x0M+kvcio7riU1R9hX0k6RcwN/dsPlLFITrndGRF6XuBeRflx+YBvWbVttyzGs0j5cvOxydgaWxZb3CNTbW0nf1bU1zNPqbQKt66rUWsi9uwxhEbExq435RjboiKLRhV/2eT/U+usZolx/qoU7+DefoCLi1oh4M6mm9a9IlwW7gR8X3RFfSID27KfcUgO9KlB1/ANQmHer3gwyu9ehjLIiQjmv3mxcT864sxoQxkC2wXNAl0p6/KmwnMK8V5ZZ58JrSu3hb7Oy6yJpBKmN6fMl00P/+2VpGcv6WXdFxOPbsiItUHZbZJUOE0qHD1Dh5tBZpSMi4mlSm+txwH5Fowo3Rm/1gy2rKS18p2NKx0t6Kam2dBfgHyLif8vE9UrSD7hntGWPOD/Ixn8qG1aPypZytuUYtq3H1uVAp6SttmE9ZPvQsaTmZrUcg1u9TaD286MNAU7SdwyFy/DFbQIK3YLtlTP9Vl1DldiqNlbSi7Nlzc9rKhIRayPiDxHxWVLPDZBunoF0QlwOvFz9dDlXJ7XEv5Hqa7EhnchXAQdKymuicnj2flcNy9zeDGQb3EU6Hh2SM31PzrDCPvPaMol9K91NWpdDc8YdStqfStcdKu+XpW4jJTNln4w5CBS6I6zl/6fstgDeQP2u/ha69dy1zPjC8OKrITdk7y8rnTjr7WUXUrvlZ0vGTSddreoC/j4iriqdv8iPSDc9l74KzUpmZ59/W2EZ1aj03dydvfeUmbcwPO8YlrcP70RqRrSGdENqJbeRzlNH9zPdQB1K+qGX19Sl0jbZluP6IcrvdrUne787Z1yx27L3Y/qZzoYgJ+lDgKTjJf113oFAqX/a92Yfi9sPFtpzn5LV7hWm34vU/VUlH5G0+fJ7Vu55pP3pB0XD36D8vo0LNQurINX4k7qmGwP8l0r6xVbqP7vcyXQgqoo/s4TUtreqmp2sicOlpFq4s4vHSdqH9ANlPakXniFpgNugsN2/KGl00fRdpLaepWVsIPXqsjvwzbzvR9LukvbPGTatzH5ZLxdl719WepBYoeyxpB5EICVaBZeStseHtGWfzMX7ZanC1bHv5f2wldQu6bWlw7eFsn6tldOHcxmFpikvqqGYi7P3T2XffaHs0aQH+pSLbZ/se632B1uh27uPle4Lkt4HTCI1R3iwaNSlpB+GJ2eJd2H6YcBXs49XZPtmYdyBpNr6DlJPQ7+sFFREfDgi/qn0xQv/H9dmw4rbyqPUd/ZWfc5XUOm7uYWUlB4i6W0l5byNlOjOJf/+kX+UVNou+yxSk47LImJtP3F9K3v/d0lb1RyXDpP0oux7r/bJpX9Huoqc90Op7DbZxuP6VEqaLyn1gX8YqRej/rpg/CHpKs37JW31w1/SpH7mt+2Y26QPDa8h3aD5tKSbSf2RA0wh9Qc7hnRQuqIwQ0T8UdJNpAPunyTdSEqejwV+TX7tXcEtwGxJPyVdqvsbUn+td/LCyQrSXelHZX3ZPkrq8uoAUo3AMlIfyAWfz9bjWGCupF+SrgDsRbrR53Qq3JBVo2rjh1R79mrgV9n2WgvcExHXVFj+GaRav9OU+huexQv96XaQuuN6rML8Q0Gt2+AyUvduxwH3S7qKdHPd20h9Eu+TU8YXSN/b+4Bjs334CVJzgamk5lWfYstE68tk/aRTv/1pCxHx4+wk/HbggaxpQpBu4p5C6nHm0qLp50s6g9Qb0t0l++XOwL2k/s+Ly7ghm+fLwDxJ15H+78eR2q8fRkqi6lkjWfixkHvzZo5ZpIToy5JeRnb1LiLOKTdDRNwi6Vuk9uL3K91wXugnfRnl2wTfQNZPOtX1yf5dUp/fLycdb64mJeCvJDUL3Ah8MLZ8ONGzkk4lPbb9j5L+F3iGtK1fSUq4Ti9Mn9W43kCqQb8BeJ2k1+XEcv423KheUOt3cwMp1u9l27iPdB/RtyMiJJ1Eqq3/afa/+DCp6c9bSMfld5e5GfJ64BZJPyN9V4dkr/mkY0JFEfEbSV8APgM8lP3vLCCdmw4h1SqfXDTLj8j6Sae6e2veQuq1Jq+d+K2kiqN/yX4gFqb5VtY0ZqDH9V+RfnQcQ+rGs9BP+hrgPWW242bZfncC6fw9S9L1pGPCeNL+uxdpv6+JpGls/Z10asuHAP5rpKegWqvEIOhixq9te5H+ST9IuoQ3h/Srex3pIHkd6QEQeV1A7Uzq8mwxKfm8HziV/rswfDEpAX+YdKB5gtQjwfiS6Y8i1QA9SEo6VmbxfZOcftxJPxpPI9Xy92XTzyMl8y8pmu4sKnftVpf4s3naSQ+KWEg6AW6xXEq6BizZtl/J4l9LSgB+S363fD3Zcs4qsz7zqdANZBP2rwHFV8s2yKZvI13FeTSbfj7pUeijKmxnkW5IvoHUz/i67Pu8Gfg3YK8y+8DJNax/btkly5tcMnwYqfbsDtKJfxXpR+AHyflfzOY5nnS5fA0p+buE9BCXXsp0iUhKXH5GeiLlumy+2aQ+wGcM8PveqrxsOy8h/RDYqsvLCst6VxbP6mw7RdG4cttOpOPAQ9l+8CSpH/OdKuxr8/OW1U9s47L9bTbpWLM+K+tnwMEV5ns96eFRS7Jt/mfga0BnyXSTC+vcz6vfmKnQBSPpfp+N5HSR2s8yP1a0jaN0u5KS8v8hnUfWZ++XAPvlLOusbBk9WayF7/wZ0jlg92r2s6Jxf0tKbpdm8S0gnd+OyFsGVfSTTqpsCeBjFaY5mpSs9+V9PwzwuE7qjel3pHPzClLnDq+utB1zxh1A+lHyRLbfLSLd53DqAP/PC/Ft077pV2Nfyr4ssyFPLzxtstqnEpoZm58efA+pdvm7rY7HXiDpONKV0jdFxHUtiuEsUk9DtT75s2kkfYnUReaLowlXMrNmYbNIPZmd1ejybGhym3QzM+vPYaSau4v6m9Ca7jBSE7yWJOjbkbeSttNQb2poQ4jbpJuZWUUR8S1euKnPBpGI+HirY9geRMRL+5/KbHBxkm5mNoRJ+hf6f/YB1Pb0WTMbRJT/tOk8v4iISk99tUHEbdLNzIYwSfPZ+omledx21mw7lT30qhqnRMTFjYzF6sdJupmZmZnZIOMbR83MzMzMBhkn6WZmZmZmg4yTdDMzMzOzQcZJupmZmZnZIOMk3czMzMxskHGSbmZmZmY2yDhJt0FDUkh6Sfb3xZLOyf7ukbSwAeVtLmMA854l6ZJ6x1ShvDdImtOs8szMBiNJ10s6qQHLrXg+kNQn6cX1LtesEifpVleSTpB0R3ZAeyo7oB7S6ri2N8U/WAAi4v8iYr9WxmRmOy5J8yWtlrRC0nJJf5D0PkkNyyPyKkMi4piI+GGjyiwnIsZFxKOVpmlUhZLtuJykW91I+hhwPvAloBt4EfBdYGYr4xpsJI1odQxmZgNwbER0kJ5gey7wSeD7A1mQj4O1kzS81TFYczlJt7qQtBNwNvDBiPh5RKyMiPURcU1EnJ5Nc7CkW7NamKckfVtSWw1l/JukZ7ManROLhr9J0t2Snpe0QNJZJfMdktX6LM/Gn5yz7A5JsyR9U5Jyxk+R9PusFum3wC5F47aqPcliPDL7+yxJV0i6RNLzwMmVtoWkm7LF3JNdkXhHaRmSXiqpN5v/AUnHFY27WNJ3JF2bxftHSftk4yTpG5IWS3pO0r2SXlbtd2BmFhHPRcTVwDuAkwrHkOyY9E+F6SSdLOnmos8h6YOS5gHzsmH/kR2Xn5d0p6Q3ZMOPBv4NeEd2HLyntAxJwyR9WtLj2THtR9m5CEmTs/JOkvSX7NzxqX5WrTPvuFkUe6E55t9KejCb7glJ/yqpHbge2COLt0/SHpJGSTpf0pPZ63xJo4qW+4nsHPCkpH/S1s0+/1PSdZJWAodXOt8VrfMp2bhlSlc7Xp0d65dL+nZt37a1kpN0q5fXAaOBKytMsxH4KCnBfR3wRuADVS5/YjbfnsBJwIWSCs0/VgLvBnYG3gS8X9JbACS9iHTg/BawK3AgMLt4wZImADcAt0TEhyMicsr/MXBnFsMXshhqMRO4IovxUipsi4g4NJvnFdkl1p+WxDsSuAb4DbAb8CHg0qLtAXA88HmgE3gE+GI2/CjgUGDfLJZ3AEtqXBczMyLiT8BC4A01zPYW4DXA/tnn20nH5S7ScfZySaMj4lekq7I/zY6Dr8hZ1snZ63DgxcA4oDQJPQTYj3SM/aykl1aIrdxxs9T3gX/Oriq8DLgxIlYCxwBPZvGOi4gngU8Br83W8RXAwcCnYfMPkY8BRwIvAQ7LKeuELI4O4GYqnO+KvAaYSjq+n5/FcCRwAPB2SXnl2CDkJN3qZQLwbERsKDdBRNwZEbdFxIaImA9cQP5BqZzPRMTaiPg9cC3w9my5vRFxX0Rsioh7gcuKlnsi8LuIuCyr2V8SEcVJ+h7A74HLI+LTeYVmif6ri8q/iZQk1+LWiPhFFuPqbdwWryWdjM6NiHURcSPwS9IJpuDnEfGn7Pu4lHSCAFhPOthPAxQRD0XEUzWui5lZwZOkBLtaX46IpRGxGiAiLsmOyxsi4t+BUaSkuhonAl+PiEcjog84E3intmxK8/nsmHsPcA8pUS6n3HGz1Hpgf0njI2JZRNzVT4xnR8TiiHiG9CPgH7Nxbwd+EBEPRMSqbFypqyLiluzcsaaf813BF7Jpf0NK6i/Lyn8C+D/goArx2iDiJN3qZQmwiyq0M5S0r6RfSnpaqdnHlyhqNtKPZVlNRcHjpAQbSa9RaqryjKTngPcVLXcv4M8VlvsmYAzwXxWm2aNM+bVYUPxhG7fFHsCCiNhUEs+eRZ+fLvp7FSmpJ0vovw18B1gk6UJJ42tbFTOzzfYEltYwfemx8OOSHsqa3y0HdqK2Y2HxsfhxYATpnqiC3GNhGdVO+/fA3wKPKzWDfF2NMe5RNK54e2yxbfKG9XO+K1hU9PfqnM+VtoENIk7SrV5uBdaQLmWW85/Aw8DUiBhPam+4VfvvMjqzNn8FLyLV4EC6RHo1sFdE7ERKuAvLXQDsQ3nfA34FXFey/GJPlSm/YCUwtvBB6eaeXUuWUdqEZlu2xZPAXtqyV4UXAU9UM3NEfDMiXkW69LkvcHqV5ZqZbSbp1aQkvdDufItjIamZYqnNx8Ks/fknSTXKnRGxM/AcLxwL85oeFnuSdBNrwYuADWyZlNZdRNweETNJzQ1/AfysMKrKGAvnrqeASUXj9sorruRzpfOdDTFO0q0uIuI54LPAdyS9RdJYSSMlHSPpq9lkHcDzQJ+kacD7ayzm85LasgP7m4HLi5a7NCLWSDqY1Iav4FLgSElvlzRC0gRJpZcwTwPmAL+UNCZn3R4H7igq/xDg2KJJ5gKjsxt6RpLaG44qXU6J/rbFIlIbyzx/JJ0MP5Ft454snp/0UybZDUSvyeJcSfphtbG/+czMCiSNl/Rm0jHnkoi4Lxs1G/i77Pj/EuA9/Syqg5RUPwOMkPRZoPjK3iJgssp383gZ8FGlG/vH8UIb9rLNLrdVdg44UdJOEbGedBwvHEMXAROU3bxaFOOnJe0qaRfSebLQreTPgFOUOgIYm43rT6XznQ0xTtKtbiLi66SbYD5NOuguICXAv8gm+VfSAWUFqQb7pzmLKedpYBmpBuJS4H0R8XA27gPA2ZJWkA5yhVoNIuIvpMuSHyddkp1NSZvE7EbRU7N4r5I0Oqf8E0g34ywFPgf8qGj+57IY/ptUm72SdDNVJf1ti7OAH2Z347+9JN51wHGkm5SeJXVz+e6i7VHJ+Ky8ZaTLrkuAr1Uxn5nZNdlxdgHpZsSvA6cUjf8GsI6UrP6QdKyu5NekG/vnko5Ha9iyeUehImaJpLx23xcB/wPcBDyWzf+hGtZnoP4RmJ81VXwf8C6A7Bh8GfBoduzeAziHVMlzL3AfcFc2jIi4HvgmMIt0o+qt2fLXVii77PnOhh7ld2RhZmZmZs2S9TxzPzCqkVcDbPvhmnQzMzOzFpD01qwJTSfwFeAaJ+hW4CTdzMzMrDX+mdQ89M+ktu213qtlQ5ibu5iZmZmZDTKuSTczMzMzG2QamqRLOlrSHEmPSDojZ/z7JN0nabakmyXtXzTuzGy+OZL+ptplmpmZmZlt7xrW3CV7oMtc4K9J3dHdDhwfEQ8WTTM+Ip7P/j4O+EBEHJ0l65cBB5OeyPU70kNX6G+ZeXbZZZeYPHlyHdeuspUrV9LeXu65OK0zGOMajDGB46qV46rOnXfe+WxElD7oyuqgv+P8YNoXHEs+x1LeYIrHseQrxFLX43xENOQFvA74ddHnM4EzK0x/PHB93rSkvlRfV+syC69XvepV0UyzZs1qannVGoxxDcaYIhxXrRxXdYA7okHH3B391d9xfjDtC44ln2MpbzDF41jyFWKp53F+RF0y/Xx7suVDCRaSHgazBUkfJD0Apw04omje20rm3TP7u99lZss9lfSAGrq7u+nt7a15BQaqr6+vqeVVazDGNRhjAsdVK8dlZmZWX41M0pUzbKu2NRHxHdKj5E8gPanypArz5rWhz22vExEXAhcCzJgxI3p6eqqLug56e3tpZnnVGoxxDcaYwHHVynGZmZnVVyOT9IXAXkWfJ5Ee6V7OT4D/rGLeWpZpZmZmZrbdaWSSfjswVdIU4AngncAJxRNImhoR87KPbwIKf18N/FjS10k3jk4F/kSqYa+4TDPbduvXr2fhwoWsWbOmqul32mknHnrooQZHVbtWxTV69GgmTZrEyJEjm162mZkNDQ1L0iNig6TTSDd9DgcuiogHJJ1NalR/NXCapCPoM2BxAAAgAElEQVSB9cAyUlMXsul+BjwIbAA+GBEbAfKW2ah1MNtRLVy4kI6ODiZPnoyU1/psSytWrKCjo6MJkdWmFXFFBEuWLGHhwoVMmTKlqWWbmdnQ0ciadCLiOuC6kmGfLfr7IxXm/SLwxWqWaWb1tWbNmqoTdNuSJCZMmMAzzzzT6lDMzGw75ieOmlkuJ+gD521nZmbbykm6mZmZmdkg4yTdzAal+fPnM2bMGA488EAAxo0bV5flnnXWWXzta1/rd7qTTz6ZK664ouI0p59+OhMnTqxqeWZmZrVoaJt0M7Ntsc8++zB79uxWh1HWeeedN2geSW1mZkOLk3Qzq+jz1zzAg08+X3GajRs3Mnz48KqXuf8e4/ncsQcMKJ6+vj5mzpzJsmXLWL9+Peeccw4zZ85k/vz5HH300RxyyCHcdtttvOIVr+Ad73gHX/nKV1i8eDGXXnopBx98MAD33HMPRxxxBAsWLOATn/gE733ve4kIPvShD3HjjTcyZcoU0tOdk7PPPptrrrmG1atX8/rXv54LLrjA7c6bQNJHgX8iPbTuPuCUiKiuX1Azs+2cm7vkuP+J5/jTY0tbHYaZ5Rg9ejRXXnkld911F7NmzeLjH//45oT6kUce4SMf+Qj33nsvDz/8MJdffjk333wzX/va1/jSl760eRn33nsv1157Lbfeeitnn302Tz75JFdeeSVz5szhvvvu43vf+x5/+MMfNk9/2mmncfvtt3P//fezevVqfvnLXzZ9vXc0kvYEPgzMiIiXkbrdfWdrozIzax7XpOc4/3dzeWL5Gq7/yBtaHYpZy1VT493M/sgjgn/7t3/jpptuYtiwYTzxxBMsWrQIgClTpjB9+nQADjjgAA499FAkMX36dObPn795GTNnzmTMmDGMGTOGww8/nD/96U/cdNNNHH/88QwfPpw99tiDI444YvP0s2bN4qtf/SqrVq1i6dKlHHDAARx77LFNWd8d3AhgjKT1wFj8hGkz24E4Sc/RObaN+5+ofHnfzFrj0ksv5ZlnnuHOO+9k5MiRTJ48efOTUUeNGrV5umHDhm3+PGzYMDZs2LB5XGlTlcLnvCYsa9as4QMf+AB33HEHe+21F2eddVbVT2K1gYuIJyR9DfgLsBr4TUT8pngaSacCpwJ0d3fT29tbdnl9fX254+974rn6BV3B9D136jeWVnAs+QZTLDC44nEs+RoRi5P0HF3j2li6ch0R4XanZoPMc889x2677cbIkSOZNWsWjz/+eM3LuOqqqzjzzDNZuXIlvb29nHvuuWzcuJELLriAd7/73SxevJhZs2ZxwgknbE7Id9llF/r6+rjiiit429veVu/VshKSOoGZwBRgOXC5pHdFxCWFaSLiQuBCgBkzZkRPT0/Z5fX29pI3/uQzrq1r3OXMP/GFssvF0gqOJd9gigUGVzyOJV8jYnGSnqNrbBvrNm5i5bqNjBvlTWQ2mJx44okce+yxzJgxgwMPPJBp06bVvIyDDz6YN73pTfzlL3/hM5/5DHvssQdvfetbufHGG5k+fTr77rsvhx12GAA777wz733ve5k+fTqTJ0/m1a9+db1XyfIdCTwWEc8ASPo58HrgkopzmZkNEc5Ac3S1twGwbOU6J+lmg0RfXx+QarRvvfXW3Gnuv//+zX9ffPHFrFixAoDJkydvHnfWWWflziuJb3/727njzjnnHM4555yBhm4D8xfgtZLGkpq7vBG4o7UhmZk1j3t3yVFI0pesXNfiSMx2XMOHD+e5557b/DCjwej000/nkksucV/pDRARfwSuAO4idb84jKxpi5nZjsDVxDk6i2rSzaw19tprLxYsWNDqMCo677zzOO+881odxpAVEZ8DPtfqOMzMWsE16TkmuCbdbIuH+VhtvO3MzGxbOUnP4Zp029GNHj2aJUuWONkcgIhgyZIljB49utWhmJnZdszNXXJ0jBrByOFi6Son6bZjmjRpEgsXLuSZZ56pavo1a9YMyqS0VXGNHj2aSZMmNb1cMzMbOpyk55BE59g2lvY5Sbcd08iRI5kyZUrV0/f29nLQQQc1MKKBGaxxmZmZ9cfNXcroam9zTbqZmZmZtYST9DK62tNTR83MzMzMms1Jehmd7W2+cdTMzMzMWsJJehkT2tvcBaOZmZmZtYST9DI6x7bx3Or1bNi4qdWhmJmZmdkOxkl6GRPGpb7Sl69e3+JIzMzMzGxH4yS9jM6xKUn3zaNmZmZm1mxO0svoaneSbmZmZmat4SS9DCfpZmZmZtYqTtLLcJJuZmZmZq3iJL2MQpt095VuZmZmZs3mJL2MthHD6Bg1wn2lm5mZmVnTOUmvoLO9jWWrnKSbmZmZWXM5Sa+gq73NbdLNzMzMrOkamqRLOlrSHEmPSDojZ/zHJD0o6V5JN0jaOxt+uKTZRa81kt6SjbtY0mNF4w5sVPxO0s3MzMysFRqWpEsaDnwHOAbYHzhe0v4lk90NzIiIlwNXAF8FiIhZEXFgRBwIHAGsAn5TNN/phfERMbtR69DV3uYbR83MzMys6RpZk34w8EhEPBoR64CfADOLJ8iS8VXZx9uASTnLeRtwfdF0TdPV3saSleuIiGYXbWZmZmY7sBENXPaewIKizwuB11SY/j3A9TnD3wl8vWTYFyV9FrgBOCMi1pbOJOlU4FSA7u5uent7q488s+zpdazdsInf3NDLqBGqer6+vr4BlddogzGuwRgTOK5aOS4zM7P6amSSnpfV5lZJS3oXMAM4rGT47sB04NdFg88EngbagAuBTwJnb1VQxIXZeGbMmBE9PT01r8Di9gVcPvde9n/la9ira2zV8/X29jKQ8hptMMY1GGMCx1Urx2VmZlZfjWzushDYq+jzJODJ0okkHQl8Cjgup0b87cCVEbG+MCAinopkLfADUrOahujMnjrqbhjNzMzMrJkamaTfDkyVNEVSG6nZytXFE0g6CLiAlKAvzlnG8cBlJfPsnr0LeAtwfwNiB1KbdMA9vJiZmZlZUzWsuUtEbJB0GqmpynDgooh4QNLZwB0RcTVwHjAOuDzl3PwlIo4DkDSZVBP/+5JFXyppV1JzmtnA+xq1Dk7SzczMzKwVGtkmnYi4DriuZNhni/4+ssK880k3n5YOP6KOIVbUNdZJupmZmZk1n584WsH4MSMYPkxO0s3MzMysqZykVyCJzrFtvnHUzMzMzJrKSXo/JrS3uSbdzMzMzJrKSXo/OttHOkk3M2sySftJml30el7Sv7Q6LjOzZmnojaNDQVd7G3OeXtHqMMzMdigRMQc4EEDScOAJ4MqWBmVm1kSuSe9Hl5u7mJm12huBP0fE460OxMysWVyT3o+usW0sX72ejZuC4cPU6nDMzHZE76TkwXYAkk4FTgXo7u6mt7e37AL6+vpyx398+oZ6xVhRcdnlYmkFx5JvMMUCgysex5KvEbE4Se9HV3sbEfDc6vWbH25kZmbNkT2x+jjgzNJxEXEhcCHAjBkzoqenp+xyent7yRt/8hnX1inSyuaf+ELZ5WJpBceSbzDFAoMrHseSrxGxuLlLPzo3P3V0bYsjMTPbIR0D3BURi1odiJlZMzlJ70fX5iR9fYsjMTPbIR1PTlMXM7Ohzkl6P7pck25m1hKSxgJ/Dfy81bGYmTWb26T3wzXpZmatERGrgAmtjsPMrBVck96PzrEpSV+2yt0wmpmZmVlzOEnvx+iRw2lvG86SPifpZmZmZtYcTtKr0Nne5pp0MzMzM2saJ+lVmNDexhI/ddTMzMzMmsRJehU629tY5iTdzMzMzJrESXoVutrbWOok3czMzMyaxEl6FbrGOkk3MzMzs+Zxkl6FrnFtrF6/kdXrNrY6FDMzMzPbAThJr0JX1lf6UvfwYmZmZmZN4CS9Cp3ZU0d986iZmZmZNYOT9CpMyJJ0d8NoZmZmZs3gJL0Krkk3MzMzs2Zykl6FQk26e3gxMzMzs2Zwkl6F8aNHMkxO0s3MzMysOZykV2HYMNE5ts29u5iZmZlZUzhJr1JXextL+5ykm5mZmVnjOUmvUme7a9LNzMzMrDmcpFdpQnube3cxMzMzs6ZoaJIu6WhJcyQ9IumMnPEfk/SgpHsl3SBp76JxGyXNzl5XFw2fIumPkuZJ+qmktkauQ0Fne5tvHDUzMzOzpmhYki5pOPAd4Bhgf+B4SfuXTHY3MCMiXg5cAXy1aNzqiDgwex1XNPwrwDciYiqwDHhPo9ahWNfYNpatWsemTdGM4szMzMxsB9bImvSDgUci4tGIWAf8BJhZPEFEzIqIVdnH24BJlRYoScARpIQe4IfAW+oadRld7W1sCnhu9fpmFGdmZmZmO7ARDVz2nsCCos8LgddUmP49wPVFn0dLugPYAJwbEb8AJgDLI2JD0TL3zFuYpFOBUwG6u7vp7e0dyDps9vSTqchfzbqZ3cdV/m3T19e3zeU1wmCMazDGBI6rVo7LzMysvhqZpCtnWG5bEUnvAmYAhxUNflFEPCnpxcCNku4Dnq92mRFxIXAhwIwZM6Knp6eG0Lc2bO4zXHjvn5j6sgOZMbmr4rS9vb1sa3mNMBjjGowxgeOqleMyMzOrr0Y2d1kI7FX0eRLwZOlEko4EPgUcFxFrC8Mj4sns/VGgFzgIeBbYWVLhx0XuMhuhqz3dn7rEN4+amZmZWYM1Mkm/HZia9cbSBrwTuLp4AkkHAReQEvTFRcM7JY3K/t4F+CvgwYgIYBbwtmzSk4CrGrgOm3VmSbq7YTQzMzOzRmtYkp61Gz8N+DXwEPCziHhA0tmSCr21nAeMAy4v6WrxpcAdku4hJeXnRsSD2bhPAh+T9Aipjfr3G7UOxbrGuibdzMzMzJqjkW3SiYjrgOtKhn226O8jy8z3B2B6mXGPknqOaaoxbcMZM3K4a9LNzMzMrOH8xNEadLW3sXSVk3QzMzMzaywn6TXo8lNHzczMzKwJnKTXoLO9zc1dzMzMzKzhnKTXYEJ7m28cNTNrEkk7S7pC0sOSHpL0ulbHZGbWLA29cXSo6RzrmnQzsyb6D+BXEfG2rCvfsa0OyMysWVyTXoMJ49pYuW4ja9ZvbHUoZmZDmqTxwKFk3exGxLqIWN7aqMzMmsc16TXozPpKX7ZqHbvvNKbF0ZiZDWkvBp4BfiDpFcCdwEciYmVhAkmnAqcCdHd309vbW3ZhfX19ueM/Pn1DXYMup7jscrG0gmPJN5higcEVj2PJ14hYnKTXoKt9JABLVzpJNzNrsBHAK4EPRcQfJf0HcAbwmcIEEXEhcCHAjBkzoqenp+zCent7yRt/8hnX1jXocuaf+ELZ5WJpBceSbzDFAoMrHseSrxGxuLlLDbraRwG4G0Yzs8ZbCCyMiD9mn68gJe1mZjsEJ+k1KK5JNzOzxomIp4EFkvbLBr0ReLCFIZmZNZWbu9SgUJPuHl7MzJriQ8ClWc8ujwKntDgeM7OmcZJeg53GjERyTbqZWTNExGxgRqvjMDNrBTd3qcHwYWLnMSNZuspJupmZmZk1jpP0GnW1t7km3czMzMwaykl6jZykm5mZmVmjOUmvUVd7G8tWrm91GGZmZmY2hDlJr1FXextLXJNuZmZmZg3kJL1GXe1tLFu1johodShmZmZmNkQ5Sa9R59g2Nm4Knl+9odWhmJmZmdkQ5SS9Rl3tbQDuhtHMzMzMGsZJeo02J+lul25mZmZmDeIkvUZO0s3MzMys0Zyk16iQpC9zkm5mZmZmDeIkvUaFJN3dMJqZmZlZozhJr9GYkcMZNWIYy3zjqJmZmZk1iJP0GkliQnsbS/qcpJuZmZlZYzhJH4DO7IFGZmZmZmaN4CR9ALra29y7i5mZmZk1jJP0AXCSbmZmZmaN5CR9ADrHtrkLRjMzMzNrmIYm6ZKOljRH0iOSzsgZ/zFJD0q6V9INkvbOhh8o6VZJD2Tj3lE0z8WSHpM0O3sd2Mh1yDOhvY0VazewdsPGZhdtZmZmZjuAhiXpkoYD3wGOAfYHjpe0f8lkdwMzIuLlwBXAV7Phq4B3R8QBwNHA+ZJ2Lprv9Ig4MHvNbtQ6lNOZ9ZW+fNX6ZhdtZmZmZjuARtakHww8EhGPRsQ64CfAzOIJImJWRKzKPt4GTMqGz42IednfTwKLgV0bGGtNJmRJutulm5mZmVkjNDJJ3xNYUPR5YTasnPcA15cOlHQw0Ab8uWjwF7NmMN+QNKoewdai00m6mZmZmTXQiAYuWznDIndC6V3ADOCwkuG7A/8DnBQRm7LBZwJPkxL3C4FPAmfnLPNU4FSA7u5uent7B7QSeZ5YkUK5+fbZrF+49Sbs6+ura3n1MhjjGowxgeOqleMyMzOrr0Ym6QuBvYo+TwKeLJ1I0pHAp4DDImJt0fDxwLXApyPitsLwiHgq+3OtpB8A/5pXeERcSErimTFjRvT09GzTyhR7tm8tn7rld0zc+yX0vH7yVuN7e3upZ3n1MhjjGowxgeOqleMyMzOrr0Y2d7kdmCppiqQ24J3A1cUTSDoIuAA4LiIWFw1vA64EfhQRl5fMs3v2LuAtwP0NXIdcO48ZCbi5i5mZmZk1RsNq0iNig6TTgF8Dw4GLIuIBSWcDd0TE1cB5wDjg8pRz85eIOA54O3AoMEHSydkiT856crlU0q6k5jSzgfc1ah3KGTF8GDuPHcmyVU7SzczMzKz+GtnchYi4DriuZNhni/4+ssx8lwCXlBl3RD1jHKiusW0scU26mZmZmTWAnzg6QJ3tfuqomZmZmTWGk/QB6mpvc5t0MzMzM2uIhjZ3Gcq6xrZxz4LlrQ7DzGzIkjQfWAFsBDZExIzWRmRm1jxO0geoa1wby1atIyLIbno1M7P6Ozwinm11EGZmzVZTcxdJ7ZKGNyqY7UnX2DbWbwxWrN3Q6lDMzMzMbIipmKRLGibpBEnXSloMPAw8JekBSedJmtqcMAefzvY2AN88ambWOAH8RtKd2VOkzcx2GP01d5kF/A44E7g/IjYBSOoCDgfOlXRl1mXiDmVClqQvWbmOvSe0tzgaM7Mh6a8i4klJuwG/lfRwRNxUGJkl7qcCdHd309vbW3ZBfX19ueM/Pr05V0OLyy4XSys4lnyDKRYYXPE4lnyNiKW/JP3IiFhfOjAilgL/C/yvpJF1jWg74Zp0M7PGiogns/fFkq4EDgZuKhp/IXAhwIwZM6Knp6fssnp7e8kbf/IZ19Y15nLmn/hC2eViaQXHkm8wxQKDKx7Hkq8RsVRs7lJI0CXtI2lU9nePpA9L2rl4mh1NoSbd3TCamdVfdg9UR+Fv4Cjg/tZGZWbWPNXeOPq/wEZJLwG+D0wBftywqLYDnU7SzcwaqRu4WdI9wJ+AayPiVy2OycysaartgnFTRGyQ9Fbg/Ij4lqS7GxnYYNfeNpy24cNYuspJuplZvUXEo8ArWh2HmVmrVFuTvl7S8cBJwC+zYTtkW/QCSempo33NS9IXr1jDSnf5aGZmZjbkVZuknwK8DvhiRDwmaQqww/XoUqqzPT3QqFne9p+38uXrH2paeWZmZmbWGlU1d4mIB4EPF31+DDi3UUFtLya0tzWtTfryVev4y9JV3LPguaaUZ2ZmZmatU1VNuqQ3S7pb0lJJz0taIen5Rgc32HU2MUmfu6gve1/Bxk3RlDLNzMzMrDWqbe5yPqk9+oSIGB8RHRExvoFxbReaWZM+d9EKANZu2MTjS1Y2pUwzMzMza41qk/QFpCeOugq3SOfYNp5fs4H1Gzc1vKxHFvdt/nvO0ysaXp6ZmZmZtU61XTB+ArhO0u+BtYWBEfH1hkS1nehqTx3cLFu1jt06Rje0rLmLVjBtYgdzFq3g4adXcMz03RtanpmZmZm1TrU16V8EVgGjgY6i1w6tq30UAMtWNv6hq3MX9TF9z52YPKHdNelmZmZmQ1y1NeldEXFUQyPZDnVmNelLVq6lkb9Zlq1cx7N9a5naPY4VazZsbp9uZmZmZkNTtTXpv5PkJL3EhCbVpBeS8qndHew7sYP5S1ayZv3GhpZpZmZmZq1TbZL+QeBXkla7C8YXFGrSl65c28+U22ZedtPovt0dTJvYwaaAeYv6+pnLzMzMzLZX1T7MaIdvf56nc2wbAEsbXJM+b9EKxo0awR47jWbN+vRVPPz080yftFNDyzUzMzOz1qhYky5pcj/jJWlSPQPanowcPozxo0ewbFVj+0qfu6iPl+w2DklMntDOqBHDfPOomZmZ2RDWX036eZKGAVcBdwLPkHp4eQlwOPBG4HPAwkYGOZh1tbexpMEPNJq3eAWH77cbAMOHiand45jjm0fNzMzMhqyKSXpE/IOk/YETgf8H7E7qivEh4DrgixGxpuFRDmJd7W0sa2CSvnTlOp7tW8e+3S+0ONq3u4Ob5z3bsDLNzMzMrLX6bZMeEQ8Cn2pCLNulrvY2nljeuN8p8zb37DJu87BpEzv4+V1PsGzlOjrb2xpWtpmZmZm1RrW9u1gZnWMbW5M+t6hnl4L9Jo4H4GG3SzczMzMbkpykb6OucW0sXbmOiGjI8gs9u+y+0+jNw6ZNTAn7nKd3+F4wzczMzIYkJ+nbqGtsG+s2bmLlusY8XGjuohWbe3Yp2K1jFDuPHckc95VuZmZmNiRV1U86gKQ9gb2L54mImxoR1PakK2sTvmzlOsaNqnpzVu2RxX0cMW23LYZJYr/uDtekm5mZmQ1RVdWkS/oKcAvwaeD07PWvVcx3tKQ5kh6RdEbO+I9JelDSvZJukLR30biTJM3LXicVDX+VpPuyZX5TxVXMLVBI0hvRDWNezy4F+03sYO6ivoY1szEzMzOz1qm26vctwH4RsbbaBUsaDnwH+GtSP+q3S7o66y2m4G5gRkSskvR+4KvAOyR1kfpfnwEEcGc27zLgP4FTgdtI3UAeDVxfbVz11llUk15vczf37JKfpPet3cDCZavZq2ts3cs2MzMzs9aptk36o8DIGpd9MPBIRDwaEeuAnwAziyeIiFkRsSr7eBtQeHrp3wC/jYilWWL+W+BoSbsD4yPi1khVyD8i/YBomQkNrEkvdL+4b1H3iwUv3DzqHl7MzMzMhppqa9JXAbMl3QBsrk2PiA9XmGdPYEHR54XAaypM/x5eqBHPm3fP7LUwZ/hWJJ1KqnGnu7ub3t7eCkUP3Kr1qbnJ7fc+xC4rHgGgr6+vLuXNenAtY0bAw3fdxpySVj2rN6Ryr7/1HkYsrq6v9HrFVU+DMSZwXLVyXGZmZvVVbZJ+dfaqRV5b8dwG1JLeRWraclg/81a9zIi4ELgQYMaMGdHT09NPuAMTEYzsvZ6u3feip2caAL29vdSjvP+aeyvT9tjE4Yf/Ve74Pe+4kfVjO+npOaiq5dUrrnoajDGB46qV4zIzM6uvqpL0iPihpDZg32zQnIhY389sC4G9ij5PAp4snUjSkaQnmh5W1OZ9IdBTMm9vNnxSyfCtltlMkugc28bSvkY0d+njyJd2lx2/38QON3cxMzMzG4Kq7d2lB5hHuhH0u8BcSYf2M9vtwFRJU7IE/52U1MZLOgi4ADguIhYXjfo1cJSkTkmdwFHAryPiKWCFpNdmvbq8G7iqmnVopK72Npauqm+SvqRvLUtWrmNqTnv0gv0mdvDnZ/pYt2FTXcs2MzMzs9aqtrnLvwNHRcQcAEn7ApcBryo3Q0RskHQaKeEeDlwUEQ9IOhu4IyKuBs4DxgGXZz0p/iUijouIpZK+QEr0Ac6OiKXZ3+8HLgbGkNqwt6xnl4Ku9vTU0Xqamz2oKK/7xYJpEzvYsCl49Nk+pk0cX9fyzczMzKx1qk3SRxYSdICImCup395eIuI6UjeJxcM+W/T3kRXmvQi4KGf4HcDLqoy7KTrb23joyfo+WOiRxYXuFyvXpEPq4cVJupmZmdnQUW2Sfoek7wP/k30+EbizMSFtfyY0oLnL3EV9dIwawcTxo8tO8+JdxjFimNwu3czMzGyIqbaf9PcDDwAfBj4CPAi8r1FBbW86x7axfNV6NmysX9vwuYtWMLV7HJUeqNo2Yhj77DrOSbqZDUmShku6W9IvWx2LmVmzVdu7y1rg69nLSnRlDzRavno9u4wbVZdlzlvcx1H7l+/ZpWDfiR3c9fiyupRpZjbIfAR4CHB7PjPb4VSsSZf0s+z9Pkn3lr6aE+LgV0jS63Xz6LN9a1m6ch1TK9w0WjBtYgdPLF/NijX99YhpZrb9kDQJeBPw362OxcysFfqrSf9I9v7mRgeyPat3kj4v69ll6m7lbxot2C9L5OcuWsGr9u6qS/lmZoPA+cAngLK1FbU8Wbrc02c/Pn3DNoZZneKyB9OTcB1LvsEUCwyueBxLvkbEUjFJz/olB/hARHyyeJykrwCf3HquHU8hSV9WryQ969mlUveLBS/08NLnJN3MhgRJbwYWR8Sd2XM6ctXyZOlyT589+YxrtzHa6sw/8YWyB9OTcB1LvsEUCwyueBxLvkbEUu2No3+dM+yYegayPSsk6UvqlKTPXbSCjtEj6B7ff/v2SZ1jaG8bzpyn69sFpJlZC/0VcJyk+cBPgCMkXdLakMzMmqu/Nunvl3QfsF9Je/THALdJz+w8NnUZX6+a9LmL+ti3u6Nizy4Fkth3YgcPu4cXMxsiIuLMiJgUEZNJT6u+MSLe1eKwzMyaqr826T8mPdHzy8AZRcNXFD0BdIc3asRwOkaNqFtN+iNV9uxSMG1iB9ff/zQRUVVib2ZmZmaDW8Wa9Ih4LiLmR8TxEfE4sBoIYJykFzUlwu1EZ3sby+rwQKNaenYp2K+7g+Wr1rN4xdptLt/MbDCJiN6IcOcFZrbDqapNuqRjJc0DHgN+D8wn1bBbpqu9rS69u8xdVLhptP+eXQr2m5i6EHaTFzMzM7OhodobR88BXgvMjYgpwBuBWxoW1XaoXkl6ofvFanp2KZiW9fAy10m6mZmZ2ZBQbZK+PiKWAMMkDYuIWcCBDYxru9PV3laXG0fnLlrB+NEj2K2j+ieXdra3sVvHKNekm5mZmY9fJb4AACAASURBVA0R/d04WrBc0jjgJuBSSYuB5jwBYjvR1d7GkpXriIhtWs68xX1MrbJnl2L7TexgziJ3w2hmZmY2FFRbkz4TWAV8FPgV8Gfg2EYFtT3qHNvG2g2bWL1+44CXERHMW7SipvboBft1dzBvUR8bN23bjwQzMzMza71+a9IlDQeuiogjgU3ADxse1XZoQvZAo21pl/5s3zqWrVrP1N2qb49esN/EDtZu2MT8JSvZZ9fak3wzMzMzGzz6rUmPiI3AKkk7NSGe7VZnHZL0eZt7dqk9SZ+W9fDim0fNzMzMtn/VtklfA9wn6bfAysLAiPhwQ6LaDnXVIUkfSPeLBVO7xyGlbhiPmb77gGMwMzMzs9arNkm/NntZGcVJetcAlzFvcR/jR49g1xp6dikYPXI4kye0M8c16WZmZmbbvaqS9IhwO/R+dI2tQ5K+qI99B9CzS8F+3R3MWeQk3czMzGx7V+0TRx+T9Gjpq9HBbU/GjxnB8GFi2aqBNXeJCOYuXsHUAbRHL9hvYgfzl6xk9bqB9zBjZmZmZq1XbXOXGUV/jwb+AQZcYTwkSaJzbPbU0dpbq/BM31qWr1o/oPboBdMmdhABjyzuY/ok3+drZmZmtr2qqiY9IpYUvZ6IiPOBIxoc23ZnQnvbgG8cfWRRHzCwnl0K9puY5n34aT/UyMzMzGx7VlVNuqRXFn0cRqpZH3g2OUR1to8ccJJe6Nll6m4Dr0nfe0I7o0YM882jZmZmZtu5apu7/HvR3xuA+cDb6x7Ndq6rvW3ACfLcxX3sNGbkgHp2KRg+TEztHuebR83MzMy2c9X27nJ4owMZCrra21i2aj0wsuZ55y1awb7d4wbcs0vBft3juWneM9u0DDMz+//t3Xd4HNX5//33rV5tSy5yb7hhY3AvVFMSDAk1JgEcwCQ8JAQIhBIgJCQhPQFSCMkXfoFAEpsaIBB6sSA0F4w7ttxtucjdliyrn+ePmTVrsbK00jZJn9d17aXdMzNnbs2Mdm/NniIiEl9HTNLN7KYjLXfO3RfZcFq3/Kw09pRXUeea+gWFxzlHUUkZXzq25ZMQDeuey78XFHtDQfpjt4uIiIhI69JYx9Fc/zEOuAbo5T++DQyPbmitT352Gs7BgerwtttRVsm+g9UMaUF79IBA51G1SxcRERFpvY54y9c591MAM3sdGOOcK/Vf/wR4OurRtTJ5/p3r0ioX1nar/JFdWjJGesCwQ0n6fiYf1bnF9YmIiIhI7DVpCEagLxA8bEkV0D/i0bRy+c1M0g+N7NKCMdIDuuam0ykrVZ1HRURERFqxpibp/wTmmtlPzOzHwBzgscY2MrOpZrbSzFab2e0hlp9sZgvMrMbMpgWVn2pmC4MeFWZ2vr/sUX8G1MCyUU38HaKu+Ul6GZ2yUuma0/yRXQLMjKEFuaxQcxcRERGRVqupo7v8wsxeAU7yi650zn1ypG3MLBl4APgCUAzMM7MXnHPLg1bbCMwAbqm3v9nAKL+efGA18HrQKrc6555pSuyxFEjSy6rDbe5SypBuuS0e2SVgWPdcnvm4mLo6R1JSZOoUERERkdhp8jAkzrkFwIIw6p4ArHbOrQUwsyeA84BDSbpzbr2/rO4I9UwDXnHOlYex77jIywr/TrpzjlXby/hyBEZ2CRjavQMHqmrZvPcgffKzIlaviIiIiMRGeGMFhqcXsCnodTEwsRn1XAzUH+rxF2Z2F/AWcLtzrrL+RmZ2NXA1QEFBAYWFhc3YdfgykmH3gaom729vRR37DlbD/m0UFu6KSAzle2oBeObNDxjd7bNTXFZWFrPj0FSJGBMornApLhERkciKZpIeqp1FWO1AzKwHMBJ4Laj4DmAbkAY8BNwG3P25HTn3kL+ccePGuSlTpoSz62brMudtKqiiqft7b9VOKJzDl04YzfGDukQkhrEV1fx8zuukde3PlCmDDpUXFhY2Oa5YScSYQHGFS3GJiIhEVlM7jjZHMdAn6HVvYEuYdXwVeM45d2jkcefcVuepBP6O16wmYXTOTqO0qvH1Aj4b2aXlwy8G5Gak0qtTpjqPioiIiLRS0UzS5wGDzWyAmaXhNVt5Icw6LgEeDy7w765jXi/L84GlEYg1YvKy0ygLo036qu1l5GWl0iUnsrODDuuey8pt+yNap4iIiIjERtSSdOdcDXAdXlOVT4GnnHPLzOxuMzsXwMzGm1kxcBHwoJktC2xvZv3x7sS/U6/qmWa2BFgCdAF+Hq3foTnys9PC6ji6qqSUwQWRG9klYGj3XNbuOEBVzZH65IqIiIhIIopmm3Sccy8DL9cruyvo+Ty8ZjChtl2P1/m0fvlpkY0ysvKz0iht4hCMzjmKSko557ieEY9jaPdcauoca3eWMax7h4jXLyIiIiLRE83mLu1SXnYaVbVwsKq20XW3l1ayv6KGIRFsjx4QSMxXql26iIiISKujJD3COvsTGu0ub7z36GedRnMiHseALtmkJJk6j4pIq2RmGWY218wWmdkyM/tpvGMSEYklJekRlucn6XsONJ6kryopA4jKnfS0lCSO6pqjO+ki0lpVAqc5547Dm4F6qplNinNMIiIxoyQ9wg7dSW9Kkr69lPzsNLrkpEcllqHdc5Wki0ir5A+1W+a/TPUfYc21ISLSmkW142h7lBdGkl5UUsagbpFv6hIwtHsuLyzaQmlFNbkZqVHbj4hINJhZMvAxMAh4wDk3p97yJs8s3dDsszePrIlcwEdw/8z/HHpekHn460ga2atjWOsn0qy8iqVhiRSPYgktGrEoSY+w/KymJemBkV3OGxX5kV0ChnX3mtEUlZQytl9+1PYjIhINzrlaYJSZdQKeM7NjnHNLg5Y3eWbphmafnXH7SxGOunE3j6zh3iXR+fhdP31KWOsn0qy8iqVhiRSPYgktGrGouUuEdcxMxWg8SS/ZX0lplEZ2CQjUrc6jItKaOef2AoXA1DiHIiISM0rSIywpychJa3x0l1Xb/ZFdukUvSe+dl0lOeorapYtIq2NmXf076JhZJnAGsCK+UYmIxI6au0RBbpo1OrpL0aGRXaLXJt3MGFKQozvpItIa9QAe89ulJ+HNWv3fOMckIhIzStKjIDfV2NVIkr6qxBvZpXOURnYJGNq9A68s3YpzGhRBRFoP59xiYHS84xARiRc1d4mCpt1JL2VwFEd2CRjWPZe95dVsL62M+r5EREREJDKUpEdBTpodseOoc45V28ui2mk0YGh3dR4VERERaW2UpEdBbqqxp7yKurrQTUw+G9kl+nfSh/r/CKzctj/q+xIRERGRyFCSHgW5aUadg/0V1SGXF5V4d7UHRXFkl4C87DS65abrTrqIiIhIK6IkPQpy0gygwc6jgSQ9FnfSwWvyEtiniIiIiCQ+JelR0MGbdLTBzqOrSsroHIORXQKGdc9lVUkZdRrhRURERKRVUJIeBTmpR76Tvmp7KYNjdBcdvGEYK2vqKDmgJF1ERESkNVCSHgW5fnOXUHfSnXOsKonNyC4Bgc6jxWV1MduniIiIiDSfkvQoCLRJ313++SR92/4KSitrYjJGesDgghySDIpLlaSLiIiItAZK0qMgPdnITE1md9nnk/SikjIABsfwTnpGajL9O2frTrqIiIhIK6EkPUrys9NC3klfdWhkl9gl6eCN8KI76SIiIiKtg5L0KMnPTgs56+iqkjK65KSRn50W03iGds9le7njYFVtTPcrIiIiIuFTkh4ledlpITuOFm0vZXAMJjGqb1j3XBzeyDIiIiIiktiUpEdJ5xDNXZxzrC4pi+nwiwGB5jWaeVREREQk8SlJj5K8rLTPdRzdus8f2SXG7dEB+nXOJi0JVipJFxEREUl4StKjpHNOGgeqaqmo/qwN+Krt3sguQ2I4/GJAcpLRMyeJohIl6SIiIiKJTkl6lORleR1D9wQ1eYnXyC4BvXOT1NxFREREpBVQkh4l+dmpAIeN8FJUUkqXnHTyYjyyS0DvnCR2lFaGHHVGRERERBKHkvQoyc9OB2DPgepDZUUlZTGdabS+3rneTKgrtu2PWwwiIiIi0jgl6VESuJO+60Al4I/ssr2MIXEY2SWgd453utV5VERERCSxRTVJN7OpZrbSzFab2e0hlp9sZgvMrMbMptVbVmtmC/3HC0HlA8xsjpmtMrMnzSw+bUca8dmddK9pydZ9FZTFaWSXgI7pRl5WqjqPioiIiCS4qCXpZpYMPACcBQwHLjGz4fVW2wjMAGaFqOKgc26U/zg3qPw3wO+dc4OBPcA3Ix58BHTMTMXsszbpRXHuNApgZgztnqvOoyIiIiIJLpp30icAq51za51zVcATwHnBKzjn1jvnFgN1TanQzAw4DXjGL3oMOD9yIUdOcpLRKTP10IRGq0q84Rfj2SYdYFj3DhRtK6WuzsU1DhERERFpWDST9F7ApqDXxX5ZU2WY2Xwz+8jMAol4Z2Cvc66mmXXGVH522mF30uM5skvAkIJcDlTVsnnvwbjGISIiIiINS4li3RaiLJzbt32dc1vMbCDwtpktAUINSxKyTjO7GrgaoKCggMLCwjB23TJlZWUUFhaSXHOQtZsPUlhYyMerD9I1jZjGESqu8j2rAHjmzQ8Y3S2ap79pAscq0Siu8CguERGRyIpmllYM9Al63RvY0tSNnXNb/J9rzawQGA38G+hkZin+3fQG63TOPQQ8BDBu3Dg3ZcqUZvwKzVNYWMiUKVN4fNN81u8s55RTTqLk7de4aFwfpkwZEbM4QsV18eQT+fmc10jr2p8pUwbFLZbgmGJ5bppKcYVHcYmIiERWNJu7zAMG+6OxpAEXAy80sg0AZpZnZun+8y7ACcBy55wDZgOBkWCuAP4T8cgjJD87jV0Hqtiyr4IDVbUMjuPwiwE56Sn0zstU51ERERGRBBa1JN2/030d8BrwKfCUc26Zmd1tZucCmNl4MysGLgIeNLNl/uZHA/PNbBFeUv5r59xyf9ltwE1mthqvjfrD0fodWiovK4095VUUbYv/yC7BhnXPZaUmNBIRERFJWFFtlOycexl4uV7ZXUHP5+E1Wam/3QfAyAbqXIs3ckzCy89Oo7bO8fGGPUD8R3YJGNo9l8KVO6iqqSMtRfNZiYiIiCQaZWhRlO+P5DJn3S665qbTKSsx5l0aUpBLTZ1jzY6yeIciIiIiIiEoSY+iQJK+aNM+hiRAe/SAYd07ALBS7dJFJEGZWR8zm21mn5rZMjO7Id4xiYjEkpL0KAok6VW1dQzulhjt0QEGds0mKy2Zxz5cT3lVTaPri4jEQQ1ws3PuaGAScG2IWatFRNosJelRlBfUvCVROo0CpCYnce9Fx7Fo016u/sfHVFTXxjskEZHDOOe2OucW+M9L8QYgSNjJ60REIi3+s9m0YZ1zPkvSE2H4xWBnjezBb6cdxy1PL+L6xz/hL9PHkJqs/9lEJPGYWX+8uTLm1Ctv8qR1DU1sdfPI2H+bWJAZvf3ePzO8UYkLMsPfJmBkr47N2q4hiTT5WCLFAokVj2IJLRqxKEmPoszUZNJTkqisqWNIAjV3CZg2tjcHKmv48QvLuPXpRdz31VEkJYWaKFZEJD7MLAdvIrsbnXOHjR0bzqR1DU1sNeP2lyIYbdPcPLKGe5ckxsdvS2JZP31KRGNJpMnHEikWSKx4FEto0YglMd4l2igzo3N2GjV1jo5ZqfEOJ6Qrju9PWWUNv3ttJdnpKfz8/GMwU6IuIvFnZql4CfpM59yz8Y5HRCSWlKRHWfeOGXTITMwEPeDaUwdRVlnDXwvXkJORwu1ThylRF5G4Mu9N6GHgU+fcffGOR0Qk1pSkR9kfLx7dKtp6f//MoZRV1PDgO2vpkJHKtacOindIItK+nQBcBiwxs4V+2Q/8SfJERNo8JelR1ic/K94hNImZ8dNzR3Ag0PQlLZkZJwyId1gi0k45594D9JWeiLRbStLlkKQk47fTjuVAVQ0/eXE52ekpXDSuT7zDEhEREWl3Er8dhsRUSnISf7pkNCcN7sJt/17My0u2xjskERERkXZHSbp8TnpKMg9eNpYxffO44YlPmL1ye7xDEhEREWlXlKRLSFlpKTxy5XiGds/l2//8mI/W7op3SCIiIiLthpJ0aVCHjFQeu3ICvfMyueqx+Swu3hvvkERERETaBSXpckSdc9KZedUk8rJTufyRuazcVhrvkKQd+WjtLlZs29/4iiIiIm2MknRpVPeOGcz85iTSkpP4+sNzWL/zQLxDknZge2kFV/59Hjc+sRDnXLzDERERiSkl6dIkfTtnMfOqidTU1jH9b3PYuu9gvEOSNu4vs9dwsLqWFdtKWbBRTa1ERKR9UZIuTTa4IJd/fGMi+w9WM/1vc9hZVhnvkKSN2rz3ILPmbOSc43qSk57CzDkb4h2SiIhITClJl7CM7N2RR64cz5a9B7ns4bnsK6+Od0jSBt3/1ioAbj9rGOeP7slLi7eyt7wqzlGJiIjEjpJ0Cdv4/vk8eNk4Vm8v5cpH53KgsibeIUkbsm7nAZ7+uJhLJ/alV6dMLp3Qj8qaOv69YHO8QxMREYkZJenSLKcM6cr9l4xm4aa9XP3P+VRU18Y7JGkj/vBmEanJxndOPQqA4T07MKZvJ2bO2aAOpCIi0m4oSZdmm3pMD3437TjeX72L37y6It7hSBuwclspLyzawozjB9AtN+NQ+aUT+7F2xwE+Wrs7jtGJiIjEjpJ0aZGvjO3NZZP68dgH61m0SSNwSMvc+/pKctJS+PYpAw8r//KxPeiQkcKsuRvjFJmIiEhsKUmXFrt16lC65KRzx7NLqKmti3c40kot2rSX15eXcNVJA+mUlXbYsozUZKaN7cOrS7dqVCEREWkXlKRLi3XISOXu80awfOt+Hnl/XbzDkVbqntdXkpeVyjdO7B9y+aUT+1Bd63h6fnFsAxMREYkDJekSEWeO6M4ZRxdw3xtFbNpdHu9wpJWZs3YX/1u1k2+fchS5Gakh1xnULZeJA/J5fO5G6urUgVRERNo2JekSEWbG3eeNINmMHz6/VKNwSJM557jn9ZV0zU3n8sn9j7ju9En92Li7nPdW74xNcCIiInGiJF0ipmenTG45cyjvFO3ghUVb4h2OtBLvFO1g3vo9XH/aIDLTko+47pkjCuicnaYZSEVEpM1Tki4Rdfnk/hzXuyM/++9yzRApjXLOce/rRfTqlMnF4/s2un56SjLTxvXmzU+3U7K/IgYRioiIxIeSdImo5CTjVxcey57yan71ssZOlyN7bdk2lmzexw1nDCYtpWlvR5dO6EttnePJeZuiHJ2IiEj8RDVJN7OpZrbSzFab2e0hlp9sZgvMrMbMpgWVjzKzD81smZktNrOvBS171MzWmdlC/zEqmr+DhG94zw5cddIAnpy/iY/W7op3OAlly96DPDF3I2WVNfEOJe5q6xz3vVHEwK7ZXDi6V5O369c5m5MGd+HxuRs15KeIiLRZUUvSzSwZeAA4CxgOXGJmw+utthGYAcyqV14OXO6cGwFMBf5gZp2Clt/qnBvlPxZG5ReQFrnx9CH0yc/kB88toaK6Nt7hJIS1O8r4yl8/4PZnl3DCr9/mj2+uYt/B6niHFTcvLtpCUUkZ3ztjCCnJ4b0VTZ/Yl637KihcuSNK0YmIiMRXNO+kTwBWO+fWOueqgCeA84JXcM6td84tBurqlRc551b5z7cA24GuUYxVIiwzLZmfnz+StTsO8JfCNfEOJ+5WbNvPVx/8iKqaOu6/ZDQTBuTz+zeLOPHXb/O711aw+0D7ar9fXVvH798s4ugeHfjSyB5hb3/60QV0y03XDKQiItJmpUSx7l5AcKPRYmBiuJWY2QQgDQjO9H5hZncBbwG3O+c+NwWhmV0NXA1QUFBAYWFhuLtutrKyspjur6niEdekHsk88PYqulcW0zPn8/8TtodjtXZfLffOryAtybh1fAa5e4qY3hdO6pTBi2ur+cvsNfzt3TWc2ieVqQNS6JTe8P/ObeV4FW6qZsOuKm4Yk867777TrH1O6lbHiyu288wrb9MlM/QxS9TjJSIi0phoJukWoiyswbPNrAfwT+AK51zgbvsdwDa8xP0h4Dbg7s/tyLmH/OWMGzfOTZkyJZxdt0hhYSGx3F9TxSOuY8ZVcvq97/BccQZPXj2ZpKTDL4u2fqzmrtvNfY/OIz83k1lXTaJPftZhyy8HVm8v5YHZa/jPws3MLq7lkgl9+dYpA+nRMTNqcUVaOHFVVNdyxz2FjOrTiRsvOh6zUG8VjRs86iD//c3brE/qxbQpQ1scl4iISCKJZnOXYqBP0OveQJMHzzazDsBLwA+dcx8Fyp1zW52nEvg7XrMaSVBdctK58+yjmbd+D0/Ob1+jcbxbtIPLH5lDtw7pPPWtyZ9L0AMGdcvl918bxds3T+G8UT3510cbOOW3hfzguSVtcvbWWXM2snVfBbeeObTZCTpAr06ZnDq0G0/O30S1OpCKiEgbE80kfR4w2MwGmFkacDHwQlM29Nd/DviHc+7pest6+D8NOB9YGtGoJeIuGtebSQPz+eXLn7K9tH2Mbf36sm1c9dh8+nfO5qlvTQ55V7y+/l2y+e2045h9yxQuGtebZ+YXc+o9hdz69CLW7TwQg6ijr7yqhr8UrmbywM6cMKhLi+ubPqkvO0oreXN5SQSiExERSRxRS9KdczXAdcBrwKfAU865ZWZ2t5mdC2Bm482sGLgIeNDMlvmbfxU4GZgRYqjFmWa2BFgCdAF+Hq3fQSLDzPjlBSOprKnj7heXxzucqPvPws1cM3MBR/fswBNXT6JLTnpY2/fJz+IXF4zk3e+fymWT+/HCoi2cfm8hNzzxCZvLWvcd47+/v56dZVXccmbo5inhOmVIN3p1ymTmHHUgFRGRtiWabdJxzr0MvFyv7K6g5/PwmsHU3+5fwL8aqPO0CIcpMTCwaw7XnTqI+94o4itjtnPqsG7xDikqnpy3kdufXcKE/vk8PGM8OenN/xPr3jGDH58zgu9MGcTf3lvLPz/cwAtVtby392OuO20QI3p2jGDk0bfvYDUPvrOG04Z1Y2y/vIjUmZxkXDKhD/e8XsT6nQfo3yU7IvWKiIjEm2YclZj59ilHMbhbDj98fikH2uBkPo+8t47b/r2Ekwd35dErJ7QoQQ/WNTedO846mvdvO40vH5XKe6t28qU/vcdVj81j6eZ9EdlHLPztf2vZX1HDzV8cEtF6vzquDylJxuMajrFNMbNHzGy7malJo4i0S0rSJWbSUpL45YUj2bz3IL9/oyje4UTUA7NXc/d/l3PmiAIeunwsmWnJEd9HXnYaXxmcxnu3n8bNXxjC/A17uPCvH7B8y/6I7yvSdpVV8sh76/jSyB4R/wagW4cMvjC8gKfmb6KyRhNntSGP4k1mJyLSLilJl5ga3z+fSyf25ZH317Wqu8ANcc7x21dX8LvXVnLB6F48cOkY0lMin6AH65iZyvWnD+bNm06hU2Yq181akPDfTPy1cA0Hq2v53hciexc9YPrEfuwpr+bVpduiUr/EnnPuXWB3vOMQEYmXqLZJFwnltqnDeGN5Cbc/u5jvjQhr6PyEUlfnuPu/y3n0g/VcOrEvPz/vmM+NAx9NXXLS+ePFo5n+t4/40X+Wct9XRzW+URxs21fBPz7awAWjezOoW05U9nH8UZ3p1zmLmXM2ct6oXlHZhySecCata2hiq5tHxv4f3ILM+Ow3lJbEEumJwhJh8rEl/s2jgky4f+Z/orafkb3C+0YxEY5NQCLEkojnKRrHRUm6xFzHzFR+cs4Irp21gDdy0jg93gE1Q22d445nF/PU/GKuOnEAd37p6BaN+d1ck4/qzHdPH8wf3lzF8Ud1YdrYz/XDjrv7316Fc44bzxgctX0kJRmXTujLr15ZwaqSUgYX5EZtX5I4wpm0rqGJrWbc/lKUomvYzSNruHdJYnz8tiSW9dOnRDSWRJh8LHA9RPschXvsEuHYBCRCLIl4nqJxXNTcReLi7JHdOW1YN55dXdXqJuyprq3jxicX8tT8Yr57+uC4JegB1582mEkD8/nR80tZvb00bnGEsnFXOU/O28TXxvdpcDKnSJk2tjdpyUkajlFERNoEJekSF2bG3eeNwIC7/rMU51pHs5eK6lqu+dcCXly0hTvOGsZNXxgS1wQdvGEI/3jxaLLSkrl25idUVCdO58k/vFVEcpJx/WnRu4se0DknnbNGduffC4o5WJU4x0BERKQ5lKRL3PTOy+LCwWnMXrmDl5ZsjXc4jSqvquGqx+bz5qcl/Oy8EXzrlKPiHdIhBR0yuPerx7GypJSfJsiEUau3l/L8J5u5fHI/CjpkxGSfl07oS2lFDf9dvCUm+5PoMbPHgQ+BoWZWbGbfjHdMIiKxpCRd4uqMvimM7NWRn7ywnH3l1fEOp0H7K6q5/OG5fLBmJ/dcdByXTe4f75A+Z8rQbnz7lKN4fO5GXlwU/yT1vjeKyExN5popg2K2zwkD8hnULUdNXtoA59wlzrkezrlU51xv59zD8Y5JRCSWlKRLXCUnGb+6cCS7D1Ty61dXxDucw5RX1bB8y35eWryVr/9tDgs37eX+S8YkZOfMgJu/OIQxfTtxx7NL2LDrQNziWLp5Hy8v2cY3TxxAfnZazPZrZkyf2JeFm/aybEvrH+JTRETar8ToXi7t2jG9OvLNEwfw//63jgtG92LCgPyY7bu6to5Nu8tZt/PAYY8Vm8vZ/eprh9bLTE3mocvHctqwgpjF1hypyUn86ZLRfOlP73HdrE945prJUR+3PZR7X19Jx8xUrjp5YMz3feHo3vzm1RXMmrORL+TFfPciIiIRoSRdEsL3vjCEl5ds4wfPLeEn54wgPTWJjJRkMlKTSA/8TE0mPSWJ9JSksDpr1tU5SkorWLfjAGvrJeMbd5dTW/dZp9WOmakM7JrN0fnJTD5mIAO65DCgSzYDumRHZRbRaOidl8Vvpx3Lt/75Mb9+ZQU/UsyGAQAAFhpJREFUPmdETPf/8YbdzF65g+9PHUqHjNSY7hugY1YqXz62J89/spkTT06P+f5FREQiQUm6JISstBR+fsExfOPReXz94TlHXNcMP1n3kvcMP3nPSE0mIyWZdD+xTzLYuLucDbvKORg04klGahL9O2dzdI9czh7Z/VAiPrBLNnl+0wxvvNPoj0gSLWeO6M6M4/vz9/fXM2lgZ84c0T0m+11VUsqtTy+mS046M47vH5N9hjJ9Yl+e+biYj7bUcFbcohAREWk+JemSME4d2o3CW6ZQsr+SiupaKmvqqKiuPex5ZU0dldW1VAReV9dRUXP4OqUVNeyorqTOOXrnZXHCoC6HkvABXbMpyM2I6cyg8XLH2cOYv2E3339mMcf06kivTplR3d+zC4q587mlZKUl88D0MWSlxe/tZVSfTgzv0YHC4jKcc3EfJlNERCRcStIlofTrnE2/ztnxDqNNSE9J5s+XjOHL97/Hdx//hCeunkRqcuT7ildU1/LI0kreLV7EhAH53H/J6JgNudgQM+PSiX354fNLWVS8j1F9OsU1HhERkXBpdBeRNqx/l2x+eeFIPt6wh/veKIp4/Wt3lHH+A+/zbnEN35lyFLOumhj3BD3g/NG9yEiGmR9tiHcoIiIiYVOSLtLGnXtcTy6Z0Ie/Fq7hnaIdEav3xUVbOOf+9yjZX8FNY9P5/tRhpEThTn1z5aSnMKlnCi8u3sK+g4k7Br+IiEgoifOJKiJRc9eXRzC0IJebnlxIyf6KFtVVUV3LD59fwvWPf8LQ7rm89N2TOLZrYracO7VPChXVdTy3oDgi9TnnWLOjjFlzNrJ0s8ZhFxGR6EnMT1YRiajMtGT+fOlozv3z+9z4xEL+ddVEkpvReXbDrgNcO2sBSzfv5/87aQDfnzqM1OQkIt+QJjL6dUjmuD6dmDlnI1cc3z/sDqR1dY4V20qZu24Xc9fvZu663ewsqwLgu6cP5pheHaMRtoiIiJJ0kfZicEEud583glufWcyf317NDWeEN8Tkq0u3cuvTizGD/3f5OL4wPLEndgqYPrEv339mMfPW72l0oqzq2jqWbdnvJeXrvKR8f0UNAL06ZXLy4K5MGJDPhAH5DOiiDs4iIhI9StJF2pFpY3vz4Zpd/PGtIiYMyGfyUZ0b3aaqpo5fvfIpf39/Pcf17sifLx1Dn/ysGEQbGecc25Of/Xc5s+Zs+FySXlFdy+Lifcxdt4s563bz8YY9lFd5Y+oP7JLN2SN7HErKe+e1nt9ZRERaPyXpIu2ImfGz849h4aa93PDEJ7xyw0l0zml4Vs7iPeVcO+sTFm3ay4zj+/ODs48mLaV1dWXJTEvmK2N6M2vORm45s5z1O8uZ4yflCzftpaqmDoBh3XOZNrY3Ewd0ZvyAPLrlJsYoNSIi0j4pSRdpZ7LTU7j/0tFc8JcPuOmpRfx9xviQkzu9ubyEm59eRF2d4y/Tx3D2yB5xiDYypk/sy6MfrOfE38wGIDnJOKZnB66Y3I8JAzozvn8enbLS4hyliIjIZ5Ski7RDI3p25EdfHs6Pnl/KQ/9by7dPOerQsuraOu55bSUPvruW4T068JfpY+jfyttfDy7I5ftTh3KgsoYJAzoztl8eOel6+xMRkcSlTymRdurrE/vy4Zqd3PPaSsb3z2dsvzy27jvIdbM+4eMNe5g+sS8/+vJwMlKT4x1qRHxnyqB4hyAiItJkStJF2ikz41cXHsuSzf/ju49/wu1nDeOu/yylsqaOP148ivNG9Yp3iCIiIu1W6+oBJiIR1TEzlfsvGUPJ/gquf/wTuuVm8MJ1JypBFxERiTPdSRdp50b16cQ9Fx3Hp1v3c+MZQ8hMaxvNW0RERFozJekiwvmje3H+aN09FxERSRRq7iIiIiIikmCimqSb2VQzW2lmq83s9hDLTzazBWZWY2bT6i27wsxW+Y8rgsrHmtkSv84/mdnnB3gWEREREWnFopakm1ky8ABwFjAcuMTMhtdbbSMwA5hVb9t84MfARGAC8GMzy/MX/xW4GhjsP6ZG6VcQEREREYmLaN5JnwCsds6tdc5VAU8A5wWv4Jxb75xbDNTV2/ZM4A3n3G7n3B7gDWCqmfUAOjjnPnTOOeAfwPlR/B1ERERERGIumh1HewGbgl4X490Zb+62vfxHcYjyzzGzq/HuuFNQUEBhYWETd91yZWVlMd1fUyViXIkYEyiucCkuERGRyIpmkh6qrbhr4bZNrtM59xDwEMC4cePclClTmrjrlissLCSW+2uqRIwrEWMCxRUuxSUiIhJZ0WzuUgz0CXrdG9jSwm2L/efNqVNEREREpFWIZpI+DxhsZgPMLA24GHihidu+BnzRzPL8DqNfBF5zzm0FSs1skj+qy+XAf6IRvIiIiIhIvEQtSXfO1QDX4SXcnwJPOeeWmdndZnYugJmNN7Ni4CLgQTNb5m+7G/gZXqI/D7jbLwO4BvgbsBpYA7wSrd9BRERERCQeojrjqHPuZeDlemV3BT2fx+HNV4LXewR4JET5fOCYyEYqIiIiIpI4NOOoiIgkpMYmxBMRacuUpIuISMJp4oR4IiJtlpJ0ERFJRI1OiCci0paZN3Fn22ZmO4ANMdxlF2BnDPfXVIkYVyLGBIorXIqrafo557rGO4jWwMymAVOdc1f5ry8DJjrnrgta59CkdcBQYOURqkyka0GxhKZYGpZI8SiW0AKxROx9PqodRxNFrD8UzWy+c25cLPfZFIkYVyLGBIorXIpLoqDRyeuCJ61rtLIEuhYUS2iKpWGJFI9iCS0asai5i4iIJKKWTIgnItLqKUkXEZFE1JIJ8UREWr120dwlDpr09WscJGJciRgTKK5wKS6JKOdcjZkFJsRLBh5xzi1rQZWJdC0oltAUS8MSKR7FElrEY2kXHUdFRERERFoTNXcREREREUkwStJFRERERBKMkvQmMLOhZrYw6LHfzG40s3wze8PMVvk/8/z1zcz+5E9lvdjMxgTVdYW//iozuyICsX3PzJaZ2VIze9zMMvyOVnP8fTzpd7rCzNL916v95f2D6rnDL19pZme2MKYb/HiWmdmNfllcjpWZPWJm281saVBZxGIxs7FmtsTf5k9mFmrYuKbEdJF/vOrMbFy99UOeG2tgyvSGzn8z4/qdma3wj8dzZtYpQeL6mR/TQjN73cx6+uUxOYcSXw1dY0HLTzazBWZWY95468HLInodNDcWMxtlZh/6f/eLzexrQcseNbN19tlnzqgYHZvaoH2+EFTe3L/d5h6bU+3wz9wKMzu/JcemCbHcZGbL/XPxlpn1C1oW62smZCzRuGZaeFxifb00dFzicb182z/3C83sPQuaDdnC/Gw8IuecHmE88DowbQP6Ab8FbvfLbwd+4z8/G3gFb5zfScAcvzwfWOv/zPOf57Ugll7AOiDTf/0UMMP/ebFf9n/ANf7z7wD/5z+/GHjSfz4cWASkAwOANUByM2M6BlgKZOF1TH4TGByvYwWcDIwBlgaVRSwWYC4w2d/mFeCsZsZ0NN5kLIXAuKDykOfGf6wBBgJp/jrDg66Dz53/Zsb1RSDFf/6boGMV77g6BD3/Lp9d1zE5h3rE73Gkayxonf7AscA/gGlB5ZH+W25JLEOAwf7znsBWoJP/+tHgdWNxbPxlZQ3UG/bfbktjqXfOdgNZzT02TYzl1KB9XMNnn4/xuGYaiiWi10xLYonT9dJgLHG4XoI/g84FXvWfh/3ZeKSH7qSH73RgjXNuA94U1Y/55Y8B5/vPzwP+4TwfAZ3MrAdwJvCGc263c24P8AYwtYXxpACZZpaClxhvBU4DnmkgrkC8zwCn+//5nwc84ZyrdM6tA1bjTcndHEcDHznnyp1zNcA7wAXE6Vg5597F+4MNFpFY/GUdnHMfOu+v8x9BdYUVk3PuU+dcqNkSGzo3IadM989nQ+e/OXG97p9HgI/wxqpOhLj2B73M5rNJbmJyDiWuQl5jwSs459Y75xYDdfW2jfR10OxYnHNFzrlV/vMtwHagpRPvteTYhNSCv91IxTINeMU5V96UeFsQy+ygfQS/18XjmgkZSxSumZYcl5CifL00JZZYXS9H+gxq8mdjY4EoSQ/fxcDj/vMC59xWAP9nN7+8F7ApaJtiv6yh8mZxzm0G7gE24iXn+4CPgb1BiVXwPg7t31++D+gc4biWAiebWWczy8K7s9mHOB+reiIVSy//eTRiDAg3ps40fP5b6ht4d4sSIi4z+4WZbQKmA3c1M65YnEOJrJa8N0T6OojI+5SZTcC7u7YmqPgX/tf6vzez9CZW1dJ4Msxsvpl9FGguQPP/diP1Hh78mRsQ7rEJN5Zv0rT3ulhcM8GxHBKha6alscTzegl5XIjh9WJm15rZGrxv57/byLbN+ntQkh4Gv13VucDTja0aoswdoby58eTh/Sc2AO+rr2zgrCPsI+pxOec+xWsW8QbwKt5XOjVH2CQmx6qJwo0lFjEmRExmdifeeZyZKHE55+50zvXxY7ouUeKSqGvJOYv0ddDi68e/I/tP4ErnXOCO8h3AMGA83tf3tzW1uhbG09d505pfCvzBzI5qQZ2ROjYj8cbKD2jOsWlyLGb2dWAc8LtGto36cQkRS6A8UtdMS2OJy/XSyHGJ2fXinHvAOXeUX+cPG9m2WcdFSXp4zgIWOOdK/Ncl/kURuDi2++UNTWcd6WmuzwDWOed2OOeqgWeB4/G+4g9MVBW8j0P795d3xGtGENG4nHMPO+fGOOdO9utfRfyPVbBIxVLM4V+3RWPa8nBj2knD579ZzOso9WVguv+1bkLEFWQW8JVmxhWLcyiR1ZL3hkhfBy16nzKzDsBLwA/95lmA9w2f32SrEvg7TW9+2KJ4/CYUOOfW4vWPGU3z/3Yj8R7+VeA5//MtEGNzjk2TYjGzM4A7gXP9+o+0bVSvmQZiifQ106JY4nG9NBSLL6bXS5An+KxJT2RzGhdGY/r2/vBPxJVBr3/H4R0Qf+s//xKHd16b6z7r0LAOr/NJnv88vwXxTASW4bVFN7y2X9fj3ekP7rTxHf/5tRzecfQp//kIDu/osJZmdhz16+vm/+wLrPB/17gdK7zOScGdDiMWC97U5ZP4rOPQ2c2JKai8kMM7joY8N3h9Edb6ZYFOKCP8bUKe/2Yeq6nAcqBrvfXiHdfgoOfXA8/E+hzqEZ/Hka6xEOs+yuc7jkbsOmhhLGnAW8CNIdbt4f804A/Ar2NwbPKAdP95F7ybK4FO32H/7bYklqDyj4BTW3psmhILXoK5Jvi9JV7XzBFiieg108JYYn69NBRLnK6X4M+gc4D5/vOwPxuPGEtjK+hx6CRkAbuAjkFlnf0/mFX+z8AfrgEP+BfTEg5Pur6B15FgNUEJfwvi+ileIrwU7+uvdLzew3P9fTwd9IeU4b9e7S8fGFTPnX68K2nh6BbA//ASu0XA6fE8Vnht07YC1Xj/yX4zkrHgfeW21N/mz+DN4tuMmC7wn1cCJcBrjZ0bvPb+Rf6yO4PKQ57/Zsa1Gq8d3UL/8X8JEte//eO+GHgR6BXLc6hHfB+hrjHgbry7a+B9tV0MHMB7314WreugubEAX/ev6YVBj1H+srf963cp8C8gJ9rHBu9b2CV479tLgG8G1dncv92WnKf+wGYgqV6dzTo2TYjlTbz33sC5eCGO10zIWKJxzbQglnhcL0c6R7G+Xv6Id5N0ITCboISbMD8bj/Qwf0MREREREUkQapMuIiIiIpJglKSLiIiIiCQYJekiIiIiIglGSbqIiIiISIJRki4iEWFmF5nZMjOrM7NxR1hvvZktMbOFZja/3rLrzWylX89v/bLOZjbbzMrM7M/11k8zs4fMrMjMVpjZV/zym8xsuT/L3Ftm1s8v72dmH/v7XmZm3/bLs8zsJb+OZWb26yb8vsPM7EMzqzSzW4LK+/jxfurXdUM4x1FERAS8cRtFxGdmNwIPOefKw9xuBvC68yd3aOvMbAowwzk3I6h4KXAh8GATqjjVObezXp2n4s2ge6xzrtLMuvmLKoAfAcf4j2B3Atudc0PMLAlvTGOAT/CGXyw3s2vwpm3+Gt5Qjsf79ecAS83sBWAvcI9zbrY/s/BbZnaWcy7UtNMBu/Gmgj6/XnkNcLNzboGZ5QIfm9kbzrnlTTguIiIigO6ki9R3I96Y+E1mZsnADKBnNAJqLZxznzrnVragimvwJpqo9Ovb7v884Jx7Dy9Zr+8bwK/89eoCib9zbnbQP1of4c8M6Jyrcp/NUpeO/x7onCt3zs0OrAMsCGxjZl3N7N9mNs9/nBCIzzk3D2/c4uDjsNU5t8B/Xgp8CvRqwXEREZF2SEm6tFtmlu03cVhkZkvN7Md4ifZsM5vtr/NXM5vvN1v4adC2683sLjN7D7gEb1KLmX4zisy4/EKthwNe95udXB1UPgQ4yczmmNk7Zjb+SJWYWSf/6c/MbIGZPW1mBSFW/SbebICB7fqY2WK8SZp+U//bD7/ec/AmugJv0orfO+fGA18B/tbUX9TM+uPNkjenqduIiIiAmrtI+zYV2OKc+xKAmXUEruTwphh3Oud2+3fL3zKzY51zi/1lFc65E/1trwJucc7Npw0zszl4d6BzgHwzW+gvus0591oTqznBObfFb87yhpmtcM69i/d+lIc3zfZ44CkzG+gannEtBe9u9/vOuZvM7CbgHuCyoHi/jvcP1CmBMufcJuBYM+sJPG9mzzjnSvz1U/BmOP2Tc26tv8kZwHAzC1TRwcxy/bvkDfKb0/wbbwrv/U08NiIiIoDupEv7tgQ4w8x+Y2YnOef2hVjnq2a2AK+N8whgeNCyJ2MRZCJxzk10zo0CrsKbknmU/2hqgk7gzrXfnOU5YIK/qBh41nnmAnVAlyNUtQso9+sAb/rpMYGFZnYGXpv1c4OauNSPYxlwUlDxQ8Aq59wfgsqSgMlBv2uvJiToqXgJ+kzn3LNHWldERCQUJenSbjnnioCxeMn6r8zsruDlZjYAuAU43Tl3LPASkBG0yoFYxdpW+E2McgPPgS/idTgFeB44zV82BEgDdoaqB8C/w/4iMMUvOh1Y7m8/Gq8D67mBtu1+ee9AcyQzywNOAFb6r38OdMTrlxDsdeC6oDpGNfI7GvAw8Klz7r4jrSsiItIQJenSbvnNHcqdc//CayYxBigFcv1VOuAl4vv8ts5nHaG64O3aJTO7wMyKgcnAS2b2ml/e08xe9lcrAN4zs0XAXOAl59yr/rJHgIFmthR4Argi0NTFzNYD9wEzzKzYzALfaNwG/MRvY34ZcLNf/ju8JjlP+/0EXvDLjwbm+Pt/B29ElyVm1hvvrvtwYIG/zVX+Nt8FxvnDOS4HAsM2dvd/35uAH/pxdcBL/C8DTvPrWWhmZ7f4AIuISLtiDTf3FGnbzOxMvGSuDm+EjmvwEsxrga3OuVPN7FFgIrAWqMRr4vGonzSOC7RdN2987l8CB/GaRhyM8a8jIiIibYiSdBERERGRBKPmLiIiIiIiCUZJuoiIiIhIglGSLiIiIiKSYJSki4iIiIgkGCXpIiIiIiIJRkm6iIiIiEiCUZIuIiIiIpJg/n8YjyjQoe4lfQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -89,9 +89,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": { @@ -115,19 +115,23 @@ " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", "\n", " fig = plt.figure(figsize=(12, 6))\n", - " fig.suptitle(owner_info, fontsize=20)\n", + " fig.suptitle(owner_info, fontsize=21)\n", "\n", " ax = fig.add_subplot(1, 2, 1)\n", " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", " ax.legend([str(symbol)])\n", - " ax.set_xlabel('start')\n", - " ax.set_ylabel('duration (ms)')\n", - " ax.title.set_text('Callback durations')\n", + " ax.set_xlabel('start', size=14)\n", + " ax.set_ylabel('duration (ms)', size=14)\n", + " ax.title.set_text('Callback duration')\n", + " ax.title.set_size(16)\n", " ax.grid()\n", "\n", " ax = fig.add_subplot(1, 2, 2)\n", " duration_ms.hist(column='duration', ax=ax)\n", + " ax.set_xlabel('duration (ms)', size=14)\n", + " ax.set_ylabel('frequency', size=14)\n", " ax.title.set_text('Duration histogram')\n", + " ax.title.set_size(16)\n", "\n", " plt.show()" ] From 0bbea50cea00a100e1e46d3269cf205453063f73 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 28 Jun 2019 14:49:15 +0200 Subject: [PATCH 94/98] Use bokeh for callback duration plots --- .../analysis/callback_duration.ipynb | 510 ++++++++++++++++-- 1 file changed, 476 insertions(+), 34 deletions(-) diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb index 6d71525..6faabbe 100644 --- a/tracetools_analysis/analysis/callback_duration.ipynb +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -22,8 +22,14 @@ "sys.path.insert(0, '../')\n", "sys.path.insert(0, '../../../ros2/ros2_tracing/tracetools_read/')\n", "import os\n", - "import pickle\n", - "import matplotlib.pyplot as plt\n", + "\n", + "from bokeh.plotting import figure\n", + "from bokeh.plotting import output_notebook\n", + "from bokeh.io import show\n", + "from bokeh.layouts import row\n", + "from bokeh.models import ColumnDataSource\n", + "import numpy as np\n", + "import pandas as pd\n", "\n", "from tracetools_analysis.analysis import load\n", "from tracetools_analysis.analysis import ros2_processor\n", @@ -40,7 +46,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "550 events\n" + "374 events\n" ] } ], @@ -65,37 +71,472 @@ "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "" + "text/html": [ + "\n", + "
\n", + " \n", + " Loading BokehJS ...\n", + "
" ] }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + "\n", + " if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n", + " root._bokeh_onload_callbacks = [];\n", + " root._bokeh_is_loading = undefined;\n", + " }\n", + "\n", + " var JS_MIME_TYPE = 'application/javascript';\n", + " var HTML_MIME_TYPE = 'text/html';\n", + " var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n", + " var CLASS_NAME = 'output_bokeh rendered_html';\n", + "\n", + " /**\n", + " * Render data to the DOM node\n", + " */\n", + " function render(props, node) {\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(script);\n", + " }\n", + "\n", + " /**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + " function handleClearOutput(event, handle) {\n", + " var cell = handle.cell;\n", + "\n", + " var id = cell.output_area._bokeh_element_id;\n", + " var server_id = cell.output_area._bokeh_server_id;\n", + " // Clean up Bokeh references\n", + " if (id != null && id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + "\n", + " if (server_id !== undefined) {\n", + " // Clean up Bokeh references\n", + " var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n", + " cell.notebook.kernel.execute(cmd, {\n", + " iopub: {\n", + " output: function(msg) {\n", + " var id = msg.content.text.trim();\n", + " if (id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + " }\n", + " }\n", + " });\n", + " // Destroy server and session\n", + " var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n", + " cell.notebook.kernel.execute(cmd);\n", + " }\n", + " }\n", + "\n", + " /**\n", + " * Handle when a new output is added\n", + " */\n", + " function handleAddOutput(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + "\n", + " // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n", + " if ((output.output_type != \"display_data\") || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + "\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + "\n", + " if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n", + " toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n", + " // store reference to embed id on output_area\n", + " output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " }\n", + " if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + " }\n", + "\n", + " function register_renderer(events, OutputArea) {\n", + "\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[toinsert.length - 1]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " /* Handle when an output is cleared or removed */\n", + " events.on('clear_output.CodeCell', handleClearOutput);\n", + " events.on('delete.Cell', handleClearOutput);\n", + "\n", + " /* Handle when a new output is added */\n", + " events.on('output_added.OutputArea', handleAddOutput);\n", + "\n", + " /**\n", + " * Register the mime type and append_mime function with output_area\n", + " */\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " /* Is output safe? */\n", + " safe: true,\n", + " /* Index of renderer in `output_area.display_order` */\n", + " index: 0\n", + " });\n", + " }\n", + "\n", + " // register the mime type if in Jupyter Notebook environment and previously unregistered\n", + " if (root.Jupyter !== undefined) {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + "\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " }\n", + "\n", + " \n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " var NB_LOAD_WARNING = {'data': {'text/html':\n", + " \"
\\n\"+\n", + " \"

\\n\"+\n", + " \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n", + " \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n", + " \"

\\n\"+\n", + " \"
    \\n\"+\n", + " \"
  • re-rerun `output_notebook()` to attempt to load from CDN again, or
    • \\n\"+\n", + " \"
  • use INLINE resources instead, as so:
    • \\n\"+\n", + " \"
\\n\"+\n", + " \"\\n\"+\n", + " \"from bokeh.resources import INLINE\\n\"+\n", + " \"output_notebook(resources=INLINE)\\n\"+\n", + " \"\\n\"+\n", + " \"
\"}};\n", + "\n", + " function display_loaded() {\n", + " var el = document.getElementById(\"1001\");\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS is loading...\";\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(display_loaded, 100)\n", + " }\n", + " }\n", + "\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls == null || js_urls.length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length;\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " };var element = document.getElementById(\"1001\");\n", + " if (element == null) {\n", + " console.error(\"Bokeh: ERROR: autoload.js configured with elementid '1001' but no matching script tag was found. \")\n", + " return false;\n", + " }\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-gl-1.2.0.min.js\"];\n", + " var css_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.2.0.min.css\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.2.0.min.css\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.2.0.min.css\"];\n", + "\n", + " var inline_js = [\n", + " function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + " \n", + " function(Bokeh) {\n", + " \n", + " },\n", + " function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " \n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (var i = 0; i < inline_js.length; i++) {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " }if (force === true) {\n", + " display_loaded();\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " } else if (force !== true) {\n", + " var cell = $(document.getElementById(\"1001\")).parents('.cell').data().cell;\n", + " cell.output_area.append_execute_result(NB_LOAD_WARNING)\n", + " }\n", + "\n", + " }\n", + "\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n", + " run_inline_js();\n", + " } else {\n", + " load_libs(css_urls, js_urls, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + "}(window));" + ], + "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\n \n\n \n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n var NB_LOAD_WARNING = {'data': {'text/html':\n \"
\\n\"+\n \"

\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"

\\n\"+\n \"
    \\n\"+\n \"
  • re-rerun `output_notebook()` to attempt to load from CDN again, or
    • \\n\"+\n \"
  • use INLINE resources instead, as so:
    • \\n\"+\n \"
\\n\"+\n \"\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"\\n\"+\n \"
\"}};\n\n function display_loaded() {\n var el = document.getElementById(\"1001\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };var element = document.getElementById(\"1001\");\n if (element == null) {\n console.error(\"Bokeh: ERROR: autoload.js configured with elementid '1001' but no matching script tag was found. \")\n return false;\n }\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.2.0.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-gl-1.2.0.min.js\"];\n var css_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.2.0.min.css\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.2.0.min.css\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.2.0.min.css\"];\n\n var inline_js = [\n function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\n \n function(Bokeh) {\n \n },\n function(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n \n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }if (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n var cell = $(document.getElementById(\"1001\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function embed_document(root) {\n", + " \n", + " var docs_json = {\"710b83fb-e539-40b6-948f-65ef8636a944\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1050\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1089\",\"type\":\"Row\"},{\"attributes\":{\"callback\":null},\"id\":\"1006\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1072\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"overlay\":{\"id\":\"1103\",\"type\":\"BoxAnnotation\"}},\"id\":\"1073\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"below\":[{\"id\":\"1061\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1065\",\"type\":\"Grid\"},{\"id\":\"1070\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1066\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1087\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1051\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1077\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1053\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1057\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1055\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1059\",\"type\":\"LinearScale\"}},\"id\":\"1050\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1074\",\"type\":\"SaveTool\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1046\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1014\",\"type\":\"LinearAxis\"},{\"attributes\":{\"data_source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1038\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1039\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1041\",\"type\":\"CDSView\"}},\"id\":\"1040\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1038\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1075\",\"type\":\"ResetTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1051\",\"type\":\"Title\"},{\"attributes\":{\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1018\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1015\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1076\",\"type\":\"HelpTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1053\",\"type\":\"DataRange1d\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1024\",\"type\":\"PanTool\"},{\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"id\":\"1027\",\"type\":\"SaveTool\"},{\"id\":\"1028\",\"type\":\"ResetTool\"},{\"id\":\"1029\",\"type\":\"HelpTool\"}]},\"id\":\"1030\",\"type\":\"Toolbar\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1019\",\"type\":\"LinearAxis\"},{\"attributes\":{\"callback\":null},\"id\":\"1055\",\"type\":\"DataRange1d\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1071\",\"type\":\"PanTool\"},{\"id\":\"1072\",\"type\":\"WheelZoomTool\"},{\"id\":\"1073\",\"type\":\"BoxZoomTool\"},{\"id\":\"1074\",\"type\":\"SaveTool\"},{\"id\":\"1075\",\"type\":\"ResetTool\"},{\"id\":\"1076\",\"type\":\"HelpTool\"}]},\"id\":\"1077\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1024\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1012\",\"type\":\"LinearScale\"},{\"attributes\":{\"data_source\":{\"id\":\"1084\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1085\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1086\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1088\",\"type\":\"CDSView\"}},\"id\":\"1087\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"below\":[{\"id\":\"1014\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1018\",\"type\":\"Grid\"},{\"id\":\"1023\",\"type\":\"Grid\"},{\"id\":\"1048\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1019\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1004\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1030\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1006\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1010\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1008\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1012\",\"type\":\"LinearScale\"}},\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1057\",\"type\":\"LinearScale\"},{\"attributes\":{\"overlay\":{\"id\":\"1047\",\"type\":\"BoxAnnotation\"}},\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1059\",\"type\":\"LinearScale\"},{\"attributes\":{\"source\":{\"id\":\"1084\",\"type\":\"ColumnDataSource\"}},\"id\":\"1088\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1027\",\"type\":\"SaveTool\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1099\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1062\",\"type\":\"BasicTicker\"}},\"id\":\"1061\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1028\",\"type\":\"ResetTool\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"NUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"0EICRpc3uz86HjNQGf+2PzwtP3CVJ7Q/51Wd1QJ7tD/7O9ujN9yzP1Cm0eRiDLQ/mMCtu3mqsz9Kfy+FB82mP67vw0FClLM/2GK3zyoztT8vhQfNrnujP3I2HQHcLLY/HEKVmj3Qsj9WgzC3e7mzP5Ykz/V9OLw/x4SYS6q2uz/RkVz+Q/q5P4TXLm04LLk/PtAKDFndsj+et7HZkeqzP2uBPSZSmrU/zZVBtcGJtD8Nq3gj88izPzbLZaNzfrI/e4UF9wMetD9vERjrG5ikP3lafuAqT7Q/GyrG+ZtQtD/LLhhcc0ezP84Xey++aLM/h78ma9RDuD8MeQQ3UrbMPzhpGhTNA7A/FRqIZTOHrD8sRfKVQEqwP4UoX9BCAqY/mdcRh2wgtT+/ZOPBFrulPyuIga59AaU/shLzrKQVrz+zYOKPos6kP//sR4rIsKo/QC/cuTDSsz+wAKYMHNCyPxFzSdV2E7A/bsMoCB7fsj8LQQ5KmGmzPyuHFtnO97M/wjV39L9csz83xeOiWkSkPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"XDij+uG5dkLNd8L64bl2QrS34frhuXZCKfgA++G5dkJbOCD74bl2QqN4P/vhuXZCErle++G5dkI8+H374bl2QlA5nfvhuXZCj3m8++G5dkLauNv74bl2Qk36+vvhuXZCKTsa/OG5dkJAezn84bl2QpC7WPzhuXZCCPx3/OG5dkIdPJf84bl2Qol8tvzhuXZCEb3V/OG5dkJw/fT84bl2Qpg9FP3huXZC9n0z/eG5dkLvvlL94bl2QgD/cf3huXZCUD+R/eG5dkL0fbD94bl2Qo2/z/3huXZCiv/u/eG5dkKhPw7+4bl2QjiALf7huXZCVsFM/uG5dkIlAmz+4bl2QjlKi/7huXZCDoCq/uG5dkJaxcn+4bl2QoEB6f7huXZCgUII/+G5dkKcgSf/4bl2QiHCRv/huXZCbgJm/+G5dkI/QoX/4bl2QuOCpP/huXZCkcTD/+G5dkLWBOP/4bl2Qq1EAgDiuXZCcYUhAOK5dkKpxUAA4rl2QucFYADiuXZCP0Z/AOK5dkIghZ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1102\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1101\",\"type\":\"UnionRenderers\"}},\"id\":\"1002\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1062\",\"type\":\"BasicTicker\"},{\"attributes\":{\"callback\":null},\"id\":\"1008\",\"type\":\"DataRange1d\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1023\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1029\",\"type\":\"HelpTool\"},{\"attributes\":{\"ticker\":{\"id\":\"1062\",\"type\":\"BasicTicker\"}},\"id\":\"1065\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1097\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Timer -- tid: 18140, period: 500 ms\"},\"id\":\"1004\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1099\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1097\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1067\",\"type\":\"BasicTicker\"}},\"id\":\"1066\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1101\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1020\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1067\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1010\",\"type\":\"LinearScale\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1039\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1102\",\"type\":\"Selection\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1067\",\"type\":\"BasicTicker\"}},\"id\":\"1070\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1046\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1103\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"L4UHza57oz/iwbsBCwWtP0r/N5szR7M/pB2SteELuD/+O+zPj9C8PywtI/WeysA/WDxQAvYswz+FS30PTY/FP7Jaqhyk8cc/32nXKftTyj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"4sG7AQsFrT9K/zebM0ezP6QdkrXhC7g//jvsz4/QvD8sLSP1nsrAP1g8UAL2LMM/hUt9D02PxT+yWqocpPHHP99p1yn7U8o/DHkEN1K2zD8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[10,9,24,6,0,0,0,0,0,1]},\"selected\":{\"id\":\"1105\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1104\",\"type\":\"UnionRenderers\"}},\"id\":\"1084\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1086\",\"type\":\"Quad\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1047\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1104\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"items\":[{\"id\":\"1049\",\"type\":\"LegendItem\"}]},\"id\":\"1048\",\"type\":\"Legend\"},{\"attributes\":{},\"id\":\"1105\",\"type\":\"Selection\"},{\"attributes\":{\"source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"}},\"id\":\"1041\",\"type\":\"CDSView\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1085\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1071\",\"type\":\"PanTool\"},{\"attributes\":{\"label\":{\"value\":\"timer\"},\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1049\",\"type\":\"LegendItem\"}],\"root_ids\":[\"1089\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"710b83fb-e539-40b6-948f-65ef8636a944\",\"roots\":{\"1089\":\"dd26af77-eedc-422e-8660-c38111a4266d\"}}];\n", + " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", + "\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " } else {\n", + " var attempts = 0;\n", + " var timer = setInterval(function(root) {\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " clearInterval(timer);\n", + " }\n", + " attempts++;\n", + " if (attempts > 100) {\n", + " console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n", + " clearInterval(timer);\n", + " }\n", + " }, 10, root)\n", + " }\n", + "})(window);" + ], + "application/vnd.bokehjs_exec.v0+json": "" + }, "metadata": { - "needs_background": "light" + "application/vnd.bokehjs_exec.v0+json": { + "id": "1089" + } }, "output_type": "display_data" }, { "data": { - "image/png": "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\n", - "text/plain": [ - "" + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n" ] }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function embed_document(root) {\n", + " \n", + " var docs_json = {\"7b13e0ac-cf5b-4109-8b7f-23e4e1fef775\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1203\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1250\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1289\",\"type\":\"Row\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1224\",\"type\":\"PanTool\"},{\"id\":\"1225\",\"type\":\"WheelZoomTool\"},{\"id\":\"1226\",\"type\":\"BoxZoomTool\"},{\"id\":\"1227\",\"type\":\"SaveTool\"},{\"id\":\"1228\",\"type\":\"ResetTool\"},{\"id\":\"1229\",\"type\":\"HelpTool\"}]},\"id\":\"1230\",\"type\":\"Toolbar\"},{\"attributes\":{\"ticker\":{\"id\":\"1262\",\"type\":\"BasicTicker\"}},\"id\":\"1265\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1210\",\"type\":\"LinearScale\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1267\",\"type\":\"BasicTicker\"}},\"id\":\"1270\",\"type\":\"Grid\"},{\"attributes\":{\"below\":[{\"id\":\"1261\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1265\",\"type\":\"Grid\"},{\"id\":\"1270\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1266\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1287\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1251\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1277\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1253\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1257\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1255\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1259\",\"type\":\"LinearScale\"}},\"id\":\"1250\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1224\",\"type\":\"PanTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1208\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1318\",\"type\":\"Selection\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1285\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1225\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1319\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1257\",\"type\":\"LinearScale\"},{\"attributes\":{\"callback\":null},\"id\":\"1255\",\"type\":\"DataRange1d\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"W3ufqkIDqT/gXj7+d+mxPxQALadOUbc/RqEbUCW5vD89IYX8fRDBP9Zx/FBpxMM/cMJzpVR4xj8JE+v5PyzJP6NjYk4r4Ms/PbTZohaUzj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"4F4+/nfpsT8UAC2nTlG3P0ahG1Alubw/PSGF/H0QwT/WcfxQacTDP3DCc6VUeMY/CRPr+T8syT+jY2JOK+DLPz202aIWlM4/a4Ko+wCk0D8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[6,7,1,28,3,3,1,0,0,1]},\"selected\":{\"id\":\"1321\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1320\",\"type\":\"UnionRenderers\"}},\"id\":\"1284\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"overlay\":{\"id\":\"1247\",\"type\":\"BoxAnnotation\"}},\"id\":\"1226\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1320\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1271\",\"type\":\"PanTool\"},{\"id\":\"1272\",\"type\":\"WheelZoomTool\"},{\"id\":\"1273\",\"type\":\"BoxZoomTool\"},{\"id\":\"1274\",\"type\":\"SaveTool\"},{\"id\":\"1275\",\"type\":\"ResetTool\"},{\"id\":\"1276\",\"type\":\"HelpTool\"}]},\"id\":\"1277\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1227\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1321\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1271\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1228\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1267\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1272\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"below\":[{\"id\":\"1214\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1218\",\"type\":\"Grid\"},{\"id\":\"1223\",\"type\":\"Grid\"},{\"id\":\"1248\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1219\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1240\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1204\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1230\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1206\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1210\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1208\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1212\",\"type\":\"LinearScale\"}},\"id\":\"1203\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"overlay\":{\"id\":\"1319\",\"type\":\"BoxAnnotation\"}},\"id\":\"1273\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1259\",\"type\":\"LinearScale\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1246\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1214\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1262\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1274\",\"type\":\"SaveTool\"},{\"attributes\":{\"data_source\":{\"id\":\"1202\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1238\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1239\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1241\",\"type\":\"CDSView\"}},\"id\":\"1240\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1215\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1275\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1220\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1202\",\"type\":\"ColumnDataSource\"}},\"id\":\"1241\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1276\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1244\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null},\"id\":\"1253\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1246\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"PiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"a4Ko+wCk0D/uluSAXU2+P3R+iuPAq70/W7Iqwk1GwT+VYdwNorXAP5hPVgxXB8A/NlZinpW0vj+FWz6Skh6yP9UhN8MN+Lw/Ff93RIXqwD9D5PT1fM2qP4dT5uYb0b0/h4bFqGvtvT+4PUFiu3vAP8tneR7cnb0/0qsBSkONvj+6vg8HCVG+PzSAt0CC4sE/IZIhx9YzwD/aqiSyD7K8P2JJufscH70/jINLx5xnwD/aHOc24V69P33PSIRGsL0/U+qScYxkvz/equtQTUmuP7yWkA96Nr8/HXHIBtLFvj93nnjOFhC+Pxrh7UEIyL8/z57L1CR4xz/mWUkrvqHEPzyh15/E57I/SrN5HAbzwz+nBMQkXMizP9jWT/9Z87M/hJ1i1SDMwz+Cb5o+O+CqP99uSQ7Y1bA/S6yMRj6vtD9be5+qQgOpP+HUB5J3DrU/DB6mfXN/wT9d3hyu1R7AP7bz/dR46bY/5ulcUUoIvj+pT3KHTWS+P/q5oSk7/bw/Ft16TQ8Kvj9O8bioFhGxPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[1,4,7,10,13,16,19,22,25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,73,76,79,82,85,88,91,94,97,100,103,106,109,112,115,118,121,124,127,130,133,136,139,142,145,148],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"PUWj+uG5dkIagML64bl2QmzB4frhuXZClwEB++G5dkL1QSD74bl2QtqBP/vhuXZCTcJe++G5dkI3/X374bl2QhRCnfvhuXZCbYK8++G5dkJWvNv74bl2QucD+/vhuXZCLEYa/OG5dkK6hTn84bl2QgXEWPzhuXZCIQl4/OG5dkIBRZf84bl2QqiFtvzhuXZCs8bV/OG5dkIOB/X84bl2QoNGFP3huXZCs4Yz/eG5dkLTx1L94bl2QoEHcv3huXZCAEmR/eG5dkISgrD94bl2QkjJz/3huXZCjgjv/eG5dkL9Rw7+4bl2QrSILf7huXZCKc1M/uG5dkI6D2z+4bl2QjVUi/7huXZCxIaq/uG5dkIYy8n+4bl2Qr8G6f7huXZCzkwI/+G5dkJvhSf/4bl2QmzHRv/huXZCbQlm/+G5dkKgR4X/4bl2QkGKpP/huXZCeM3D/+G5dkKQDeP/4bl2QjxMAgDiuXZCm44hAOK5dkKWzkAA4rl2QnQOYADiuXZCkU5/AOK5dkJfiZ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1318\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1317\",\"type\":\"UnionRenderers\"}},\"id\":\"1202\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1315\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1262\",\"type\":\"BasicTicker\"}},\"id\":\"1261\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1286\",\"type\":\"Quad\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1313\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1267\",\"type\":\"BasicTicker\"}},\"id\":\"1266\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1247\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1212\",\"type\":\"LinearScale\"},{\"attributes\":{\"data_source\":{\"id\":\"1284\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1285\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1286\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1288\",\"type\":\"CDSView\"}},\"id\":\"1287\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1244\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1220\",\"type\":\"BasicTicker\"}},\"id\":\"1219\",\"type\":\"LinearAxis\"},{\"attributes\":{\"items\":[{\"id\":\"1249\",\"type\":\"LegendItem\"}]},\"id\":\"1248\",\"type\":\"Legend\"},{\"attributes\":{\"source\":{\"id\":\"1284\",\"type\":\"ColumnDataSource\"}},\"id\":\"1288\",\"type\":\"CDSView\"},{\"attributes\":{\"callback\":null},\"id\":\"1206\",\"type\":\"DataRange1d\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1240\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1249\",\"type\":\"LegendItem\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1239\",\"type\":\"Line\"},{\"attributes\":{\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1218\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1313\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_pong, tid: 18141, topic: /ping\"},\"id\":\"1204\",\"type\":\"Title\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1220\",\"type\":\"BasicTicker\"}},\"id\":\"1223\",\"type\":\"Grid\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1238\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1317\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1315\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1251\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1229\",\"type\":\"HelpTool\"}],\"root_ids\":[\"1289\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"7b13e0ac-cf5b-4109-8b7f-23e4e1fef775\",\"roots\":{\"1289\":\"a6878e09-3326-4d28-a9a7-276b7a6f6564\"}}];\n", + " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", + "\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " } else {\n", + " var attempts = 0;\n", + " var timer = setInterval(function(root) {\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " clearInterval(timer);\n", + " }\n", + " attempts++;\n", + " if (attempts > 100) {\n", + " console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n", + " clearInterval(timer);\n", + " }\n", + " }, 10, root)\n", + " }\n", + "})(window);" + ], + "application/vnd.bokehjs_exec.v0+json": "" + }, "metadata": { - "needs_background": "light" + "application/vnd.bokehjs_exec.v0+json": { + "id": "1289" + } }, "output_type": "display_data" }, { "data": { - "image/png": "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\n", - "text/plain": [ - "" + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n" ] }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function embed_document(root) {\n", + " \n", + " var docs_json = {\"5802d7e0-bd5f-4040-95dd-fda2cbedf1ed\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1419\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1466\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1505\",\"type\":\"Row\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1462\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1431\",\"type\":\"BasicTicker\"}},\"id\":\"1430\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1462\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1547\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1431\",\"type\":\"BasicTicker\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"9BlQb0bNlz9f3Px1Xa6kP8SrUbQXdq0/lD1T+egesz9HpX0YxoK3P/kMqDej5rs/VjppK0AlwD8wbv66LlfCPwiik0odicQ/4tUo2gu7xj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"X9z8dV2upD/Eq1G0F3atP5Q9U/noHrM/R6V9GMaCtz/5DKg3o+a7P1Y6aStAJcA/MG7+ui5Xwj8IopNKHYnEP+LVKNoLu8Y/uwm+afrsyD8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[6,5,19,11,5,2,0,0,0,2]},\"selected\":{\"id\":\"1553\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1552\",\"type\":\"UnionRenderers\"}},\"id\":\"1500\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"items\":[{\"id\":\"1465\",\"type\":\"LegendItem\"}]},\"id\":\"1464\",\"type\":\"Legend\"},{\"attributes\":{\"ticker\":{\"id\":\"1431\",\"type\":\"BasicTicker\"}},\"id\":\"1434\",\"type\":\"Grid\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"y9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"FqHYCpqWyD8wgPChREu6P2aDTDJyFrI/RPzDlh5NsT+rdk1IawyyP6dbdoh/2LY/0c3+QLlttz+kGvZ7Yp2iP4CBIECGjrE/Sdbh6CrdsT/0GVBvRs2XP3x/g/bq47E/Wg2Jeyx9tD/w94vZklW5PwlP6PUn8bE/guMybmqgsT9i9UcYBiy1P6YKRiV1ArI/cNBefTz0tT/NP/omTYOyP7AD54wo7bE/vHfUmBBzsT8W9rTDX5OxPwCQEyaMZrE/DkxuFFlruD/9+bZgqS6gP/cdw2M/i7E/DFhyFYvftD8b8WQ3M/q1P+twdJXurrc/LCy4H/DAvD+ELuHQWzy8P97M6EfDKas/tOTxtPzAsT/rc7UV+8umP3nMQGX8+6w/7QxTW+ogsz8TZARUOIKkP7sJvmn67Mg/FJZ4QNmUqz86QDBHj9+bPxkfZi/bTqs/AJF++zpwsj9Z4Cu69ZqyPwAbECGunLk/z72HS447tT/7WpcaoZ+1P0BNLVvri7Q/4zPZP08Dsj/gEoB/SpWgPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[2,5,8,11,14,17,20,23,26,29,32,35,38,41,44,47,50,53,56,59,62,65,68,71,74,77,80,83,86,89,92,95,98,101,104,107,110,113,116,119,122,125,128,131,134,137,140,143,146,149],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"RVKj+uG5dkLwh8L64bl2Qr/I4frhuXZCngoB++G5dkKgSiD74bl2QvuJP/vhuXZC5sle++G5dkIvAX774bl2Qp5JnfvhuXZC6om8++G5dkJBv9v74bl2QmAL+/vhuXZCx00a/OG5dkJXjzn84bl2Qt/LWPzhuXZCDhJ4/OG5dkLhTJf84bl2QmyNtvzhuXZC29DV/OG5dkJAD/X84bl2QpBOFP3huXZCzY4z/eG5dkJDz1L94bl2QtsOcv3huXZC31CR/eG5dkKFhbD94bl2Ql3Rz/3huXZC4w/v/eG5dkLqTw7+4bl2QkSQLf7huXZCxtxM/uG5dkIPGmz+4bl2QvRZi/7huXZCXZCq/uG5dkLY0Mn+4bl2QuoL6f7huXZCilgI/+G5dkKuiif/4bl2QhrbRv/huXZCdg9m/+G5dkKDSoX/4bl2QlmQpP/huXZChNXD/+G5dkJyFeP/4bl2QqlVAgDiuXZCXpYhAOK5dkKE1kAA4rl2QjkWYADiuXZCeFV/AOK5dkLwjJ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1550\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1549\",\"type\":\"UnionRenderers\"}},\"id\":\"1418\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1487\",\"type\":\"PanTool\"},{\"id\":\"1488\",\"type\":\"WheelZoomTool\"},{\"id\":\"1489\",\"type\":\"BoxZoomTool\"},{\"id\":\"1490\",\"type\":\"SaveTool\"},{\"id\":\"1491\",\"type\":\"ResetTool\"},{\"id\":\"1492\",\"type\":\"HelpTool\"}]},\"id\":\"1493\",\"type\":\"Toolbar\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1456\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1465\",\"type\":\"LegendItem\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1460\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1436\",\"type\":\"BasicTicker\"}},\"id\":\"1435\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1487\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1436\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1491\",\"type\":\"ResetTool\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1436\",\"type\":\"BasicTicker\"}},\"id\":\"1439\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1488\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1426\",\"type\":\"LinearScale\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1455\",\"type\":\"Line\"},{\"attributes\":{\"overlay\":{\"id\":\"1551\",\"type\":\"BoxAnnotation\"}},\"id\":\"1489\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"source\":{\"id\":\"1500\",\"type\":\"ColumnDataSource\"}},\"id\":\"1504\",\"type\":\"CDSView\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1454\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1490\",\"type\":\"SaveTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1467\",\"type\":\"Title\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1501\",\"type\":\"Quad\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1440\",\"type\":\"PanTool\"},{\"id\":\"1441\",\"type\":\"WheelZoomTool\"},{\"id\":\"1442\",\"type\":\"BoxZoomTool\"},{\"id\":\"1443\",\"type\":\"SaveTool\"},{\"id\":\"1444\",\"type\":\"ResetTool\"},{\"id\":\"1445\",\"type\":\"HelpTool\"}]},\"id\":\"1446\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1492\",\"type\":\"HelpTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1469\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1440\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1550\",\"type\":\"Selection\"},{\"attributes\":{\"callback\":null},\"id\":\"1471\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1441\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1473\",\"type\":\"LinearScale\"},{\"attributes\":{\"overlay\":{\"id\":\"1463\",\"type\":\"BoxAnnotation\"}},\"id\":\"1442\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1475\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1443\",\"type\":\"SaveTool\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1502\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1549\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1553\",\"type\":\"Selection\"},{\"attributes\":{\"callback\":null},\"id\":\"1422\",\"type\":\"DataRange1d\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1547\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1478\",\"type\":\"BasicTicker\"}},\"id\":\"1477\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1444\",\"type\":\"ResetTool\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1551\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1428\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1545\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1445\",\"type\":\"HelpTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_ping, tid: 18140, topic: /pong\"},\"id\":\"1420\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1478\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1552\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"ticker\":{\"id\":\"1478\",\"type\":\"BasicTicker\"}},\"id\":\"1481\",\"type\":\"Grid\"},{\"attributes\":{\"below\":[{\"id\":\"1477\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1481\",\"type\":\"Grid\"},{\"id\":\"1486\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1482\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1503\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1467\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1493\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1469\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1473\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1471\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1475\",\"type\":\"LinearScale\"}},\"id\":\"1466\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1545\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1483\",\"type\":\"BasicTicker\"}},\"id\":\"1482\",\"type\":\"LinearAxis\"},{\"attributes\":{\"below\":[{\"id\":\"1430\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1434\",\"type\":\"Grid\"},{\"id\":\"1439\",\"type\":\"Grid\"},{\"id\":\"1464\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1435\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1456\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1420\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1446\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1422\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1426\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1424\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1428\",\"type\":\"LinearScale\"}},\"id\":\"1419\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1463\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"data_source\":{\"id\":\"1418\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1454\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1455\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1457\",\"type\":\"CDSView\"}},\"id\":\"1456\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"data_source\":{\"id\":\"1500\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1501\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1502\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1504\",\"type\":\"CDSView\"}},\"id\":\"1503\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1483\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1418\",\"type\":\"ColumnDataSource\"}},\"id\":\"1457\",\"type\":\"CDSView\"},{\"attributes\":{\"callback\":null},\"id\":\"1424\",\"type\":\"DataRange1d\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1483\",\"type\":\"BasicTicker\"}},\"id\":\"1486\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1460\",\"type\":\"BasicTickFormatter\"}],\"root_ids\":[\"1505\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"5802d7e0-bd5f-4040-95dd-fda2cbedf1ed\",\"roots\":{\"1505\":\"bb511789-b27e-4def-b167-377df1424c7e\"}}];\n", + " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", + "\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " } else {\n", + " var attempts = 0;\n", + " var timer = setInterval(function(root) {\n", + " if (root.Bokeh !== undefined) {\n", + " embed_document(root);\n", + " clearInterval(timer);\n", + " }\n", + " attempts++;\n", + " if (attempts > 100) {\n", + " console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n", + " clearInterval(timer);\n", + " }\n", + " }, 10, root)\n", + " }\n", + "})(window);" + ], + "application/vnd.bokehjs_exec.v0+json": "" + }, "metadata": { - "needs_background": "light" + "application/vnd.bokehjs_exec.v0+json": { + "id": "1505" + } }, "output_type": "display_data" } @@ -105,35 +546,36 @@ "\n", "callback_symbols = data_util.get_callback_symbols()\n", "\n", + "output_notebook()\n", + "psize = 450\n", + "\n", "# Plot durations\n", "for obj, symbol in callback_symbols.items():\n", " owner_info = data_util.get_callback_owner_info(obj)\n", " if owner_info is None:\n", " owner_info = '[unknown]'\n", "\n", + " # Duration\n", " duration_ns = data_util.get_callback_durations(obj)\n", " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", + " source = ColumnDataSource(duration_ms)\n", + " duration = figure(title=owner_info, x_axis_label='start', y_axis_label='duration (ms)',\n", + " plot_width=psize, plot_height=psize)\n", + " duration.title.align = 'center'\n", + " duration.line(x='timestamp', y='duration', legend=str(symbol), line_width=2, source=source)\n", "\n", - " fig = plt.figure(figsize=(12, 6))\n", - " fig.suptitle(owner_info, fontsize=21)\n", + " # Histogram\n", + " dur_hist, edges = np.histogram(duration_ms['duration'])\n", + " duration_ms_hist = pd.DataFrame({'duration': dur_hist, \n", + " 'left': edges[:-1], \n", + " 'right': edges[1:]})\n", + " hist = figure(title='Duration histogram', x_axis_label='duration (ms)', y_axis_label='frequency',\n", + " plot_width=psize, plot_height=psize)\n", + " hist.title.align = 'center'\n", + " hist.quad(bottom=0, top=duration_ms_hist['duration'], \n", + " left=duration_ms_hist['left'], right=duration_ms_hist['right'])\n", "\n", - " ax = fig.add_subplot(1, 2, 1)\n", - " duration_ms.plot(x='timestamp', y='duration', ax=ax)\n", - " ax.legend([str(symbol)])\n", - " ax.set_xlabel('start', size=14)\n", - " ax.set_ylabel('duration (ms)', size=14)\n", - " ax.title.set_text('Callback duration')\n", - " ax.title.set_size(16)\n", - " ax.grid()\n", - "\n", - " ax = fig.add_subplot(1, 2, 2)\n", - " duration_ms.hist(column='duration', ax=ax)\n", - " ax.set_xlabel('duration (ms)', size=14)\n", - " ax.set_ylabel('frequency', size=14)\n", - " ax.title.set_text('Duration histogram')\n", - " ax.title.set_size(16)\n", - "\n", - " plt.show()" + " show(row(duration, hist))" ] }, { From ad40057db5250953baf603164f74bbb53b221e40 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 1 Jul 2019 10:06:47 +0200 Subject: [PATCH 95/98] Make get_callback_durations() return a formatted sub-df --- .../tracetools_analysis/analysis/utils.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/tracetools_analysis/tracetools_analysis/analysis/utils.py b/tracetools_analysis/tracetools_analysis/analysis/utils.py index adda780..2140730 100644 --- a/tracetools_analysis/tracetools_analysis/analysis/utils.py +++ b/tracetools_analysis/tracetools_analysis/analysis/utils.py @@ -14,6 +14,7 @@ """Module for data model utility class.""" +from datetime import datetime as dt from typing import Any from typing import Mapping from typing import Union @@ -59,12 +60,20 @@ class DataModelUtil(): Get durations of callback instances for a given callback object. :param callback_obj: the callback object value - :return: a dataframe containing the durations of all callback instances for that object + :return: a dataframe containing the start timestamp (datetime) + and duration (ms) of all callback instances for that object """ - return self._data.callback_instances.loc[ + data = self._data.callback_instances.loc[ self._data.callback_instances.loc[:, 'callback_object'] == callback_obj, - : + ['timestamp', 'duration'] ] + # Transform both columns to ms + data[['timestamp', 'duration']] = data[ + ['timestamp', 'duration'] + ].apply(lambda d: d / 1000000.0) + # Transform start timestamp column to datetime objects + data['timestamp'] = data['timestamp'].apply(lambda t: dt.fromtimestamp(t / 1000.0)) + return data def get_callback_owner_info( self, callback_obj: int From fa95f0c8bdefea18fb324be60d1bc6f708f9ae46 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 1 Jul 2019 10:08:01 +0200 Subject: [PATCH 96/98] Enhance date/time plotting --- .../analysis/callback_duration.ipynb | 52 +++++++++++-------- 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/tracetools_analysis/analysis/callback_duration.ipynb b/tracetools_analysis/analysis/callback_duration.ipynb index 6faabbe..e7d033c 100644 --- a/tracetools_analysis/analysis/callback_duration.ipynb +++ b/tracetools_analysis/analysis/callback_duration.ipynb @@ -21,6 +21,7 @@ "# src/ros2/ros2_tracing/tracetools_read/\n", "sys.path.insert(0, '../')\n", "sys.path.insert(0, '../../../ros2/ros2_tracing/tracetools_read/')\n", + "import datetime as dt\n", "import os\n", "\n", "from bokeh.plotting import figure\n", @@ -28,6 +29,8 @@ "from bokeh.io import show\n", "from bokeh.layouts import row\n", "from bokeh.models import ColumnDataSource\n", + "from bokeh.models import DatetimeTickFormatter\n", + "from bokeh.models import PrintfTickFormatter\n", "import numpy as np\n", "import pandas as pd\n", "\n", @@ -46,7 +49,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "374 events\n" + "459 events\n" ] } ], @@ -390,7 +393,7 @@ "\n", "\n", "\n", - "
\n" + "
\n" ] }, "metadata": {}, @@ -402,8 +405,8 @@ "(function(root) {\n", " function embed_document(root) {\n", " \n", - " var docs_json = {\"710b83fb-e539-40b6-948f-65ef8636a944\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1050\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1089\",\"type\":\"Row\"},{\"attributes\":{\"callback\":null},\"id\":\"1006\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1072\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"overlay\":{\"id\":\"1103\",\"type\":\"BoxAnnotation\"}},\"id\":\"1073\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"below\":[{\"id\":\"1061\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1065\",\"type\":\"Grid\"},{\"id\":\"1070\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1066\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1087\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1051\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1077\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1053\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1057\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1055\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1059\",\"type\":\"LinearScale\"}},\"id\":\"1050\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1074\",\"type\":\"SaveTool\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1046\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1014\",\"type\":\"LinearAxis\"},{\"attributes\":{\"data_source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1038\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1039\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1041\",\"type\":\"CDSView\"}},\"id\":\"1040\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1038\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1075\",\"type\":\"ResetTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1051\",\"type\":\"Title\"},{\"attributes\":{\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1018\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1015\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1076\",\"type\":\"HelpTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1053\",\"type\":\"DataRange1d\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1024\",\"type\":\"PanTool\"},{\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"id\":\"1027\",\"type\":\"SaveTool\"},{\"id\":\"1028\",\"type\":\"ResetTool\"},{\"id\":\"1029\",\"type\":\"HelpTool\"}]},\"id\":\"1030\",\"type\":\"Toolbar\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1019\",\"type\":\"LinearAxis\"},{\"attributes\":{\"callback\":null},\"id\":\"1055\",\"type\":\"DataRange1d\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1071\",\"type\":\"PanTool\"},{\"id\":\"1072\",\"type\":\"WheelZoomTool\"},{\"id\":\"1073\",\"type\":\"BoxZoomTool\"},{\"id\":\"1074\",\"type\":\"SaveTool\"},{\"id\":\"1075\",\"type\":\"ResetTool\"},{\"id\":\"1076\",\"type\":\"HelpTool\"}]},\"id\":\"1077\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1024\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1012\",\"type\":\"LinearScale\"},{\"attributes\":{\"data_source\":{\"id\":\"1084\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1085\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1086\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1088\",\"type\":\"CDSView\"}},\"id\":\"1087\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"below\":[{\"id\":\"1014\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1018\",\"type\":\"Grid\"},{\"id\":\"1023\",\"type\":\"Grid\"},{\"id\":\"1048\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1019\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1004\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1030\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1006\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1010\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1008\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1012\",\"type\":\"LinearScale\"}},\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1057\",\"type\":\"LinearScale\"},{\"attributes\":{\"overlay\":{\"id\":\"1047\",\"type\":\"BoxAnnotation\"}},\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1059\",\"type\":\"LinearScale\"},{\"attributes\":{\"source\":{\"id\":\"1084\",\"type\":\"ColumnDataSource\"}},\"id\":\"1088\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1027\",\"type\":\"SaveTool\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1099\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1062\",\"type\":\"BasicTicker\"}},\"id\":\"1061\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1028\",\"type\":\"ResetTool\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"NUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQTVGayivhpZBNUZrKK+GlkE1Rmsor4aWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"0EICRpc3uz86HjNQGf+2PzwtP3CVJ7Q/51Wd1QJ7tD/7O9ujN9yzP1Cm0eRiDLQ/mMCtu3mqsz9Kfy+FB82mP67vw0FClLM/2GK3zyoztT8vhQfNrnujP3I2HQHcLLY/HEKVmj3Qsj9WgzC3e7mzP5Ykz/V9OLw/x4SYS6q2uz/RkVz+Q/q5P4TXLm04LLk/PtAKDFndsj+et7HZkeqzP2uBPSZSmrU/zZVBtcGJtD8Nq3gj88izPzbLZaNzfrI/e4UF9wMetD9vERjrG5ikP3lafuAqT7Q/GyrG+ZtQtD/LLhhcc0ezP84Xey++aLM/h78ma9RDuD8MeQQ3UrbMPzhpGhTNA7A/FRqIZTOHrD8sRfKVQEqwP4UoX9BCAqY/mdcRh2wgtT+/ZOPBFrulPyuIga59AaU/shLzrKQVrz+zYOKPos6kP//sR4rIsKo/QC/cuTDSsz+wAKYMHNCyPxFzSdV2E7A/bsMoCB7fsj8LQQ5KmGmzPyuHFtnO97M/wjV39L9csz83xeOiWkSkPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"XDij+uG5dkLNd8L64bl2QrS34frhuXZCKfgA++G5dkJbOCD74bl2QqN4P/vhuXZCErle++G5dkI8+H374bl2QlA5nfvhuXZCj3m8++G5dkLauNv74bl2Qk36+vvhuXZCKTsa/OG5dkJAezn84bl2QpC7WPzhuXZCCPx3/OG5dkIdPJf84bl2Qol8tvzhuXZCEb3V/OG5dkJw/fT84bl2Qpg9FP3huXZC9n0z/eG5dkLvvlL94bl2QgD/cf3huXZCUD+R/eG5dkL0fbD94bl2Qo2/z/3huXZCiv/u/eG5dkKhPw7+4bl2QjiALf7huXZCVsFM/uG5dkIlAmz+4bl2QjlKi/7huXZCDoCq/uG5dkJaxcn+4bl2QoEB6f7huXZCgUII/+G5dkKcgSf/4bl2QiHCRv/huXZCbgJm/+G5dkI/QoX/4bl2QuOCpP/huXZCkcTD/+G5dkLWBOP/4bl2Qq1EAgDiuXZCcYUhAOK5dkKpxUAA4rl2QucFYADiuXZCP0Z/AOK5dkIghZ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1102\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1101\",\"type\":\"UnionRenderers\"}},\"id\":\"1002\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1062\",\"type\":\"BasicTicker\"},{\"attributes\":{\"callback\":null},\"id\":\"1008\",\"type\":\"DataRange1d\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1023\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1029\",\"type\":\"HelpTool\"},{\"attributes\":{\"ticker\":{\"id\":\"1062\",\"type\":\"BasicTicker\"}},\"id\":\"1065\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1097\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Timer -- tid: 18140, period: 500 ms\"},\"id\":\"1004\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1099\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1097\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1067\",\"type\":\"BasicTicker\"}},\"id\":\"1066\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1101\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1020\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1067\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1010\",\"type\":\"LinearScale\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1039\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1102\",\"type\":\"Selection\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1067\",\"type\":\"BasicTicker\"}},\"id\":\"1070\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1046\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1103\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"L4UHza57oz/iwbsBCwWtP0r/N5szR7M/pB2SteELuD/+O+zPj9C8PywtI/WeysA/WDxQAvYswz+FS30PTY/FP7Jaqhyk8cc/32nXKftTyj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"4sG7AQsFrT9K/zebM0ezP6QdkrXhC7g//jvsz4/QvD8sLSP1nsrAP1g8UAL2LMM/hUt9D02PxT+yWqocpPHHP99p1yn7U8o/DHkEN1K2zD8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[10,9,24,6,0,0,0,0,0,1]},\"selected\":{\"id\":\"1105\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1104\",\"type\":\"UnionRenderers\"}},\"id\":\"1084\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1086\",\"type\":\"Quad\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1047\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1104\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"items\":[{\"id\":\"1049\",\"type\":\"LegendItem\"}]},\"id\":\"1048\",\"type\":\"Legend\"},{\"attributes\":{},\"id\":\"1105\",\"type\":\"Selection\"},{\"attributes\":{\"source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"}},\"id\":\"1041\",\"type\":\"CDSView\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1085\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1071\",\"type\":\"PanTool\"},{\"attributes\":{\"label\":{\"value\":\"timer\"},\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1049\",\"type\":\"LegendItem\"}],\"root_ids\":[\"1089\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", - " var render_items = [{\"docid\":\"710b83fb-e539-40b6-948f-65ef8636a944\",\"roots\":{\"1089\":\"dd26af77-eedc-422e-8660-c38111a4266d\"}}];\n", + " var docs_json = {\"25f18ded-2f35-4a38-abec-8df60f34ad3e\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1052\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1091\",\"type\":\"Row\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1073\",\"type\":\"PanTool\"},{\"id\":\"1074\",\"type\":\"WheelZoomTool\"},{\"id\":\"1075\",\"type\":\"BoxZoomTool\"},{\"id\":\"1076\",\"type\":\"SaveTool\"},{\"id\":\"1077\",\"type\":\"ResetTool\"},{\"id\":\"1078\",\"type\":\"HelpTool\"}]},\"id\":\"1079\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1050\",\"type\":\"DatetimeTickFormatter\"},{\"attributes\":{},\"id\":\"1015\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1073\",\"type\":\"PanTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1008\",\"type\":\"DataRange1d\"},{\"attributes\":{\"source\":{\"id\":\"1086\",\"type\":\"ColumnDataSource\"}},\"id\":\"1090\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1074\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1023\",\"type\":\"Grid\"},{\"attributes\":{\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1018\",\"type\":\"Grid\"},{\"attributes\":{\"data_source\":{\"id\":\"1086\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1087\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1088\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1090\",\"type\":\"CDSView\"}},\"id\":\"1089\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"overlay\":{\"id\":\"1104\",\"type\":\"BoxAnnotation\"}},\"id\":\"1075\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"below\":[{\"id\":\"1063\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1067\",\"type\":\"Grid\"},{\"id\":\"1072\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1068\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1089\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1053\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1079\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1055\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1059\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1057\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1061\",\"type\":\"LinearScale\"}},\"id\":\"1052\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1076\",\"type\":\"SaveTool\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1020\",\"type\":\"BasicTicker\"}},\"id\":\"1019\",\"type\":\"LinearAxis\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1024\",\"type\":\"PanTool\"},{\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"id\":\"1027\",\"type\":\"SaveTool\"},{\"id\":\"1028\",\"type\":\"ResetTool\"},{\"id\":\"1029\",\"type\":\"HelpTool\"}]},\"id\":\"1030\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1077\",\"type\":\"ResetTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1053\",\"type\":\"Title\"},{\"attributes\":{\"label\":{\"value\":\"timer\"},\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1049\",\"type\":\"LegendItem\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1038\",\"type\":\"Line\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1039\",\"type\":\"Line\"},{\"attributes\":{\"callback\":null},\"id\":\"1055\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1078\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1010\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1024\",\"type\":\"PanTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1057\",\"type\":\"DataRange1d\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1087\",\"type\":\"Quad\"},{\"attributes\":{\"overlay\":{\"id\":\"1047\",\"type\":\"BoxAnnotation\"}},\"id\":\"1026\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1059\",\"type\":\"LinearScale\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1088\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1027\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1061\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1028\",\"type\":\"ResetTool\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1100\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1064\",\"type\":\"BasicTicker\"}},\"id\":\"1063\",\"type\":\"LinearAxis\"},{\"attributes\":{\"callback\":null,\"data\":{\"duration\":{\"__ndarray__\":\"cXUAxF29xD8UzJiCNc6yPxoziXrBp7U/v2N47GextD+L4lXWNsWzP6Cp1y0CY7k/7KNTVz7Lsz/YDdsWZTa0P8goz7wcdrM/XqEPlrGhsz/tgVZgyOqyP4pamlshrLI/cQSpFDsasz8HXFfMCG+zPx2vQPSkTLI/HJjcKLLWtD+xwFd06zW1P3SZmgRvSLM/Ga2jqgmisj8NVMa/z7igPxMro5HPK7I/4zREFf4Msz8JwhVQqKezP9gQHJdxU7M/RYDTu3g/tj9uwOeHEcKzP+lEgqlm1rI/c0urIXGPtT/Z6Qd1kUK1P1TJAFDFjbM/cJo+O+C6sj8r+G2I8ZqzP7pnXaPlQLM/si0DzlKytD+3Q8Ni1LWyP5/L1CR4Q7Y/dEUpIVhVsz+TUWUYd4O0P3pU/N8RFbY/e4LEdvcAtT/4UnjQ7LqzP4C21awzvrM/2lVI+Um1sz/rjsU2qWi0PzLJyFnY07I/btv3qL9etT8Iy9jQzf60P0sEqn8QybQ/CvZf56bNtD9UxyqlZ3q1PzPFHAQdrbI/6fNRRlwAtj82qz5XW7GzP/YoXI/C9aA/Y5l+iXjrtD/59xkXDoS0PzG2EOSghLE//8wgPrDjsz8XLquwGeCyP/SLEvQXerQ//Yf029eBsz8vppnudVKzP8VU+glnt7I/\",\"dtype\":\"float64\",\"shape\":[63]},\"index\":[0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,183,186],\"timestamp\":{\"__ndarray__\":\"c0yDOMu6dkKPgqI4y7p2QhTCwTjLunZCSAPhOMu6dkKYQgA5y7p2QriCHznLunZCBsM+Ocu6dkI7A145y7p2QhdDfTnLunZC9oKcOcu6dkLpwrs5y7p2QhsD2znLunZC1UL6Ocu6dkLughk6y7p2QhvDODrLunZCDgNYOsu6dkICQ3c6y7p2QjuDljrLunZCM8O1Osu6dkLDAdU6y7p2QlBD9DrLunZCeYMTO8u6dkJYwzI7y7p2Qm0DUjvLunZCbUNxO8u6dkKWg5A7y7p2QljDrzvLunZCugPPO8u6dkKWQ+47y7p2QtODDTzLunZCw8MsPMu6dkIMBEw8y7p2QsNDazzLunZC+IOKPMu6dkL8w6k8y7p2QvQDyTzLunZC8EPoPMu6dkIphAc9y7p2Qj3EJj3LunZCZgRGPcu6dkJqRGU9y7p2QoOEhD3LunZCj8SjPcu6dkKYBMM9y7p2QotE4j3LunZCsIQBPsu6dkK8xCA+y7p2QgIFQD7LunZC0URfPsu6dkL+hH4+y7p2QvbEnT7LunZCtgW9Psu6dkIXRdw+y7p2QraD+z7LunZCAsUaP8u6dkJYBTo/y7p2QuVEWT/LunZCeYV4P8u6dkJtxZc/y7p2QisFtz/LunZCP0XWP8u6dkLnhfU/y7p2Qt/FFEDLunZC\",\"dtype\":\"float64\",\"shape\":[63]}},\"selected\":{\"id\":\"1102\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1103\",\"type\":\"UnionRenderers\"}},\"id\":\"1002\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"callback\":null},\"id\":\"1006\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1029\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1098\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1064\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1106\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1100\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1012\",\"type\":\"LinearScale\"},{\"attributes\":{\"ticker\":{\"id\":\"1064\",\"type\":\"BasicTicker\"}},\"id\":\"1067\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1020\",\"type\":\"BasicTicker\"},{\"attributes\":{\"axis_label\":\"start (2019-07-01 08:42)\",\"formatter\":{\"id\":\"1050\",\"type\":\"DatetimeTickFormatter\"},\"ticker\":{\"id\":\"1015\",\"type\":\"BasicTicker\"}},\"id\":\"1014\",\"type\":\"LinearAxis\"},{\"attributes\":{\"below\":[{\"id\":\"1014\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1018\",\"type\":\"Grid\"},{\"id\":\"1023\",\"type\":\"Grid\"},{\"id\":\"1048\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1019\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1040\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1004\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1030\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1006\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1010\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1008\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1012\",\"type\":\"LinearScale\"}},\"id\":\"1003\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1098\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1069\",\"type\":\"BasicTicker\"}},\"id\":\"1068\",\"type\":\"LinearAxis\"},{\"attributes\":{\"data_source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1038\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1039\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1041\",\"type\":\"CDSView\"}},\"id\":\"1040\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1102\",\"type\":\"Selection\"},{\"attributes\":{\"source\":{\"id\":\"1002\",\"type\":\"ColumnDataSource\"}},\"id\":\"1041\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1025\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1069\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1103\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1069\",\"type\":\"BasicTicker\"}},\"id\":\"1072\",\"type\":\"Grid\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1104\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1047\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"DVTGv8+4oD85FJkUelinP2XUa2kk+K0/SEofX+dLsj9eqoiJvJu1P3QK8rOR67g/impb3mY7vD+gysQIPIu/P1sVl5mIbcE/ZsXLLnMVwz8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"ORSZFHpYpz9l1GtpJPitP0hKH1/nS7I/XqqIibybtT90CvKzkeu4P4pqW95mO7w/oMrECDyLvz9bFZeZiG3BP2bFyy5zFcM/cXUAxF29xD8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[2,0,2,52,5,1,0,0,0,1]},\"selected\":{\"id\":\"1105\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1106\",\"type\":\"UnionRenderers\"}},\"id\":\"1086\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1105\",\"type\":\"Selection\"},{\"attributes\":{\"items\":[{\"id\":\"1049\",\"type\":\"LegendItem\"}]},\"id\":\"1048\",\"type\":\"Legend\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Timer -- tid: 9876, period: 500 ms\"},\"id\":\"1004\",\"type\":\"Title\"}],\"root_ids\":[\"1091\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"25f18ded-2f35-4a38-abec-8df60f34ad3e\",\"roots\":{\"1091\":\"55770a40-08ff-495a-8fa8-6023595f7557\"}}];\n", " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", "\n", " }\n", @@ -429,7 +432,7 @@ }, "metadata": { "application/vnd.bokehjs_exec.v0+json": { - "id": "1089" + "id": "1091" } }, "output_type": "display_data" @@ -443,7 +446,7 @@ "\n", "\n", "\n", - "
\n" + "
\n" ] }, "metadata": {}, @@ -455,8 +458,8 @@ "(function(root) {\n", " function embed_document(root) {\n", " \n", - " var docs_json = {\"7b13e0ac-cf5b-4109-8b7f-23e4e1fef775\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1203\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1250\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1289\",\"type\":\"Row\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1224\",\"type\":\"PanTool\"},{\"id\":\"1225\",\"type\":\"WheelZoomTool\"},{\"id\":\"1226\",\"type\":\"BoxZoomTool\"},{\"id\":\"1227\",\"type\":\"SaveTool\"},{\"id\":\"1228\",\"type\":\"ResetTool\"},{\"id\":\"1229\",\"type\":\"HelpTool\"}]},\"id\":\"1230\",\"type\":\"Toolbar\"},{\"attributes\":{\"ticker\":{\"id\":\"1262\",\"type\":\"BasicTicker\"}},\"id\":\"1265\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1210\",\"type\":\"LinearScale\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1267\",\"type\":\"BasicTicker\"}},\"id\":\"1270\",\"type\":\"Grid\"},{\"attributes\":{\"below\":[{\"id\":\"1261\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1265\",\"type\":\"Grid\"},{\"id\":\"1270\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1266\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1287\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1251\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1277\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1253\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1257\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1255\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1259\",\"type\":\"LinearScale\"}},\"id\":\"1250\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1224\",\"type\":\"PanTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1208\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1318\",\"type\":\"Selection\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1285\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1225\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1319\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1257\",\"type\":\"LinearScale\"},{\"attributes\":{\"callback\":null},\"id\":\"1255\",\"type\":\"DataRange1d\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"W3ufqkIDqT/gXj7+d+mxPxQALadOUbc/RqEbUCW5vD89IYX8fRDBP9Zx/FBpxMM/cMJzpVR4xj8JE+v5PyzJP6NjYk4r4Ms/PbTZohaUzj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"4F4+/nfpsT8UAC2nTlG3P0ahG1Alubw/PSGF/H0QwT/WcfxQacTDP3DCc6VUeMY/CRPr+T8syT+jY2JOK+DLPz202aIWlM4/a4Ko+wCk0D8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[6,7,1,28,3,3,1,0,0,1]},\"selected\":{\"id\":\"1321\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1320\",\"type\":\"UnionRenderers\"}},\"id\":\"1284\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"overlay\":{\"id\":\"1247\",\"type\":\"BoxAnnotation\"}},\"id\":\"1226\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1320\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1271\",\"type\":\"PanTool\"},{\"id\":\"1272\",\"type\":\"WheelZoomTool\"},{\"id\":\"1273\",\"type\":\"BoxZoomTool\"},{\"id\":\"1274\",\"type\":\"SaveTool\"},{\"id\":\"1275\",\"type\":\"ResetTool\"},{\"id\":\"1276\",\"type\":\"HelpTool\"}]},\"id\":\"1277\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1227\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1321\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1271\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1228\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1267\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1272\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"below\":[{\"id\":\"1214\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1218\",\"type\":\"Grid\"},{\"id\":\"1223\",\"type\":\"Grid\"},{\"id\":\"1248\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1219\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1240\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1204\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1230\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1206\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1210\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1208\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1212\",\"type\":\"LinearScale\"}},\"id\":\"1203\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"overlay\":{\"id\":\"1319\",\"type\":\"BoxAnnotation\"}},\"id\":\"1273\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1259\",\"type\":\"LinearScale\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1246\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1214\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1262\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1274\",\"type\":\"SaveTool\"},{\"attributes\":{\"data_source\":{\"id\":\"1202\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1238\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1239\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1241\",\"type\":\"CDSView\"}},\"id\":\"1240\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1215\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1275\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1220\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1202\",\"type\":\"ColumnDataSource\"}},\"id\":\"1241\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1276\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1244\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null},\"id\":\"1253\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1246\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"PiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQT4iptSGkZZBPiKm1IaRlkE+IqbUhpGWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"a4Ko+wCk0D/uluSAXU2+P3R+iuPAq70/W7Iqwk1GwT+VYdwNorXAP5hPVgxXB8A/NlZinpW0vj+FWz6Skh6yP9UhN8MN+Lw/Ff93RIXqwD9D5PT1fM2qP4dT5uYb0b0/h4bFqGvtvT+4PUFiu3vAP8tneR7cnb0/0qsBSkONvj+6vg8HCVG+PzSAt0CC4sE/IZIhx9YzwD/aqiSyD7K8P2JJufscH70/jINLx5xnwD/aHOc24V69P33PSIRGsL0/U+qScYxkvz/equtQTUmuP7yWkA96Nr8/HXHIBtLFvj93nnjOFhC+Pxrh7UEIyL8/z57L1CR4xz/mWUkrvqHEPzyh15/E57I/SrN5HAbzwz+nBMQkXMizP9jWT/9Z87M/hJ1i1SDMwz+Cb5o+O+CqP99uSQ7Y1bA/S6yMRj6vtD9be5+qQgOpP+HUB5J3DrU/DB6mfXN/wT9d3hyu1R7AP7bz/dR46bY/5ulcUUoIvj+pT3KHTWS+P/q5oSk7/bw/Ft16TQ8Kvj9O8bioFhGxPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[1,4,7,10,13,16,19,22,25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,73,76,79,82,85,88,91,94,97,100,103,106,109,112,115,118,121,124,127,130,133,136,139,142,145,148],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"PUWj+uG5dkIagML64bl2QmzB4frhuXZClwEB++G5dkL1QSD74bl2QtqBP/vhuXZCTcJe++G5dkI3/X374bl2QhRCnfvhuXZCbYK8++G5dkJWvNv74bl2QucD+/vhuXZCLEYa/OG5dkK6hTn84bl2QgXEWPzhuXZCIQl4/OG5dkIBRZf84bl2QqiFtvzhuXZCs8bV/OG5dkIOB/X84bl2QoNGFP3huXZCs4Yz/eG5dkLTx1L94bl2QoEHcv3huXZCAEmR/eG5dkISgrD94bl2QkjJz/3huXZCjgjv/eG5dkL9Rw7+4bl2QrSILf7huXZCKc1M/uG5dkI6D2z+4bl2QjVUi/7huXZCxIaq/uG5dkIYy8n+4bl2Qr8G6f7huXZCzkwI/+G5dkJvhSf/4bl2QmzHRv/huXZCbQlm/+G5dkKgR4X/4bl2QkGKpP/huXZCeM3D/+G5dkKQDeP/4bl2QjxMAgDiuXZCm44hAOK5dkKWzkAA4rl2QnQOYADiuXZCkU5/AOK5dkJfiZ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1318\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1317\",\"type\":\"UnionRenderers\"}},\"id\":\"1202\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1315\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1262\",\"type\":\"BasicTicker\"}},\"id\":\"1261\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1286\",\"type\":\"Quad\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1313\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1267\",\"type\":\"BasicTicker\"}},\"id\":\"1266\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1247\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1212\",\"type\":\"LinearScale\"},{\"attributes\":{\"data_source\":{\"id\":\"1284\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1285\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1286\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1288\",\"type\":\"CDSView\"}},\"id\":\"1287\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1244\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1220\",\"type\":\"BasicTicker\"}},\"id\":\"1219\",\"type\":\"LinearAxis\"},{\"attributes\":{\"items\":[{\"id\":\"1249\",\"type\":\"LegendItem\"}]},\"id\":\"1248\",\"type\":\"Legend\"},{\"attributes\":{\"source\":{\"id\":\"1284\",\"type\":\"ColumnDataSource\"}},\"id\":\"1288\",\"type\":\"CDSView\"},{\"attributes\":{\"callback\":null},\"id\":\"1206\",\"type\":\"DataRange1d\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1240\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1249\",\"type\":\"LegendItem\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1239\",\"type\":\"Line\"},{\"attributes\":{\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1218\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1313\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_pong, tid: 18141, topic: /ping\"},\"id\":\"1204\",\"type\":\"Title\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1220\",\"type\":\"BasicTicker\"}},\"id\":\"1223\",\"type\":\"Grid\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1238\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1317\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1315\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1251\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1229\",\"type\":\"HelpTool\"}],\"root_ids\":[\"1289\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", - " var render_items = [{\"docid\":\"7b13e0ac-cf5b-4109-8b7f-23e4e1fef775\",\"roots\":{\"1289\":\"a6878e09-3326-4d28-a9a7-276b7a6f6564\"}}];\n", + " var docs_json = {\"5e908bd4-c7eb-4bae-b6d0-89beed606b4c\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1198\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1247\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1286\",\"type\":\"Row\"},{\"attributes\":{},\"id\":\"1312\",\"type\":\"Selection\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1218\",\"type\":\"Grid\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1264\",\"type\":\"BasicTicker\"}},\"id\":\"1267\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1313\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"callback\":null},\"id\":\"1250\",\"type\":\"DataRange1d\"},{\"attributes\":{\"below\":[{\"id\":\"1258\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1262\",\"type\":\"Grid\"},{\"id\":\"1267\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1263\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1284\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1248\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1274\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1250\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1254\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1252\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1256\",\"type\":\"LinearScale\"}},\"id\":\"1247\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1219\",\"type\":\"PanTool\"},{\"id\":\"1220\",\"type\":\"WheelZoomTool\"},{\"id\":\"1221\",\"type\":\"BoxZoomTool\"},{\"id\":\"1222\",\"type\":\"SaveTool\"},{\"id\":\"1223\",\"type\":\"ResetTool\"},{\"id\":\"1224\",\"type\":\"HelpTool\"}]},\"id\":\"1225\",\"type\":\"Toolbar\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"YCAIkKFjlz/i7ZzBOumkP5TLNbukIK4/o1RnWgessz98wzNXvEe4P1UyAFRx47w/l1BmKJO/wD8EiMymbQ3DP3C/MiVIW8U/3PaYoyKpxz8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"4u2cwTrppD+UyzW7pCCuP6NUZ1oHrLM/fMMzV7xHuD9VMgBUceO8P5dQZiiTv8A/BIjMpm0Nwz9wvzIlSFvFP9z2mKMiqcc/SS7/If32yT8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[2,0,45,13,0,1,0,0,0,2]},\"selected\":{\"id\":\"1315\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1316\",\"type\":\"UnionRenderers\"}},\"id\":\"1281\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1314\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1222\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1315\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1219\",\"type\":\"PanTool\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1268\",\"type\":\"PanTool\"},{\"id\":\"1269\",\"type\":\"WheelZoomTool\"},{\"id\":\"1270\",\"type\":\"BoxZoomTool\"},{\"id\":\"1271\",\"type\":\"SaveTool\"},{\"id\":\"1272\",\"type\":\"ResetTool\"},{\"id\":\"1273\",\"type\":\"HelpTool\"}]},\"id\":\"1274\",\"type\":\"Toolbar\"},{\"attributes\":{\"callback\":null},\"id\":\"1203\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1316\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"callback\":null},\"id\":\"1201\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1268\",\"type\":\"PanTool\"},{\"attributes\":{\"overlay\":{\"id\":\"1242\",\"type\":\"BoxAnnotation\"}},\"id\":\"1221\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1269\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1223\",\"type\":\"ResetTool\"},{\"attributes\":{\"axis_label\":\"start (2019-07-01 08:42)\",\"formatter\":{\"id\":\"1245\",\"type\":\"DatetimeTickFormatter\"},\"ticker\":{\"id\":\"1210\",\"type\":\"BasicTicker\"}},\"id\":\"1209\",\"type\":\"LinearAxis\"},{\"attributes\":{\"overlay\":{\"id\":\"1314\",\"type\":\"BoxAnnotation\"}},\"id\":\"1270\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1308\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1264\",\"type\":\"BasicTicker\"}},\"id\":\"1263\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1224\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1254\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1271\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1210\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1272\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1264\",\"type\":\"BasicTicker\"},{\"attributes\":{\"data_source\":{\"id\":\"1197\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1233\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1234\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1236\",\"type\":\"CDSView\"}},\"id\":\"1235\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"ticker\":{\"id\":\"1259\",\"type\":\"BasicTicker\"}},\"id\":\"1262\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1207\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1273\",\"type\":\"HelpTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1248\",\"type\":\"Title\"},{\"attributes\":{\"callback\":null,\"data\":{\"duration\":{\"__ndarray__\":\"GZC93v3xyD+EhChf0EKyP90LzApFurM/dES+S6lLsj8oY3yYvWyzPwCrI0c6A7M/oyB4fHvXtD8pIO1/gLWyPxuADYgQV7I/HHxhMlUwsj+hn6nXLQKzP+RNfotOlrI/ajNOQ1Thsz8d5ssLsI+yP9FBl3DoLbI/7l9ZaVIKsj9Tlba4xmeyP9DU6xaBsbI//HCQEOULsj9tHRzsTQyZP61RD9HoDrI/C+wxkdJssj8QecvVj02yP5GA0eXN4bI/f73CgvsBsz/cSUT4F0GzP4gNFk7S/LE/SS7/If32yT/zOAzmr5CxPy8zbJT1m7E/TQ8KStHKsT9RacTMPo+xP3HIBtLFprE/yenr+Zrlsj9xHeOKi6OyPxrEB3b8F7Q/ipRm8zgMsj/+uP3yyYqxP84z9iUbD7I/9Gvrp/+svT8bf6KyYU21P8v49xkXDrQ/ODC5UWSttT81e6AVGLK2P8L2kzE+zLI/M6MfDafMsT8ng6Pk1TmyP3Yzox8Np7Q/i6azk8FRsj9/vFetTPi1P91ELc2tELI/XynLEMe6tD9XXByVm6ixP2AgCJChY5c/2UP7WMFvsz+94T5ya9KxP57RViWRfbA/Suza3m5Jsj9F2PD0SlmyP2q8dJMYBLI/n6ut2F92tz+21hcJbTmzP8mwijcyj7Q/\",\"dtype\":\"float64\",\"shape\":[63]},\"index\":[2,5,8,11,14,17,20,23,26,29,32,35,38,41,44,47,50,53,56,59,62,65,68,71,74,77,80,83,86,89,92,95,98,101,104,107,110,113,116,119,122,125,128,131,134,137,140,143,146,149,152,155,158,161,164,167,170,173,176,179,182,185,188],\"timestamp\":{\"__ndarray__\":\"H2eDOMu6dkJEkaI4y7p2QhfTwTjLunZC5xPhOMu6dkLNUgA5y7p2Qr6THznLunZCAtU+Ocu6dkJOFF45y7p2QgJTfTnLunZCUJOcOcu6dkLh0rs5y7p2QnET2znLunZCwVL6Ocu6dkL+khk6y7p2QjvTODrLunZC5RJYOsu6dkIGU3c6y7p2QgKTljrLunZCgdO1Osu6dkJtB9U6y7p2Qh9T9DrLunZCaJMTO8u6dkIE1jI7y7p2QjMVUjvLunZCmFRxO8u6dkJxk5A7y7p2QqrTrzvLunZCfRXPO8u6dkJOVO47y7p2QgyUDTzLunZC9NMsPMu6dkLlFEw8y7p2QstTazzLunZC5ZSKPMu6dkI11Kk8y7p2QrAUyTzLunZCQlToPMu6dkIjlQc9y7p2QmTVJj3LunZCzxVGPcu6dkICVWU9y7p2QgKXhD3LunZCZNWjPcu6dkJUFcM9y7p2QpFX4j3LunZCG5cBPsu6dkLX1SA+y7p2QggYQD7LunZCZFVfPsu6dkI5mH4+y7p2QifVnT7LunZC6Ri9Psu6dkKyVdw+y7p2QpqJ+z7LunZCXNcaP8u6dkI/FTo/y7p2QnFVWT/LunZC9JV4P8u6dkJq1pc/y7p2QgwWtz/LunZCM1XWP8u6dkJamPU/y7p2Qo3VFEDLunZC\",\"dtype\":\"float64\",\"shape\":[63]}},\"selected\":{\"id\":\"1312\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1313\",\"type\":\"UnionRenderers\"}},\"id\":\"1197\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"source\":{\"id\":\"1197\",\"type\":\"ColumnDataSource\"}},\"id\":\"1236\",\"type\":\"CDSView\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1282\",\"type\":\"Quad\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1234\",\"type\":\"Line\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1283\",\"type\":\"Quad\"},{\"attributes\":{\"items\":[{\"id\":\"1244\",\"type\":\"LegendItem\"}]},\"id\":\"1243\",\"type\":\"Legend\"},{\"attributes\":{},\"id\":\"1239\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_ping, tid: 9876, topic: /pong\"},\"id\":\"1199\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1259\",\"type\":\"BasicTicker\"},{\"attributes\":{\"data_source\":{\"id\":\"1281\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1282\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1283\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1285\",\"type\":\"CDSView\"}},\"id\":\"1284\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1220\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1310\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1259\",\"type\":\"BasicTicker\"}},\"id\":\"1258\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1242\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1205\",\"type\":\"LinearScale\"},{\"attributes\":{\"source\":{\"id\":\"1281\",\"type\":\"ColumnDataSource\"}},\"id\":\"1285\",\"type\":\"CDSView\"},{\"attributes\":{\"callback\":null},\"id\":\"1252\",\"type\":\"DataRange1d\"},{\"attributes\":{\"ticker\":{\"id\":\"1210\",\"type\":\"BasicTicker\"}},\"id\":\"1213\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1256\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1310\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1308\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"below\":[{\"id\":\"1209\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1213\",\"type\":\"Grid\"},{\"id\":\"1218\",\"type\":\"Grid\"},{\"id\":\"1243\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1214\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1235\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1199\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1225\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1201\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1205\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1203\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1207\",\"type\":\"LinearScale\"}},\"id\":\"1198\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1235\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1244\",\"type\":\"LegendItem\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1239\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1215\",\"type\":\"BasicTicker\"}},\"id\":\"1214\",\"type\":\"LinearAxis\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1233\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1245\",\"type\":\"DatetimeTickFormatter\"},{\"attributes\":{},\"id\":\"1215\",\"type\":\"BasicTicker\"}],\"root_ids\":[\"1286\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"5e908bd4-c7eb-4bae-b6d0-89beed606b4c\",\"roots\":{\"1286\":\"8339ff2c-a1ca-4310-a781-682c80a2e61b\"}}];\n", " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", "\n", " }\n", @@ -482,7 +485,7 @@ }, "metadata": { "application/vnd.bokehjs_exec.v0+json": { - "id": "1289" + "id": "1286" } }, "output_type": "display_data" @@ -496,7 +499,7 @@ "\n", "\n", "\n", - "
\n" + "
\n" ] }, "metadata": {}, @@ -508,8 +511,8 @@ "(function(root) {\n", " function embed_document(root) {\n", " \n", - " var docs_json = {\"5802d7e0-bd5f-4040-95dd-fda2cbedf1ed\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1419\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1466\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1505\",\"type\":\"Row\"},{\"attributes\":{\"axis_label\":\"start\",\"formatter\":{\"id\":\"1462\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1431\",\"type\":\"BasicTicker\"}},\"id\":\"1430\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1462\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1547\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1431\",\"type\":\"BasicTicker\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"9BlQb0bNlz9f3Px1Xa6kP8SrUbQXdq0/lD1T+egesz9HpX0YxoK3P/kMqDej5rs/VjppK0AlwD8wbv66LlfCPwiik0odicQ/4tUo2gu7xj8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"X9z8dV2upD/Eq1G0F3atP5Q9U/noHrM/R6V9GMaCtz/5DKg3o+a7P1Y6aStAJcA/MG7+ui5Xwj8IopNKHYnEP+LVKNoLu8Y/uwm+afrsyD8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[6,5,19,11,5,2,0,0,0,2]},\"selected\":{\"id\":\"1553\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1552\",\"type\":\"UnionRenderers\"}},\"id\":\"1500\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"items\":[{\"id\":\"1465\",\"type\":\"LegendItem\"}]},\"id\":\"1464\",\"type\":\"Legend\"},{\"attributes\":{\"ticker\":{\"id\":\"1431\",\"type\":\"BasicTicker\"}},\"id\":\"1434\",\"type\":\"Grid\"},{\"attributes\":{\"callback\":null,\"data\":{\"callback_object\":{\"__ndarray__\":\"y9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQcvW+iavhpZBy9b6Jq+GlkHL1vomr4aWQQ==\",\"dtype\":\"float64\",\"shape\":[50]},\"duration\":{\"__ndarray__\":\"FqHYCpqWyD8wgPChREu6P2aDTDJyFrI/RPzDlh5NsT+rdk1IawyyP6dbdoh/2LY/0c3+QLlttz+kGvZ7Yp2iP4CBIECGjrE/Sdbh6CrdsT/0GVBvRs2XP3x/g/bq47E/Wg2Jeyx9tD/w94vZklW5PwlP6PUn8bE/guMybmqgsT9i9UcYBiy1P6YKRiV1ArI/cNBefTz0tT/NP/omTYOyP7AD54wo7bE/vHfUmBBzsT8W9rTDX5OxPwCQEyaMZrE/DkxuFFlruD/9+bZgqS6gP/cdw2M/i7E/DFhyFYvftD8b8WQ3M/q1P+twdJXurrc/LCy4H/DAvD+ELuHQWzy8P97M6EfDKas/tOTxtPzAsT/rc7UV+8umP3nMQGX8+6w/7QxTW+ogsz8TZARUOIKkP7sJvmn67Mg/FJZ4QNmUqz86QDBHj9+bPxkfZi/bTqs/AJF++zpwsj9Z4Cu69ZqyPwAbECGunLk/z72HS447tT/7WpcaoZ+1P0BNLVvri7Q/4zPZP08Dsj/gEoB/SpWgPw==\",\"dtype\":\"float64\",\"shape\":[50]},\"index\":[2,5,8,11,14,17,20,23,26,29,32,35,38,41,44,47,50,53,56,59,62,65,68,71,74,77,80,83,86,89,92,95,98,101,104,107,110,113,116,119,122,125,128,131,134,137,140,143,146,149],\"intra_process\":{\"__ndarray__\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\",\"dtype\":\"float64\",\"shape\":[50]},\"timestamp\":{\"__ndarray__\":\"RVKj+uG5dkLwh8L64bl2Qr/I4frhuXZCngoB++G5dkKgSiD74bl2QvuJP/vhuXZC5sle++G5dkIvAX774bl2Qp5JnfvhuXZC6om8++G5dkJBv9v74bl2QmAL+/vhuXZCx00a/OG5dkJXjzn84bl2Qt/LWPzhuXZCDhJ4/OG5dkLhTJf84bl2QmyNtvzhuXZC29DV/OG5dkJAD/X84bl2QpBOFP3huXZCzY4z/eG5dkJDz1L94bl2QtsOcv3huXZC31CR/eG5dkKFhbD94bl2Ql3Rz/3huXZC4w/v/eG5dkLqTw7+4bl2QkSQLf7huXZCxtxM/uG5dkIPGmz+4bl2QvRZi/7huXZCXZCq/uG5dkLY0Mn+4bl2QuoL6f7huXZCilgI/+G5dkKuiif/4bl2QhrbRv/huXZCdg9m/+G5dkKDSoX/4bl2QlmQpP/huXZChNXD/+G5dkJyFeP/4bl2QqlVAgDiuXZCXpYhAOK5dkKE1kAA4rl2QjkWYADiuXZCeFV/AOK5dkLwjJ4A4rl2Qg==\",\"dtype\":\"float64\",\"shape\":[50]}},\"selected\":{\"id\":\"1550\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1549\",\"type\":\"UnionRenderers\"}},\"id\":\"1418\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1487\",\"type\":\"PanTool\"},{\"id\":\"1488\",\"type\":\"WheelZoomTool\"},{\"id\":\"1489\",\"type\":\"BoxZoomTool\"},{\"id\":\"1490\",\"type\":\"SaveTool\"},{\"id\":\"1491\",\"type\":\"ResetTool\"},{\"id\":\"1492\",\"type\":\"HelpTool\"}]},\"id\":\"1493\",\"type\":\"Toolbar\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1456\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1465\",\"type\":\"LegendItem\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1460\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1436\",\"type\":\"BasicTicker\"}},\"id\":\"1435\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1487\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1436\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1491\",\"type\":\"ResetTool\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1436\",\"type\":\"BasicTicker\"}},\"id\":\"1439\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1488\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1426\",\"type\":\"LinearScale\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1455\",\"type\":\"Line\"},{\"attributes\":{\"overlay\":{\"id\":\"1551\",\"type\":\"BoxAnnotation\"}},\"id\":\"1489\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"source\":{\"id\":\"1500\",\"type\":\"ColumnDataSource\"}},\"id\":\"1504\",\"type\":\"CDSView\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1454\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1490\",\"type\":\"SaveTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1467\",\"type\":\"Title\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1501\",\"type\":\"Quad\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1440\",\"type\":\"PanTool\"},{\"id\":\"1441\",\"type\":\"WheelZoomTool\"},{\"id\":\"1442\",\"type\":\"BoxZoomTool\"},{\"id\":\"1443\",\"type\":\"SaveTool\"},{\"id\":\"1444\",\"type\":\"ResetTool\"},{\"id\":\"1445\",\"type\":\"HelpTool\"}]},\"id\":\"1446\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1492\",\"type\":\"HelpTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1469\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1440\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1550\",\"type\":\"Selection\"},{\"attributes\":{\"callback\":null},\"id\":\"1471\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1441\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1473\",\"type\":\"LinearScale\"},{\"attributes\":{\"overlay\":{\"id\":\"1463\",\"type\":\"BoxAnnotation\"}},\"id\":\"1442\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1475\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1443\",\"type\":\"SaveTool\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1502\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1549\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1553\",\"type\":\"Selection\"},{\"attributes\":{\"callback\":null},\"id\":\"1422\",\"type\":\"DataRange1d\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1547\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1478\",\"type\":\"BasicTicker\"}},\"id\":\"1477\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1444\",\"type\":\"ResetTool\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1551\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1428\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1545\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1445\",\"type\":\"HelpTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_ping, tid: 18140, topic: /pong\"},\"id\":\"1420\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1478\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1552\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"ticker\":{\"id\":\"1478\",\"type\":\"BasicTicker\"}},\"id\":\"1481\",\"type\":\"Grid\"},{\"attributes\":{\"below\":[{\"id\":\"1477\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1481\",\"type\":\"Grid\"},{\"id\":\"1486\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1482\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1503\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1467\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1493\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1469\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1473\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1471\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1475\",\"type\":\"LinearScale\"}},\"id\":\"1466\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1545\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1483\",\"type\":\"BasicTicker\"}},\"id\":\"1482\",\"type\":\"LinearAxis\"},{\"attributes\":{\"below\":[{\"id\":\"1430\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1434\",\"type\":\"Grid\"},{\"id\":\"1439\",\"type\":\"Grid\"},{\"id\":\"1464\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1435\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1456\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1420\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1446\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1422\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1426\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1424\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1428\",\"type\":\"LinearScale\"}},\"id\":\"1419\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1463\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"data_source\":{\"id\":\"1418\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1454\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1455\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1457\",\"type\":\"CDSView\"}},\"id\":\"1456\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"data_source\":{\"id\":\"1500\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1501\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1502\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1504\",\"type\":\"CDSView\"}},\"id\":\"1503\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1483\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1418\",\"type\":\"ColumnDataSource\"}},\"id\":\"1457\",\"type\":\"CDSView\"},{\"attributes\":{\"callback\":null},\"id\":\"1424\",\"type\":\"DataRange1d\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1483\",\"type\":\"BasicTicker\"}},\"id\":\"1486\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1460\",\"type\":\"BasicTickFormatter\"}],\"root_ids\":[\"1505\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", - " var render_items = [{\"docid\":\"5802d7e0-bd5f-4040-95dd-fda2cbedf1ed\",\"roots\":{\"1505\":\"bb511789-b27e-4def-b167-377df1424c7e\"}}];\n", + " var docs_json = {\"b61d949d-b1bd-490c-9a29-a17619314661\":{\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1408\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"id\":\"1457\",\"subtype\":\"Figure\",\"type\":\"Plot\"}]},\"id\":\"1496\",\"type\":\"Row\"},{\"attributes\":{},\"id\":\"1432\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1540\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1464\",\"type\":\"LinearScale\"},{\"attributes\":{\"callback\":null},\"id\":\"1411\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1433\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1541\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1466\",\"type\":\"LinearScale\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1444\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1434\",\"type\":\"HelpTool\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Subscription -- node: test_pong, tid: 9877, topic: /ping\"},\"id\":\"1409\",\"type\":\"Title\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1535\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1469\",\"type\":\"BasicTicker\"}},\"id\":\"1468\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1539\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1469\",\"type\":\"BasicTicker\"},{\"attributes\":{\"callback\":null},\"id\":\"1413\",\"type\":\"DataRange1d\"},{\"attributes\":{\"ticker\":{\"id\":\"1469\",\"type\":\"BasicTicker\"}},\"id\":\"1472\",\"type\":\"Grid\"},{\"attributes\":{\"data_source\":{\"id\":\"1407\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1443\",\"type\":\"Line\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1444\",\"type\":\"Line\"},\"selection_glyph\":null,\"view\":{\"id\":\"1446\",\"type\":\"CDSView\"}},\"id\":\"1445\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1415\",\"type\":\"LinearScale\"},{\"attributes\":{\"source\":{\"id\":\"1407\",\"type\":\"ColumnDataSource\"}},\"id\":\"1446\",\"type\":\"CDSView\"},{\"attributes\":{\"axis_label\":\"frequency\",\"formatter\":{\"id\":\"1533\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1474\",\"type\":\"BasicTicker\"}},\"id\":\"1473\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1417\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1449\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null,\"data\":{\"duration\":{\"__ndarray__\":\"OKJ71jVa0T+bV3VWC+y9P5Hwvb9Be70/GAYsuYrFvz8CS65i8Zu+PwpJZvUOt78/9E2aBkXzvD8otRfRdky9PzPABdmyfL0/Z7lsdM5PvT92NA71u7C9Pz7NyYtMwL8/Gy5yT1d3vD8WaHdIMUC+P2A8g4b+CcA/lstG5/wUvz+k/+VatAC9PyS3Jt2WyL0/ij20jxX8vj9fzmxX6IOlP4du9gfKbb8/pwUv+grSvD+vsOB+wAPDP4I2OXzSicA/bJVgcTjzwT8RUrezrzzAP3IZNzXQfL4/2jnNAu0OvT+OdAZGXtbAP2fXvRWJCb4/ic4yi1BsvT/Cobd4eM/BP4TXLm04LL0/wF/MlqyKwj91j2yumufCP/SpY5XSM8M/N1FLcyuEvT88aHbdW5HCP0UsYthhTMI/n8n+eRowxD+l3H2OjxbBP79hokEKnsQ/R450BkZewj8ydOygEtfBPyZxVkRN9MU/SnmthO6SxD/uBPuvc9PCP59ZEqCmlsM/fuAqTyDswj8Z4lgXt9HAP8Bd9utOd8I/uagWEcXkvT9QOSaL+4/CP0HvjSEAOKY/NlZinpW0xD/CL/XzpiLDP3BCIQIOobY/GCe+2lGcwz8PuRluwOfBPxgjEoWWdcE/2zaMguDxwT8AA0GADB3HP0eum1JeK8E/\",\"dtype\":\"float64\",\"shape\":[63]},\"index\":[1,4,7,10,13,16,19,22,25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,73,76,79,82,85,88,91,94,97,100,103,106,109,112,115,118,121,124,127,130,133,136,139,142,145,148,151,154,157,160,163,166,169,172,175,178,181,184,187],\"timestamp\":{\"__ndarray__\":\"01mDOMu6dkLDiaI4y7p2QmbKwTjLunZCxwvhOMu6dkLZSgA5y7p2QlSLHznLunZCnss+Ocu6dkLPC145y7p2QitLfTnLunZCP4ucOcu6dkLlyrs5y7p2QhsL2znLunZCvEr6Ocu6dkIOixk6y7p2QifLODrLunZCNwtYOsu6dkIvS3c6y7p2QhuLljrLunZCCsu1Osu6dkLuBNU6y7p2QkxL9DrLunZCYIsTO8u6dkLJzDI7y7p2Qq4LUjvLunZCZkxxO8u6dkJYi5A7y7p2QnHLrzvLunZCIQzPO8u6dkJiTO47y7p2QvyLDTzLunZC7MssPMu6dkK4DEw8y7p2QvhLazzLunZCj4yKPMu6dkJCzKk8y7p2QjEMyTzLunZCHUzoPMu6dkIKjQc9y7p2QmjNJj3LunZC/gxGPcu6dkJiTGU9y7p2Qg6NhD3LunZC4cyjPcu6dkIrDcM9y7p2QiNN4j3LunZC540BPsu6dkJxzSA+y7p2Qj8PQD7LunZCUE1fPsu6dkLyjn4+y7p2QlDNnT7LunZCrA69Psu6dkJUTdw+y7p2QvKG+z7LunZCO80aP8u6dkJgDTo/y7p2QoVLWT/LunZC0414P8u6dkKRzZc/y7p2QtcNtz/LunZCfU3WP8u6dkLjjfU/y7p2QtvNFEDLunZC\",\"dtype\":\"float64\",\"shape\":[63]}},\"selected\":{\"id\":\"1537\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1538\",\"type\":\"UnionRenderers\"}},\"id\":\"1407\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1474\",\"type\":\"BasicTicker\"},{\"attributes\":{\"overlay\":{\"id\":\"1539\",\"type\":\"BoxAnnotation\"}},\"id\":\"1480\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"axis_label\":\"start (2019-07-01 08:42)\",\"formatter\":{\"id\":\"1455\",\"type\":\"DatetimeTickFormatter\"},\"ticker\":{\"id\":\"1420\",\"type\":\"BasicTicker\"}},\"id\":\"1419\",\"type\":\"LinearAxis\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1474\",\"type\":\"BasicTicker\"}},\"id\":\"1477\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1483\",\"type\":\"HelpTool\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1478\",\"type\":\"PanTool\"},{\"id\":\"1479\",\"type\":\"WheelZoomTool\"},{\"id\":\"1480\",\"type\":\"BoxZoomTool\"},{\"id\":\"1481\",\"type\":\"SaveTool\"},{\"id\":\"1482\",\"type\":\"ResetTool\"},{\"id\":\"1483\",\"type\":\"HelpTool\"}]},\"id\":\"1484\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1420\",\"type\":\"BasicTicker\"},{\"attributes\":{\"below\":[{\"id\":\"1419\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1423\",\"type\":\"Grid\"},{\"id\":\"1428\",\"type\":\"Grid\"},{\"id\":\"1453\",\"type\":\"Legend\"}],\"left\":[{\"id\":\"1424\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1445\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1409\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1435\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1411\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1415\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1413\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1417\",\"type\":\"LinearScale\"}},\"id\":\"1408\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":{\"value\":0.5},\"fill_color\":{\"value\":\"lightgrey\"},\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":{\"value\":1.0},\"line_color\":{\"value\":\"black\"},\"line_dash\":[4,4],\"line_width\":{\"value\":2},\"render_mode\":\"css\",\"right_units\":\"screen\",\"top_units\":\"screen\"},\"id\":\"1452\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1493\",\"type\":\"Quad\"},{\"attributes\":{},\"id\":\"1481\",\"type\":\"SaveTool\"},{\"attributes\":{\"ticker\":{\"id\":\"1420\",\"type\":\"BasicTicker\"}},\"id\":\"1423\",\"type\":\"Grid\"},{\"attributes\":{\"items\":[{\"id\":\"1454\",\"type\":\"LegendItem\"}]},\"id\":\"1453\",\"type\":\"Legend\"},{\"attributes\":{\"axis_label\":\"duration (ms)\",\"formatter\":{\"id\":\"1449\",\"type\":\"BasicTickFormatter\"},\"ticker\":{\"id\":\"1425\",\"type\":\"BasicTicker\"}},\"id\":\"1424\",\"type\":\"LinearAxis\"},{\"attributes\":{\"data_source\":{\"id\":\"1491\",\"type\":\"ColumnDataSource\"},\"glyph\":{\"id\":\"1492\",\"type\":\"Quad\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1493\",\"type\":\"Quad\"},\"selection_glyph\":null,\"view\":{\"id\":\"1495\",\"type\":\"CDSView\"}},\"id\":\"1494\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"label\":{\"value\":\"[lambda]\"},\"renderers\":[{\"id\":\"1445\",\"type\":\"GlyphRenderer\"}]},\"id\":\"1454\",\"type\":\"LegendItem\"},{\"attributes\":{},\"id\":\"1425\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1491\",\"type\":\"ColumnDataSource\"}},\"id\":\"1495\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1455\",\"type\":\"DatetimeTickFormatter\"},{\"attributes\":{},\"id\":\"1479\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"bottom\":{\"value\":0},\"fill_color\":{\"value\":\"#1f77b4\"},\"left\":{\"field\":\"left\"},\"line_color\":{\"value\":\"#1f77b4\"},\"right\":{\"field\":\"right\"},\"top\":{\"field\":\"top\"}},\"id\":\"1492\",\"type\":\"Quad\"},{\"attributes\":{\"dimension\":1,\"ticker\":{\"id\":\"1425\",\"type\":\"BasicTicker\"}},\"id\":\"1428\",\"type\":\"Grid\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"line_width\":2,\"x\":{\"field\":\"timestamp\"},\"y\":{\"field\":\"duration\"}},\"id\":\"1443\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1533\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1535\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"callback\":null,\"data\":{\"left\":{\"__ndarray__\":\"X85sV+iDpT9bN+9JcZ+wP4YHKGjufLY/stdghmtavD/u00xS9BvBPwQ8aeGyCsQ/GqSFcHH5xj8vDKL/L+jJP0V0vo7u1sw/W9zaHa3Fzz8=\",\"dtype\":\"float64\",\"shape\":[10]},\"right\":{\"__ndarray__\":\"WzfvSXGfsD+GByho7ny2P7LXYIZrWrw/7tNMUvQbwT8EPGnhsgrEPxqkhXBx+cY/Lwyi/y/oyT9FdL6O7tbMP1vc2h2txc8/OKJ71jVa0T8=\",\"dtype\":\"float64\",\"shape\":[10]},\"top\":[2,0,1,32,21,5,1,0,0,1]},\"selected\":{\"id\":\"1540\",\"type\":\"Selection\"},\"selection_policy\":{\"id\":\"1541\",\"type\":\"UnionRenderers\"}},\"id\":\"1491\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"active_drag\":\"auto\",\"active_inspect\":\"auto\",\"active_multi\":null,\"active_scroll\":\"auto\",\"active_tap\":\"auto\",\"tools\":[{\"id\":\"1429\",\"type\":\"PanTool\"},{\"id\":\"1430\",\"type\":\"WheelZoomTool\"},{\"id\":\"1431\",\"type\":\"BoxZoomTool\"},{\"id\":\"1432\",\"type\":\"SaveTool\"},{\"id\":\"1433\",\"type\":\"ResetTool\"},{\"id\":\"1434\",\"type\":\"HelpTool\"}]},\"id\":\"1435\",\"type\":\"Toolbar\"},{\"attributes\":{\"align\":\"center\",\"text\":\"Duration histogram\"},\"id\":\"1458\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1482\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1429\",\"type\":\"PanTool\"},{\"attributes\":{\"below\":[{\"id\":\"1468\",\"type\":\"LinearAxis\"}],\"center\":[{\"id\":\"1472\",\"type\":\"Grid\"},{\"id\":\"1477\",\"type\":\"Grid\"}],\"left\":[{\"id\":\"1473\",\"type\":\"LinearAxis\"}],\"plot_height\":450,\"plot_width\":450,\"renderers\":[{\"id\":\"1494\",\"type\":\"GlyphRenderer\"}],\"title\":{\"id\":\"1458\",\"type\":\"Title\"},\"toolbar\":{\"id\":\"1484\",\"type\":\"Toolbar\"},\"x_range\":{\"id\":\"1460\",\"type\":\"DataRange1d\"},\"x_scale\":{\"id\":\"1464\",\"type\":\"LinearScale\"},\"y_range\":{\"id\":\"1462\",\"type\":\"DataRange1d\"},\"y_scale\":{\"id\":\"1466\",\"type\":\"LinearScale\"}},\"id\":\"1457\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1537\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1538\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"callback\":null},\"id\":\"1460\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1478\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1430\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"callback\":null},\"id\":\"1462\",\"type\":\"DataRange1d\"},{\"attributes\":{\"overlay\":{\"id\":\"1452\",\"type\":\"BoxAnnotation\"}},\"id\":\"1431\",\"type\":\"BoxZoomTool\"}],\"root_ids\":[\"1496\"]},\"title\":\"Bokeh Application\",\"version\":\"1.2.0\"}};\n", + " var render_items = [{\"docid\":\"b61d949d-b1bd-490c-9a29-a17619314661\",\"roots\":{\"1496\":\"d093cb06-af36-418e-95f4-e6532fb522a3\"}}];\n", " root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n", "\n", " }\n", @@ -535,7 +538,7 @@ }, "metadata": { "application/vnd.bokehjs_exec.v0+json": { - "id": "1505" + "id": "1496" } }, "output_type": "display_data" @@ -556,24 +559,29 @@ " owner_info = '[unknown]'\n", "\n", " # Duration\n", - " duration_ns = data_util.get_callback_durations(obj)\n", - " duration_ms = duration_ns.apply(lambda d: d/1000000.0)\n", - " source = ColumnDataSource(duration_ms)\n", - " duration = figure(title=owner_info, x_axis_label='start', y_axis_label='duration (ms)',\n", + " duration_df = data_util.get_callback_durations(obj)\n", + " starttime = duration_df.loc[:, 'timestamp'].iloc[0].strftime('%Y-%m-%d %H:%M')\n", + " source = ColumnDataSource(duration_df)\n", + " duration = figure(title=owner_info,\n", + " x_axis_label=f'start ({starttime})',\n", + " y_axis_label='duration (ms)',\n", " plot_width=psize, plot_height=psize)\n", " duration.title.align = 'center'\n", " duration.line(x='timestamp', y='duration', legend=str(symbol), line_width=2, source=source)\n", + " duration.xaxis[0].formatter = DatetimeTickFormatter(seconds=['%Ss'])\n", "\n", " # Histogram\n", - " dur_hist, edges = np.histogram(duration_ms['duration'])\n", - " duration_ms_hist = pd.DataFrame({'duration': dur_hist, \n", + " dur_hist, edges = np.histogram(duration_df['duration'])\n", + " duration_hist = pd.DataFrame({'duration': dur_hist, \n", " 'left': edges[:-1], \n", " 'right': edges[1:]})\n", - " hist = figure(title='Duration histogram', x_axis_label='duration (ms)', y_axis_label='frequency',\n", + " hist = figure(title='Duration histogram',\n", + " x_axis_label='duration (ms)',\n", + " y_axis_label='frequency',\n", " plot_width=psize, plot_height=psize)\n", " hist.title.align = 'center'\n", - " hist.quad(bottom=0, top=duration_ms_hist['duration'], \n", - " left=duration_ms_hist['left'], right=duration_ms_hist['right'])\n", + " hist.quad(bottom=0, top=duration_hist['duration'], \n", + " left=duration_hist['left'], right=duration_hist['right'])\n", "\n", " show(row(duration, hist))" ] From 31f456c21c28cccd28ca944472bd1db6ba086d7f Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Mon, 1 Jul 2019 10:29:11 +0200 Subject: [PATCH 97/98] Add info to readme --- README.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/README.md b/README.md index e69de29..7fcab46 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,20 @@ +# tracetools_analysis + +Analysis tools for [ROS 2 tracing](https://gitlab.com/ros_tracing/ros2_tracing). + +# Setup + +To display results, install: + +* [Jupyter](https://jupyter.org/install) +* [Bokeh](https://bokeh.pydata.org/en/latest/docs/user_guide/quickstart.html#userguide-quickstart-install) + +# Use + +Start Jupyter Notebook: + +``` +$ jupyter notebook +``` + +Then navigate to the [`analysis/`](./tracetools_analysis/analysis/) directory, and select one of the provided notebooks, or create your own! From 44c3db97cd69050f90d45cb1ba0a6fd4415b3a65 Mon Sep 17 00:00:00 2001 From: Christophe Bedard Date: Fri, 5 Jul 2019 13:17:27 +0200 Subject: [PATCH 98/98] Make CI check test results --- .gitlab-ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index dc61ed4..f8bbd24 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -11,6 +11,7 @@ build: script: - colcon build --symlink-install --packages-up-to $PACKAGES_LIST - colcon test --packages-select $PACKAGES_LIST + - colcon test-result artifacts: paths: - install