Add stub arenas for holding appened paths adn edges for cycle detection

Author: Hendrik van Antwerpen

stack-graphs/include/stack-graphs.h

@@ -59,6 +59,9 @@ enum sg_result {
     SG_RESULT_CANCELLED,
 };
 
+// Manages the state of a collection of partial paths to be used in the path-stitching algorithm.
+struct sg_appended_paths_arena;
+
 // Manages the state of a collection of partial paths to be used in the path-stitching algorithm.
 struct sg_partial_path_arena;
 
@@ -661,6 +664,12 @@ struct sg_partial_path_arena *sg_partial_path_arena_new(void);
 // Frees a path arena, and all of its contents.
 void sg_partial_path_arena_free(struct sg_partial_path_arena *partials);
 
+// Creates a new, initially empty partial path arena.
+struct sg_appended_paths_arena *sg_appended_paths_arena_new(void);
+
+// Frees a path arena, and all of its contents.
+void sg_appended_paths_arena_free(struct sg_appended_paths_arena *partials);
+
 // Creates a new, initially empty partial path database.
 struct sg_partial_path_database *sg_partial_path_database_new(void);
 
@@ -1062,6 +1071,7 @@ void sg_forward_path_stitcher_free(struct sg_forward_path_stitcher *stitcher);
 struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_nodes(const struct sg_stack_graph *graph,
                                                                                      struct sg_partial_path_arena *partials,
                                                                                      struct sg_partial_path_database *db,
+                                                                                     struct sg_appended_paths_arena *paths,
                                                                                      size_t count,
                                                                                      const sg_node_handle *starting_nodes);
 
@@ -1075,6 +1085,7 @@ struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_n
 struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_partial_paths(const struct sg_stack_graph *graph,
                                                                                              struct sg_partial_path_arena *partials,
                                                                                              struct sg_partial_path_database *db,
+                                                                                             struct sg_appended_paths_arena *paths,
                                                                                              size_t count,
                                                                                              const struct sg_partial_path *initial_partial_paths);
 
