@@ -425,7 +425,7 @@ impl Handle<File> {
 /// Each node (except for the _root node_ and _jump to scope_ node) lives in a file, and has a
 /// _local ID_ that must be unique within its file.
 #[repr(C)]
-#[derive(Clone, Copy, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct NodeID {
     file: ControlledOption<Handle<File>>,
     local_id: u32,
 
@@ -66,6 +66,7 @@ use crate::partial::PartialPaths;
 use crate::partial::PartialSymbolStack;
 use crate::paths::Extend;
 use crate::paths::PathResolutionError;
+use crate::stats::FrequencyDistribution;
 use crate::CancellationError;
 use crate::CancellationFlag;
 
@@ -839,6 +840,7 @@ pub struct ForwardPartialPathStitcher<H> {
     similar_path_detector: Option<SimilarPathDetector<PartialPath>>,
     check_only_join_nodes: bool,
     max_work_per_phase: usize,
+    stats: Stats,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
 }
@@ -876,6 +878,7 @@ impl<H> ForwardPartialPathStitcher<H> {
             check_only_join_nodes: false,
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
+            stats: Stats::default(),
             #[cfg(feature = "copious-debugging")]
             phase_number: 1,
         }
@@ -909,6 +912,10 @@ impl<H> ForwardPartialPathStitcher<H> {
     pub fn set_max_work_per_phase(&mut self, max_work_per_phase: usize) {
         self.max_work_per_phase = max_work_per_phase;
     }
+
+    pub fn into_stats(self) -> Stats {
+        self.stats
+    }
 }
 
 impl<H: Clone> ForwardPartialPathStitcher<H> {
@@ -1056,6 +1063,21 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             self.next_iteration.2.push(new_has_split);
         }
 
+        let (graph, _, _) = candidates.get_graph_partials_and_db();
+        let end_node = &graph[partial_path.end_node];
+        if end_node.is_root() {
+            self.stats.candidates_per_root_path += candidate_count;
+            self.stats.extensions_per_root_path += extension_count;
+            self.stats.root_visits += 1;
+        } else {
+            self.stats.candidates_per_node_path += candidate_count;
+            self.stats.extensions_per_node_path += extension_count;
+            self.stats.node_visits += end_node.id();
+        }
+
+        if extension_count == 0 {
+            self.stats.maximal_path_lengh += partial_path.edges.len();
+        }
         candidate_count
     }
 
@@ -1089,6 +1111,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             self.next_iteration.1.drain(..),
             self.next_iteration.2.drain(..),
         ));
+        self.stats.queued_paths_per_phase += self.queue.len();
         let mut work_performed = 0;
         while let Some((partial_path, cycle_detector, has_split)) = self.queue.pop_front() {
             let (graph, partials, _) = candidates.get_graph_partials_and_db();
@@ -1110,6 +1133,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
                 break;
             }
         }
+        self.stats.processed_paths_per_phase += work_performed;
 
         #[cfg(feature = "copious-debugging")]
         {
@@ -1149,7 +1173,7 @@ impl ForwardPartialPathStitcher<Edge> {
         config: StitcherConfig,
         cancellation_flag: &dyn CancellationFlag,
         mut visit: F,
-    ) -> Result<(), CancellationError>
+    ) -> Result<Stats, CancellationError>
     where
         F: FnMut(&StackGraph, &mut PartialPaths, &PartialPath),
     {
@@ -1168,6 +1192,8 @@ impl ForwardPartialPathStitcher<Edge> {
             ForwardPartialPathStitcher::from_partial_paths(graph, partials, initial_paths);
         config.apply(&mut stitcher);
         stitcher.set_check_only_join_nodes(true);
+
+        let mut accepted_path_length = FrequencyDistribution::default();
         while !stitcher.is_complete() {
             cancellation_flag.check("finding complete partial paths")?;
             stitcher.process_next_phase(
@@ -1176,11 +1202,16 @@ impl ForwardPartialPathStitcher<Edge> {
             );
             for path in stitcher.previous_phase_partial_paths() {
                 if as_complete_as_necessary(graph, path) {
+                    accepted_path_length += path.edges.len();
                     visit(graph, partials, path);
                 }
             }
         }
-        Ok(())
+
+        Ok(Stats {
+            accepted_path_length,
+            ..stitcher.stats
+        })
     }
 }
 
@@ -1202,7 +1233,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
         config: StitcherConfig,
         cancellation_flag: &dyn CancellationFlag,
         mut visit: F,
-    ) -> Result<(), Err>
+    ) -> Result<Stats, Err>
     where
         I: IntoIterator<Item = Handle<Node>>,
         A: Appendable,
@@ -1225,6 +1256,8 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             ForwardPartialPathStitcher::from_partial_paths(graph, partials, initial_paths);
         config.apply(&mut stitcher);
         stitcher.set_check_only_join_nodes(true);
+
+        let mut accepted_path_length = FrequencyDistribution::default();
         while !stitcher.is_complete() {
             cancellation_flag.check("finding complete partial paths")?;
             for path in stitcher.previous_phase_partial_paths() {
@@ -1234,11 +1267,55 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             let (graph, partials, _) = candidates.get_graph_partials_and_db();
             for path in stitcher.previous_phase_partial_paths() {
                 if path.is_complete(graph) {
+                    accepted_path_length += path.edges.len();
                     visit(graph, partials, path);
                 }
             }
         }
-        Ok(())
+
+        Ok(Stats {
+            accepted_path_length,
+            ..stitcher.stats
+        })
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Stats {
+    /// The distribution of the number of queued paths per stitching phase
+    pub queued_paths_per_phase: FrequencyDistribution<usize>,
+    /// The distribution of the number of processed paths per stitching phase
+    pub processed_paths_per_phase: FrequencyDistribution<usize>,
+    /// The distribution of the length of accepted paths
+    pub accepted_path_length: FrequencyDistribution<usize>,
+    /// The distribution of the maximal length of paths (when they cannot be extended more)
+    pub maximal_path_lengh: FrequencyDistribution<usize>,
+    /// The distribution of the number of candidates for paths ending in a regular node
+    pub candidates_per_node_path: FrequencyDistribution<usize>,
+    /// The distribution of the number of candidates for paths ending in the root node
+    pub candidates_per_root_path: FrequencyDistribution<usize>,
+    /// The distribution of the number of extensions (accepted candidates) for paths ending in a regular node
+    pub extensions_per_node_path: FrequencyDistribution<usize>,
+    /// The distribution of the number of extensions (accepted candidates) for paths ending in the root node
+    pub extensions_per_root_path: FrequencyDistribution<usize>,
+    /// The number of times the root node is visited
+    pub root_visits: usize,
+    /// The distribution of the number of times a regular node is visited
+    pub node_visits: FrequencyDistribution<crate::graph::NodeID>,
+}
+
+impl std::ops::AddAssign<&Self> for Stats {
+    fn add_assign(&mut self, rhs: &Self) {
+        self.queued_paths_per_phase += &rhs.queued_paths_per_phase;
+        self.processed_paths_per_phase += &rhs.processed_paths_per_phase;
+        self.accepted_path_length += &rhs.accepted_path_length;
+        self.maximal_path_lengh += &rhs.maximal_path_lengh;
+        self.candidates_per_node_path += &rhs.candidates_per_node_path;
+        self.candidates_per_root_path += &rhs.candidates_per_root_path;
+        self.extensions_per_node_path += &rhs.extensions_per_node_path;
+        self.extensions_per_root_path += &rhs.extensions_per_root_path;
+        self.root_visits += rhs.root_visits;
+        self.node_visits += &rhs.node_visits;
     }
 }