Make similar path detection optional during path stitching

Author: Hendrik van Antwerpen

stack-graphs/include/stack-graphs.h

@@ -1024,6 +1024,13 @@ struct sg_forward_path_stitcher *sg_forward_path_stitcher_new(const struct sg_st
                                                               size_t count,
                                                               const sg_node_handle *starting_nodes);
 
+// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+// default because of the accociated preformance cost.
+void sg_forward_path_stitcher_set_similar_path_detection(struct sg_forward_path_stitcher *stitcher,
+                                                         bool detect_similar_paths);
+
 // Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 // bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 // to starve any worker threads or processes that you might be using.  If you don't call this
@@ -1078,6 +1085,13 @@ struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_p
                                                                                              size_t count,
                                                                                              const struct sg_partial_path *initial_partial_paths);
 
+// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+// default because of the accociated preformance cost.
+void sg_forward_partial_path_stitcher_set_similar_path_detection(struct sg_forward_partial_path_stitcher *stitcher,
+                                                                 bool detect_similar_paths);
+
 // Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 // bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 // to starve any worker threads or processes that you might be using.  If you don't call this

stack-graphs/src/c.rs

@@ -1825,6 +1825,21 @@ pub extern "C" fn sg_forward_path_stitcher_new(
     Box::into_raw(Box::new(ForwardPathStitcher::new(stitcher, paths))) as *mut _
 }
 
+/// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+/// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+/// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+/// default because of the accociated preformance cost.
+#[no_mangle]
+pub extern "C" fn sg_forward_path_stitcher_set_similar_path_detection(
+    stitcher: *mut sg_forward_path_stitcher,
+    detect_similar_paths: bool,
+) {
+    let stitcher = unsafe { &mut *(stitcher as *mut ForwardPathStitcher) };
+    stitcher
+        .stitcher
+        .set_similar_path_detection(detect_similar_paths);
+}
+
 /// Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 /// bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 /// to starve any worker threads or processes that you might be using.  If you don't call this
@@ -2011,6 +2026,21 @@ pub extern "C" fn sg_forward_partial_path_stitcher_from_partial_paths(
     ))) as *mut _
 }
 
+/// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+/// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+/// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+/// default because of the accociated preformance cost.
+#[no_mangle]
+pub extern "C" fn sg_forward_partial_path_stitcher_set_similar_path_detection(
+    stitcher: *mut sg_forward_partial_path_stitcher,
+    detect_similar_paths: bool,
+) {
+    let stitcher = unsafe { &mut *(stitcher as *mut InternalForwardPartialPathStitcher) };
+    stitcher
+        .stitcher
+        .set_similar_path_detection(detect_similar_paths);
+}
+
 /// Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 /// bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 /// to starve any worker threads or processes that you might be using.  If you don't call this

stack-graphs/src/stitching.rs

@@ -485,7 +485,7 @@ pub struct PathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
-    similar_path_detector: SimilarPathDetector<Path>,
+    similar_path_detector: Option<SimilarPathDetector<Path>>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -537,7 +537,7 @@ impl PathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            similar_path_detector: SimilarPathDetector::new(),
+            similar_path_detector: None,
             // 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")]
@@ -565,6 +565,18 @@ impl PathStitcher {
         self.next_iteration.0.as_mut_slices().0
     }
 
+    /// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+    /// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+    /// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+    /// default because of the accociated preformance cost.
+    pub fn set_similar_path_detection(&mut self, detect_similar_paths: bool) {
+        if detect_similar_paths {
+            self.similar_path_detector = Some(SimilarPathDetector::new());
+        } else {
+            self.similar_path_detector = None;
+        }
+    }
+
     /// Sets the maximum amount of work that can be performed during each phase of the algorithm.
     /// By bounding our work this way, you can ensure that it's not possible for our CPU-bound
     /// algorithm to starve any worker threads or processes that you might be using.  If you don't
@@ -635,14 +647,16 @@ impl PathStitcher {
                 copious_debugging!("        is invalid: cyclic");
                 continue;
             }
