extract cache into its own, shared structure

Author: nikomatsakis

chalk-integration/src/lib.rs

@@ -14,7 +14,7 @@ pub mod tls;
 use chalk_engine::solve::SLGSolver;
 use chalk_ir::interner::HasInterner;
 use chalk_ir::Binders;
-use chalk_recursive::RecursiveSolver;
+use chalk_recursive::{Cache, RecursiveSolver};
 use chalk_solve::Solver;
 use interner::ChalkIr;
 
@@ -104,7 +104,11 @@ impl SolverChoice {
             } => Box::new(RecursiveSolver::new(
                 overflow_depth,
                 max_size,
-                caching_enabled,
+                if caching_enabled {
+                    Some(Cache::default())
+                } else {
+                    None
+                },
             )),
         }
     }

chalk-recursive/src/cache.rs

@@ -0,0 +1,66 @@
+use crate::UCanonicalGoal;
+use chalk_ir::interner::Interner;
+use chalk_ir::Fallible;
+use chalk_solve::Solution;
+use rustc_hash::FxHashMap;
+use std::sync::{Arc, Mutex};
+use tracing::debug;
+use tracing::instrument;
+/// The "cache" stores results for goals that we have completely solved.
+/// Things are added to the cache when we have completely processed their
+/// result, and it can be shared amongst many solvers.
+pub struct Cache<I: Interner> {
+    data: Arc<Mutex<CacheData<I>>>,
+}
+struct CacheData<I: Interner> {
+    cache: FxHashMap<UCanonicalGoal<I>, Fallible<Solution<I>>>,
+}
+
+impl<I: Interner> Cache<I> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Record a cache result.
+    #[instrument(skip(self))]
+    pub fn insert(&self, goal: UCanonicalGoal<I>, result: Fallible<Solution<I>>) {
+        let mut data = self.data.lock().unwrap();
+        data.cache.insert(goal, result);
+    }
+
+    /// Record a cache result.
+    pub fn get(&self, goal: &UCanonicalGoal<I>) -> Option<Fallible<Solution<I>>> {
+        let data = self.data.lock().unwrap();
+        if let Some(result) = data.cache.get(&goal) {
+            debug!(?goal, ?result, "Cache hit");
+            Some(result.clone())
+        } else {
+            debug!(?goal, "Cache miss");
+            None
+        }
+    }
+}
+
+impl<I: Interner> Clone for Cache<I> {
+    fn clone(&self) -> Self {
+        Self {
+            data: self.data.clone(),
+        }
+    }
+}
+
+impl<I: Interner> Default for Cache<I> {
+    fn default() -> Self {
+        Self {
+            data: Default::default(),
+        }
+    }
+}
+
+impl<I: Interner> Default for CacheData<I> {
+    fn default() -> Self {
+        Self {
+            cache: Default::default(),
+        }
+    }
+}

chalk-recursive/src/lib.rs

@@ -3,13 +3,15 @@ use chalk_ir::{Goal, InEnvironment, UCanonical};
 
 pub type UCanonicalGoal<I> = UCanonical<InEnvironment<Goal<I>>>;
 
+mod cache;
 mod combine;
 mod fulfill;
 mod recursive;
 mod search_graph;
 pub mod solve;
 mod stack;
 
+pub use cache::Cache;
 pub use recursive::RecursiveSolver;
 
 /// The `minimums` struct is used while solving to track whether we encountered

chalk-recursive/src/recursive.rs

@@ -1,3 +1,4 @@
+use crate::cache::Cache;
 use crate::search_graph::DepthFirstNumber;
 use crate::search_graph::SearchGraph;
 use crate::solve::{SolveDatabase, SolveIteration};
@@ -7,7 +8,6 @@ use chalk_ir::Fallible;
 use chalk_ir::{interner::Interner, NoSolution};
 use chalk_ir::{Canonical, ConstrainedSubst, Goal, InEnvironment, UCanonical};
 use chalk_solve::{coinductive_goal::IsCoinductive, RustIrDatabase, Solution};
-use rustc_hash::FxHashMap;
 use std::fmt;
 use tracing::debug;
 use tracing::{info, instrument};
