.

Author: Veykril

src/function/accumulated.rs

@@ -95,8 +95,9 @@ where
         db: &'db C::DbView,
         key: Id,
     ) -> (Option<&'db AccumulatedMap>, InputAccumulatedValues) {
-        // NEXT STEP: stash and refactor `fetch` to return an `&Memo` so we can make this work
-        let memo = self.refresh_memo(db, db.zalsa(), key);
+        // NEXT STEP: stash and refactor `fetch` to return an `&Memo` so we can make this work'
+        let (zalsa, zalsa_local) = db.zalsas();
+        let memo = self.refresh_memo(db, zalsa, zalsa_local, key);
         (
             memo.revisions.accumulated.as_deref(),
             memo.revisions.accumulated_inputs.load(),

src/function/fetch.rs

@@ -3,6 +3,7 @@ use crate::function::memo::Memo;
 use crate::function::sync::ClaimResult;
 use crate::function::{Configuration, IngredientImpl, VerifyResult};
 use crate::loom::sync::AtomicMut;
+use crate::plumbing::ZalsaLocal;
 use crate::zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase};
 use crate::zalsa_local::QueryRevisions;
 use crate::Id;
@@ -15,7 +16,7 @@ where
         let (zalsa, zalsa_local) = db.zalsas();
         zalsa.unwind_if_revision_cancelled(zalsa_local);
 
-        let memo = self.refresh_memo(db, zalsa, id);
+        let memo = self.refresh_memo(db, zalsa, zalsa_local, id);
         // SAFETY: We just refreshed the memo so it is guaranteed to contain a value now.
         let memo_value = unsafe { memo.value.as_ref().unwrap_unchecked() };
 
@@ -38,13 +39,14 @@ where
         &'db self,
         db: &'db C::DbView,
         zalsa: &'db Zalsa,
+        zalsa_local: &'db ZalsaLocal,
         id: Id,
     ) -> &'db Memo<C::Output<'db>> {
         let memo_ingredient_index = self.memo_ingredient_index(zalsa, id);
         loop {
             if let Some(memo) = self
                 .fetch_hot(zalsa, id, memo_ingredient_index)
-                .or_else(|| self.fetch_cold(zalsa, db, id, memo_ingredient_index))
+                .or_else(|| self.fetch_cold(db, zalsa, zalsa_local, id, memo_ingredient_index))
             {
                 // If we get back a provisional cycle memo, and it's provisional on any cycle heads
                 // that are claimed by a different thread, we can't propagate the provisional memo
@@ -91,8 +93,9 @@ where
     #[inline(never)]
     fn fetch_cold<'db>(
         &'db self,
-        zalsa: &'db Zalsa,
         db: &'db C::DbView,
+        zalsa: &'db Zalsa,
+        zalsa_local: &'db ZalsaLocal,
         id: Id,
         memo_ingredient_index: MemoIngredientIndex,
     ) -> Option<&'db Memo<C::Output<'db>>> {
@@ -120,7 +123,7 @@ where
                 }
                 // no provisional value; create/insert/return initial provisional value
                 return match C::CYCLE_STRATEGY {
-                    CycleRecoveryStrategy::Panic => db.zalsa_local().with_query_stack(|stack| {
+                    CycleRecoveryStrategy::Panic => zalsa_local.with_query_stack(|stack| {
                         panic!(
                             "dependency graph cycle when querying {database_key_index:#?}, \
                             set cycle_fn/cycle_initial to fixpoint iterate.\n\
@@ -147,7 +150,7 @@ where
                         tracing::debug!(
                             "hit a `FallbackImmediate` cycle at {database_key_index:#?}"
                         );
-                        let active_query = db.zalsa_local().push_query(database_key_index, 0);
+                        let active_query = zalsa_local.push_query(database_key_index, 0);
                         let fallback_value = self.initial_value(db, id).expect(
                             "`CycleRecoveryStrategy::FallbackImmediate` should have initial_value",
                         );
@@ -171,9 +174,13 @@ where
         let opt_old_memo = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);
         if let Some(old_memo) = opt_old_memo {
             if old_memo.value.is_some() {
-                if let VerifyResult::Unchanged(_, cycle_heads) =
-                    self.deep_verify_memo(db, zalsa, old_memo, self.database_key_index(id))
-                {
+                if let VerifyResult::Unchanged(_, cycle_heads) = self.deep_verify_memo(
+                    db,
+                    zalsa,
+                    zalsa_local,
+                    old_memo,
+                    self.database_key_index(id),
+                ) {
                     if cycle_heads.is_empty() {
                         // SAFETY: memo is present in memo_map and we have verified that it is
                         // still valid for the current revision.
@@ -185,7 +192,7 @@ where
 
         let memo = self.execute(
             db,
-            db.zalsa_local().push_query(self.database_key_index(id), 0),
+            zalsa_local.push_query(self.database_key_index(id), 0),
             opt_old_memo,
         );
 

src/function/maybe_changed_after.rs

@@ -107,8 +107,9 @@ where
             }
 
             if let Some(mcs) = self.maybe_changed_after_cold(
-                zalsa,
                 db,
+                zalsa,
+                zalsa_local,
                 id,
                 revision,
                 memo_ingredient_index,
@@ -122,37 +123,41 @@ where
     }
 
     #[inline(never)]
+    #[allow(clippy::too_many_arguments)]
     fn maybe_changed_after_cold<'db>(
         &'db self,
-        zalsa: &Zalsa,
         db: &'db C::DbView,
+        zalsa: &Zalsa,
+        zalsa_local: &ZalsaLocal,
         key_index: Id,
         revision: Revision,
         memo_ingredient_index: MemoIngredientIndex,
         in_cycle: bool,
     ) -> Option<VerifyResult> {
-        let database_key_index = self.database_key_index(key_index);
-
         let _claim_guard = match self.sync_table.try_claim(zalsa, key_index) {
             ClaimResult::Retry => return None,
             ClaimResult::Cycle => match C::CYCLE_STRATEGY {
-                CycleRecoveryStrategy::Panic => db.zalsa_local().with_query_stack(|stack| {
-                    panic!(
-                        "dependency graph cycle when validating {database_key_index:#?}, \
+                CycleRecoveryStrategy::Panic => {
+                    let database_key_index = self.database_key_index(key_index);
+                    zalsa_local.with_query_stack(|stack| {
+                        panic!(
+                            "dependency graph cycle when validating {database_key_index:#?}, \
                             set cycle_fn/cycle_initial to fixpoint iterate.\n\
                             Query stack:\n{stack:#?}",
-                    );
-                }),
+                        );
+                    })
+                }
                 CycleRecoveryStrategy::FallbackImmediate => {
                     return Some(VerifyResult::unchanged());
                 }
                 CycleRecoveryStrategy::Fixpoint => {
                     tracing::debug!(
-                        "hit cycle at {database_key_index:?} in `maybe_changed_after`,  returning fixpoint initial value",
+                        "hit cycle at {:?} in `maybe_changed_after`,  returning fixpoint initial value",
+                        self.database_key_index(key_index)
                     );
                     return Some(VerifyResult::Unchanged(
                         InputAccumulatedValues::Empty,
-                        CycleHeads::initial(database_key_index),
+                        CycleHeads::initial(self.database_key_index(key_index)),
                     ));
                 }
             },
@@ -165,13 +170,20 @@ where
         };
 
         tracing::debug!(
-            "{database_key_index:?}: maybe_changed_after_cold, successful claim, \
+            "{:?}: maybe_changed_after_cold, successful claim, \
                 revision = {revision:?}, old_memo = {old_memo:#?}",
-            old_memo = old_memo.tracing_debug()
+            self.database_key_index(key_index),
+            old_memo = old_memo.tracing_debug(),
         );
 
         // Check if the inputs are still valid. We can just compare `changed_at`.
-        let deep_verify = self.deep_verify_memo(db, zalsa, old_memo, database_key_index);
+        let deep_verify = self.deep_verify_memo(
+            db,
+            zalsa,
+            zalsa_local,
+            old_memo,
+            self.database_key_index(key_index),
+        );
         if deep_verify.is_unchanged() {
             return Some(if old_memo.revisions.changed_at > revision {
                 VerifyResult::Changed(deep_verify.into_cycle_heads())
@@ -194,7 +206,7 @@ where
         // `in_cycle` tracks if the enclosing query is in a cycle. `deep_verify.cycle_heads` tracks
         // if **this query** encountered a cycle (which means there's some provisional value somewhere floating around).
         if old_memo.value.is_some() && !in_cycle && deep_verify.cycle_heads().is_empty() {
-            let active_query = db.zalsa_local().push_query(database_key_index, 0);
+            let active_query = zalsa_local.push_query(self.database_key_index(key_index), 0);
             let memo = self.execute(db, active_query, Some(old_memo));
             let changed_at = memo.revisions.changed_at;
 
@@ -375,6 +387,7 @@ where
         &self,
         db: &C::DbView,
         zalsa: &Zalsa,
+        zalsa_local: &ZalsaLocal,
         old_memo: &Memo<C::Output<'_>>,
         database_key_index: DatabaseKeyIndex,
     ) -> VerifyResult {
@@ -386,12 +399,7 @@ where
         let shallow_update = self.shallow_verify_memo(zalsa, database_key_index, old_memo);
         let shallow_update_possible = shallow_update.is_some();
         if let Some(shallow_update) = shallow_update {
-            if self.validate_may_be_provisional(
-                zalsa,
-                db.zalsa_local(),
-                database_key_index,
-                old_memo,
-            ) {
+            if self.validate_may_be_provisional(zalsa, zalsa_local, database_key_index, old_memo) {
                 self.update_shallow(zalsa, database_key_index, old_memo, shallow_update);
 
                 return VerifyResult::unchanged();