Implement similar path detection based on equals

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -30,6 +30,8 @@
 //! any time.
 
 use enumset::EnumSet;
+use smallvec::SmallVec;
+use std::collections::HashMap;
 
 use crate::arena::Handle;
 use crate::arena::List;
@@ -40,10 +42,110 @@ use crate::graph::StackGraph;
 use crate::partial::Cyclicity;
 use crate::partial::PartialPath;
 use crate::partial::PartialPaths;
+use crate::paths::Path;
 use crate::paths::PathResolutionError;
+use crate::paths::Paths;
 use crate::stitching::Database;
 use crate::stitching::OwnedOrDatabasePath;
 
+/// Helps detect similar paths in the path-finding algorithm.
+pub struct SimilarPathDetector<P> {
+    paths: HashMap<PathKey, SmallVec<[P; 8]>>,
+}
+
+#[doc(hidden)]
+#[derive(Clone, Eq, Hash, PartialEq)]
+pub struct PathKey {
+    start_node: Handle<Node>,
+    end_node: Handle<Node>,
+    symbol_stack_precondition_len: usize,
+    scope_stack_precondition_len: usize,
+    symbol_stack_postcondition_len: usize,
+    scope_stack_postcondition_len: usize,
+}
+
+#[doc(hidden)]
+pub trait HasPathKey: Clone {
+    type Arena;
+    fn key(&self) -> PathKey;
+}
+
+impl HasPathKey for Path {
+    type Arena = Paths;
+
+    fn key(&self) -> PathKey {
+        PathKey {
+            start_node: self.start_node,
+            end_node: self.end_node,
+            symbol_stack_precondition_len: 0,
+            scope_stack_precondition_len: 0,
+            symbol_stack_postcondition_len: self.symbol_stack.len(),
+            scope_stack_postcondition_len: self.scope_stack.len(),
+        }
+    }
+}
+
+impl HasPathKey for PartialPath {
+    type Arena = PartialPaths;
+
+    fn key(&self) -> PathKey {
+        PathKey {
+            start_node: self.start_node,
+            end_node: self.end_node,
+            symbol_stack_precondition_len: self.symbol_stack_precondition.len(),
+            scope_stack_precondition_len: self.scope_stack_precondition.len(),
+            symbol_stack_postcondition_len: self.symbol_stack_postcondition.len(),
+            scope_stack_postcondition_len: self.scope_stack_postcondition.len(),
+        }
+    }
+}
+
+impl<P> SimilarPathDetector<P>
+where
+    P: HasPathKey,
+{
+    /// Creates a new, empty cycle detector.
+    pub fn new() -> SimilarPathDetector<P> {
+        SimilarPathDetector {
+            paths: HashMap::new(),
+        }
+    }
+
+    /// Determines whether we should process this path during the path-finding algorithm.  If we have seen
+    /// a path with the same start and end node, and the same pre- and postcondition, then we return false.
+    /// Otherwise, we return true.
+    pub fn has_similar_path<Eq>(
+        &mut self,
+        graph: &StackGraph,
+        arena: &mut P::Arena,
+        path: &P,
+        eq: Eq,
+    ) -> bool
+    where
+        Eq: Fn(&mut P::Arena, &P, &P) -> bool,
+    {
+        let key = path.key();
+
+        if graph.incoming_edge_count(key.end_node) <= 1 {
+            // return false;
+        }
+
+        let possibly_similar_paths = self.paths.entry(key).or_default();
+        for other_path in possibly_similar_paths.iter() {
+            if eq(arena, path, other_path) {
+                return true;
+            }
+        }
+
+        possibly_similar_paths.push(path.clone());
+        false
+    }
+
+    pub fn max_bucket_size(&self) -> usize {
+        self.paths.iter().map(|b| b.1.len()).max().unwrap_or(0)
+    }
+}
+
 // ----------------------------------------------------------------------------
 // Cycle detector
 

stack-graphs/src/graph.rs

@@ -1301,6 +1301,7 @@ impl StackGraph {
         let edges = &mut self.outgoing_edges[source];
         if let Err(index) = edges.binary_search_by_key(&sink, |o| o.sink) {
             edges.insert(index, OutgoingEdge { sink, precedence });
+            self.incoming_edges[sink] += 1;
         }
     }
 
