diff --git a/latency_graph/latency_graph_plots.py b/latency_graph/latency_graph_plots.py
new file mode 100644
index 0000000..dce6363
--- /dev/null
+++ b/latency_graph/latency_graph_plots.py
@@ -0,0 +1,201 @@
+import math
+import re
+
+import graphviz as gv
+
+import latency_graph.latency_graph_structure as lg
+from matching.subscriptions import sanitize
+from tracing_interop.tr_types import TrContext
+
+NODE_COLORS = {
+        "sensing": {"fill": "#e1d5e7", "stroke": "#9673a6"},
+        "localization": {"fill": "#dae8fc", "stroke": "#6c8ebf"},
+        "perception": {"fill": "#d5e8d4", "stroke": "#82b366"},
+        "planning": {"fill": "#fff2cc", "stroke": "#d6b656"},
+        "control": {"fill": "#ffe6cc", "stroke": "#d79b00"},
+        "system": {"fill": "#f8cecc", "stroke": "#b85450"},
+        "vehicle_interface": {"fill": "#b0e3e6", "stroke": "#0e8088"},
+        None: {"fill": "#f5f5f5", "stroke": "#666666"}
+}
+
+NODE_NAMESPACE_MAPPING = {
+        'perception': 'perception',
+        'sensing': 'sensing',
+        'planning': 'planning',
+        'control': 'control',
+        'awapi': 'system',
+        'autoware_api': 'system',
+        'map': 'system',
+        'system': 'system',
+        'localization': 'localization',
+        'robot_state_publisher': None,
+        'aggregator_node': None,
+        'pointcloud_container': 'sensing',
+}
+
+
+def plot_latency_graph_full(lat_graph: lg.LatencyGraph, tr: TrContext, filename: str):
+    # Compare with: https://autowarefoundation.github.io/autoware-documentation/main/design/autoware-architecture/node-diagram/
+
+    g = gv.Digraph('G', filename="latency_graph.gv",
+                   node_attr={'shape': 'plain'},
+                   graph_attr={'pack': '1'})
+    g.graph_attr['rankdir'] = 'LR'
+
+    def plot_hierarchy(gv_parent, lg_node: lg.LGHierarchyLevel, **subgraph_kwargs):
+        if lg_node.name == "[NONE]":
+            return
+
+        print(f"{'  ' * lg_node.full_name.count('/')}Processing {lg_node.name}: {len(lg_node.callbacks)}")
+        with gv_parent.subgraph(name=f"cluster_{lg_node.full_name.replace('/', '__')}", **subgraph_kwargs) as c:
+            c.attr(label=lg_node.name)
+            for cb in lg_node.callbacks:
+                if isinstance(cb, lg.LGTrCallback):
+                    tr_cb = cb.cb
+                    try:
+                        sym = tr.callback_symbols.by_id.get(tr_cb.callback_object)
+                        pretty_sym = repr(sanitize(sym.symbol))
+                    except KeyError:
+                        pretty_sym = cb.name
+                    except TypeError:
+                        pretty_sym = cb.name
+                else:
+                    pretty_sym = cb.name
+
+                pretty_sym = pretty_sym.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+                c.node(cb.id(),
+                       f'<<table BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr><td port="in"></td><td>{pretty_sym}</td><td port="out"></td></tr></table>>')
+
+            for ch in lg_node.children:
+                plot_hierarchy(c, ch, **subgraph_kwargs)
+
+    def plot_lg(graph: lg.LatencyGraph):
+        for top_level_node in graph.top_node.children:
+            colors = NODE_COLORS[NODE_NAMESPACE_MAPPING.get(top_level_node.name)]
+            plot_hierarchy(g, top_level_node, graph_attr={'bgcolor': colors["fill"], 'pencolor': colors["stroke"]})
+
+        for edge in graph.edges:
+            g.edge(f"{edge.start.id()}:out", f"{edge.end.id()}:in")
+
+    plot_lg(lat_graph)
+
+    g.save(f"{filename}.gv")
+    g.render(f"{filename}.svg")
+
+    return g
+
+
+def plot_latency_graph_overview(lat_graph: lg.LatencyGraph, excl_node_patterns, input_node_patterns,
+                                output_node_patterns, max_hier_level, filename):
+    ##################################################
+    # Compute in/out topics for hierarchy level X
+    ##################################################
+
+    def get_nodes_on_level(lat_graph: lg.LatencyGraph):
+        def _traverse_node(node: lg.LGHierarchyLevel, cur_lvl=0):
+            if cur_lvl == max_hier_level:
+                return [node]
+
+            if not node.children:
+                return [node]
+
+            collected_nodes = []
+            for ch in node.children:
+                collected_nodes += _traverse_node(ch, cur_lvl + 1)
+            return collected_nodes
+
+        return _traverse_node(lat_graph.top_node)
+
+    lvl_nodes = get_nodes_on_level(lat_graph)
+    lvl_nodes = [n for n in lvl_nodes if not any(re.search(p, n.full_name) for p in excl_node_patterns)]
+
+    input_nodes = [n.full_name for n in lvl_nodes if any(re.search(p, n.full_name) for p in input_node_patterns)]
+    output_nodes = [n.full_name for n in lvl_nodes if any(re.search(p, n.full_name) for p in output_node_patterns)]
+
+    print(', '.join(map(lambda n: n, input_nodes)))
+    print(', '.join(map(lambda n: n, output_nodes)))
+    print(', '.join(map(lambda n: n.full_name, lvl_nodes)))
+
+    def _collect_callbacks(n: lg.LGHierarchyLevel):
+        callbacks = []
+        callbacks += n.callbacks
+        for ch in n.children:
+            callbacks += _collect_callbacks(ch)
+        return callbacks
+
+    cb_to_node_map = {}
+    for n in lvl_nodes:
+        cbs = _collect_callbacks(n)
+        for cb in cbs:
+            cb_to_node_map[cb.id()] = n
+
+    edges_between_nodes = {}
+    for edge in lat_graph.edges:
+        from_node = cb_to_node_map.get(edge.start.id())
+        to_node = cb_to_node_map.get(edge.end.id())
+
+        if from_node is None or to_node is None:
+            continue
+
+        if from_node.full_name == to_node.full_name:
+            continue
+
+        k = (from_node.full_name, to_node.full_name)
+
+        if k not in edges_between_nodes:
+            edges_between_nodes[k] = []
+
+        edges_between_nodes[k].append(edge)
+
+    g = gv.Digraph('G', filename="latency_graph.gv",
+                   node_attr={'shape': 'plain'},
+                   graph_attr={'pack': '1'})
+    g.graph_attr['rankdir'] = 'LR'
+
+    for n in lvl_nodes:
+        colors = NODE_COLORS[NODE_NAMESPACE_MAPPING.get(n.full_name.strip("/").split("/")[0])]
+        peripheries = "1" if n.full_name not in output_nodes else "2"
+        g.node(n.full_name, label=n.full_name, fillcolor=colors["fill"], color=colors["stroke"],
+               shape="box", style="filled", peripheries=peripheries)
+
+        if n.full_name in input_nodes:
+            helper_node_name = f"{n.full_name}__before"
+            g.node(helper_node_name, label="", shape="none", height="0", width="0")
+            g.edge(helper_node_name, n.full_name)
+
+    def compute_e2e_paths(start_nodes, end_nodes, edges):
+        frontier_paths = [[n] for n in start_nodes]
+        final_paths = []
+
+        while frontier_paths:
+            frontier_paths_new = []
+
+            for path in frontier_paths:
+                head = path[-1]
+                if head in end_nodes:
+                    final_paths.append(path)
+                    continue
+
+                out_nodes = [n_to for n_from, n_to in edges if n_from == head if n_to not in path]
+                new_paths = [path + [n] for n in out_nodes]
+                frontier_paths_new += new_paths
+
+            frontier_paths = frontier_paths_new
+
+        final_paths = [[(n_from, n_to)
+                        for n_from, n_to in zip(path[:-1], path[1:])]
+                       for path in final_paths]
+        return final_paths
+
+    e2e_paths = compute_e2e_paths(input_nodes, output_nodes, edges_between_nodes)
+
+    for (src_name, dst_name), edges in edges_between_nodes.items():
+        print(src_name, dst_name, len(edges))
+        color = "black" if any((src_name, dst_name) in path for path in e2e_paths) else "tomato"
+        g.edge(src_name, dst_name, penwidth=str(math.log(len(edges)) * 2 + .2), color=color)
+
+    g.save(f"{filename}.gv")
+    g.render(f"{filename}.svg")
+
+    return g
diff --git a/latency_graph/latency_graph.py b/latency_graph/latency_graph_structure.py
similarity index 96%
rename from latency_graph/latency_graph.py
rename to latency_graph/latency_graph_structure.py
index e2d3d6c..8587d8a 100644
--- a/latency_graph/latency_graph.py
+++ b/latency_graph/latency_graph_structure.py
@@ -1,18 +1,16 @@
 from bisect import bisect_left, bisect_right
 from collections import defaultdict
 from dataclasses import dataclass
-from itertools import combinations
-from multiprocessing import Pool
-from typing import Optional, Set, List, Iterable, Dict, Tuple
 from functools import cache
+from itertools import combinations
+from typing import Optional, Set, List, Iterable, Dict
+from uuid import UUID, uuid4
 
-import numpy as np
 from tqdm import tqdm
-from tqdm.contrib import concurrent
 
 from matching.subscriptions import sanitize
-from tracing_interop.tr_types import TrContext, TrCallbackObject, TrCallbackSymbol, TrNode, TrPublisher, TrSubscription, \
-    TrTimer, TrPublishInstance, TrSubscriptionObject, TrTopic, TrCallbackInstance, Timestamp
+from tracing_interop.tr_types import TrContext, TrCallbackObject, TrCallbackSymbol, TrNode, TrPublisher, TrTimer, \
+    TrSubscriptionObject, TrTopic
 
 TOPIC_FILTERS = ["/parameter_events", "/tf_static", "/robot_description", "diagnostics", "/rosout"]
 
@@ -203,6 +201,8 @@ class LatencyGraph:
     cb_pubs: Dict[TrCallbackObject, Set[TrPublisher]]
     pub_cbs: Dict[TrPublisher, Set[TrCallbackObject]]
 
+    _uuid: UUID
+
     def __init__(self, tr: TrContext):
         ##################################################
         # Annotate nodes with their callbacks
@@ -290,3 +290,10 @@ class LatencyGraph:
         ##################################################
 
         self.top_node = _hierarchize(lg_nodes)
