Appended partial paths do not have to shared across stitchers

Author: Hendrik van Antwerpen

stack-graphs/include/stack-graphs.h

@@ -59,9 +59,6 @@ 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;
 
@@ -664,12 +661,6 @@ 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);
 
@@ -1071,7 +1062,6 @@ 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);
 
@@ -1085,7 +1075,6 @@ 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);
 
@@ -1108,7 +1097,6 @@ 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,7 +15,6 @@ 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;
@@ -99,25 +98,6 @@ 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
@@ -1982,20 +1962,17 @@ 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(
@@ -2015,21 +1992,18 @@ 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(
@@ -2064,17 +2038,13 @@ 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, paths);
+    stitcher.stitcher.process_next_phase(graph, partials, db);
     stitcher.update_previous_phase_partial_paths(partials);
 }
 

stack-graphs/src/stitching.rs

@@ -726,6 +726,7 @@ pub struct ForwardPartialPathStitcher {
         VecDeque<PartialPath>,
         VecDeque<PartialPathAppendingCycleDetector>,
     ),
+    appended_paths: AppendedPartialPaths,
     similar_path_detector: SimilarPathDetector<PartialPath>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
@@ -750,7 +751,6 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
-        paths: &mut AppendedPartialPaths,
         starting_nodes: I,
     ) -> ForwardPartialPathStitcher
     where
@@ -776,6 +776,7 @@ impl ForwardPartialPathStitcher {
                 );
             }
         }
+        let mut appended_paths = AppendedPartialPaths::new();
         let next_iteration = candidate_partial_paths
             .iter()
             .copied()
@@ -786,7 +787,7 @@ impl ForwardPartialPathStitcher {
                         graph,
                         partials,
                         db,
-                        paths,
+                        &mut appended_paths,
                         handle.into(),
                     ),
                 )
@@ -798,6 +799,7 @@ impl ForwardPartialPathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             similar_path_detector: SimilarPathDetector::new(),
+            appended_paths,
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
             #[cfg(feature = "copious-debugging")]
