Merge pull request #264 from frederikfabriciusbjerre/perf/improve-subgraph

performance: improve subgraph and build performance

Author: frederikfabriciusbjerre

src/rust/Cargo.toml

@@ -27,4 +27,4 @@ gadjid = ['dep:gadjid']
 
 [profile.release]
 lto = true
-codegen-units = 1
+codegen-units = 1

src/rust/src/graph/builder.rs

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: MIT
 //! GraphBuilder: collects edges and emits class-agnostic CSR.
 
-use std::collections::HashSet;
 use std::sync::Arc;
 
+use rustc_hash::FxHashSet;
+
 use super::error::BuilderError;
+use super::session::EdgeBuffer;
 use super::{CaugiGraph, RegistrySnapshot};
 use crate::edges::{EdgeRegistry, EdgeSpec};
 
@@ -14,8 +16,8 @@ pub struct GraphBuilder {
     simple: bool,
     specs: Arc<[EdgeSpec]>,
     rows: Vec<Vec<HalfEdge>>,
-    seen: HashSet<(u32, u32, u8, bool)>,
-    pair_seen: HashSet<(u32, u32)>,
+    seen: FxHashSet<(u32, u32, u8, bool)>,
+    pair_seen: FxHashSet<(u32, u32)>,
 }
 
 /// Encodes the position of this endpoint in the edge: 0 = tail position, 1 = head position.
@@ -73,22 +75,36 @@ impl GraphBuilder {
             simple,
             specs,
             rows: vec![Vec::new(); n_us],
-            seen: HashSet::new(),
-            pair_seen: HashSet::new(),
+            seen: FxHashSet::default(),
+            pair_seen: FxHashSet::default(),
         }
     }
 
     /// Create a new builder from an existing registry snapshot.
     /// This is more efficient when the snapshot already exists (e.g., in GraphSession).
     pub fn new_from_snapshot(n: u32, simple: bool, snapshot: Arc<RegistrySnapshot>) -> Self {
+        Self::new_from_snapshot_with_capacity(n, simple, snapshot, 0)
+    }
+
+    /// Create a new builder with pre-reserved hash set capacity for expected edge count.
+    pub fn new_from_snapshot_with_capacity(
+        n: u32,
+        simple: bool,
+        snapshot: Arc<RegistrySnapshot>,
+        expected_edges: usize,
+    ) -> Self {
         let n_us = n as usize;
         Self {
             n,
             simple,
             specs: Arc::clone(&snapshot.specs),
             rows: vec![Vec::new(); n_us],
-            seen: HashSet::new(),
-            pair_seen: HashSet::new(),
+            seen: FxHashSet::with_capacity_and_hasher(expected_edges, Default::default()),
+            pair_seen: if simple {
+                FxHashSet::with_capacity_and_hasher(expected_edges, Default::default())
+            } else {
+                FxHashSet::default()
+            },
         }
     }
 
@@ -117,10 +133,9 @@ impl GraphBuilder {
             return Err(BuilderError::SelfLoop { node: u });
         }
 
-        let spec: EdgeSpec = self
+        let spec = self
             .specs
             .get(etype as usize)
-            .cloned()
             .ok_or(BuilderError::InvalidEdgeCode { code: etype })?;
 
         if self.simple {
@@ -159,6 +174,82 @@ impl GraphBuilder {
         });
     }
 