+        self._uuid = uuid4()
+
+    def __hash__(self):
+        return hash(self._uuid)
+
+    def __eq__(self, other):
+        return isinstance(other, LatencyGraph) and other._uuid == self._uuid
diff --git a/latency_graph/message_tree.py b/latency_graph/message_tree.py
deleted file mode 100644
index 9544bd7..0000000
--- a/latency_graph/message_tree.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from dataclasses import dataclass
-from typing import List
-
-from tracing_interop.tr_types import TrPublishInstance, TrCallbackInstance
-
-
-@dataclass
-class DepTree:
-    head: TrCallbackInstance | TrPublishInstance
-    deps: List['DepTree']
-
-    def depth(self):
-        return 1 + max(map(DepTree.depth, self.deps), default=0)
-
-    def size(self):
-        return 1 + sum(map(DepTree.size, self.deps))
-
-    def fanout(self):
-        if not self.deps:
-            return 1
-
-        return sum(map(DepTree.fanout, self.deps))
-
-    def e2e_lat(self):
-        return self.head.timestamp - self.critical_path()[-1].timestamp
-
-    def critical_path(self):
-        if not self.deps:
-            return [self.head]
-
-        return [self.head, *min(map(DepTree.critical_path, self.deps), key=lambda ls: ls[-1].timestamp)]
diff --git a/message_tree/__init__.py b/message_tree/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/message_tree/message_tree_algorithms.py b/message_tree/message_tree_algorithms.py
new file mode 100644
index 0000000..6be5df6
--- /dev/null
+++ b/message_tree/message_tree_algorithms.py
@@ -0,0 +1,335 @@
+import re
+from bisect import bisect_right
+from collections import defaultdict
+from functools import cache
+from typing import List
+
+from tqdm import tqdm
+
+from latency_graph.latency_graph_structure import LatencyGraph
+from matching.subscriptions import sanitize
+from message_tree.message_tree_structure import DepTree, E2EBreakdownItem
+from tracing_interop.tr_types import TrCallbackInstance, TrPublishInstance, TrPublisher, TrCallbackObject, TrContext, \
+    TrSubscriptionObject, TrTimer, TrNode, TrTopic
+
+
+__dep_tree_cache = {}
+
+
+def _repr(inst: TrCallbackInstance | TrPublishInstance):
+    """
+    If a string representation is found for `inst`, it is returned, else an empty string is returned.
+    """
+    match inst:
+        case TrPublishInstance(publisher=pub):
+            return pub.topic_name if pub else ""
+        case TrCallbackInstance(callback_obj=cb_obj):
+            cb_obj: TrCallbackObject
+            return repr(sanitize(cb_obj.callback_symbol.symbol)) if cb_obj and cb_obj.callback_symbol else ""
+    raise TypeError(f"Argument has to be callback or publish instance, is {type(inst).__name__}")
+
+
+def get_dep_tree(inst: TrPublishInstance | TrCallbackInstance, lat_graph: LatencyGraph, tr: TrContext,
+                 excluded_path_patterns, time_limit_s):
+    """
+    Finds all (desired) dependencies of a publish/callback instance and returns a dependency tree.
+
+    The dependencies can be filtered via `time_limit_s`, which is the maximum difference in start time between `inst`
+    and any dependency in the tree.
+    Another filter is `excluded_path_patterns`, which cuts off paths where one instance's string representation matches
+    any of the given regex patterns.
+    """
+
+
+    start_time = inst.timestamp
+
+    def __get_dep_tree(inst, is_dep_cb, visited=None):
+
+        # If inst owner has been visited already, skip (loop prevention)
+        if visited is not None and owner(inst) in visited:
+            return None
+
+        # If we want to retrieve the tree, look in the cache first
+        cache_key = (inst, is_dep_cb)
+        if cache_key in __dep_tree_cache:
+            return __dep_tree_cache[cache_key]
+
+        if visited is None:
+            visited = tuple()
+
+        if any(re.search(p, _repr(inst)) for p in excluded_path_patterns):
+            return None
+
+        if inst.timestamp - start_time > time_limit_s:
+            return None
+
+        children_are_dep_cbs = False
+
+        match inst:
+            case TrPublishInstance(publisher=pub):
+                deps = [get_msg_dep_cb(inst, lat_graph)]
+            case TrCallbackInstance() as cb_inst:
+                cb_inst: TrCallbackInstance
+                deps = [inst_get_dep_msg(cb_inst, tr)]
+                if not is_dep_cb:
+                    deps += inst_get_dep_insts(cb_inst, tr)
+                    children_are_dep_cbs = True
+            case _:
+                print("[WARN] Expected inst to be of type TrPublishInstance or TrCallbackInstance, "
+                      f"got {type(inst).__name__}")
+                return None
+        # print("Rec level", lvl)
+        deps = list(filter(None, deps))
+        # Copy visited set for each child because we don't want separate paths to interfere with each other
+        deps = [__get_dep_tree(dep, children_are_dep_cbs, {*visited, owner(inst)}) for dep in deps]
+        deps = list(filter(None, deps))
+
+        # Create tree instance, cache and return it
+        ret_tree = DepTree(inst, deps)
+        __dep_tree_cache[cache_key] = ret_tree
+        return ret_tree
+
+    return __get_dep_tree(inst, False)
+
+
+def build_dep_trees(end_topics, lat_graph, tr, excluded_path_patterns, time_limit_s):
+    """
+    Builds the dependency trees for all messages published in any of `end_topics` and returns them as a list.
+    """
+    all_trees = []
+    for end_topic in end_topics:
+        end_topic: TrTopic
+        print(f"====={end_topic.name}")
+
+        pubs = end_topic.publishers
+        for pub in pubs:
+            msgs = list(pub.instances)
+            for msg in tqdm(msgs, desc="Processing output messages"):
+                msg: TrPublishInstance
+                tree = get_dep_tree(msg, lat_graph, tr, excluded_path_patterns, time_limit_s)
+                all_trees.append(tree)
+    return all_trees
+
+
+def inst_get_dep_msg(inst: TrCallbackInstance, tr: TrContext):
+    if inst.callback_object not in tr.callback_objects.by_callback_object:
+        # print("Callback not found (2)")
+        return None
+
+    if not isinstance(inst.callback_obj.owner, TrSubscriptionObject):
+        # print(f"Wrong type: {type(inst.callback_obj.owner)}")
+        return None
+
+    sub_obj: TrSubscriptionObject = inst.callback_obj.owner
+    if sub_obj and sub_obj.subscription and sub_obj.subscription.topic:
+        # print(f"Subscription has no topic")
+        pubs = sub_obj.subscription.topic.publishers
+    else:
+        pubs = []
+
+    def _pub_latest_msg_before(pub: TrPublisher, inst):
+        i_latest_msg = bisect_right(pub.instances, inst.timestamp, key=lambda x: x.timestamp) - 1
+        if i_latest_msg < 0 or i_latest_msg >= len(pub.instances):
+            return None
+        latest_msg = pub.instances[i_latest_msg]
+        if latest_msg.timestamp >= inst.timestamp:
+            return None
+
+        return latest_msg
+
+    msgs = [_pub_latest_msg_before(pub, inst) for pub in pubs]
+    msgs = list(filter(None, msgs))
+    msgs.sort(key=lambda i: i.timestamp, reverse=True)
+    if msgs:
+        msg = msgs[0]
+        return msg
+
+    # print(f"No messages found for topic {sub_obj.subscription.topic}")
+    return None
+
+
+def inst_get_dep_insts(inst: TrCallbackInstance, tr: TrContext):
+    if inst.callback_object not in tr.callback_objects.by_callback_object:
+        # print("Callback not found")
+        return []
+    dep_cbs = get_cb_dep_cbs(inst.callback_obj, tr)
+
+    def _cb_to_chronological_inst(cb: TrCallbackObject, inst):
+        i_inst_latest = bisect_right(cb.callback_instances, inst.timestamp, key=lambda x: x.timestamp)
+
+        for inst_before in cb.callback_instances[i_inst_latest::-1]:
+            if inst_before.t_end < inst.timestamp:
+                return inst_before
+
+        return None
+
+    insts = [_cb_to_chronological_inst(cb, inst) for cb in dep_cbs]
+    insts = list(filter(None, insts))
+    return insts
+
+
+def get_cb_dep_cbs(cb: TrCallbackObject, tr: TrContext):
+    match cb.owner:
+        case TrSubscriptionObject() as sub_obj:
+            sub_obj: TrSubscriptionObject
+            owner = sub_obj.subscription.node
+        case TrTimer() as tmr:
+            tmr: TrTimer
+            owner = tmr.node
+        case _:
+            raise RuntimeError(f"Encountered {cb.owner} as callback owner")
+
+    owner: TrNode
+    dep_sub_objs = {sub.subscription_object for sub in owner.subscriptions}
+    dep_cbs = {tr.callback_objects.by_id.get(sub_obj.id) for sub_obj in dep_sub_objs if sub_obj is not None}
+    dep_cbs |= {tr.callback_objects.by_id.get(tmr.id) for tmr in owner.timers}
+    dep_cbs.discard(cb)
+    dep_cbs.discard(None)
+
+    return dep_cbs
+
+
+def get_msg_dep_cb(msg: TrPublishInstance, lat_graph: LatencyGraph):
+    """
+    For a given message instance `msg`, find the publishing callback,
+    as well as the message instances that callback depends on (transitively within its TrNode).
+    """
+
+    # Find CB instance that published msg
+    # print(f"PUB {msg.publisher.node.path if msg.publisher.node is not None else '??'} ==> {msg.publisher.topic_name}")
+    pub_cbs = lat_graph.pub_cbs.get(msg.publisher)
+    if pub_cbs is None:
+        # print("Publisher unknown to lat graph. Skipping.")
+        return None
+
+    # print(f"Found {len(pub_cbs)} pub cbs")
+    cb_inst_candidates = []
+    for cb in pub_cbs:
+        # print(f"  > CB ({len(cb.callback_instances)} instances): {cb.callback_symbol.symbol if cb.callback_symbol else cb.id}")
+        i_inst_after = bisect_right(cb.callback_instances, msg.timestamp, key=lambda x: x.timestamp)
+
+        for inst in cb.callback_instances[:i_inst_after]:
+            if msg.timestamp > inst.t_end:
+                continue
+
+            assert inst.t_start <= msg.timestamp <= inst.t_end
+
+            cb_inst_candidates.append(inst)
+
+    if len(cb_inst_candidates) > 1:
+        # print("Found multiple possible callbacks")
+        return None
+    if not cb_inst_candidates:
+        # print("Found no possible callbacks")
+        return None
+
+    dep_inst = cb_inst_candidates[0]
+    return dep_inst
+
+
+def e2e_paths_sorted_desc(tree: DepTree, input_topic_patterns):
+    """
+    Return all paths through `tree` that start with a callback instance publishing on a topic matching any of
+    `input_topic_patterns`. The paths are sorted by length in a descending manner (element 0 is longest).
+    """
+
+    def _collect_all_paths(t: DepTree):
+        return [(*_collect_all_paths(d), t.head) for d in t.deps]
+
+    def _trim_path(path):
+        valid_input = False
+        i = -1
+        for i, inst in enumerate(path):
+            match inst:
+                case TrPublishInstance(publisher=pub):
+                    pub: TrPublisher
+                    if pub and any(re.search(p, pub.topic_name) for p in input_topic_patterns):
+                        valid_input = True
+                        break
+
+        if not valid_input:
+            return None
+
+        if i == 0 or not isinstance(path[i - 1], TrCallbackInstance):
+            print(f"[WARN] Message has no publishing callback in dep tree.")
+            return path[i:]  # Return path from first message that fits an input topic pattern
+
+        return path[i - 1:]  # Return path from its publishing callback if it exists
+
+    paths = _collect_all_paths(tree)
+    paths = list(filter(lambda p: p is not None, map(_trim_path, tqdm(paths, desc="_trim_path"))))
+    paths.sort(key=lambda path: path[-1].timestamp - path[0].timestamp, reverse=True)
+    return paths
+
+
+def e2e_latency_breakdown(path: list):
+    """
+    Separates E2E latency into a sequence of dds, idle, and cpu times.
+    This method expects a publish instance at the last position in `path`.
+
+    The return format is a list of the form [("<type>", <time>), ("<type>", <time>), ...] with type bein gone of the
+    three mentioned above.
+    """
+    ret_list: List[E2EBreakdownItem] = []
+
+    cb_inst: TrCallbackInstance
+    cb_inst_prev: TrCallbackInstance
+    pub_inst: TrPublishInstance
+    pub_inst_prev: TrPublishInstance
+
+    last_inst = None
+    for inst in path:
+        match inst:
+            case TrCallbackInstance() as cb_inst:
+                match last_inst:
+                    case TrCallbackInstance() as cb_inst_prev:
+                        ret_list.append(E2EBreakdownItem("idle", cb_inst.t_start - cb_inst_prev.t_end,
+                                                         (cb_inst_prev, cb_inst)))
+                    case TrPublishInstance() as pub_inst_prev:
+                        ret_list.append(E2EBreakdownItem("dds", cb_inst.t_start - pub_inst_prev.timestamp,
+                                                         (pub_inst_prev, inst)))
+            case TrPublishInstance() as pub_inst:
+                match last_inst:
+                    case TrCallbackInstance() as cb_inst_prev:
+                        ret_list.append(E2EBreakdownItem("cpu", pub_inst.timestamp - cb_inst_prev.t_start,
+                                                         (cb_inst_prev, pub_inst)))
+                    case TrPublishInstance():
+                        raise TypeError(f"Found two publish instances in a row in an E2E path.")
+        last_inst = inst
+
+    if not isinstance(last_inst, TrPublishInstance):
+        raise TypeError(f"Last instance in path is not a message but a {type(last_inst).__name__}")
+
+    return ret_list
+
+
+@cache
+def owner(inst: TrCallbackInstance | TrPublishInstance):
+    match inst:
+        case TrCallbackInstance(callback_obj=cb_obj):
+            cb_obj: TrCallbackObject
+            if cb_obj and cb_obj.callback_symbol:
+                sym = repr(sanitize(cb_obj.callback_symbol.symbol))
+            else:
+                sym = str(cb_obj.id)
+            return sym
+        case TrPublishInstance(publisher=pub):
+            pub: TrPublisher
+            topic = pub.topic_name
+            return topic
+        case _:
+            raise ValueError()
+
+
+def _repr_path(path: List[TrPublishInstance | TrCallbackInstance]):
+    return " -> ".join(map(owner, path))
+
+
+def aggregate_e2e_paths(paths: List[List[TrPublishInstance | TrCallbackInstance]]):
+    path_cohorts = defaultdict(list)
+
+    for path in paths:
+        key = _repr_path(path)
+        path_cohorts[key].append(path)
+
+    return path_cohorts
diff --git a/message_tree/message_tree_plots.py b/message_tree/message_tree_plots.py
new file mode 100644
index 0000000..c4f8ece
--- /dev/null
+++ b/message_tree/message_tree_plots.py
@@ -0,0 +1,49 @@
+from typing import List
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+
+from message_tree.message_tree_structure import E2EBreakdownItem
+
+
+def e2e_breakdown_type_hist(items: List[E2EBreakdownItem]):
+    """
+    Given a list of e2e breakdown instances of the form `("<type>", <duration>)`, plots a histogram for each encountered
+    type.
+    """
+    plot_types = ("dds", "idle", "cpu")
+    assert all(item.type in plot_types for item in items)
+
+    fig: Figure
+    fig, axes = plt.subplots(1, 3, num="E2E type breakdown histograms")
+    fig.suptitle("E2E Latency Breakdown by Resource Type")
+
+    for type, ax in zip(plot_types, axes):
+        ax: Axes
+
+        durations = [item.duration for item in items if item.type == type]
+
+        ax.set_title(type)
+        ax.hist(durations)
+        ax.set_xlabel("Duration [s]")
+        ax.set_ylabel("Occurrences")
+
+    return fig
+
+
+def e2e_breakdown_inst_stack(*paths: List[E2EBreakdownItem]):
+    fig: Figure
+    ax: Axes
+    fig, ax = plt.subplots(num="E2E instance breakdown stackplot")
+    fig.suptitle("Detailed E2E Latency Path Breakdown")
+
+    bottom = 0
+    for i in range(len(paths)):
+        e2e_items = [path[i] for path in paths]
+        durations = np.array([item.duration for item in e2e_items])
+        ax.bar(range(len(paths)), durations, bottom=bottom)
+        bottom = durations + bottom
+
+    return fig
diff --git a/message_tree/message_tree_structure.py b/message_tree/message_tree_structure.py
new file mode 100644
index 0000000..7356d4d
--- /dev/null
+++ b/message_tree/message_tree_structure.py
@@ -0,0 +1,20 @@
+from collections import namedtuple
+
+
+E2EBreakdownItem = namedtuple("E2EBreakdownItem", ("type", "duration", "location"))
+DepTree = namedtuple("DepTree", ("head", "deps"))
+
+
+def depth(tree: DepTree):
+    return 1 + max(map(depth, tree.deps), default=0)
+
+
+def size(tree: DepTree):
+    return 1 + sum(map(size, tree.deps))
+
+
+def fanout(tree: DepTree):
+    if not tree.deps:
+        return 1
+
+    return sum(map(fanout, tree.deps))
diff --git a/trace-analysis.ipynb b/trace-analysis.ipynb
index df1359e..7c2f59a 100644
--- a/trace-analysis.ipynb
+++ b/trace-analysis.ipynb
@@ -9,7 +9,6 @@
     "import sys\n",
     "import re\n",
     "import math\n",