@@ -1097,6 +1108,7 @@ void sg_forward_partial_path_stitcher_set_max_work_per_phase(struct sg_forward_p
 void sg_forward_partial_path_stitcher_process_next_phase(const struct sg_stack_graph *graph,
                                                          struct sg_partial_path_arena *partials,
                                                          struct sg_partial_path_database *db,
+                                                         struct sg_appended_paths_arena *paths,
                                                          struct sg_forward_partial_path_stitcher *stitcher);
 
 // Frees a forward path stitcher.

stack-graphs/src/c.rs

@@ -15,6 +15,7 @@ use std::sync::atomic::AtomicUsize;
 use libc::c_char;
 
 use crate::arena::Handle;
+use crate::cycles::AppendedPartialPaths;
 use crate::graph::File;
 use crate::graph::InternedString;
 use crate::graph::Node;
@@ -98,6 +99,25 @@ pub extern "C" fn sg_partial_path_arena_free(partials: *mut sg_partial_path_aren
     drop(unsafe { Box::from_raw(partials) })
 }
 
+/// Manages the state of a collection of partial paths to be used in the path-stitching algorithm.
+pub struct sg_appended_paths_arena {
+    pub inner: AppendedPartialPaths,
+}
+
+/// Creates a new, initially empty partial path arena.
+#[no_mangle]
+pub extern "C" fn sg_appended_paths_arena_new() -> *mut sg_appended_paths_arena {
+    Box::into_raw(Box::new(sg_appended_paths_arena {
+        inner: AppendedPartialPaths::new(),
+    }))
+}
+
+/// Frees a path arena, and all of its contents.
+#[no_mangle]
+pub extern "C" fn sg_appended_paths_arena_free(partials: *mut sg_appended_paths_arena) {
+    drop(unsafe { Box::from_raw(partials) })
+}
+
 /// Contains a "database" of partial paths.
 ///
 /// This type is meant to be a lazily loaded "view" into a proper storage layer.  During the
@@ -1962,17 +1982,20 @@ pub extern "C" fn sg_forward_partial_path_stitcher_from_nodes(
     graph: *const sg_stack_graph,
     partials: *mut sg_partial_path_arena,
     db: *mut sg_partial_path_database,
+    paths: *mut sg_appended_paths_arena,
     count: usize,
     starting_nodes: *const sg_node_handle,
 ) -> *mut sg_forward_partial_path_stitcher {
     let graph = unsafe { &(*graph).inner };
     let partials = unsafe { &mut (*partials).inner };
     let db = unsafe { &mut (*db).inner };
+    let paths = unsafe { &mut (*paths).inner };
     let starting_nodes = unsafe { std::slice::from_raw_parts(starting_nodes, count) };
     let stitcher = ForwardPartialPathStitcher::from_nodes(
         graph,
         partials,
         db,
+        paths,
         starting_nodes.iter().copied().map(sg_node_handle::into),
     );
     Box::into_raw(Box::new(InternalForwardPartialPathStitcher::new(
@@ -1992,18 +2015,21 @@ pub extern "C" fn sg_forward_partial_path_stitcher_from_partial_paths(
     graph: *const sg_stack_graph,
     partials: *mut sg_partial_path_arena,
     db: *mut sg_partial_path_database,
+    paths: *mut sg_appended_paths_arena,
     count: usize,
     initial_partial_paths: *const sg_partial_path,
 ) -> *mut sg_forward_partial_path_stitcher {
     let graph = unsafe { &(*graph).inner };
     let partials = unsafe { &mut (*partials).inner };
     let db = unsafe { &mut (*db).inner };
+    let paths = unsafe { &mut (*paths).inner };
     let initial_partial_paths =
         unsafe { std::slice::from_raw_parts(initial_partial_paths as *const PartialPath, count) };
     let stitcher = ForwardPartialPathStitcher::from_partial_paths(
         graph,
         partials,
         db,
+        paths,
         initial_partial_paths.to_vec(),
     );
     Box::into_raw(Box::new(InternalForwardPartialPathStitcher::new(
@@ -2038,13 +2064,17 @@ pub extern "C" fn sg_forward_partial_path_stitcher_process_next_phase(
     graph: *const sg_stack_graph,
     partials: *mut sg_partial_path_arena,
     db: *mut sg_partial_path_database,
+    paths: *mut sg_appended_paths_arena,
     stitcher: *mut sg_forward_partial_path_stitcher,
 ) {
     let graph = unsafe { &(*graph).inner };
     let partials = unsafe { &mut (*partials).inner };
     let db = unsafe { &mut (*db).inner };
+    let paths = unsafe { &mut (*paths).inner };
     let stitcher = unsafe { &mut *(stitcher as *mut InternalForwardPartialPathStitcher) };
-    stitcher.stitcher.process_next_phase(graph, partials, db);
+    stitcher
+        .stitcher
+        .process_next_phase(graph, partials, db, paths);
     stitcher.update_previous_phase_partial_paths(partials);
 }
 

stack-graphs/src/cycles.rs

@@ -135,11 +135,22 @@ where
     }
 }
 
+// ----------------------------------------------------------------------------
+// Cycle detector when appending edges
+
 #[derive(Clone)]
 pub struct EdgeAppendingCycleDetector {
     edges: VecDeque<Edge>,
 }
 
+pub struct AppendedEdges {}
+
+impl AppendedEdges {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
 impl EdgeAppendingCycleDetector {
     pub fn new() -> Self {
         Self {
@@ -151,6 +162,7 @@ impl EdgeAppendingCycleDetector {
         &mut self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
+        _edges: &mut AppendedEdges,
         edge: Edge,
     ) -> Result<(), ()> {
         let end_node = edge.sink;
@@ -188,16 +200,28 @@ impl EdgeAppendingCycleDetector {
     }
 }
 
+// ----------------------------------------------------------------------------
+// Cycle detector when appending partial paths
+
 #[derive(Clone)]
 pub struct PartialPathAppendingCycleDetector {
     paths: VecDeque<OwnedOrDatabasePath>,
 }
 
+pub struct AppendedPartialPaths {}
+
+impl AppendedPartialPaths {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
 impl PartialPathAppendingCycleDetector {
     pub fn from_partial_path(
         _graph: &StackGraph,
         _partials: &mut PartialPaths,
         _db: &mut Database,
+        _paths: &mut AppendedPartialPaths,
         path: OwnedOrDatabasePath,
     ) -> Self {
         Self {
@@ -210,6 +234,7 @@ impl PartialPathAppendingCycleDetector {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &Database,
+        _paths: &mut AppendedPartialPaths,
         path: OwnedOrDatabasePath,
     ) -> Result<(), ()> {
         let end_node = path.get(db).end_node;

stack-graphs/src/partial.rs

@@ -45,6 +45,7 @@ use smallvec::SmallVec;
 use crate::arena::Deque;
 use crate::arena::DequeArena;
 use crate::arena::Handle;
+use crate::cycles::AppendedEdges;
 use crate::cycles::EdgeAppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
@@ -2382,6 +2383,7 @@ impl PartialPath {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         file: Handle<File>,
+        edges: &mut AppendedEdges,
         path_cycle_detector: EdgeAppendingCycleDetector,
         result: &mut R,
     ) {
@@ -2406,7 +2408,7 @@ impl PartialPath {
                 continue;
             }
             if new_cycle_detector
-                .append_edge(graph, partials, extension)
+                .append_edge(graph, partials, edges, extension)
                 .is_err()
             {
                 copious_debugging!("         * cycle");
@@ -2698,6 +2700,7 @@ impl PartialPaths {
         copious_debugging!("Find all partial paths in {}", graph[file]);
         let mut similar_path_detector = SimilarPathDetector::new();
         let mut queue = VecDeque::new();
+        let mut edges = AppendedEdges::new();
         queue.extend(
             graph
                 .nodes_for_file(file)
@@ -2725,7 +2728,14 @@ impl PartialPaths {
                 }
             } else {
                 copious_debugging!("    * extend");
-                path.extend_from_file(graph, self, file, path_cycle_detector, &mut queue);
+                path.extend_from_file(
+                    graph,
+                    self,
+                    file,
+                    &mut edges,
+                    path_cycle_detector,
+                    &mut queue,
+                );
             }
         }
         Ok(())

stack-graphs/src/stitching.rs

@@ -48,6 +48,7 @@ use crate::arena::List;
 use crate::arena::ListArena;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
+use crate::cycles::AppendedPartialPaths;
 use crate::cycles::PartialPathAppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
 use crate::graph::Node;
@@ -749,6 +750,7 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
+        paths: &mut AppendedPartialPaths,
         starting_nodes: I,
     ) -> ForwardPartialPathStitcher
     where
@@ -784,6 +786,7 @@ impl ForwardPartialPathStitcher {
                         graph,
                         partials,
                         db,
+                        paths,
                         handle.into(),
                     ),
                 )
@@ -816,6 +819,7 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
+        paths: &mut AppendedPartialPaths,
         initial_partial_paths: Vec<PartialPath>,
     ) -> ForwardPartialPathStitcher {
         let next_iteration = initial_partial_paths
@@ -825,6 +829,7 @@ impl ForwardPartialPathStitcher {
                     graph,
                     partials,
                     db,
+                    paths,
                     p.clone().into(),
                 );
                 (p, c)
@@ -888,6 +893,7 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
+        paths: &mut AppendedPartialPaths,
         partial_path: &PartialPath,
         cycle_detector: PartialPathAppendingCycleDetector,
     ) -> usize {
@@ -934,7 +940,7 @@ impl ForwardPartialPathStitcher {
                     continue;
                 }
                 if new_cycle_detector
-                    .append_partial_path(graph, partials, db, extension.into())
+                    .append_partial_path(graph, partials, db, paths, extension.into())
                     .is_err()
                 {
                     copious_debugging!("        is invalid: cyclic");
@@ -968,6 +974,7 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
+        paths: &mut AppendedPartialPaths,
     ) {
         copious_debugging!("==> Start phase {}", self.phase_number);
         self.queue.extend(
@@ -996,7 +1003,7 @@ impl ForwardPartialPathStitcher {
                 continue;
             }
             work_performed +=
-                self.stitch_partial_path(graph, partials, db, &partial_path, cycle_detector);
+                self.stitch_partial_path(graph, partials, db, paths, &partial_path, cycle_detector);
             if work_performed >= self.max_work_per_phase {
                 break;
             }
@@ -1031,8 +1038,9 @@ impl ForwardPartialPathStitcher {
         I: IntoIterator<Item = Handle<Node>>,
         F: FnMut(&StackGraph, &mut PartialPaths, &PartialPath),
     {
+        let mut paths = AppendedPartialPaths::new();
         let mut stitcher =
-            ForwardPartialPathStitcher::from_nodes(graph, partials, db, starting_nodes);
+            ForwardPartialPathStitcher::from_nodes(graph, partials, db, &mut paths, starting_nodes);
         stitcher.set_should_extend(|g, _, p| p.starts_at_reference(g));
         while !stitcher.is_complete() {
             cancellation_flag.check("finding complete partial paths")?;
@@ -1042,7 +1050,7 @@ impl ForwardPartialPathStitcher {
             for path in complete_partial_paths {
                 visit(graph, partials, path);
             }
-            stitcher.process_next_phase(graph, partials, db);
+            stitcher.process_next_phase(graph, partials, db, &mut paths);
         }
         Ok(())
     }