Lazy fetching

Author: Veykril

src/function.rs

@@ -5,6 +5,7 @@ use crate::{
     cycle::CycleRecoveryStrategy,
     ingredient::{fmt_index, MaybeChangedAfter},
     key::DatabaseKeyIndex,
+    plumbing::MemoIngredientMap,
     salsa_struct::SalsaStructInDb,
     table::Table,
     zalsa::{IngredientIndex, MemoIngredientIndex, Zalsa},
@@ -194,7 +195,7 @@ where
 
     #[inline]
     fn memo_ingredient_index(&self, zalsa: &Zalsa, id: Id) -> MemoIngredientIndex {
-        self.memo_ingredient_indices[zalsa.ingredient_index(id)]
+        self.memo_ingredient_indices.get_zalsa_id(zalsa, id)
     }
 }
 
@@ -254,7 +255,7 @@ where
             Self::evict_value_from_memo_for(
                 table.memos_mut(evict),
                 &self.deleted_entries,
-                self.memo_ingredient_indices[ingredient_index],
+                self.memo_ingredient_indices.get(ingredient_index),
             )
         });
         std::mem::take(&mut self.deleted_entries);

src/function/maybe_changed_after.rs

@@ -2,7 +2,6 @@ use crate::{
     accumulator::accumulated_map::InputAccumulatedValues,
     ingredient::MaybeChangedAfter,
     key::DatabaseKeyIndex,
-    plumbing::ZalsaLocal,
     zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase},
     zalsa_local::{ActiveQueryGuard, QueryEdge, QueryOrigin},
     AsDynDatabase as _, Id, Revision,
@@ -40,14 +39,9 @@ where
                     };
                 }
                 drop(memo_guard); // release the arc-swap guard before cold path
-                if let Some(mcs) = self.maybe_changed_after_cold(
-                    zalsa,
-                    db.zalsa_local(),
-                    db,
-                    id,
-                    revision,
-                    memo_ingredient_index,
-                ) {
+                if let Some(mcs) =
+                    self.maybe_changed_after_cold(zalsa, db, id, revision, memo_ingredient_index)
+                {
                     return mcs;
                 } else {
                     // We failed to claim, have to retry.
@@ -62,14 +56,14 @@ where
     fn maybe_changed_after_cold<'db>(
         &'db self,
         zalsa: &Zalsa,
-        zalsa_local: &ZalsaLocal,
         db: &'db C::DbView,
         key_index: Id,
         revision: Revision,
         memo_ingredient_index: MemoIngredientIndex,
     ) -> Option<MaybeChangedAfter> {
         let database_key_index = self.database_key_index(key_index);
 
+        let zalsa_local = db.zalsa_local();
         let _claim_guard = zalsa.sync_table_for(key_index).claim(
             db.as_dyn_database(),
             zalsa,

src/lib.rs

@@ -92,7 +92,7 @@ pub mod plumbing {
     pub use crate::ingredient::Jar;
     pub use crate::key::DatabaseKeyIndex;
     pub use crate::memo_ingredient_indices::{
-        IngredientIndices, MemoIngredientIndices, MemoIngredientSingletonIndex,
+        IngredientIndices, MemoIngredientIndices, MemoIngredientMap, MemoIngredientSingletonIndex,
     };
     pub use crate::revision::Revision;
     pub use crate::runtime::stamp;

src/memo_ingredient_indices.rs

@@ -1,7 +1,5 @@
-use std::ops;
-
 use crate::zalsa::{MemoIngredientIndex, Zalsa};
-use crate::IngredientIndex;
+use crate::{Id, IngredientIndex};
 
 /// An ingredient has an [ingredient index][IngredientIndex]. However, Salsa also supports
 /// enums of salsa structs (and other salsa enums), and those don't have a constant ingredient index,
@@ -89,24 +87,28 @@ pub struct MemoIngredientIndices {
     indices: Box<[MemoIngredientIndex]>,
 }
 
-impl ops::Index<IngredientIndex> for MemoIngredientIndices {
-    type Output = MemoIngredientIndex;
-
-    #[inline]
-    fn index(&self, index: IngredientIndex) -> &Self::Output {
-        &self.indices[index.as_usize()]
+impl MemoIngredientMap for MemoIngredientIndices {
+    #[inline(always)]
+    fn get_zalsa_id(&self, zalsa: &Zalsa, id: Id) -> MemoIngredientIndex {
+        self.get(zalsa.ingredient_index(id))
+    }
+    #[inline(always)]
+    fn get(&self, index: IngredientIndex) -> MemoIngredientIndex {
+        self.indices[index.as_usize()]
     }
 }
 
 #[derive(Debug)]
 pub struct MemoIngredientSingletonIndex(MemoIngredientIndex);
 
-impl ops::Index<IngredientIndex> for MemoIngredientSingletonIndex {
-    type Output = MemoIngredientIndex;
-
-    #[inline]
-    fn index(&self, _: IngredientIndex) -> &Self::Output {
-        &self.0
+impl MemoIngredientMap for MemoIngredientSingletonIndex {
+    #[inline(always)]
+    fn get_zalsa_id(&self, _: &Zalsa, _: Id) -> MemoIngredientIndex {
+        self.0
+    }
+    #[inline(always)]
+    fn get(&self, _: IngredientIndex) -> MemoIngredientIndex {
+        self.0
     }
 }
 
@@ -120,3 +122,8 @@ impl From<(&Zalsa, IngredientIndices, IngredientIndex)> for MemoIngredientSingle
         Self(zalsa.next_memo_ingredient_index(struct_ingredient, ingredient))
     }
 }
+
+pub trait MemoIngredientMap: Send + Sync {
+    fn get_zalsa_id(&self, zalsa: &Zalsa, id: Id) -> MemoIngredientIndex;
+    fn get(&self, index: IngredientIndex) -> MemoIngredientIndex;
+}

src/salsa_struct.rs

@@ -1,13 +1,11 @@
 use std::any::TypeId;
 
-use crate::memo_ingredient_indices::IngredientIndices;
+use crate::memo_ingredient_indices::{IngredientIndices, MemoIngredientMap};
 use crate::zalsa::Zalsa;
 use crate::Id;
 
 pub trait SalsaStructInDb: Sized {
-    type MemoIngredientMap: std::ops::Index<crate::IngredientIndex, Output = crate::zalsa::MemoIngredientIndex>
-        + Send
-        + Sync;
+    type MemoIngredientMap: MemoIngredientMap;
 
     /// Lookup or create ingredient indices.
     ///