@@ -1323,6 +1324,14 @@ impl StackGraph {
             None => Either::Left(std::iter::empty()),
         }
     }
+
+    /// Returns an iterator of all of the edges that begin at a particular source node.
+    pub fn incoming_edge_count(&self, sink: Handle<Node>) -> usize {
+        match self.incoming_edges.get(sink) {
+            Some(count) => *count,
+            None => 0,
+        }
+    }
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -1410,6 +1419,7 @@ pub struct StackGraph {
     pub(crate) nodes: Arena<Node>,
     pub(crate) source_info: SupplementalArena<Node, SourceInfo>,
     node_id_handles: NodeIDHandles,
+    incoming_edges: SupplementalArena<Node, usize>,
     outgoing_edges: SupplementalArena<Node, SmallVec<[OutgoingEdge; 8]>>,
     pub(crate) debug_info: SupplementalArena<Node, DebugInfo>,
 }
@@ -1588,6 +1598,7 @@ impl Default for StackGraph {
             nodes,
             source_info: SupplementalArena::new(),
             node_id_handles: NodeIDHandles::new(),
+            incoming_edges: SupplementalArena::new(),
             outgoing_edges: SupplementalArena::new(),
             debug_info: SupplementalArena::new(),
         }

stack-graphs/src/partial.rs

@@ -48,6 +48,7 @@ use crate::arena::DequeArena;
 use crate::arena::Handle;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
+use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
 use crate::graph::File;
 use crate::graph::Node;
@@ -2464,6 +2465,7 @@ impl PartialPath {
         file: Handle<File>,
         edges: &mut Appendables<Edge>,
         path_cycle_detector: AppendingCycleDetector<Edge>,
+        similar_path_detector: &mut SimilarPathDetector<PartialPath>,
         result: &mut R,
     ) {
         let extensions = graph.outgoing_edges(self.end_node);
@@ -2479,13 +2481,21 @@ impl PartialPath {
                 continue;
             }
             let mut new_path = self.clone();
-            let mut new_cycle_detector = path_cycle_detector.clone();
             // If there are errors adding this edge to the partial path, or resolving the resulting
             // partial path, just skip the edge — it's not a fatal error.
             if new_path.append(graph, partials, extension).is_err() {
                 copious_debugging!("         * invalid extension");
                 continue;
             }
+            if similar_path_detector.has_similar_path(
+                graph,
+                partials,
+                &new_path,
+                |ps, left, right| left.equals(ps, right),
+            ) {
+                copious_debugging!("    * too many similar");
+            }
+            let mut new_cycle_detector = path_cycle_detector.clone();
             new_cycle_detector.append(edges, extension);
             result.push((new_path, new_cycle_detector));
         }
@@ -2792,6 +2802,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 = Appendables::new();
         queue.extend(
@@ -2827,10 +2838,15 @@ impl PartialPaths {
                     file,
                     &mut edges,
                     path_cycle_detector,
+                    &mut similar_path_detector,
                     &mut queue,
                 );
             }
         }
+        copious_debugging!(
+            " Max similar path bucket size: {}",
+            similar_path_detector.max_bucket_size()
+        );
         Ok(())
     }
 }

stack-graphs/src/paths.rs

@@ -28,6 +28,7 @@ use crate::arena::List;
 use crate::arena::ListArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
+use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
 use crate::graph::Node;
 use crate::graph::NodeID;
