Put IngredientIndex into SyncTable

Author: Veykril

src/function.rs

@@ -160,7 +160,7 @@ where
             lru: lru::Lru::new(lru),
             deleted_entries: Default::default(),
             view_caster,
-            sync_table: Default::default(),
+            sync_table: SyncTable::new(index),
         }
     }
 
@@ -252,10 +252,7 @@ where
     /// Attempts to claim `key_index`, returning `false` if a cycle occurs.
     fn wait_for(&self, db: &dyn Database, key_index: Id) -> bool {
         let zalsa = db.zalsa();
-        match self
-            .sync_table
-            .try_claim(db, zalsa, self.database_key_index(key_index))
-        {
+        match self.sync_table.try_claim(db, zalsa, key_index) {
             ClaimResult::Retry | ClaimResult::Claimed(_) => true,
             ClaimResult::Cycle => false,
         }

src/function/fetch.rs

@@ -104,12 +104,11 @@ where
         id: Id,
         memo_ingredient_index: MemoIngredientIndex,
     ) -> Option<&'db Memo<C::Output<'db>>> {
-        let database_key_index = self.database_key_index(id);
-
         // Try to claim this query: if someone else has claimed it already, go back and start again.
-        let _claim_guard = match self.sync_table.try_claim(db, zalsa, database_key_index) {
+        let _claim_guard = match self.sync_table.try_claim(db, zalsa, id) {
             ClaimResult::Retry => return None,
             ClaimResult::Cycle => {
+                let database_key_index = self.database_key_index(id);
                 // check if there's a provisional value for this query
                 // Note we don't `validate_may_be_provisional` the memo here as we want to reuse an
                 // existing provisional memo if it exists
@@ -125,7 +124,7 @@ where
                 }
                 // no provisional value; create/insert/return initial provisional value
                 return self
-                    .initial_value(db, database_key_index.key_index())
+                    .initial_value(db, id)
                     .map(|initial_value| {
                         tracing::debug!(
                             "hit cycle at {database_key_index:#?}, \
@@ -156,7 +155,7 @@ where
         };
 
         // Push the query on the stack.
-        let active_query = db.zalsa_local().push_query(database_key_index);
+        let active_query = db.zalsa_local().push_query(self.database_key_index(id));
 
         // Now that we've claimed the item, check again to see if there's a "hot" value.
         let opt_old_memo = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);

src/function/maybe_changed_after.rs

@@ -98,7 +98,7 @@ where
     ) -> Option<VerifyResult> {
         let database_key_index = self.database_key_index(key_index);
 
-        let _claim_guard = match self.sync_table.try_claim(db, zalsa, database_key_index) {
+        let _claim_guard = match self.sync_table.try_claim(db, zalsa, key_index) {
             ClaimResult::Retry => return None,
             ClaimResult::Cycle => match C::CYCLE_STRATEGY {
                 CycleRecoveryStrategy::Panic => panic!(

src/function/sync.rs

@@ -7,14 +7,14 @@ use crate::{
     key::DatabaseKeyIndex,
     runtime::{BlockResult, WaitResult},
     zalsa::Zalsa,
-    Database, Id,
+    Database, Id, IngredientIndex,
 };
 
 /// Tracks the keys that are currently being processed; used to coordinate between
 /// worker threads.
-#[derive(Default)]
 pub(crate) struct SyncTable {
     syncs: Mutex<FxHashMap<Id, SyncState>>,
+    ingredient: IngredientIndex,
 }
 
 pub(crate) enum ClaimResult<'a> {
@@ -32,14 +32,21 @@ struct SyncState {
 }
 
 impl SyncTable {
+    pub(crate) fn new(ingredient: IngredientIndex) -> Self {
+        Self {
+            syncs: Default::default(),
+            ingredient,
+        }
+    }
+
     pub(crate) fn try_claim<'me>(
         &'me self,
         db: &'me (impl ?Sized + Database),
         zalsa: &'me Zalsa,
-        database_key_index: DatabaseKeyIndex,
+        key_index: Id,
     ) -> ClaimResult<'me> {
         let mut write = self.syncs.lock();
-        match write.entry(database_key_index.key_index()) {
+        match write.entry(key_index) {
             std::collections::hash_map::Entry::Occupied(occupied_entry) => {
                 let &mut SyncState {
                     id,
@@ -55,7 +62,7 @@ impl SyncTable {
                 match zalsa.runtime().block_on(
                     db.as_dyn_database(),
                     db.zalsa_local(),
-                    database_key_index,
+                    DatabaseKeyIndex::new(self.ingredient, key_index),
                     id,
                     write,
                 ) {
@@ -69,7 +76,7 @@ impl SyncTable {
                     anyone_waiting: false,
                 });
                 ClaimResult::Claimed(ClaimGuard {
-                    database_key_index,
+                    key_index,
                     zalsa,
                     sync_table: self,
                     _padding: false,
@@ -83,7 +90,7 @@ impl SyncTable {
 /// released when this value is dropped.
 #[must_use]
 pub(crate) struct ClaimGuard<'me> {
-    database_key_index: DatabaseKeyIndex,
+    key_index: Id,
     zalsa: &'me Zalsa,
     sync_table: &'me SyncTable,
     // Reduce the size of ClaimResult by making more niches available in ClaimGuard; this fits into
@@ -95,14 +102,13 @@ impl ClaimGuard<'_> {
     fn remove_from_map_and_unblock_queries(&self) {
         let mut syncs = self.sync_table.syncs.lock();
 
-        let SyncState { anyone_waiting, .. } =
-            syncs.remove(&self.database_key_index.key_index()).unwrap();
+        let SyncState { anyone_waiting, .. } = syncs.remove(&self.key_index).unwrap();
 
         drop(syncs);
 
         if anyone_waiting {
             self.zalsa.runtime().unblock_queries_blocked_on(
-                self.database_key_index,
+                DatabaseKeyIndex::new(self.sync_table.ingredient, self.key_index),
                 if std::thread::panicking() {
                     WaitResult::Panicked
                 } else {