+    /// Build CSR directly from a trusted EdgeBuffer, skipping per-edge validation.
+    ///
+    /// This is safe when edges have already been validated (e.g., from a session
+    /// that validated them on insertion). Skips hash-set duplicate detection and
+    /// bounds checks, going straight to CSR construction.
+    pub fn build_from_edge_buffer(
+        n: u32,
+        simple: bool,
+        edges: &EdgeBuffer,
+        snapshot: Arc<RegistrySnapshot>,
+    ) -> Result<CaugiGraph, String> {
+        let n_us = n as usize;
+        let edge_count = edges.len();
+
+        // Pre-allocate rows with estimated capacity (2 halves per edge, spread across n nodes).
+        let avg_degree = if n_us > 0 {
+            (2 * edge_count / n_us).max(1)
+        } else {
+            0
+        };
+        let mut rows: Vec<Vec<HalfEdge>> = (0..n_us)
+            .map(|_| Vec::with_capacity(avg_degree))
+            .collect();
+
+        for i in 0..edge_count {
+            let u = edges.from[i];
+            let v = edges.to[i];
+            let etype = edges.etype[i];
+
+            // Tail half at u (source), head half at v (target).
+            rows[u as usize].push(HalfEdge {
+                nbr: v,
+                etype,
+                side: Side::Tail,
+            });
+            rows[v as usize].push(HalfEdge {
+                nbr: u,
+                etype,
+                side: Side::Head,
+            });
+        }
+
+        // Sort each row for CSR canonical order.
+        for row in &mut rows {
+            row.sort_unstable();
+        }
+
+        // Build CSR arrays.
+        let mut row_index = Vec::with_capacity(n_us + 1);
+        row_index.push(0);
+        for row in &rows {
+            row_index.push(row_index.last().unwrap() + row.len() as u32);
+        }
+
+        let nnz = *row_index.last().unwrap() as usize;
+        let mut col = vec![0u32; nnz];
+        let mut ety = vec![0u8; nnz];
+        let mut side_arr = vec![0u8; nnz];
+
+        for (i, row) in rows.iter().enumerate() {
+            let mut k = row_index[i] as usize;
+            for h in row {
+                col[k] = h.nbr;
+                ety[k] = h.etype;
+                side_arr[k] = match h.side {
+                    Side::Tail => 0,
+                    Side::Head => 1,
+                };
+                k += 1;
+            }
+        }
+
+        let snap = RegistrySnapshot::from_specs(snapshot.specs.clone(), 1);
+        CaugiGraph::from_csr(row_index, col, ety, side_arr, simple, snap)
+    }
+
     pub fn finalize(mut self) -> Result<CaugiGraph, String> {
         self.take_and_build()
     }