@@ -878,18 +879,24 @@ impl Path {
         paths: &mut Paths,
         edges: &mut Appendables<Edge>,
         path_cycle_detector: AppendingCycleDetector<Edge>,
+        similar_path_detector: &mut SimilarPathDetector<Path>,
         result: &mut R,
     ) {
         let extensions = graph.outgoing_edges(self.end_node);
         result.reserve(extensions.size_hint().0);
         for extension in extensions {
             let mut new_path = self.clone();
-            let mut new_cycle_detector = path_cycle_detector.clone();
             // If there are errors adding this edge to the path, or resolving the resulting path,
             // just skip the edge — it's not a fatal error.
             if new_path.append(graph, paths, extension).is_err() {
                 continue;
             }
+            if similar_path_detector.has_similar_path(graph, paths, &new_path, |ps, left, right| {
+                left.equals(ps, right)
+            }) {
+                continue;
+            }
+            let mut new_cycle_detector = path_cycle_detector.clone();
             new_cycle_detector.append(edges, extension);
             result.push((new_path, new_cycle_detector));
         }
@@ -917,6 +924,7 @@ impl Paths {
         I: IntoIterator<Item = Handle<Node>>,
         F: FnMut(&StackGraph, &mut Paths, Path),
     {
+        let mut similar_path_detector = SimilarPathDetector::new();
         let mut queue = starting_nodes
             .into_iter()
             .filter_map(|node| {
@@ -935,7 +943,14 @@ impl Paths {
                 .all(|c| c == Cyclicity::StrengthensPrecondition)
             {
             } else {
-                path.extend(graph, self, &mut edges, path_cycle_detector, &mut queue);
+                path.extend(
+                    graph,
+                    self,
+                    &mut edges,
+                    path_cycle_detector,
+                    &mut similar_path_detector,
+                    &mut queue,
+                );
             }
         }
         Ok(())

stack-graphs/src/stitching.rs

@@ -50,6 +50,7 @@ use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
+use crate::cycles::SimilarPathDetector;
 use crate::graph::Node;
 use crate::graph::StackGraph;
 use crate::graph::Symbol;
@@ -484,6 +485,7 @@ pub struct PathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
+    similar_path_detector: SimilarPathDetector<Path>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -535,6 +537,7 @@ impl PathStitcher {
             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,
             #[cfg(feature = "copious-debugging")]
@@ -631,6 +634,15 @@ impl PathStitcher {
                 copious_debugging!("        is invalid: cyclic");
                 continue;
             }
+            if self.similar_path_detector.has_similar_path(
+                graph,
+                paths,
+                &path,
+                |ps, left, right| left.equals(ps, right),
+            ) {
+                copious_debugging!("        is invalid: too many similar");
+                continue;
+            }
             copious_debugging!("        is {}", new_path.display(graph, paths));
             self.next_iteration.0.push_back(new_path);
             self.next_iteration.1.push_back(new_cycle_detector);
@@ -677,6 +689,10 @@ impl PathStitcher {
 
         #[cfg(feature = "copious-debugging")]
         {
+            copious_debugging!(
+                "    Max similar path bucket size: {}",
+                self.similar_path_detector.max_bucket_size()
+            );
             copious_debugging!("==> End phase {}", self.phase_number);
             self.phase_number += 1;
         }
@@ -756,6 +772,7 @@ pub struct ForwardPartialPathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
+    similar_path_detector: SimilarPathDetector<PartialPath>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -820,6 +837,7 @@ impl ForwardPartialPathStitcher {
             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,
             #[cfg(feature = "copious-debugging")]
@@ -856,6 +874,7 @@ impl ForwardPartialPathStitcher {
             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,
             #[cfg(feature = "copious-debugging")]
@@ -958,6 +977,15 @@ impl ForwardPartialPathStitcher {
                     copious_debugging!("        is invalid: cyclic");
                     continue;
                 }
+                if self.similar_path_detector.has_similar_path(
+                    graph,
+                    partials,
+                    &partial_path,
+                    |ps, left, right| left.equals(ps, right),
+                ) {
+                    copious_debugging!("        is invalid: too many similar");
+                    continue;
+                }
             }
             copious_debugging!("        is {}", new_partial_path.display(graph, partials));
             self.next_iteration.0.push_back(new_partial_path);
@@ -1009,6 +1037,10 @@ impl ForwardPartialPathStitcher {
 
         #[cfg(feature = "copious-debugging")]
         {
+            copious_debugging!(
+                "    Max similar path bucket size: {}",
+                self.similar_path_detector.max_bucket_size()
+            );
             copious_debugging!("==> End phase {}", self.phase_number);
             self.phase_number += 1;
         }