@@ -819,17 +821,17 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
-        paths: &mut AppendedPartialPaths,
         initial_partial_paths: Vec<PartialPath>,
     ) -> ForwardPartialPathStitcher {
+        let mut appended_paths = AppendedPartialPaths::new();
         let next_iteration = initial_partial_paths
             .into_iter()
             .map(|p| {
                 let c = PartialPathAppendingCycleDetector::from_partial_path(
                     graph,
                     partials,
                     db,
-                    paths,
+                    &mut appended_paths,
                     p.clone().into(),
                 );
                 (p, c)
@@ -839,6 +841,7 @@ impl ForwardPartialPathStitcher {
             candidate_partial_paths: Vec::new(),
             queue: VecDeque::new(),
             next_iteration,
+            appended_paths,
             similar_path_detector: SimilarPathDetector::new(),
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
@@ -893,7 +896,6 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
-        paths: &mut AppendedPartialPaths,
         partial_path: &PartialPath,
         cycle_detector: PartialPathAppendingCycleDetector,
     ) -> usize {
@@ -940,7 +942,13 @@ impl ForwardPartialPathStitcher {
                     continue;
                 }
                 if new_cycle_detector
-                    .append_partial_path(graph, partials, db, paths, extension.into())
+                    .append_partial_path(
+                        graph,
+                        partials,
+                        db,
+                        &mut self.appended_paths,
+                        extension.into(),
+                    )
                     .is_err()
                 {
                     copious_debugging!("        is invalid: cyclic");
@@ -974,7 +982,6 @@ impl ForwardPartialPathStitcher {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
-        paths: &mut AppendedPartialPaths,
     ) {
         copious_debugging!("==> Start phase {}", self.phase_number);
         self.queue.extend(
@@ -1003,7 +1010,7 @@ impl ForwardPartialPathStitcher {
                 continue;
             }
             work_performed +=
-                self.stitch_partial_path(graph, partials, db, paths, &partial_path, cycle_detector);
+                self.stitch_partial_path(graph, partials, db, &partial_path, cycle_detector);
             if work_performed >= self.max_work_per_phase {
                 break;
             }
@@ -1038,9 +1045,8 @@ 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, &mut paths, starting_nodes);
+            ForwardPartialPathStitcher::from_nodes(graph, partials, db, starting_nodes);
         stitcher.set_should_extend(|g, _, p| p.starts_at_reference(g));
         while !stitcher.is_complete() {
             cancellation_flag.check("finding complete partial paths")?;
@@ -1050,7 +1056,7 @@ impl ForwardPartialPathStitcher {
             for path in complete_partial_paths {
                 visit(graph, partials, path);
             }
-            stitcher.process_next_phase(graph, partials, db, &mut paths);
+            stitcher.process_next_phase(graph, partials, db);
         }
         Ok(())
     }

stack-graphs/tests/it/c/can_find_qualified_definitions_with_phased_partial_path_stitching.rs

@@ -9,8 +9,6 @@ use std::collections::BTreeSet;
 
 use controlled_option::ControlledOption;
 use pretty_assertions::assert_eq;
-use stack_graphs::c::sg_appended_paths_arena_free;
-use stack_graphs::c::sg_appended_paths_arena_new;
 use stack_graphs::c::sg_forward_partial_path_stitcher_free;
 use stack_graphs::c::sg_forward_partial_path_stitcher_from_partial_paths;
 use stack_graphs::c::sg_forward_partial_path_stitcher_process_next_phase;
@@ -119,7 +117,6 @@ fn check_find_qualified_definitions(
     let partials = sg_partial_path_arena_new();
     let rust_partials = unsafe { &mut (*partials).inner };
     let db = sg_partial_path_database_new();
-    let paths = sg_appended_paths_arena_new();
 
     // Create a new external storage layer holding _all_ of the partial paths in the stack graph.
     let mut storage_layer = StorageLayer::new(graph.graph, partials);
@@ -151,7 +148,6 @@ fn check_find_qualified_definitions(
         graph.graph,
         partials,
         db,
-        paths,
         1,
         &initial_partial_path as *const PartialPath as *const _,
     );
@@ -237,13 +233,7 @@ fn check_find_qualified_definitions(
         }
 
         // And then kick off the next phase!
-        sg_forward_partial_path_stitcher_process_next_phase(
-            graph.graph,
-            partials,
-            db,
-            paths,
-            stitcher,
-        );
+        sg_forward_partial_path_stitcher_process_next_phase(graph.graph, partials, db, stitcher);
     }
     copious_debugging!("==> Path stitching done");
 
@@ -254,7 +244,6 @@ fn check_find_qualified_definitions(
         .collect::<BTreeSet<_>>();
     assert_eq!(expected_partial_paths, results);
 
-    sg_appended_paths_arena_free(paths);
     sg_forward_partial_path_stitcher_free(stitcher);
     sg_partial_path_database_free(db);
     sg_partial_path_arena_free(partials);

stack-graphs/tests/it/c/can_jump_to_definition_with_phased_partial_path_stitching.rs

@@ -8,8 +8,6 @@
 use std::collections::BTreeSet;
 
 use pretty_assertions::assert_eq;
-use stack_graphs::c::sg_appended_paths_arena_free;
-use stack_graphs::c::sg_appended_paths_arena_new;
 use stack_graphs::c::sg_forward_partial_path_stitcher_free;
 use stack_graphs::c::sg_forward_partial_path_stitcher_from_nodes;
 use stack_graphs::c::sg_forward_partial_path_stitcher_process_next_phase;
@@ -110,7 +108,6 @@ fn check_jump_to_definition(graph: &TestGraph, file: &str, expected_partial_path
     let partials = sg_partial_path_arena_new();
     let rust_partials = unsafe { &mut (*partials).inner };
     let db = sg_partial_path_database_new();
-    let paths = sg_appended_paths_arena_new();
 
     // Create a new external storage layer holding _all_ of the partial paths in the stack graph.
     let mut storage_layer = StorageLayer::new(graph.graph, partials);
@@ -136,7 +133,6 @@ fn check_jump_to_definition(graph: &TestGraph, file: &str, expected_partial_path
         graph.graph,
         partials,
         db,
-        paths,
         references.len(),
         references.as_ptr() as *const _,
     );
@@ -222,13 +218,7 @@ fn check_jump_to_definition(graph: &TestGraph, file: &str, expected_partial_path
         }
 
         // And then kick off the next phase!
-        sg_forward_partial_path_stitcher_process_next_phase(
-            graph.graph,
-            partials,
-            db,
-            paths,
-            stitcher,
-        );
+        sg_forward_partial_path_stitcher_process_next_phase(graph.graph, partials, db, stitcher);
     }
     copious_debugging!("==> Path stitching done");
 
@@ -239,7 +229,6 @@ fn check_jump_to_definition(graph: &TestGraph, file: &str, expected_partial_path
         .collect::<BTreeSet<_>>();
     assert_eq!(expected_partial_paths, results);
 
-    sg_appended_paths_arena_free(paths);
     sg_forward_partial_path_stitcher_free(stitcher);
     sg_partial_path_database_free(db);
     sg_partial_path_arena_free(partials);