Experiment: Remove database usage from remove_stale_output

Author: Veykril

src/function/diff_outputs.rs

@@ -1,7 +1,7 @@
 use super::{memo::Memo, Configuration, IngredientImpl};
 use crate::{
     hash::FxHashSet, key::OutputDependencyIndex, zalsa::Zalsa, zalsa_local::QueryRevisions,
-    AsDynDatabase as _, Database, DatabaseKeyIndex, Event, EventKind,
+    Database, DatabaseKeyIndex, Event, EventKind,
 };
 
 impl<C> IngredientImpl<C>
@@ -56,6 +56,6 @@ where
             })
         });
 
-        output.remove_stale_output(zalsa, db.as_dyn_database(), key);
+        output.remove_stale_output(zalsa);
     }
 }

src/ingredient.rs

@@ -75,13 +75,8 @@ pub trait Ingredient: Any + std::fmt::Debug + Send + Sync {
     /// revision, but was NOT output in the current revision.
     ///
     /// This hook is used to clear out the stale value so others cannot read it.
-    fn remove_stale_output(
-        &self,
-        db: &dyn Database,
-        executor: DatabaseKeyIndex,
-        stale_output_key: Id,
-    ) {
-        let _ = (db, executor, stale_output_key);
+    fn remove_stale_output(&self, zalsa: &Zalsa, stale_output_key: Id) {
+        let _ = (zalsa, stale_output_key);
         unreachable!("only tracked struct ingredients can have stale outputs")
     }
 

src/key.rs

@@ -36,15 +36,10 @@ impl OutputDependencyIndex {
         }
     }
 
-    pub(crate) fn remove_stale_output(
-        &self,
-        zalsa: &Zalsa,
-        db: &dyn Database,
-        executor: DatabaseKeyIndex,
-    ) {
+    pub(crate) fn remove_stale_output(&self, zalsa: &Zalsa) {
         zalsa
             .lookup_ingredient(self.ingredient_index)
-            .remove_stale_output(db, executor, self.key_index)
+            .remove_stale_output(zalsa, self.key_index)
     }
 
     pub(crate) fn mark_validated_output(

src/table/memo.rs

@@ -221,30 +221,22 @@ impl MemoTable {
     ///
     /// The caller needs to make sure to not call this function until no more references into
     /// the database exist as there may be outstanding borrows into the pointer contents.
-    pub(crate) unsafe fn into_memos(
-        self,
-    ) -> impl Iterator<Item = (MemoIngredientIndex, Box<dyn Memo>)> {
+    pub(crate) unsafe fn into_memos(self) -> impl Iterator<Item = Box<dyn Memo>> {
         self.memos
             .into_inner()
             .into_iter()
-            .zip(0..)
-            .filter_map(|(mut memo, index)| memo.data.take().map(|d| (d, index)))
+            .filter_map(|mut memo| memo.data.take())
             .map(
-                |(
-                    MemoEntryData {
-                        type_id: _,
-                        to_dyn_fn,
-                        atomic_memo,
-                    },
-                    index,
-                )| {
+                |MemoEntryData {
+                     type_id: _,
+                     to_dyn_fn,
+                     atomic_memo,
+                 }| {
                     // SAFETY: The `atomic_memo` field is never null.
                     let memo =
                         unsafe { to_dyn_fn(NonNull::new_unchecked(atomic_memo.into_inner())) };
                     // SAFETY: The caller guarantees that there are no outstanding borrows into the `Box` contents.
-                    let memo = unsafe { Box::from_raw(memo.as_ptr()) };
-
-                    (MemoIngredientIndex::from_usize(index), memo)
+                    unsafe { Box::from_raw(memo.as_ptr()) }
                 },
             )
     }

src/tracked_struct.rs

@@ -13,7 +13,7 @@ use crate::{
     salsa_struct::SalsaStructInDb,
     table::{memo::MemoTable, sync::SyncTable, Slot, Table},
     zalsa::{IngredientIndex, Zalsa},
-    Database, Durability, Event, EventKind, Id, Revision,
+    Database, Durability, Id, Revision,
 };
 
 pub mod tracked_field;
@@ -584,14 +584,7 @@ where
     /// Using this method on an entity id that MAY be used in the current revision will lead to
     /// unspecified results (but not UB). See [`InternedIngredient::delete_index`] for more
     /// discussion and important considerations.
-    pub(crate) fn delete_entity(&self, db: &dyn crate::Database, id: Id) {
-        db.salsa_event(&|| {
-            Event::new(crate::EventKind::DidDiscard {
-                key: self.database_key_index(id),
-            })
-        });
-
-        let zalsa = db.zalsa();
+    pub(crate) fn delete_entity(&self, zalsa: &Zalsa, id: Id) {
         let current_revision = zalsa.current_revision();
         let data = Self::data_raw(zalsa.table(), id);
 
@@ -618,19 +611,9 @@ where
 
         // SAFETY: We have verified that no more references to these memos exist and so we are good
         // to drop them.
-        for (memo_ingredient_index, memo) in unsafe { memo_table.into_memos() } {
-            let ingredient_index =
-                zalsa.ingredient_index_for_memo(self.ingredient_index, memo_ingredient_index);
-
-            let executor = DatabaseKeyIndex {
-                ingredient_index,
-                key_index: id,
-            };
-
-            db.salsa_event(&|| Event::new(EventKind::DidDiscard { key: executor }));
-
+        for memo in unsafe { memo_table.into_memos() } {
             for stale_output in memo.origin().outputs() {
-                stale_output.remove_stale_output(zalsa, db, executor);
+                stale_output.remove_stale_output(zalsa);
             }
         }
 
@@ -756,17 +739,12 @@ where
         // FIXME: delete this method
     }
 
-    fn remove_stale_output(
-        &self,
-        db: &dyn Database,
-        _executor: DatabaseKeyIndex,
-        stale_output_key: crate::Id,
-    ) {
+    fn remove_stale_output(&self, zalsa: &Zalsa, stale_output_key: crate::Id) {
         // This method is called when, in prior revisions,
         // `executor` creates a tracked struct `salsa_output_key`,
         // but it did not in the current revision.
         // In that case, we can delete `stale_output_key` and any data associated with it.
-        self.delete_entity(db, stale_output_key);
+        self.delete_entity(zalsa, stale_output_key);
     }
 
     fn fmt_index(&self, index: Option<crate::Id>, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

src/zalsa.rs

@@ -220,15 +220,6 @@ impl Zalsa {
             .as_ref()
     }
 
-    pub(crate) fn ingredient_index_for_memo(
-        &self,
-        struct_ingredient_index: IngredientIndex,
-        memo_ingredient_index: MemoIngredientIndex,
-    ) -> IngredientIndex {
-        self.memo_ingredient_indices.read()[struct_ingredient_index.as_usize()]
-            [memo_ingredient_index.as_usize()]
-    }
-
     /// Starts unwinding the stack if the current revision is cancelled.
     ///
     /// This method can be called by query implementations that perform