rxgraph 0.2.0__tar.gz → 0.3.0__tar.gz

{rxgraph-0.2.0 → rxgraph-0.3.0}/Cargo.lock

@@ -1293,7 +1293,7 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rxgraph"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "arrow",
@@ -1311,7 +1311,7 @@ dependencies = [
 
 [[package]]
 name = "rxgraph-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "arrow",

{rxgraph-0.2.0 → rxgraph-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxgraph
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{rxgraph-0.2.0 → rxgraph-0.3.0}/crates/rxgraph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rxgraph"
-version = "0.2.0"
+version = "0.3.0"
 edition.workspace = true
 rust-version.workspace = true
 description = "High-performance graph traversal engine"
@@ -40,3 +40,7 @@ harness = false
 [[bench]]
 name = "flight_routes"
 harness = false
+
+[[bench]]
+name = "memory"
+harness = false

rxgraph-0.3.0/crates/rxgraph/benches/memory.rs

@@ -0,0 +1,121 @@
+//! Memory benchmarking for graph construction, holding, and from-source search.
+//!
+//! Unlike the criterion benches (which measure time), this binary uses `stats_alloc` to
+//! report allocation deltas at each stage. Run with:
+//!
+//! ```sh
+//! cargo bench -p rxgraph --bench memory
+//! ```
+//!
+//! It builds a large, sparse graph where only a small subset is reachable from the source,
+//! and reports bytes allocated/RSS.
+
+use std::{alloc::System, hint::black_box, sync::Arc, time::Instant};
+
+use arrow::{
+    array::{ArrayRef, UInt64Array},
+    datatypes::{DataType, Field, Schema},
+    record_batch::RecordBatch,
+};
+use rxgraph::Graph;
+use stats_alloc::{INSTRUMENTED_SYSTEM, Region, StatsAlloc};
+
+#[global_allocator]
+static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
+
+/// Number of nodes in the synthetic graph.
+const NODES: u64 = 5_000_000;
+/// Length of the single reachable chain from node 0 (the "working set").
+const REACHABLE_CHAIN: u64 = 5_000;
+
+fn batch(fields: Vec<Field>, columns: Vec<ArrayRef>) -> RecordBatch {
+    RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap()
+}
+
+/// Builds a graph with `NODES` contiguous u64 node ids and a single linear chain of
+/// `REACHABLE_CHAIN` edges from node 0. Everything past the chain is unreachable, so a
+/// search from node 0 only ever needs a tiny working set.
+fn tables() -> (RecordBatch, RecordBatch) {
+    let node_ids: Vec<u64> = (0..NODES).collect();
+    let nodes = batch(
+        vec![Field::new("id", DataType::UInt64, false)],
+        vec![Arc::new(UInt64Array::from(node_ids)) as ArrayRef],
+    );
+
+    let edge_count = REACHABLE_CHAIN;
+    let edge_ids: Vec<u64> = (0..edge_count).collect();
+    let srcs: Vec<u64> = (0..edge_count).collect();
+    let dests: Vec<u64> = (1..=edge_count).collect();
+    let edges = batch(
+        vec![
+            Field::new("id", DataType::UInt64, false),
+            Field::new("src", DataType::UInt64, false),
+            Field::new("dest", DataType::UInt64, false),
+        ],
+        vec![
+            Arc::new(UInt64Array::from(edge_ids)) as ArrayRef,
+            Arc::new(UInt64Array::from(srcs)),
+            Arc::new(UInt64Array::from(dests)),
+        ],
+    );
+
+    (nodes, edges)
+}
+
+fn mib(bytes: isize) -> f64 {
+    bytes as f64 / (1024.0 * 1024.0)
+}
+
+/// Runs the received callback inside an allocation-tracking region and reports memory use.
+///
+/// Two distinct numbers are reported:
+/// - `retained`: net bytes still held after the call returns (allocated minus freed). This
+///   is what grows the resident set. A value that escapes the closure (e.g. the graph)
+///   counts here; a result that is dropped inside the closure does not.
+/// - `churn`: total bytes allocated during the call, regardless of whether they were freed
+///   again before returning. High churn with ~zero retained means lots of short-lived
+///   allocations (e.g. WCC building one Vec per component, then handing it back and dropping
+///   it), not a memory leak.
+fn measure<T>(label: &str, f: impl FnOnce() -> T) -> T {
+    let region = Region::new(GLOBAL);
+    let started = Instant::now();
+    let value = f();
+    let stats = region.change();
+    let elapsed = started.elapsed();
+    let retained = stats.bytes_allocated as isize - stats.bytes_deallocated as isize;
+    eprintln!(
+        "{label:<28} retained={:>9.2} MiB  churn={:>8.2} MiB in {:<8} allocs (freed={:.2} MiB)  {elapsed:?}",
+        mib(retained),
+        mib(stats.bytes_allocated as isize),
+        stats.allocations,
+        mib(stats.bytes_deallocated as isize),
+    );
+    value
+}
+
+fn main() {
+    eprintln!("memory profile: nodes={NODES} reachable_chain={REACHABLE_CHAIN}\n");
+
+    let (nodes, edges) = tables();
+
+    // Construction: forward CSR + identity only. Reverse CSR is NOT built here (lazy).
+    let graph = measure("construct", || Graph::new(nodes, edges).unwrap());
+
+    // Forward-only BFS from node 0: touches only the reachable chain.
+    measure("bfs_from_source", || {
+        black_box(graph.bfs_u64(0, None).unwrap());
+    });
+
+    // First degree query forces the lazy reverse CSR to materialize.
+    measure("in_degrees (builds rev CSR)", || {
+        black_box(graph.in_degrees());
+    });
+
+    // Subsequent reverse-adjacency use is free (cached).
+    measure("weakly_connected (rev cached)", || {
+        black_box(graph.weakly_connected_components_u64());
+    });
+
+    // Keep the graph alive so its footprint is attributed to the stages above.
+    black_box(&graph);
+}

{rxgraph-0.2.0 → rxgraph-0.3.0}/crates/rxgraph/src/graph/csr.rs

@@ -1,17 +1,29 @@
-use anyhow::Result;
+use anyhow::{Result, bail};
 
 use super::repo::{EdgeId, NodeId};
 
+/// Type used for CSR row offsets. `u32` keeps per-node overhead small; edge counts are
+/// already bounded by `EdgeId = u32`, so offsets cannot exceed `u32::MAX`.
+pub(crate) type Offset = u32;
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct Csr {
-    pub(crate) offsets: Vec<usize>,
+    pub(crate) offsets: Vec<Offset>,
     pub(crate) edge_ids: Vec<EdgeId>,
     pub(crate) dests: Vec<NodeId>,
 }
 
 /// Constructs a CSR (Compressed Sparse Row) data structure for outgoing edges.
 pub(crate) fn build_csr(node_count: usize, edges: &[(NodeId, NodeId)]) -> Result<Csr> {
-    let mut offsets = vec![0usize; node_count + 1];
+    if edges.len() > Offset::MAX as usize {
+        bail!(
+            "too many edges for u32 CSR offsets ({} > {})",
+            edges.len(),
+            Offset::MAX
+        );
+    }
+
+    let mut offsets = vec![0 as Offset; node_count + 1];
 
     for &(src, _dest) in edges {
         offsets[src as usize + 1] += 1;
@@ -26,8 +38,7 @@ pub(crate) fn build_csr(node_count: usize, edges: &[(NodeId, NodeId)]) -> Result
     let mut cursor = offsets.clone();
 
     for (edge_id, &(src, dest)) in edges.iter().enumerate() {
-        let pos = cursor[src as usize];
-        // TODO: Check?
+        let pos = cursor[src as usize] as usize;
         edge_ids[pos] = edge_id as EdgeId;
         dests[pos] = dest;
         cursor[src as usize] += 1;

{rxgraph-0.2.0 → rxgraph-0.3.0}/crates/rxgraph/src/graph/graph.rs

@@ -35,6 +35,11 @@ impl Graph {
         })
     }
 
+    /// Replaces the payload (attribute) tables, reusing the existing topology.
+    pub fn set_payloads(&mut self, nodes: RecordBatch, edges: RecordBatch) -> Result<()> {
+        self.repo.set_payloads(nodes, edges)
+    }
+
     /// Number of node rows.
     pub fn node_count(&self) -> usize {
         self.repo.nodes.num_rows()
@@ -211,6 +216,8 @@ impl Graph {
     pub fn weakly_connected_components(&self) -> Vec<Vec<GraphId<'_>>> {
         let mut visited = vec![0u8; self.node_count()];
         let mut components = Vec::new();
+        // Reused across components to reduce allocations.
+        let mut frontier = Vec::new();
 
         for start in 0..self.node_count() {
             if visited[start] != 0 {
@@ -218,7 +225,8 @@ impl Graph {
             }
 
             let mut component = Vec::new();
-            let mut frontier = vec![start as NodeId];
+            frontier.clear();
+            frontier.push(start as NodeId);
             let mut head = 0;
             visited[start] = 1;
 
@@ -253,6 +261,8 @@ impl Graph {
     pub fn weakly_connected_components_u64(&self) -> Option<Vec<Vec<u64>>> {
         let mut visited = vec![0u8; self.node_count()];
         let mut components = Vec::new();
+        // Reused across components to reduce allocations.
+        let mut frontier = Vec::new();
 
         for start in 0..self.node_count() {
             if visited[start] != 0 {
@@ -260,7 +270,8 @@ impl Graph {
             }
 
             let mut component = Vec::new();
-            let mut frontier = vec![start as NodeId];
+            frontier.clear();
+            frontier.push(start as NodeId);
             let mut head = 0;
             visited[start] = 1;
 

{rxgraph-0.2.0 → rxgraph-0.3.0}/crates/rxgraph/src/graph/repo.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt};
+use std::{collections::HashMap, fmt, sync::OnceLock};
 
 use anyhow::{Context, Result, bail};
 use arrow::array::{
@@ -8,13 +8,13 @@ use arrow_schema::DataType;
 
 use crate::{
     arrow::validate_field_exists,
-    graph::csr::{Csr, build_csr},
+    graph::csr::{Csr, Offset, build_csr},
 };
 
-/// Compact internal node identifier used by traversal code.
+/// Compact internal node identifier used for traversal.
 pub type NodeId = u32;
 
-/// Compact internal edge identifier used by traversal code.
+/// Compact internal edge identifier used for traversal.
 pub type EdgeId = u32;
 
 pub const ID_COL: &str = "id";
@@ -100,17 +100,34 @@ pub trait GraphRepo {
 
 #[derive(Debug)]
 pub(crate) struct Repo {
-    csr_offsets: Vec<usize>,
+    csr_offsets: Vec<Offset>,
     csr_dests: Vec<NodeId>,
     edge_ids: Vec<EdgeId>,
-    incoming_offsets: Vec<usize>,
-    incoming_srcs: Vec<NodeId>,
-    out_degrees: Vec<usize>,
-    in_degrees: Vec<usize>,
-    degrees: Vec<usize>,
+
     identity: Identity,
     pub nodes: RecordBatch,
     pub edges: RecordBatch,
+
+    /// Reverse adjacency (incoming edges).
+    /// Used for optimization - only some searches require it and it's built lazily on first use
+    /// to keep construction memory and time low (and proportional) foraward only workloads
+    /// (like BFS, as opposed to WCC or degrees).
+    incoming: OnceLock<IncomingCsr>,
+    /// Endpoints retained to build the reverse CSR lazily without re-reading Arrow columns.
+    edge_endpoints: Vec<(NodeId, NodeId)>,
+
+    /// Degree vectors, only used when whole-graph degree query and cached after.
+    /// Search-only workloads never touch these, so construction stays cheap;
+    /// degree-heavy workloads pay the O(n) build once instead of on every call.
+    out_degrees: OnceLock<Vec<usize>>,
+    in_degrees: OnceLock<Vec<usize>>,
+    degrees: OnceLock<Vec<usize>>,
+}
+
+#[derive(Debug)]
+struct IncomingCsr {
+    offsets: Vec<Offset>,
+    srcs: Vec<NodeId>,
 }
 
 #[derive(Debug)]
@@ -203,6 +220,33 @@ impl Repo {
         self.identity.is_contiguous_u64()
     }
 
+    /// Replaces the payload (attribute) tables without rebuilding topology.
+    ///
+    /// Used by lazy graphs to swap in column-projected payload batches for a single search.
+    /// The new batches must keep the original row order and count: DSL column reads index
+    /// payload arrays by internal node/edge ID, which equals the Arrow row position.
+    /// Identity (`id`/`src`/`dest`) is resolved from the precomputed mapping, not these
+    /// batches, so the projected batches only need the columns the kernel references.
+    pub(crate) fn set_payloads(&mut self, nodes: RecordBatch, edges: RecordBatch) -> Result<()> {
+        if nodes.num_rows() != self.nodes.num_rows() {
+            bail!(
+                "projected nodes table has {} rows but topology expects {}",
+                nodes.num_rows(),
+                self.nodes.num_rows()
+            );
+        }
+        if edges.num_rows() != self.edges.num_rows() {
+            bail!(
+                "projected edges table has {} rows but topology expects {}",
+                edges.num_rows(),
+                self.edges.num_rows()
+            );
+        }
+        self.nodes = nodes;
+        self.edges = edges;
+        Ok(())
+    }
+
     pub(crate) fn internal_node_u64(&self, external: u64) -> Option<NodeId> {
         self.identity.internal_node_u64(external)
     }
@@ -215,8 +259,8 @@ impl Repo {
 impl GraphRepo for Repo {
     fn outgoing(&self, node: NodeId) -> impl Iterator<Item = (EdgeId, NodeId)> {
         let i = node as usize;
-        let start = self.csr_offsets[i];
-        let end = self.csr_offsets[i + 1];
+        let start = self.csr_offsets[i] as usize;
+        let end = self.csr_offsets[i + 1] as usize;
 
         self.edge_ids[start..end]
             .iter()
@@ -226,16 +270,17 @@ impl GraphRepo for Repo {
 
     fn outgoing_slice(&self, node: NodeId) -> (&[EdgeId], &[NodeId]) {
         let i = node as usize;
-        let start = self.csr_offsets[i];
-        let end = self.csr_offsets[i + 1];
+        let start = self.csr_offsets[i] as usize;
+        let end = self.csr_offsets[i + 1] as usize;
         (&self.edge_ids[start..end], &self.csr_dests[start..end])
     }
 
     fn incoming(&self, node: NodeId) -> impl Iterator<Item = NodeId> {
+        let incoming = self.incoming();
         let i = node as usize;
-        let start = self.incoming_offsets[i];
-        let end = self.incoming_offsets[i + 1];
-        self.incoming_srcs[start..end].iter().copied()
+        let start = incoming.offsets[i] as usize;
+        let end = incoming.offsets[i + 1] as usize;
+        incoming.srcs[start..end].iter().copied()
     }
 
     fn internal_node(&self, external: GraphId<'_>) -> Option<NodeId> {
@@ -251,25 +296,61 @@ impl GraphRepo for Repo {
     }
 
     fn out_degree(&self, node: NodeId) -> usize {
-        self.out_degrees[node as usize]
+        let i = node as usize;
+        (self.csr_offsets[i + 1] - self.csr_offsets[i]) as usize
     }
 
     fn in_degree(&self, node: NodeId) -> usize {
-        self.in_degrees[node as usize]
+        let incoming = self.incoming();
+        let i = node as usize;
+        (incoming.offsets[i + 1] - incoming.offsets[i]) as usize
     }
 }
 
 impl Repo {
+    /// Returns the reverse-adjacency CSR, building it on first use.
+    fn incoming(&self) -> &IncomingCsr {
+        self.incoming.get_or_init(|| {
+            let incoming_edges = self
+                .edge_endpoints
+                .iter()
+                .map(|&(src, dest)| (dest, src))
+                .collect::<Vec<_>>();
+            let Csr { offsets, dests, .. } = build_csr(self.nodes.num_rows(), &incoming_edges)
+                .expect("incoming CSR has the same edge count as the forward CSR");
+            IncomingCsr {
+                offsets,
+                srcs: dests,
+            }
+        })
+    }
+
     pub(crate) fn out_degrees(&self) -> Vec<usize> {
-        self.out_degrees.clone()
+        self.out_degrees
+            .get_or_init(|| degrees_from_offsets(&self.csr_offsets))
+            .clone()
     }
 
     pub(crate) fn in_degrees(&self) -> Vec<usize> {
-        self.in_degrees.clone()
+        self.in_degrees
+            .get_or_init(|| degrees_from_offsets(&self.incoming().offsets))
+            .clone()
     }
 
     pub(crate) fn degrees(&self) -> Vec<usize> {
-        self.degrees.clone()
+        self.degrees.get_or_init(|| self.compute_degrees()).clone()
+    }
+
+    fn compute_degrees(&self) -> Vec<usize> {
+        let out = &self.csr_offsets;
+        let incoming = &self.incoming().offsets;
+        (0..self.nodes.num_rows())
+            .map(|i| {
+                let out_deg = (out[i + 1] - out[i]) as usize;
+                let in_deg = (incoming[i + 1] - incoming[i]) as usize;
+                out_deg + in_deg
+            })
+            .collect()
     }
 }
 
@@ -285,23 +366,6 @@ impl Repo {
             edge_ids,
             dests: csr_dests,
         } = build_csr(nodes.num_rows(), &edge_endpoints).context("failed to construct CSR")?;
-        let incoming_edges = edge_endpoints
-            .iter()
-            .map(|&(src, dest)| (dest, src))
-            .collect::<Vec<_>>();
-        let Csr {
-            offsets: incoming_offsets,
-            dests: incoming_srcs,
-            ..
-        } = build_csr(nodes.num_rows(), &incoming_edges)
-            .context("failed to construct incoming CSR")?;
-        let out_degrees = degrees_from_offsets(&csr_offsets);
-        let in_degrees = degrees_from_offsets(&incoming_offsets);
-        let degrees = out_degrees
-            .iter()
-            .zip(&in_degrees)
-            .map(|(out, incoming)| out + incoming)
-            .collect();
 
         Ok(Self {
             nodes,
@@ -309,18 +373,21 @@ impl Repo {
             csr_offsets,
             csr_dests,
             edge_ids,
-            incoming_offsets,
-            incoming_srcs,
-            out_degrees,
-            in_degrees,
-            degrees,
+            incoming: OnceLock::new(),
+            edge_endpoints,
             identity,
+            out_degrees: OnceLock::new(),
+            in_degrees: OnceLock::new(),
+            degrees: OnceLock::new(),
         })
     }
 }
 
-fn degrees_from_offsets(offsets: &[usize]) -> Vec<usize> {
-    offsets.windows(2).map(|pair| pair[1] - pair[0]).collect()
+fn degrees_from_offsets(offsets: &[Offset]) -> Vec<usize> {
+    offsets
+        .windows(2)
+        .map(|pair| (pair[1] - pair[0]) as usize)
+        .collect()
 }
 
 struct Preprocessed {
@@ -688,4 +755,56 @@ mod tests {
                 .contains("missing dest")
         );
     }
+
+    #[test]
+    fn set_payloads_swaps_columns_and_keeps_topology() {
+        let nodes = record_batch!((ID_COL, UInt64, [0, 1, 2])).unwrap();
+        let edges = record_batch!(
+            (ID_COL, UInt64, [0, 1]),
+            (EDGE_SRC_COL, UInt64, [0, 1]),
+            (EDGE_DEST_COL, UInt64, [1, 2])
+        )
+        .unwrap();
+        let mut repo = Repo::from_tables(nodes, edges).unwrap();
+
+        // Project to a different set of payload columns (same row counts).
+        let new_nodes =
+            record_batch!((ID_COL, UInt64, [0, 1, 2]), ("score", Int64, [10, 20, 30])).unwrap();
+        let new_edges = record_batch!(
+            (ID_COL, UInt64, [0, 1]),
+            (EDGE_SRC_COL, UInt64, [0, 1]),
+            (EDGE_DEST_COL, UInt64, [1, 2])
+        )
+        .unwrap();
+        repo.set_payloads(new_nodes, new_edges).unwrap();
+
+        // Topology is unchanged after the swap.
+        assert_eq!(outgoing_for(&repo, GraphId::U64(0)), vec![GraphId::U64(1)]);
+        assert!(repo.nodes.column_by_name("score").is_some());
+    }
+
+    #[test]
+    fn set_payloads_rejects_row_count_mismatch() {
+        let nodes = record_batch!((ID_COL, UInt64, [0, 1, 2])).unwrap();
+        let edges = record_batch!(
+            (ID_COL, UInt64, [0]),
+            (EDGE_SRC_COL, UInt64, [0]),
+            (EDGE_DEST_COL, UInt64, [1])
+        )
+        .unwrap();
+        let mut repo = Repo::from_tables(nodes, edges).unwrap();
+
+        let bad_nodes = record_batch!((ID_COL, UInt64, [0, 1])).unwrap();
+        let same_edges = record_batch!(
+            (ID_COL, UInt64, [0]),
+            (EDGE_SRC_COL, UInt64, [0]),
+            (EDGE_DEST_COL, UInt64, [1])
+        )
+        .unwrap();
+        let err = repo
+            .set_payloads(bad_nodes, same_edges)
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("projected nodes table has 2 rows"));
+    }
 }

{rxgraph-0.2.0 → rxgraph-0.3.0}/crates/rxgraph/src/traversal/algo.rs

@@ -12,6 +12,7 @@ use crate::{
     traversal::{
         GraphPath, SearchResult, SearchStats,
         config::{TraversalConfig, TraversalStrategy},
+        progress::Progress,
     },
 };
 
@@ -36,6 +37,7 @@ impl Graph {
             max_revisits_per_node,
             parallel,
             intermediate_states,
+            progress,
         } = config;
         let kernel = kernel.bind(self)?;
         let cfg = RunConfig {
@@ -45,6 +47,7 @@ impl Graph {
             strategy,
             max_revisits_per_node,
             intermediate_states,
+            progress,
         };
 
         match (parallel, strategy) {
@@ -65,6 +68,7 @@ struct RunConfig {
     strategy: TraversalStrategy,
     max_revisits_per_node: usize,
     intermediate_states: bool,
+    progress: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -104,8 +108,10 @@ fn search_serial<'a>(
 ) -> Result<SearchResult<'a>> {
     let (mut arena, mut frontier, mut stats) = initial_arena(graph, cfg, kernel)?;
     let mut paths = Vec::new();
+    let mut progress = Progress::new(cfg.progress);
 
     while let Some(parent) = pop(&mut frontier, cfg.strategy) {
+        progress.tick(&stats);
         if arena[parent].depth >= cfg.max_depth {
             continue;
         }
@@ -128,6 +134,7 @@ fn search_serial<'a>(
                 paths.push(materialize(graph, &arena, child, cfg, kernel)?);
                 stats.stopped_paths += 1;
                 if cfg.max_paths.is_some_and(|max| paths.len() >= max) {
+                    progress.finish(&stats);
                     return Ok(SearchResult { paths, stats });
                 }
             } else {
@@ -136,6 +143,7 @@ fn search_serial<'a>(
         }
     }
 
+    progress.finish(&stats);
     Ok(SearchResult { paths, stats })
 }
 
@@ -147,8 +155,10 @@ fn search_bfs_parallel<'a>(
     let (mut arena, frontier, mut stats) = initial_arena(graph, cfg, kernel)?;
     let mut frontier = frontier.into_iter().collect::<Vec<_>>();
     let mut paths = Vec::new();
+    let mut progress = Progress::new(cfg.progress);
 
     while !frontier.is_empty() {
+        progress.tick(&stats);
         let edge_count = frontier
             .iter()
             .map(|&p| graph.repo.out_degree(arena[p].node))
@@ -187,11 +197,13 @@ fn search_bfs_parallel<'a>(
             && paths.len() >= max
         {
             paths.truncate(max);
+            progress.finish(&stats);
             return Ok(SearchResult { paths, stats });
         }
         frontier = next;
     }
 
+    progress.finish(&stats);
     Ok(SearchResult { paths, stats })
 }
 
@@ -202,12 +214,16 @@ fn search_dfs_parallel<'a>(
 ) -> Result<SearchResult<'a>> {
     let (queue, mut stats) = initial_tasks(graph, cfg, kernel)?;
     let mut seed_paths = Vec::new();
+    let mut progress = Progress::new(cfg.progress);
+    progress.tick(&stats);
     let seeds = build_dfs_seeds(graph, cfg, kernel, queue, &mut seed_paths, &mut stats)?;
+    progress.tick(&stats);
 
     if let Some(max) = cfg.max_paths
         && seed_paths.len() >= max
     {
         seed_paths.truncate(max);
+        progress.finish(&stats);
         return Ok(SearchResult {
             paths: seed_paths,
             stats,
@@ -235,6 +251,7 @@ fn search_dfs_parallel<'a>(
     if let Some(max) = cfg.max_paths {
         paths.truncate(max);
     }
+    progress.finish(&stats);
     Ok(SearchResult { paths, stats })
 }