-            if self.similar_path_detector.has_similar_path(
-                graph,
-                paths,
-                &new_path,
-                |ps, left, right| left.equals(ps, right),
-            ) {
-                copious_debugging!("        is invalid: too many similar");
-                continue;
+            if let Some(similar_path_detector) = &mut self.similar_path_detector {
+                if similar_path_detector.has_similar_path(
+                    graph,
+                    paths,
+                    &new_path,
+                    |ps, left, right| left.equals(ps, right),
+                ) {
+                    copious_debugging!("        is invalid: too many similar");
+                    continue;
+                }
             }
             self.next_iteration.0.push_back(new_path);
             self.next_iteration.1.push_back(new_cycle_detector);
@@ -689,10 +703,12 @@ impl PathStitcher {
 
         #[cfg(feature = "copious-debugging")]
         {
-            copious_debugging!(
-                "    Max similar path bucket size: {}",
-                self.similar_path_detector.max_bucket_size()
-            );
+            if let Some(similar_path_detector) = &self.similar_path_detector {
+                copious_debugging!(
+                    "    Max similar path bucket size: {}",
+                    similar_path_detector.max_bucket_size()
+                );
+            }
             copious_debugging!("==> End phase {}", self.phase_number);
             self.phase_number += 1;
         }
@@ -772,7 +788,7 @@ pub struct ForwardPartialPathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
-    similar_path_detector: SimilarPathDetector<PartialPath>,
+    similar_path_detector: Option<SimilarPathDetector<PartialPath>>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -837,7 +853,7 @@ impl ForwardPartialPathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            similar_path_detector: SimilarPathDetector::new(),
+            similar_path_detector: None,
             // 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")]
@@ -874,7 +890,7 @@ impl ForwardPartialPathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            similar_path_detector: SimilarPathDetector::new(),
+            similar_path_detector: None,
             // 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")]
@@ -902,6 +918,18 @@ impl ForwardPartialPathStitcher {
         self.next_iteration.0.as_mut_slices().0
     }
 
+    /// Sets whether similar path detection should be enabled during path stitching. Paths are similar
+    /// if start and end node, and pre- and postconditions are the same. The presence of similar paths
+    /// can lead to exponential blow up during path stitching. Similar path detection is disabled by
+    /// default because of the accociated preformance cost.
+    pub fn set_similar_path_detection(&mut self, detect_similar_paths: bool) {
+        if detect_similar_paths {
+            self.similar_path_detector = Some(SimilarPathDetector::new());
+        } else {
+            self.similar_path_detector = None;
+        }
+    }
+
     /// Sets the maximum amount of work that can be performed during each phase of the algorithm.
     /// By bounding our work this way, you can ensure that it's not possible for our CPU-bound
     /// algorithm to starve any worker threads or processes that you might be using.  If you don't
@@ -978,14 +1006,16 @@ impl ForwardPartialPathStitcher {
                     copious_debugging!("        is invalid: cyclic");
                     continue;
                 }
-                if self.similar_path_detector.has_similar_path(
-                    graph,
-                    partials,
-                    &new_partial_path,
-                    |ps, left, right| left.equals(ps, right),
-                ) {
-                    copious_debugging!("        is invalid: too many similar");
-                    continue;
+                if let Some(similar_path_detector) = &mut self.similar_path_detector {
+                    if similar_path_detector.has_similar_path(
+                        graph,
+                        partials,
+                        &new_partial_path,
+                        |ps, left, right| left.equals(ps, right),
+                    ) {
+                        copious_debugging!("        is invalid: too many similar");
+                        continue;
+                    }
                 }
             }
             self.next_iteration.0.push_back(new_partial_path);
@@ -1037,10 +1067,12 @@ impl ForwardPartialPathStitcher {
 
         #[cfg(feature = "copious-debugging")]
         {
-            copious_debugging!(
-                "    Max similar path bucket size: {}",
-                self.similar_path_detector.max_bucket_size()
-            );
+            if let Some(similar_path_detector) = &self.similar_path_detector {
+                copious_debugging!(
+                    "    Max similar path bucket size: {}",
+                    similar_path_detector.max_bucket_size()
+                );
+            }
             copious_debugging!("==> End phase {}", self.phase_number);
             self.phase_number += 1;
         }