@@ -22,12 +22,10 @@ struct RecursiveContext<I: Interner> {
     /// The "cache" stores results for goals that we have completely solved.
     /// Things are added to the cache when we have completely processed their
     /// result.
-    cache: FxHashMap<UCanonicalGoal<I>, Fallible<Solution<I>>>,
+    cache: Option<Cache<I>>,
 
     /// The maximum size for goals.
     max_size: usize,
-
-    caching_enabled: bool,
 }
 
 /// A Solver is the basic context in which you can propose goals for a given
@@ -45,13 +43,9 @@ pub struct RecursiveSolver<I: Interner> {
 }
 
 impl<I: Interner> RecursiveSolver<I> {
-    pub fn new(overflow_depth: usize, max_size: usize, caching_enabled: bool) -> Self {
+    pub fn new(overflow_depth: usize, max_size: usize, cache: Option<Cache<I>>) -> Self {
         Self {
-            ctx: Box::new(RecursiveContext::new(
-                overflow_depth,
-                max_size,
-                caching_enabled,
-            )),
+            ctx: Box::new(RecursiveContext::new(overflow_depth, max_size, cache)),
         }
     }
 }
@@ -83,13 +77,12 @@ impl<T> MergeWith<T> for Fallible<T> {
 }
 
 impl<I: Interner> RecursiveContext<I> {
-    pub fn new(overflow_depth: usize, max_size: usize, caching_enabled: bool) -> Self {
+    pub fn new(overflow_depth: usize, max_size: usize, cache: Option<Cache<I>>) -> Self {
         RecursiveContext {
             stack: Stack::new(overflow_depth),
             search_graph: SearchGraph::new(),
-            cache: FxHashMap::default(),
+            cache,
             max_size,
-            caching_enabled,
         }
     }
 
@@ -202,9 +195,11 @@ impl<'me, I: Interner> SolveDatabase<I> for Solver<'me, I> {
         minimums: &mut Minimums,
     ) -> Fallible<Solution<I>> {
         // First check the cache.
-        if let Some(value) = self.context.cache.get(&goal) {
-            debug!("solve_reduced_goal: cache hit, value={:?}", value);
-            return value.clone();
+        if let Some(cache) = &self.context.cache {
+            if let Some(value) = cache.get(&goal) {
+                debug!("solve_reduced_goal: cache hit, value={:?}", value);
+                return value.clone();
+            }
         }
 
         // Next, check if the goal is in the search tree already.
@@ -260,10 +255,8 @@ impl<'me, I: Interner> SolveDatabase<I> for Solver<'me, I> {
             // cache now. This is a sort of hack to alleviate the
             // worst of the repeated work that we do during tabling.
             if subgoal_minimums.positive >= dfn {
-                if self.context.caching_enabled {
-                    self.context
-                        .search_graph
-                        .move_to_cache(dfn, &mut self.context.cache);
+                if let Some(cache) = &mut self.context.cache {
+                    self.context.search_graph.move_to_cache(dfn, cache);
                     debug!("solve_reduced_goal: SCC head encountered, moving to cache");
                 } else {
                     debug!(

chalk-recursive/src/search_graph.rs

@@ -4,7 +4,7 @@ use std::ops::IndexMut;
 use std::usize;
 
 use super::stack::StackDepth;
-use crate::{Minimums, UCanonicalGoal};
+use crate::{Cache, Minimums, UCanonicalGoal};
 use chalk_ir::{
     interner::Interner, Canonical, ClausePriority, ConstrainedSubst, Constraints, Fallible,
     NoSolution,
@@ -104,12 +104,8 @@ impl<I: Interner> SearchGraph<I> {
 
     /// Removes all nodes with a depth-first-number greater than or
     /// equal to `dfn`, adding their final solutions into the cache.
-    #[instrument(level = "debug", skip(self))]
-    pub(crate) fn move_to_cache(
-        &mut self,
-        dfn: DepthFirstNumber,
-        cache: &mut FxHashMap<UCanonicalGoal<I>, Fallible<Solution<I>>>,
-    ) {
+    #[instrument(level = "debug", skip(self, cache))]
+    pub(crate) fn move_to_cache(&mut self, dfn: DepthFirstNumber, cache: &Cache<I>) {
         self.indices.retain(|_key, value| *value < dfn);
         for node in self.nodes.drain(dfn.index..) {
             assert!(node.stack_depth.is_none());