-    "import graphviz as gv\n",
     "from tqdm import tqdm\n",
     "from bisect import bisect_right\n",
     "from termcolor import colored\n",
@@ -34,6 +33,15 @@
     "collapsed": false
    }
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# User Settings"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -129,6 +137,8 @@
     "E2E_EXCLUDED_PATH_PATTERNS = [r\"NDTScanMatcher\"]\n",
     "\n",
     "\n",
+    "DDD = False\n",
+    "\n",
     "# This code overrides the above constants with environment variables, do not edit.\n",
     "for env_key, env_value in os.environ.items():\n",
     "    if env_key.startswith(\"ANA_NB_\"):\n",
@@ -169,12 +179,15 @@
    "source": [
     "sys.path.append(os.path.join(TRACING_WS_BUILD_PATH, \"tracetools_read/\"))\n",
     "sys.path.append(os.path.join(TRACING_WS_BUILD_PATH, \"tracetools_analysis/\"))\n",
+    "# noinspection PyUnresolvedReferences\n",
     "from tracetools_read.trace import *\n",
+    "# noinspection PyUnresolvedReferences\n",
     "from tracetools_analysis.loading import load_file\n",
+    "# noinspection PyUnresolvedReferences\n",
     "from tracetools_analysis.processor.ros2 import Ros2Handler\n",
     "\n",
     "from tracing_interop.tr_types import *\n",
-    "from latency_graph.message_tree import DepTree\n",
+    "from message_tree.message_tree_structure import DepTree\n",
     "from matching.subscriptions import sanitize"
    ],
    "metadata": {
@@ -184,7 +197,7 @@
   {
    "cell_type": "markdown",
    "source": [
-    "# Organize Trace Data"
+    "# Load Trace Data"
    ],
    "metadata": {
     "collapsed": false
@@ -246,7 +259,7 @@
   {
    "cell_type": "markdown",
    "source": [
-    "# E2E Latency Calculation"
+    "# Analyze ROS Graph"
    ],
    "metadata": {
     "collapsed": false
@@ -257,7 +270,7 @@
    "execution_count": null,
    "outputs": [],
    "source": [
-    "from latency_graph import latency_graph as lg\n",
+    "import latency_graph.latency_graph_structure as lg\n",
     "\n",
     "\n",
     "def _make_latency_graph():\n",
@@ -271,95 +284,9 @@
    }
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
+   "cell_type": "markdown",
    "source": [
-    "%%skip_if_false DFG_ENABLED\n",
-    "%%skip_if_false DFG_PLOT\n",
-    "\n",
-    "#################################################\n",
-    "# Plot DFG\n",
-    "#################################################\n",
-    "\n",
-    "# Compare with: https://autowarefoundation.github.io/autoware-documentation/main/design/autoware-architecture/node-diagram/\n",
-    "node_colors = {\n",
-    "        \"sensing\": {\"fill\": \"#e1d5e7\", \"stroke\": \"#9673a6\"},\n",
-    "        \"localization\": {\"fill\": \"#dae8fc\", \"stroke\": \"#6c8ebf\"},\n",
-    "        \"perception\": {\"fill\": \"#d5e8d4\", \"stroke\": \"#82b366\"},\n",
-    "        \"planning\": {\"fill\": \"#fff2cc\", \"stroke\": \"#d6b656\"},\n",
-    "        \"control\": {\"fill\": \"#ffe6cc\", \"stroke\": \"#d79b00\"},\n",
-    "        \"system\": {\"fill\": \"#f8cecc\", \"stroke\": \"#b85450\"},\n",
-    "        \"vehicle_interface\": {\"fill\": \"#b0e3e6\", \"stroke\": \"#0e8088\"},\n",
-    "        None: {\"fill\": \"#f5f5f5\", \"stroke\": \"#666666\"}\n",
-    "}\n",
-    "\n",
-    "node_namespace_mapping = {\n",
-    "        'perception': 'perception',\n",
-    "        'sensing': 'sensing',\n",
-    "        'planning': 'planning',\n",
-    "        'control': 'control',\n",
-    "        'awapi': 'system',\n",
-    "        'autoware_api': 'system',\n",
-    "        'map': 'system',\n",
-    "        'system': 'system',\n",
-    "        'localization': 'localization',\n",
-    "        'robot_state_publisher': None,\n",
-    "        'aggregator_node': None,\n",
-    "        'pointcloud_container': 'sensing',\n",
-    "}\n",
-    "\n",
-    "\n",
-    "g = gv.Digraph('G', filename=\"latency_graph.gv\",\n",
-    "               node_attr={'shape': 'plain'},\n",
-    "               graph_attr={'pack': '1'})\n",
-    "g.graph_attr['rankdir'] = 'LR'\n",
-    "\n",
-    "\n",
-    "def plot_hierarchy(gv_parent, lg_node: lg.LGHierarchyLevel, **subgraph_kwargs):\n",
-    "    if lg_node.name == \"[NONE]\":\n",
-    "        return\n",
-    "\n",
-    "    print(f\"{'  ' * lg_node.full_name.count('/')}Processing {lg_node.name}: {len(lg_node.callbacks)}\")\n",
-    "    with gv_parent.subgraph(name=f\"cluster_{lg_node.full_name.replace('/', '__')}\", **subgraph_kwargs) as c:\n",
-    "        c.attr(label=lg_node.name)\n",
-    "        for cb in lg_node.callbacks:\n",
-    "            if isinstance(cb, lg.LGTrCallback):\n",
-    "                tr_cb = cb.cb\n",
-    "                try:\n",
-    "                    sym = _tracing_context.callback_symbols.by_id.get(tr_cb.callback_object)\n",
-    "                    pretty_sym = repr(sanitize(sym.symbol))\n",
-    "                except KeyError:\n",
-    "                    pretty_sym = cb.name\n",
-    "                except TypeError:\n",
-    "                    pretty_sym = cb.name\n",
-    "            else:\n",
-    "                pretty_sym = cb.name\n",
-    "\n",
-    "            pretty_sym = pretty_sym.replace(\"&\", \"&amp;\").replace(\"<\", \"&lt;\").replace(\">\", \"&gt;\")\n",
-    "\n",
-    "            c.node(cb.id(),\n",
-    "                   f'<<table BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\"><tr><td port=\"in\"></td><td>{pretty_sym}</td><td port=\"out\"></td></tr></table>>')\n",
-    "\n",
-    "        for ch in lg_node.children:\n",
-    "            plot_hierarchy(c, ch, **subgraph_kwargs)\n",
-    "\n",
-    "\n",
-    "def plot_lg(graph: lg.LatencyGraph):\n",
-    "    for top_level_node in graph.top_node.children:\n",
-    "        colors = node_colors[node_namespace_mapping.get(top_level_node.name)]\n",
-    "        plot_hierarchy(g, top_level_node, graph_attr={'bgcolor': colors[\"fill\"], 'pencolor': colors[\"stroke\"]})\n",
-    "\n",
-    "    for edge in graph.edges:\n",
-    "        g.edge(f\"{edge.start.id()}:out\", f\"{edge.end.id()}:in\")\n",
-    "\n",
-    "\n",
-    "plot_lg(lat_graph)\n",
-    "\n",
-    "g.save(\"latency_graph.gv\")\n",
-    "g.render(\"latency_graph.svg\")\n",
-    "\n",
-    "g"
+    "## Plot ROS Graph (full)"
    ],
    "metadata": {
     "collapsed": false
@@ -373,123 +300,43 @@
     "%%skip_if_false DFG_ENABLED\n",
     "%%skip_if_false DFG_PLOT\n",
     "\n",
+    "#################################################\n",
+    "# Plot full DFG, down to the callback level\n",
+    "#################################################\n",
     "\n",
-    "##################################################\n",
-    "# Compute in/out topics for hierarchy level X\n",
-    "##################################################\n",
+    "from latency_graph.latency_graph_plots import plot_latency_graph_full\n",
     "\n",
-    "def get_nodes_on_level(lat_graph: lg.LatencyGraph):\n",
-    "    def _traverse_node(node: lg.LGHierarchyLevel, cur_lvl=0):\n",
-    "        if cur_lvl == DFG_MAX_HIER_LEVEL:\n",
-    "            return [node]\n",
+    "plot_latency_graph_full(lat_graph, _tracing_context, \"latency_graph_full\")"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Plot Latency Graph (overview)"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "%%skip_if_false DFG_ENABLED\n",
+    "%%skip_if_false DFG_PLOT\n",
     "\n",
-    "        if not node.children:\n",
-    "            return [node]\n",
+    "#################################################\n",
+    "# Plot overview of DFG, down to a certain\n",
+    "# hierarchy level\n",
+    "#################################################\n",
     "\n",
-    "        collected_nodes = []\n",
-    "        for ch in node.children:\n",
-    "            collected_nodes += _traverse_node(ch, cur_lvl + 1)\n",
-    "        return collected_nodes\n",
+    "from latency_graph.latency_graph_plots import plot_latency_graph_overview\n",
     "\n",
-    "    return _traverse_node(lat_graph.top_node)\n",
-    "\n",
-    "\n",
-    "lvl_nodes = get_nodes_on_level(lat_graph)\n",
-    "lvl_nodes = [n for n in lvl_nodes if not any(re.search(p, n.full_name) for p in DFG_EXCL_NODE_PATTERNS)]\n",
-    "\n",
-    "input_nodes = [n.full_name for n in lvl_nodes if any(re.search(p, n.full_name) for p in DFG_INPUT_NODE_PATTERNS)]\n",
-    "output_nodes = [n.full_name for n in lvl_nodes if any(re.search(p, n.full_name) for p in DFG_OUTPUT_NODE_PATTERNS)]\n",
-    "\n",
-    "print(', '.join(map(lambda n: n, input_nodes)))\n",
-    "print(', '.join(map(lambda n: n, output_nodes)))\n",
-    "print(', '.join(map(lambda n: n.full_name, lvl_nodes)))\n",
-    "\n",
-    "\n",
-    "def _collect_callbacks(n: lg.LGHierarchyLevel):\n",
-    "    callbacks = []\n",
-    "    callbacks += n.callbacks\n",
-    "    for ch in n.children:\n",
-    "        callbacks += _collect_callbacks(ch)\n",
-    "    return callbacks\n",
-    "\n",
-    "\n",
-    "cb_to_node_map = {}\n",
-    "for n in lvl_nodes:\n",
-    "    cbs = _collect_callbacks(n)\n",
-    "    for cb in cbs:\n",
-    "        cb_to_node_map[cb.id()] = n\n",
-    "\n",
-    "edges_between_nodes = {}\n",
-    "for edge in lat_graph.edges:\n",
-    "    from_node = cb_to_node_map.get(edge.start.id())\n",
-    "    to_node = cb_to_node_map.get(edge.end.id())\n",
-    "\n",
-    "    if from_node is None or to_node is None:\n",
-    "        continue\n",
-    "\n",
-    "    if from_node.full_name == to_node.full_name:\n",
-    "        continue\n",
-    "\n",
-    "    k = (from_node.full_name, to_node.full_name)\n",
-    "\n",
-    "    if k not in edges_between_nodes:\n",
-    "        edges_between_nodes[k] = []\n",
-    "\n",
-    "    edges_between_nodes[k].append(edge)\n",
-    "\n",
-    "g = gv.Digraph('G', filename=\"latency_graph.gv\",\n",
-    "               node_attr={'shape': 'plain'},\n",
-    "               graph_attr={'pack': '1'})\n",
-    "g.graph_attr['rankdir'] = 'LR'\n",
-    "\n",
-    "for n in lvl_nodes:\n",
-    "    colors = node_colors[node_namespace_mapping.get(n.full_name.strip(\"/\").split(\"/\")[0])]\n",
-    "    peripheries = \"1\" if n.full_name not in output_nodes else \"2\"\n",
-    "    g.node(n.full_name, label=n.full_name, fillcolor=colors[\"fill\"], color=colors[\"stroke\"],\n",
-    "           shape=\"box\", style=\"filled\", peripheries=peripheries)\n",
-    "\n",
-    "    if n.full_name in input_nodes:\n",
-    "        helper_node_name = f\"{n.full_name}__before\"\n",
-    "        g.node(helper_node_name, label=\"\", shape=\"none\", height=\"0\", width=\"0\")\n",
-    "        g.edge(helper_node_name, n.full_name)\n",
-    "\n",
-    "\n",
-    "def compute_e2e_paths(start_nodes, end_nodes, edges):\n",
-    "    frontier_paths = [[n] for n in start_nodes]\n",
-    "    final_paths = []\n",
-    "\n",
-    "    while frontier_paths:\n",
-    "        frontier_paths_new = []\n",
-    "\n",
-    "        for path in frontier_paths:\n",
-    "            head = path[-1]\n",
-    "            if head in end_nodes:\n",
-    "                final_paths.append(path)\n",
-    "                continue\n",
-    "\n",
-    "            out_nodes = [n_to for n_from, n_to in edges if n_from == head if n_to not in path]\n",
-    "            new_paths = [path + [n] for n in out_nodes]\n",
-    "            frontier_paths_new += new_paths\n",
-    "\n",
-    "        frontier_paths = frontier_paths_new\n",
-    "\n",
-    "    final_paths = [[(n_from, n_to)\n",
-    "                    for n_from, n_to in zip(path[:-1], path[1:])]\n",
-    "                   for path in final_paths]\n",
-    "    return final_paths\n",
-    "\n",
-    "\n",
-    "e2e_paths = compute_e2e_paths(input_nodes, output_nodes, edges_between_nodes)\n",
-    "\n",
-    "for (src_name, dst_name), edges in edges_between_nodes.items():\n",
-    "    print(src_name, dst_name, len(edges))\n",
-    "    color = \"black\" if any((src_name, dst_name) in path for path in e2e_paths) else \"tomato\"\n",
-    "    g.edge(src_name, dst_name, penwidth=str(math.log(len(edges)) * 2 + .2), color=color)\n",
-    "\n",
-    "g.save(\"level_graph.gv\")\n",
-    "g.render(\"level_graph.svg\")\n",
-    "\n",
-    "g"
+    "plot_latency_graph_overview(lat_graph, DFG_EXCL_NODE_PATTERNS, DFG_INPUT_NODE_PATTERNS, DFG_OUTPUT_NODE_PATTERNS, DFG_MAX_HIER_LEVEL, \"latency_graph_overview\")"
    ],
    "metadata": {
     "collapsed": false,
@@ -499,169 +346,9 @@
    }
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
+   "cell_type": "markdown",
    "source": [
-    "\n",
-    "%%skip_if_false E2E_ENABLED\n",
-    "\n",
-    "\n",
-    "def inst_get_dep_msg(inst: TrCallbackInstance):\n",
-    "    if inst.callback_object not in _tracing_context.callback_objects.by_callback_object:\n",
-    "        # print(\"Callback not found (2)\")\n",
-    "        return None\n",
-    "\n",
-    "    if not isinstance(inst.callback_obj.owner, TrSubscriptionObject):\n",
-    "        # print(f\"Wrong type: {type(inst.callback_obj.owner)}\")\n",
-    "        return None\n",
-    "\n",
-    "    sub_obj: TrSubscriptionObject = inst.callback_obj.owner\n",
-    "    if sub_obj and sub_obj.subscription and sub_obj.subscription.topic:\n",
-    "        # print(f\"Subscription has no topic\")\n",
-    "        pubs = sub_obj.subscription.topic.publishers\n",
-    "    else:\n",
-    "        pubs = []\n",
-    "\n",
-    "    def _pub_latest_msg_before(pub: TrPublisher, inst):\n",
-    "        i_latest_msg = bisect_right(pub.instances, inst.timestamp, key=lambda x: x.timestamp) - 1\n",
-    "        if i_latest_msg < 0 or i_latest_msg >= len(pub.instances):\n",
-    "            return None\n",
-    "        latest_msg = pub.instances[i_latest_msg]\n",
-    "        if latest_msg.timestamp >= inst.timestamp:\n",
-    "            return None\n",
-    "\n",
-    "        return latest_msg\n",
-    "\n",
-    "    msgs = [_pub_latest_msg_before(pub, inst) for pub in pubs]\n",
-    "    msgs = list(filter(None, msgs))\n",
-    "    msgs.sort(key=lambda i: i.timestamp, reverse=True)\n",
-    "    if msgs:\n",
-    "        msg = msgs[0]\n",
-    "        return msg\n",
-    "\n",
-    "    # print(f\"No messages found for topic {sub_obj.subscription.topic}\")\n",
-    "    return None\n",
-    "\n",
-    "\n",
-    "def inst_get_dep_insts(inst: TrCallbackInstance):\n",
-    "    if inst.callback_object not in _tracing_context.callback_objects.by_callback_object:\n",
-    "        # print(\"Callback not found\")\n",
-    "        return []\n",
-    "    dep_cbs = get_cb_dep_cbs(inst.callback_obj)\n",
-    "\n",
-    "    def _cb_to_chronological_inst(cb: TrCallbackObject, inst):\n",
-    "        i_inst_latest = bisect_right(cb.callback_instances, inst.timestamp, key=lambda x: x.timestamp)\n",
-    "\n",
-    "        for inst_before in cb.callback_instances[i_inst_latest::-1]:\n",
-    "            if inst_before.t_end < inst.timestamp:\n",
-    "                return inst_before\n",
-    "\n",
-    "        return None\n",
-    "\n",
-    "    insts = [_cb_to_chronological_inst(cb, inst) for cb in dep_cbs]\n",
-    "    insts = list(filter(None, insts))\n",
-    "    return insts\n",
-    "\n",
-    "\n",
-    "def get_cb_dep_cbs(cb: TrCallbackObject):\n",
-    "    match cb.owner:\n",
-    "        case TrSubscriptionObject() as sub_obj:\n",
-    "            sub_obj: TrSubscriptionObject\n",
-    "            owner = sub_obj.subscription.node\n",
-    "        case TrTimer() as tmr:\n",
-    "            tmr: TrTimer\n",
-    "            owner = tmr.node\n",
-    "        case _:\n",
-    "            raise RuntimeError(f\"Encountered {cb.owner} as callback owner\")\n",
-    "\n",
-    "    owner: TrNode\n",
-    "    dep_sub_objs = {sub.subscription_object for sub in owner.subscriptions}\n",
-    "    dep_cbs = {callback_objects.by_id.get(sub_obj.id) for sub_obj in dep_sub_objs if sub_obj is not None}\n",
-    "    dep_cbs |= {callback_objects.by_id.get(tmr.id) for tmr in owner.timers}\n",
-    "    dep_cbs.discard(cb)\n",
-    "    dep_cbs.discard(None)\n",
-    "\n",
-    "    return dep_cbs\n",
-    "\n",
-    "\n",
-    "def get_msg_dep_cb(msg: TrPublishInstance):\n",
-    "    \"\"\"\n",
-    "    For a given message instance `msg`, find the publishing callback,\n",
-    "    as well as the message instances that callback depends on (transitively within its TrNode).\n",
-    "    \"\"\"\n",
-    "\n",
-    "    # Find CB instance that published msg\n",
-    "    # print(f\"PUB {msg.publisher.node.path if msg.publisher.node is not None else '??'} ==> {msg.publisher.topic_name}\")\n",
-    "    pub_cbs = lat_graph.pub_cbs.get(msg.publisher)\n",
-    "    if pub_cbs is None:\n",
-    "        # print(\"Publisher unknown to lat graph. Skipping.\")\n",
-    "        return None\n",
-    "\n",
-    "    # print(f\"Found {len(pub_cbs)} pub cbs\")\n",
-    "    cb_inst_candidates = []\n",
-    "    for cb in pub_cbs:\n",
-    "        # print(f\"  > CB ({len(cb.callback_instances)} instances): {cb.callback_symbol.symbol if cb.callback_symbol else cb.id}\")\n",
-    "        i_inst_after = bisect_right(cb.callback_instances, msg.timestamp, key=lambda x: x.timestamp)\n",
-    "\n",
-    "        for inst in cb.callback_instances[:i_inst_after]:\n",
-    "            if msg.timestamp > inst.t_end:\n",
-    "                continue\n",
-    "\n",
-    "            assert inst.t_start <= msg.timestamp <= inst.t_end\n",
-    "\n",
-    "            cb_inst_candidates.append(inst)\n",
-    "\n",
-    "    if len(cb_inst_candidates) > 1:\n",
-    "        # print(\"Found multiple possible callbacks\")\n",
-    "        return None\n",
-    "    if not cb_inst_candidates:\n",
-    "        # print(\"Found no possible callbacks\")\n",
-    "        return None\n",
-    "\n",
-    "    dep_inst = cb_inst_candidates[0]\n",
-    "    return dep_inst\n",
-    "\n",
-    "\n",
-    "def get_dep_tree(inst: TrPublishInstance | TrCallbackInstance, lvl=0, visited=None, is_dep_cb=False,\n",
-    "                 start_time=None):\n",
-    "    if visited is None:\n",
-    "        visited = set()\n",
-    "\n",
-    "    if start_time is None:\n",
-    "        start_time = inst.timestamp\n",
-    "\n",
-    "    if inst.timestamp - start_time > E2E_TIME_LIMIT_S:\n",
-    "        return None\n",
-    "\n",
-    "    children_are_dep_cbs = False\n",
-    "\n",
-    "    match inst:\n",
-    "        case TrPublishInstance(publisher=pub):\n",
-    "            if pub.topic in visited:\n",
-    "                return None\n",
-    "\n",
-    "            visited.add(pub.topic)\n",
-    "            deps = [get_msg_dep_cb(inst)]\n",
-    "        case TrCallbackInstance() as cb_inst:\n",
-    "            cb_inst: TrCallbackInstance\n",
-    "            if cb_inst.callback_obj in visited:\n",
-    "                return None\n",
-    "\n",
-    "            visited.add(cb_inst.callback_obj)\n",
-    "            deps = [inst_get_dep_msg(cb_inst)]\n",
-    "            if not is_dep_cb:\n",
-    "                deps += inst_get_dep_insts(cb_inst)\n",
-    "                children_are_dep_cbs = True\n",
-    "        case _:\n",
-    "            print(\n",
-    "                f\"[WARN] Expected inst to be of type TrPublishInstance or TrCallbackInstance, got {type(inst).__name__}\")\n",
-    "            return None\n",
-    "    #print(\"Rec level\", lvl)\n",
-    "    deps = list(filter(None, deps))\n",
-    "    deps = [get_dep_tree(dep, lvl + 1, set(visited), children_are_dep_cbs, start_time) for dep in deps]\n",
-    "    deps = list(filter(None, deps))\n",
-    "    return DepTree(inst, deps)"
+    "# Analyze Message Flow"
    ],
    "metadata": {
     "collapsed": false
@@ -674,25 +361,15 @@
    "source": [
     "%%skip_if_false E2E_ENABLED\n",
     "\n",
+    "from message_tree.message_tree_algorithms import build_dep_trees\n",
+    "\n",
     "end_topics = [t for t in _tracing_context.topics if any(re.search(f, t.name) for f in E2E_OUTPUT_TOPIC_PATTERNS)]\n",
     "\n",
-    "def build_dep_trees():\n",
-    "    all_trees = []\n",
-    "    for end_topic in end_topics:\n",
-    "        end_topic: TrTopic\n",
-    "        print(f\"====={end_topic.name}\")\n",
-    "\n",
-    "        pubs = end_topic.publishers\n",
-    "        for pub in pubs:\n",
-    "            msgs = list(pub.instances)\n",
-    "            for msg in tqdm(msgs, mininterval=5.0, desc=\"Processing output messages\"):\n",
-    "                msg: TrPublishInstance\n",
-    "                tree = get_dep_tree(msg)\n",
-    "                all_trees.append(tree)\n",
-    "    return all_trees\n",
+    "def _build_dep_trees():\n",
+    "    return build_dep_trees(end_topics, lat_graph, _tracing_context, E2E_EXCLUDED_PATH_PATTERNS, E2E_TIME_LIMIT_S)\n",
     "\n",
     "try:\n",
-    "    trees = cached(\"trees\", build_dep_trees, [TR_PATH], not CACHING_ENABLED)\n",
+    "    trees = cached(\"trees\", _build_dep_trees, [TR_PATH], not CACHING_ENABLED)\n",
     "except Exception as e:\n",
     "    import traceback\n",
     "    print(e)\n",
@@ -759,97 +436,6 @@
     "collapsed": false
    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "%%skip_if_false E2E_ENABLED\n",
-    "\n",
-    "from collections import defaultdict\n",
-    "\n",
-    "def leaf_topics(tree: DepTree, lvl=0):\n",
-    "    ret_list = []\n",
-    "    match tree.head:\n",
-    "        case TrPublishInstance(publisher=pub):\n",
-    "            if pub:\n",
-    "                ret_list += [(lvl, pub.topic_name)]\n",
-    "    ret_list += [(lvl, None)]\n",
-    "\n",
-    "    for dep in tree.deps:\n",
-    "        ret_list += leaf_topics(dep, lvl + 1)\n",
-    "    return ret_list\n",
-    "\n",
-    "\n",
-    "def all_e2es(tree: DepTree, t_start=None):\n",
-    "    if t_start is None:\n",
-    "        t_start = tree.head.timestamp\n",
-    "\n",
-    "    if not tree.deps:\n",
-    "        return [t_start - tree.head.timestamp]\n",
-    "\n",
-    "    ret_list = []\n",
-    "    for dep in tree.deps:\n",
-    "        ret_list += all_e2es(dep, t_start)\n",
-    "    return ret_list\n",
-    "\n",
-    "\n",
-    "in_topics_found = defaultdict(lambda: 0)\n",
-    "leaf_topics_found = defaultdict(lambda: 0)\n",
-    "def relevant_e2es(tree: DepTree, input_topic_patterns, t_start=None, path=None):\n",
-    "    if t_start is None:\n",
-    "        t_start = tree.head.timestamp\n",
-    "\n",
-    "    if path is None:\n",
-    "        path = []\n",
-    "\n",
-    "    latency = t_start - tree.head.timestamp\n",
-    "    if latency > E2E_TIME_LIMIT_S:\n",
-    "        return []\n",
-    "\n",
-    "    new_path = [tree.head] + path\n",
-    "\n",
-    "    match tree.head:\n",
-    "        case TrPublishInstance(publisher=pub):\n",
-    "            leaf_topics_found[pub.topic_name] += 1\n",
-    "            if pub and any(re.search(f, pub.topic_name) for f in input_topic_patterns):\n",
-    "                in_topics_found[pub.topic_name] += 1\n",
-    "                return [(latency, new_path)]\n",
-    "\n",
-    "    ret_list = []\n",
-    "    for dep in tree.deps:\n",
-    "        ret_list += relevant_e2es(dep, input_topic_patterns, t_start, new_path)\n",
-    "    return ret_list\n",
-    "\n",
-    "\n",
-    "e2ess = []\n",
-    "e2ess_trees = []\n",
-    "e2e_pathss = []\n",
-    "for tree in trees:\n",
-    "    try:\n",
-    "        e2es, e2e_paths = zip(*relevant_e2es(tree, E2E_INPUT_TOPIC_PATTERNS))\n",
-    "    except ValueError as e:\n",
-    "        print(end='!')\n",
-    "        continue\n",
-    "    e2ess.append(e2es)\n",
-    "    e2ess_trees.append(tree)\n",
-    "    e2e_pathss.append(e2e_paths)\n",
-    "\n",
-    "print()\n",
-    "print(f\"[ENTKÄFERN] IN-TOPICS FOUND in {len(e2ess)}/{len(trees)} trees\")\n",
-    "in_topics_found = \"\\n  \".join(map(lambda pair: f\"{pair[0]:.<110s} {pair[1]:>10d}\", in_topics_found.items()))\n",
-    "print(f\"  {in_topics_found}\")\n",
-    "\n",
-    "print(f\"[ENTKÄFERN] LEAF TOPICS FOUND\")\n",
-    "leaf_topics_found = \"\\n  \".join(map(lambda pair: f\"{pair[0]:.<110s} {pair[1]:>10d}\", leaf_topics_found.items()))\n",
-    "print(f\"  {leaf_topics_found}\")\n",
-    "\n",
-    "trees = e2ess_trees  # Filter non-E2E trees"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -857,21 +443,22 @@
    "source": [
     "%%skip_if_false E2E_ENABLED\n",
     "%%skip_if_false E2E_PLOT\n",
+    "%%skip_if_false DDD\n",
     "\n",
     "\n",
     "fig, ax = plt.subplots(num=\"e2e_plot\")\n",
     "DS = 1\n",
-    "times = [tree.head.timestamp - trees[0].head.timestamp for tree in trees[::DS]]\n",
+    "times = [tree.head.timestamp - trees[0].head.timestamp for tree in trees]\n",
     "\n",
     "ax2 = ax.twinx()\n",
-    "ax2.plot(times, list(map(lambda paths: sum(map(len, paths)) / len(paths), e2e_pathss[::DS])), color=\"orange\")\n",
+    "ax2.plot(times, list(map(lambda paths: sum(map(len, paths)) / len(paths), e2e_pathss)), color=\"orange\")\n",
     "ax2.fill_between(times,\n",
-    "                 list(map(lambda paths: min(map(len, paths)), e2e_pathss[::DS])),\n",
-    "                 list(map(lambda paths: max(map(len, paths)), e2e_pathss[::DS])),\n",
+    "                 list(map(lambda paths: min(map(len, paths)), e2e_pathss)),\n",
+    "                 list(map(lambda paths: max(map(len, paths)), e2e_pathss)),\n",
     "                 alpha=.3, color=\"orange\")\n",
     "\n",
-    "ax.plot(times, [np.mean(e2es) for e2es in e2ess[::DS]])\n",
-    "ax.fill_between(times, [np.min(e2es) for e2es in e2ess[::DS]], [np.max(e2es) for e2es in e2ess[::DS]], alpha=.3)\n",
+    "ax.plot(times, [np.mean(e2es) for e2es in e2ess])\n",
+    "ax.fill_between(times, [np.min(e2es) for e2es in e2ess], [np.max(e2es) for e2es in e2ess], alpha=.3)\n",
     "\n",
     "\n",
     "def scatter_topic(topic_name, y=0, **scatter_kwargs):\n",
@@ -899,71 +486,6 @@
     "collapsed": false
    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "%%skip_if_false E2E_ENABLED\n",
-    "\n",
-    "def critical_path(self):\n",
-    "    if not self.deps:\n",
-    "        return [self.head]\n",
-    "    return [self.head, *min(map(critical_path, self.deps), key=lambda ls: ls[-1].timestamp)]\n",
-    "\n",
-    "\n",
-    "def e2e_lat(self):\n",
-    "    return self.head.timestamp - critical_path(self)[-1].timestamp\n",
-    "\n",
-    "\n",
-    "def get_relevant_tree(tree: DepTree, accept_leaf=lambda x: True, root=None):\n",
-    "    if root is None:\n",
-    "        root = tree.head\n",
-    "\n",
-    "    if accept_leaf(tree.head, root):\n",
-    "        return DepTree(tree.head, [])  # Cut subtrees because we already found our input topic\n",
-    "\n",
-    "    relevant_deps = [get_relevant_tree(dep, accept_leaf, root) for dep in tree.deps]\n",
-    "    if not any(relevant_deps):\n",
-    "        return None\n",
-    "\n",
-    "    return DepTree(tree.head, [dep for dep in relevant_deps if dep])\n",
-    "\n",
-    "\n",
-    "def fanout(self):\n",
-    "    if not self.deps:\n",
-    "        return 1\n",
-    "\n",
-    "    return sum(map(fanout, self.deps))\n",
-    "\n",
-    "\n",
-    "def sort_subtree(subtree: DepTree, sort_func=lambda t: t.head.timestamp - e2e_lat(t)):\n",
-    "    subtree.deps.sort(key=sort_func)\n",
-    "    for dep in subtree.deps:\n",
-    "        sort_subtree(dep, sort_func)\n",
-    "    return subtree\n",
-    "\n",
-    "\n",
-    "def _leaf_filter(inst, root):\n",
-    "    if root.timestamp - inst.timestamp > E2E_TIME_LIMIT_S:\n",
-    "        return False\n",
-    "\n",
-    "    match inst:\n",
-    "        case TrPublishInstance(publisher=pub):\n",
-    "            return pub and any(re.search(f, pub.topic_name) for f in E2E_INPUT_TOPIC_PATTERNS)\n",
-    "    return False\n",
-    "\n",
-    "\n",
-    "relevant_trees = [get_relevant_tree(tree, _leaf_filter) for tree in trees]\n",
-    "relevant_trees = [t for t in relevant_trees if t]"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%%%skip_if_false E2E_ENABLED\n"
-    }
-   }
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -972,84 +494,27 @@
     "%%skip_if_false E2E_ENABLED\n",
     "%%skip_if_false E2E_PLOT\n",
     "\n",
-    "def dict_safe_append(dictionary, key, value):\n",
-    "    if key not in dictionary:\n",
-    "        dictionary[key] = []\n",
-    "    dictionary[key].append(value)\n",
+    "%load_ext line_profiler\n",
     "\n",
     "\n",
-    "fig, (ax, ax_rel) = plt.subplots(2, 1, sharex=True, num=\"crit_plot\")\n",
-    "ax.set_prop_cycle(cycler('color', [plt.cm.nipy_spectral(i / 4) for i in range(5)]))\n",
-    "ax_rel.set_prop_cycle(cycler('color', [plt.cm.nipy_spectral(i / 4) for i in range(5)]))\n",
+    "from message_tree.message_tree_algorithms import e2e_paths_sorted_desc\n",
+    "from message_tree.message_tree_plots import e2e_breakdown_type_hist\n",
     "\n",
-    "critical_paths = [critical_path(tree) for tree in relevant_trees[::DS]]\n",
+    "def _map_tree_to_e2es(tree):\n",
+    "    return e2e_paths_sorted_desc(tree, E2E_INPUT_TOPIC_PATTERNS)\n",
     "\n",
-    "time_breakdown = {}\n",
+    "def ppp():\n",
+    "    trees_paths = [e2e_paths_sorted_desc(tree, E2E_INPUT_TOPIC_PATTERNS) for tree in tqdm(trees, desc=\"Extracting E2E paths\")]\n",
+    "    all_paths = [p for paths in trees_paths for p in paths]\n",
+    "    all_e2e_items = [i for p in all_paths for i in p]\n",
     "\n",
-    "for path in critical_paths:\n",
-    "    tmr_cb_calc_time = 0.0\n",
-    "    sub_cb_calc_time = 0.0\n",
-    "    tmr_cb_relevant_time = 0.0\n",
-    "    sub_cb_relevant_time = 0.0\n",
-    "    dds_time = 0.0\n",
-    "    idle_time = 0.0\n",
+    "    return all_e2e_items\n",
     "\n",
-    "    last_pub_time = None\n",
-    "    last_cb_time = None\n",
-    "    for inst in path:\n",
-    "        match inst:\n",
-    "            case TrPublishInstance(timestamp=t):\n",
-    "                assert last_pub_time is None, \"Two publication without callback inbetween\"\n",
+    "%lprun -f e2e_paths_sorted_desc ppp()\n",
     "\n",
-    "                if last_cb_time is not None:\n",
-    "                    dds_time += last_cb_time - t\n",
+    "e2e_breakdown_type_hist(ppp())\n",
     "\n",
-    "                last_pub_time = t\n",
-    "                last_cb_time = None\n",
-    "            case TrCallbackInstance(callback_obj=cb, timestamp=t, duration=d):\n",
-    "                if last_pub_time is not None:\n",
-    "                    assert last_pub_time <= t + d, \"Publication out of CB instance timeframe\"\n",
-    "\n",
-    "                    match cb.owner:\n",
-    "                        case TrTimer():\n",
-    "                            tmr_cb_calc_time += d\n",
-    "                            tmr_cb_relevant_time += last_pub_time - t\n",
-    "                        case TrSubscriptionObject():\n",
-    "                            sub_cb_calc_time += d\n",
-    "                            sub_cb_relevant_time += last_pub_time - t\n",
-    "                elif last_cb_time is not None:\n",
-    "                    idle_time += last_cb_time - (t + d)\n",
-    "                last_pub_time = None\n",
-    "                last_cb_time = t\n",
-    "\n",
-    "    dict_safe_append(time_breakdown, \"Timer CB\", tmr_cb_relevant_time)\n",
-    "    dict_safe_append(time_breakdown, \"Subscription CB\", sub_cb_relevant_time)\n",
-    "    dict_safe_append(time_breakdown, \"DDS\", dds_time)\n",
-    "    dict_safe_append(time_breakdown, \"Idle\", idle_time)\n",
-    "\n",
-    "time_breakdown = {k: np.array(v) for k, v in time_breakdown.items()}\n",
-    "\n",
-    "timer_cb_times = [sum(inst.duration for inst in path if\n",
-    "                      isinstance(inst, TrCallbackInstance) and isinstance(inst.callback_obj, TrTimer)) for path in\n",
-    "                  critical_paths]\n",
-    "sub_cb_times = [sum(inst.duration for inst in path if isinstance(inst, TrCallbackInstance)) for path in critical_paths]\n",
-    "\n",
-    "labels, values = list(zip(*time_breakdown.items()))\n",
-    "\n",
-    "#ax.plot(range(len(relevant_trees[::DS])), [e2e_lat(tree) for tree in relevant_trees[::DS]], label=\"Total E2E\")\n",
-    "ax.stackplot(range(len(relevant_trees[::DS])), values, labels=labels)\n",
-    "ax.legend()\n",
-    "ax.set_title(\"End-to-End Latency Breakdown\")\n",
-    "ax.set_ylabel(\"End-to-End Latency [s]\")\n",
-    "\n",
-    "timestep_mags = np.array([sum(vs) for vs in zip(*values)])\n",
-    "ax_rel.stackplot(range(len(relevant_trees[::DS])), [val / timestep_mags for val in values], labels=labels)\n",
-    "ax_rel.set_title(\"End-to-End Latency Breakdown (relative)\")\n",
-    "ax_rel.set_ylabel(\"End-to-End Latency Fraction\")\n",
-    "ax_rel.set_xlabel(\"Timestep\")\n",
-    "ax_rel.legend()\n",
-    "\n",
-    "None"
+    "None\n"
    ],
    "metadata": {
     "collapsed": false
@@ -1060,338 +525,15 @@
    "execution_count": null,
    "outputs": [],
    "source": [
+    "import pickle\n",
     "\n",
-    "\n",
-    "%%skip_if_false E2E_ENABLED\n",
-    "%%skip_if_false E2E_PLOT\n",
-    "\n",
-    "fig, ax = plt.subplots(num=\"crit_pdf\")\n",
-    "ax.set_prop_cycle(cycler('color', [plt.cm.nipy_spectral(i / 4) for i in range(5)]))\n",
-    "\n",
-    "kde = stats.gaussian_kde(timestep_mags)\n",
-    "xs = np.linspace(timestep_mags.min(), timestep_mags.max(), 1000)\n",
-    "ax.plot(xs, kde(xs), label=\"End-to-End Latency\")\n",
-    "perc = 50\n",
-    "ax.axvline(np.percentile(timestep_mags, perc), label=f\"{perc}th percentile\")\n",
-    "\n",
-    "ax2 = ax.twinx()\n",
-    "ax2.hist(timestep_mags, 50)\n",
-    "ax2.set_ylim(0, ax2.get_ylim()[1])\n",
-    "\n",
-    "ax.set_title(\"Time Distribution for E2E Breakdown\")\n",
-    "ax.set_xlabel(\"Time [s]\")\n",
-    "ax.set_ylabel(\"Frequency\")\n",
-    "ax.set_xlim(0, 2.01)\n",
-    "ax.set_ylim(0, ax.get_ylim()[1])\n",
-    "ax.legend()\n",
-    "\n",
-    "None"
+    "with open(\"trees.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(trees, f)\n"
    ],
    "metadata": {
     "collapsed": false
    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "%%skip_if_false E2E_ENABLED\n",
-    "%%skip_if_false E2E_PLOT\n",
-    "\n",
-    "tree = relevant_trees[E2E_PLOT_TIMESTAMP]\n",
-    "e2es = e2ess[E2E_PLOT_TIMESTAMP]\n",
-    "e2e_paths = e2e_pathss[E2E_PLOT_TIMESTAMP]\n",
-    "margin_y = .2\n",
-    "margin_x = 0\n",
-    "arr_width = 1 - margin_y\n",
-    "\n",
-    "\n",
-    "def cb_str(inst: TrCallbackInstance):\n",
-    "    cb: TrCallbackObject = inst.callback_obj\n",
-    "    if not cb:\n",
-    "        return None\n",
-    "    ret_str = f\"- {inst.duration * 1e3:07.3f}ms \"\n",
-    "    #if cb.callback_symbol:\n",
-    "    #    ret_str = repr(sanitize(cb.callback_symbol.symbol))\n",
-    "\n",
-    "    match cb.owner:\n",
-    "        case TrSubscriptionObject(subscription=sub):\n",
-    "            sub: TrSubscription\n",
-    "            ret_str = f\"{ret_str}{sub.node.path if sub.node else None} <- {sub.topic_name}\"\n",
-    "        case TrTimer(period=p, node=node):\n",
-    "            p: int\n",
-    "            node: TrNode\n",
-    "            ret_str = f\"{ret_str}{node.path if node else None} <- @{1 / (p * 1e-9):.2f}Hz\"\n",
-    "    return ret_str\n",
-    "\n",
-    "\n",
-    "def ts_str(inst, prev):\n",
-    "    return f\"{(inst.timestamp - prev) * 1e3:+09.3f}ms\"\n",
-    "\n",
-    "\n",
-    "def bw_str(bw):\n",
-    "    return bytes_str(bw['mean'])\n",
-    "\n",
-    "\n",
-    "def trunc_chars(string, w, e2e):\n",
-    "    if w < e2e * .005:\n",
-    "        return \"\"\n",
-    "    n_chars = max(math.floor(w / (e2e * .17) * 65) - 5, 0)\n",
-    "    if n_chars < 4:\n",
-    "        return \"\"\n",
-    "\n",
-    "    return \"...\" + string[-n_chars:] if n_chars < len(string) else string\n",
-    "\n",
-    "\n",
-    "#e2e_paths = sorted(e2e_paths, key=lambda path: path[-1].timestamp - path[0].timestamp, reverse=True)\n",
-    "#for y, e2e_path in reversed(list(enumerate(e2e_paths))):\n",
-    "#    last_pub_ts = None\n",
-    "#    last_cb_end = None\n",
-    "#    print(f\"=== {y}:\")\n",
-    "#    for inst in e2e_path:\n",
-    "\n",
-    "#tree = sort_subtree(get_relevant_tree(tree, _leaf_filter))\n",
-    "\n",
-    "t_start = tree.head.timestamp\n",
-    "t_min = t_start - e2e_lat(tree)\n",
-    "t_e2e = t_start - t_min\n",
-    "\n",
-    "legend_entries = {}\n",
-    "\n",
-    "\n",
-    "def plot_subtree(subtree: DepTree, ax: plt.Axes, y_labels, y=0, next_cb_start=0):\n",
-    "    height = fanout(subtree)\n",
-    "    inst = subtree.head\n",
-    "\n",
-    "    match inst:\n",
-    "        case TrCallbackInstance(timestamp=t_cb, duration=d_cb):\n",
-    "            is_sub = isinstance(inst.callback_obj.owner, TrSubscriptionObject)\n",
-    "\n",
-    "            r_x = t_cb - t_start + margin_x / 2\n",
-    "            r_y = y + margin_y / 2\n",
-    "            r_w = max(d_cb - margin_x, 0)\n",
-    "            r_h = height - margin_y\n",
-    "\n",
-    "            r = mpatch.Rectangle((r_x, r_y), r_w, r_h,\n",
-    "                                 ec=\"cadetblue\" if is_sub else \"indianred\", fc=\"lightblue\" if is_sub else \"lightcoral\",\n",
-    "                                 zorder=9000)\n",
-    "            ax.add_artist(r)\n",
-    "\n",
-    "            text = repr(sanitize(\n",
-    "                inst.callback_obj.callback_symbol.symbol)) if inst.callback_obj and inst.callback_obj.callback_symbol else \"??\"\n",
-    "            text = trunc_chars(text, r_w, t_e2e)\n",
-    "            if text:\n",
-    "                ax.text(r_x + r_w / 2, r_y + r_h / 2, text, ha=\"center\", va=\"center\", backgroundcolor=(1, 1, 1, .5),\n",
-    "                        zorder=11000)\n",
-    "\n",
-    "            if is_sub and \"Subscription CB\" not in legend_entries:\n",
-    "                legend_entries[\"Subscription CB\"] = r\n",
-    "            elif not is_sub and \"Timer CB\" not in legend_entries:\n",
-    "                legend_entries[\"Timer CB\"] = r\n",
-    "\n",
-    "            if next_cb_start is not None:\n",
-    "                r_x = t_cb - t_start + d_cb - margin_x / 2\n",
-    "                r_y = y + .5 - arr_width / 2\n",
-    "                r_w = next_cb_start - (t_cb + d_cb) + margin_x\n",
-    "                r_h = arr_width\n",
-    "                r = mpatch.Rectangle((r_x, r_y), r_w, r_h, color=\"orange\")\n",
-    "                ax.add_artist(r)\n",
-    "\n",
-    "                if is_sub:\n",
-    "                    node = inst.callback_obj.owner.subscription.node\n",
-    "                else:\n",
-    "                    node = inst.callback_obj.owner.node\n",
-    "                text = node.path\n",
-    "\n",
-    "                text = trunc_chars(text, r_w, t_e2e)\n",
-    "                if text:\n",
-    "                    ax.text(r_x + r_w / 2, r_y + r_h / 2, text, ha=\"center\", va=\"center\", backgroundcolor=(1, 1, 1, .5),\n",
-    "                            zorder=11000)\n",
-    "\n",
-    "                if \"Idle\" not in legend_entries:\n",
-    "                    legend_entries[\"Idle\"] = r\n",
-    "\n",
-    "            next_cb_start = t_cb\n",
-    "        case TrPublishInstance(timestamp=t_pub, publisher=pub):\n",
-    "            if not subtree.deps:\n",
-    "                y_labels.append(pub.topic_name if pub else None)\n",
-    "\n",
-    "            scatter = ax.scatter(t_pub - t_start, y + .5, color=\"cyan\", marker=\".\", zorder=10000)\n",
-    "\n",
-    "            if \"Publication\" not in legend_entries:\n",
-    "                legend_entries[\"Publication\"] = scatter\n",
-    "\n",
-    "            if next_cb_start is not None:\n",
-    "                r_x = t_pub - t_start\n",
-    "                r_y = y + .5 - arr_width / 2\n",
-    "                r_w = max(next_cb_start - t_pub + margin_x / 2, 0)\n",
-    "                r = mpatch.Rectangle((r_x, r_y), r_w, arr_width, color=\"lightgreen\")\n",
-    "                ax.add_artist(r)\n",
-    "                if pub:\n",
-    "                    text = pub.topic_name\n",
-    "                    text = trunc_chars(text, r_w, t_e2e)\n",
-    "                    if text:\n",
-    "                        ax.text(r_x + r_w / 2, r_y + arr_width / 2, text, ha=\"center\", va=\"center\",\n",
-    "                                backgroundcolor=(1, 1, 1, .5), zorder=11000)\n",
-    "\n",
-    "                if \"DDS\" not in legend_entries:\n",
-    "                    legend_entries[\"DDS\"] = r\n",
-    "\n",
-    "                topic_stats = msg_sizes.get(pub.topic_name) if BW_ENABLED else None\n",
-    "                if topic_stats:\n",
-    "                    size_str = bw_str(topic_stats)\n",
-    "                    ax.text(r_x + r_w / 2, r_y + arr_width + margin_y, size_str, ha=\"center\",\n",
-    "                            backgroundcolor=(1, 1, 1, .5), zorder=11000)\n",
-    "            else:\n",
-    "                print(\"[WARN] Tried to publish to another PublishInstance\")\n",
-    "            next_cb_start = None\n",
-    "\n",
-    "    acc_fanout = 0\n",
-    "    for dep in subtree.deps:\n",
-    "        acc_fanout += plot_subtree(dep, ax, y_labels, y + acc_fanout, next_cb_start)\n",
-    "    return height\n",
-    "\n",
-    "\n",
-    "fig, ax = plt.subplots(num=\"path_viz\")\n",
-    "ax.set_ylim(0, len(e2es))\n",
-    "\n",
-    "y_labels = []\n",
-    "plot_subtree(tree, ax, y_labels)\n",
-    "\n",
-    "tree_e2e = e2e_lat(tree)\n",
-    "plot_margin_x = .01 * tree_e2e\n",
-    "ax.set_xlim(-tree_e2e - plot_margin_x, plot_margin_x)\n",
-    "ax.set_yticks(np.array(range(len(y_labels))) + .5, y_labels)\n",
-    "ax.set_title(f\"Timestep {E2E_PLOT_TIMESTAMP}: {(tree.head.timestamp - relevant_trees[0].head.timestamp):10.6f}s\")\n",
-    "ax.set_xlabel(\"Time relative to output message [s]\")\n",
-    "ax.set_ylabel(\"Start topic\")\n",
-    "\n",
-    "labels, handles = list(zip(*legend_entries.items()))\n",
-    "ax.legend(handles, labels)\n",
-    "print(len(y_labels))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%%%skip_if_false E2E_ENABLED\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "# Find Top Critical Paths\n",
-    "\n",
-    "For each message tree, find its critical path and runner-up candidates. Then, for the whole timeseries, find the top critical paths by occurence count.\n",
-    "Critical paths are abstracted by their E2E-latency and a list of passed CBs and topics.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "%%skip_if_false E2E_ENABLED\n",
-    "\n",
-    "\n",
-    "def _owner(inst):\n",
-    "    match inst:\n",
-    "        case TrCallbackInstance(callback_obj=cb_obj):\n",
-    "            cb_obj: TrCallbackObject\n",
-    "            if cb_obj and cb_obj.callback_symbol:\n",
-    "                sym = repr(sanitize(cb_obj.callback_symbol.symbol))\n",
-    "            else:\n",
-    "                sym = str(cb_obj.id)\n",
-    "            return sym\n",
-    "        case TrPublishInstance(publisher=pub):\n",
-    "            pub: TrPublisher\n",
-    "            topic = pub.topic_name\n",
-    "            return topic\n",
-    "        case _:\n",
-    "            raise ValueError()\n",
-    "\n",
-    "\n",
-    "critical_paths = {}\n",
-    "print(len(relevant_trees))\n",
-    "for tree in tqdm(relevant_trees):\n",
-    "    crit = critical_path(tree)\n",
-    "\n",
-    "    key = tuple(map(_owner, crit[::-1]))\n",
-    "    if key not in critical_paths:\n",
-    "        critical_paths[key] = []\n",
-    "    critical_paths[key].append(crit)\n",
-    "\n",
-    "items = list(critical_paths.items())\n",
-    "items.sort(key=lambda pair: len(pair[1]), reverse=True)\n",
-    "\n",
-    "out_df = pd.DataFrame(columns=[\"path\", \"timestamp\", \"e2e_latency\"])\n",
-    "for key, paths in items:\n",
-    "    path_records = [{\"path\": \" -> \".join(key),\n",
-    "                     \"timestamp\": p[0].timestamp,\n",
-    "                     \"e2e_latency\": p[0].timestamp - p[-1].timestamp}\n",
-    "                    for p in paths]\n",
-    "    out_df = out_df.append(path_records)\n",
-    "    print(\n",
-    "        f\"======== {len(paths)}x: {sum(map(lambda p: p[0].timestamp - p[-1].timestamp, paths)) / len(paths) * 1000:.3f}ms\")\n",
-    "    paths_durations = []\n",
-    "    for path in paths:\n",
-    "        next_inst = None\n",
-    "        durations = []\n",
-    "        for inst in path:\n",
-    "            match inst:\n",
-    "                case TrCallbackInstance(timestamp=t, duration=d):\n",
-    "                    if not next_inst:\n",
-    "                        durations.append(d)\n",
-    "                    else:\n",
-    "                        durations.append(min(d, next_inst.timestamp - t))\n",
-    "                case TrPublishInstance(timestamp=t):\n",
-    "                    if not next_inst:\n",
-    "                        durations.append(0.0)\n",
-    "                    else:\n",
-    "                        durations.append(next_inst.timestamp - t)\n",
-    "                case _:\n",
-    "                    raise ValueError()\n",
-    "            next_inst = inst\n",
-    "        paths_durations.append(durations)\n",
-    "\n",
-    "    durations = list(map(lambda l: sum(l) / len(l), zip(*paths_durations)))[::-1]\n",
-    "    assert len(durations) == len(key)\n",
-    "    perc = np.percentile(durations, [70, 90, 95, 100])\n",
-    "    colors = [\"green\", \"yellow\", \"red\", \"magenta\"]\n",
-    "    for part, duration in zip(key, durations):\n",
-    "        E2E_PLOT_TIMESTAMP = 0\n",
-    "        for j, p in enumerate(perc):\n",
-    "            if duration < p:\n",
-    "                break\n",
-    "            E2E_PLOT_TIMESTAMP = j\n",
-    "        dur_str = colored(f\"{duration * 1000 :>.3f}ms\", colors[E2E_PLOT_TIMESTAMP])\n",
-    "        print(f\"  -> {dur_str} {part}\")\n",
-    "\n",
-    "# Filter out excluded path patterns\n",
-    "out_df = out_df[~out_df[\"path\"].apply(lambda path: any(re.search(f, path) for f in E2E_EXCLUDED_PATH_PATTERNS))]\n",
-    "\n",
-    "out_df.to_csv(os.path.join(OUT_PATH, \"e2e.csv\"), sep=\"\\t\", index=False)\n"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%%%skip_if_false E2E_ENABLED\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [],
-   "metadata": {
-    "collapsed": false
-   }
-  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/tracing_interop/tr_types.py b/tracing_interop/tr_types.py
index 7a636b5..d97ebd7 100644
--- a/tracing_interop/tr_types.py
+++ b/tracing_interop/tr_types.py
@@ -1,3 +1,4 @@
+from uuid import UUID, uuid4
 from collections import namedtuple, UserList, defaultdict
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -75,6 +76,7 @@ class TrContext:
     publish_instances: Index['TrPublishInstance']
     callback_instances: Index['TrCallbackInstance']
     topics: Index['TrTopic']
+    _uuid: UUID
 
     def __init__(self, handler: Ros2Handler):
         print("[TrContext] Processing ROS 2 objects from traces...")
@@ -110,6 +112,14 @@ class TrContext:
         self.topics = Index((TrTopic(name=name, _c=self) for name in _unique_topic_names),
                             name=False)
 
+        self._uuid = uuid4()
+
+    def __hash__(self):
+        return hash(self._uuid)
+
+    def __eq__(self, other):
+        return isinstance(other, TrContext) and other._uuid == self._uuid
+
     def __repr__(self):
         return f"TrContext"