@@ -177,7 +268,7 @@ impl GraphBuilder {
     fn build_from_rows(
         &mut self,
         mut rows: Vec<Vec<HalfEdge>>,
-        _seen: HashSet<(u32, u32, u8, bool)>,
+        _seen: FxHashSet<(u32, u32, u8, bool)>,
     ) -> Result<CaugiGraph, String> {
         let n = self.n as usize;
 

src/rust/src/graph/session.rs

@@ -17,7 +17,8 @@ use super::CaugiGraph;
 use super::RegistrySnapshot;
 use crate::edges::{EdgeRegistry, EdgeSpec};
 use crate::graph::NeighborMode;
-use std::collections::{HashMap, HashSet};
+use rustc_hash::FxHashSet;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 /// The target graph class for typed view construction.
@@ -122,7 +123,7 @@ impl EdgeBuffer {
 /// The session holds:
 /// - **Variables**: Mutable inputs (n, simple, class, registry, edges, names)
 /// - **Declarations**: Lazily computed outputs (core, view)
-/// - **Queries**: Computed on demand without caching
+/// - **Queries**: Computed on demand (no query-level caching)
 ///
 /// # Invalidation Rules
 ///
@@ -147,6 +148,9 @@ pub struct GraphSession {
     // ═══════════════════════════════════════════════════════════════════════════
     core_valid: bool,
     view_valid: bool,
+    /// When true, edges are known to be valid (e.g., subset of an already-valid
+    /// graph) and `build_core` can skip per-edge validation.
+    edges_trusted: bool,
 
     // ═══════════════════════════════════════════════════════════════════════════
     // DECLARATIONS (computed values)
@@ -183,6 +187,7 @@ impl GraphSession {
 
             core_valid: false,
             view_valid: false,
+            edges_trusted: false,
 
             core: None,
             view: None,
@@ -210,12 +215,79 @@ impl GraphSession {
 
             core_valid: false,
             view_valid: false,
+            edges_trusted: false,
 
             core: None,
             view: None,
         }
     }
 
+    /// Create a new session from an existing registry snapshot plus full data.
+    /// Edges are marked as trusted (skipping validation on build).
+    pub fn from_snapshot_with_data(
+        registry: Arc<RegistrySnapshot>,
+        simple: bool,
+        class: GraphClass,
+        edges: EdgeBuffer,
+        names: Vec<String>,
+    ) -> Self {
+        let n = names.len() as u32;
+        let name_to_index = Self::build_name_to_index(&names);
+        Self {
+            n,
+            simple,
+            graph_class: class,
+            registry,
+            edges,
+            names,
+            name_to_index,
+            core_valid: false,
+            view_valid: false,
+            edges_trusted: true,
+            core: None,
+            view: None,
+        }
+    }
+
+    /// Create a session with a pre-built CSR core (e.g., from CSR-based subgraph extraction).
+    /// The edge buffer is reconstructed from the CSR so future mutations are possible.
+    pub fn from_prebuilt_core(
+        registry: Arc<RegistrySnapshot>,
+        simple: bool,
+        class: GraphClass,
+        core: CaugiGraph,
+        names: Vec<String>,
+    ) -> Self {
+        // Reconstruct edge buffer from CSR: collect tail-side half-edges only
+        // (each undirected edge has both a tail and head half; we only want one copy).
+        let n = core.n();
+        let mut edges = EdgeBuffer::new();
+        for u in 0..n {
+            for k in core.row_range(u) {
+                if core.side[k] == 0 {
+                    // side 0 = Tail position → this node is the source
+                    edges.push(u, core.col_index[k], core.etype[k]);
+                }
+            }
+        }
+
+        let name_to_index = Self::build_name_to_index(&names);
+        Self {
+            n,
+            simple,
+            graph_class: class,
+            registry,
+            edges,
+            names,
+            name_to_index,
+            core_valid: true,
+            view_valid: false,
+            edges_trusted: true,
+            core: Some(Arc::new(core)),
+            view: None,
+        }
+    }
+
     /// Clone for R's copy-on-write semantics.
     ///
     /// Creates a deep copy with all declarations invalidated.
@@ -233,6 +305,7 @@ impl GraphSession {
             // Invalidate all declarations in the clone
             core_valid: false,
             view_valid: false,
+            edges_trusted: self.edges_trusted,
             core: None,
             view: None,
         }
@@ -244,6 +317,7 @@ impl GraphSession {
 
     fn invalidate_core(&mut self) {
         self.core_valid = false;
+        self.edges_trusted = false;
         self.core = None;
         self.invalidate_view();
     }
@@ -277,7 +351,7 @@ impl GraphSession {
     }
 
     pub fn replace_edges_for_pairs(&mut self, new_edges: EdgeBuffer) {
-        let mut remove_pairs: HashSet<(u32, u32)> = HashSet::with_capacity(new_edges.len());
+        let mut remove_pairs: FxHashSet<(u32, u32)> = FxHashSet::with_capacity_and_hasher(new_edges.len(), Default::default());
         if self.simple {
             for i in 0..new_edges.len() {
                 let u = new_edges.from[i];
@@ -292,8 +366,8 @@ impl GraphSession {
         }
 
         let mut kept = EdgeBuffer::with_capacity(self.edges.len() + new_edges.len());
-        let mut seen: HashSet<(u32, u32, u8)> =
-            HashSet::with_capacity(self.edges.len() + new_edges.len());
+        let mut seen: FxHashSet<(u32, u32, u8)> =
+            FxHashSet::with_capacity_and_hasher(self.edges.len() + new_edges.len(), Default::default());
 
         for i in 0..self.edges.len() {
             let u = self.edges.from[i];
@@ -371,8 +445,21 @@ impl GraphSession {
     // ═══════════════════════════════════════════════════════════════════════════
 
     fn build_core(&self) -> Result<CaugiGraph, String> {
-        let mut builder =
-            GraphBuilder::new_from_snapshot(self.n, self.simple, Arc::clone(&self.registry));
+        if self.edges_trusted {
+            return GraphBuilder::build_from_edge_buffer(
+                self.n,
+                self.simple,
+                &self.edges,
+                Arc::clone(&self.registry),
+            );
+        }
+
+        let mut builder = GraphBuilder::new_from_snapshot_with_capacity(
+            self.n,
+            self.simple,
+            Arc::clone(&self.registry),
+            self.edges.len(),
+        );
 
         for i in 0..self.edges.len() {
             builder