Experiment: Remove database usage from mark_validated_output

Author: Veykril

src/function.rs

@@ -237,11 +237,11 @@ where
 
     fn mark_validated_output(
         &self,
-        db: &dyn Database,
+        zalsa: &Zalsa,
         executor: DatabaseKeyIndex,
         output_key: crate::Id,
     ) {
-        self.validate_specified_value(db, executor, output_key);
+        self.validate_specified_value(zalsa, executor, output_key);
     }
 
     fn requires_reset_for_new_revision(&self) -> bool {

src/function/fetch.rs

@@ -50,7 +50,7 @@ where
         let memo_ingredient_index = self.memo_ingredient_index(zalsa, id);
         loop {
             if let Some(memo) = self
-                .fetch_hot(zalsa, db, id, memo_ingredient_index)
+                .fetch_hot(zalsa, id, memo_ingredient_index)
                 .or_else(|| self.fetch_cold(zalsa, db, id, memo_ingredient_index))
             {
                 return memo;
@@ -62,14 +62,13 @@ where
     fn fetch_hot<'db>(
         &'db self,
         zalsa: &'db Zalsa,
-        db: &'db C::DbView,
         id: Id,
         memo_ingredient_index: MemoIngredientIndex,
     ) -> Option<&'db Memo<C::Output<'db>>> {
         let memo_guard = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);
         if let Some(memo) = memo_guard {
             if memo.value.is_some()
-                && self.shallow_verify_memo(db, zalsa, self.database_key_index(id), memo)
+                && self.shallow_verify_memo(zalsa, self.database_key_index(id), memo)
             {
                 // Unsafety invariant: memo is present in memo_map and we have verified that it is
                 // still valid for the current revision.

src/function/maybe_changed_after.rs

@@ -31,7 +31,7 @@ where
             // Check if we have a verified version: this is the hot path.
             let memo_guard = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);
             if let Some(memo) = memo_guard {
-                if self.shallow_verify_memo(db, zalsa, database_key_index, memo) {
+                if self.shallow_verify_memo(zalsa, database_key_index, memo) {
                     return if memo.revisions.changed_at > revision {
                         MaybeChangedAfter::Yes
                     } else {
@@ -118,7 +118,6 @@ where
     #[inline]
     pub(super) fn shallow_verify_memo(
         &self,
-        db: &C::DbView,
         zalsa: &Zalsa,
         database_key_index: DatabaseKeyIndex,
         memo: &Memo<C::Output<'_>>,
@@ -146,13 +145,8 @@ where
         );
         if last_changed <= verified_at {
             // No input of the suitable durability has changed since last verified.
-            memo.mark_as_verified(
-                db,
-                revision_now,
-                database_key_index,
-                memo.revisions.accumulated_inputs.load(),
-            );
-            memo.mark_outputs_as_verified(zalsa, db.as_dyn_database(), database_key_index);
+            memo.mark_as_verified(revision_now, memo.revisions.accumulated_inputs.load());
+            memo.mark_outputs_as_verified(zalsa, database_key_index);
             return true;
         }
 
@@ -181,7 +175,7 @@ where
             old_memo = old_memo.tracing_debug()
         );
 
-        if self.shallow_verify_memo(db, zalsa, database_key_index, old_memo) {
+        if self.shallow_verify_memo(zalsa, database_key_index, old_memo) {
             return true;
         }
 
@@ -241,16 +235,12 @@ where
                             // by this function cannot be read until this function is marked green,
                             // so even if we mark them as valid here, the function will re-execute
                             // and overwrite the contents.
-                            dependency_index.mark_validated_output(
-                                zalsa,
-                                dyn_db,
-                                database_key_index,
-                            );
+                            dependency_index.mark_validated_output(zalsa, database_key_index);
                         }
                     }
                 }
 
-                old_memo.mark_as_verified(db, zalsa.current_revision(), database_key_index, inputs);
+                old_memo.mark_as_verified(zalsa.current_revision(), inputs);
                 true
             }
         }

src/function/memo.rs

@@ -8,10 +8,7 @@ use crate::revision::AtomicRevision;
 use crate::table::memo::MemoTable;
 use crate::zalsa::MemoIngredientIndex;
 use crate::zalsa_local::QueryOrigin;
-use crate::{
-    key::DatabaseKeyIndex, zalsa::Zalsa, zalsa_local::QueryRevisions, Event, EventKind, Id,
-    Revision,
-};
+use crate::{key::DatabaseKeyIndex, zalsa::Zalsa, zalsa_local::QueryRevisions, Id, Revision};
 
 use super::{Configuration, IngredientImpl};
 
@@ -136,31 +133,22 @@ impl<V> Memo<V> {
 
     /// Mark memo as having been verified in the `revision_now`, which should
     /// be the current revision.
-    pub(super) fn mark_as_verified<Db: ?Sized + crate::Database>(
+    pub(super) fn mark_as_verified(
         &self,
-        db: &Db,
         revision_now: Revision,
-        database_key_index: DatabaseKeyIndex,
         accumulated: InputAccumulatedValues,
     ) {
-        db.salsa_event(&|| {
-            Event::new(EventKind::DidValidateMemoizedValue {
-                database_key: database_key_index,
-            })
-        });
-
         self.verified_at.store(revision_now);
         self.revisions.accumulated_inputs.store(accumulated);
     }
 
     pub(super) fn mark_outputs_as_verified(
         &self,
         zalsa: &Zalsa,
-        db: &dyn crate::Database,
         database_key_index: DatabaseKeyIndex,
     ) {
         for output in self.revisions.origin.outputs() {
-            output.mark_validated_output(zalsa, db, database_key_index);
+            output.mark_validated_output(zalsa, database_key_index);
         }
     }
 

src/function/specify.rs

@@ -2,9 +2,9 @@ use crate::{
     accumulator::accumulated_map::InputAccumulatedValues,
     revision::AtomicRevision,
     tracked_struct::TrackedStructInDb,
-    zalsa::ZalsaDatabase,
+    zalsa::{Zalsa, ZalsaDatabase},
     zalsa_local::{QueryOrigin, QueryRevisions},
-    AsDynDatabase as _, Database, DatabaseKeyIndex, Id,
+    AsDynDatabase as _, DatabaseKeyIndex, Id,
 };
 
 use super::{memo::Memo, Configuration, IngredientImpl};
@@ -103,11 +103,10 @@ where
     /// it would have specified `key` again.
     pub(super) fn validate_specified_value(
         &self,
-        db: &dyn Database,
+        zalsa: &Zalsa,
         executor: DatabaseKeyIndex,
         key: Id,
     ) {
-        let zalsa = db.zalsa();
         let memo_ingredient_index = self.memo_ingredient_index(zalsa, key);
 
         let memo = match self.get_memo_from_table_for(zalsa, key, memo_ingredient_index) {
@@ -125,12 +124,6 @@ where
             ),
         }
 
-        let database_key_index = self.database_key_index(key);
-        memo.mark_as_verified(
-            db,
-            zalsa.current_revision(),
-            database_key_index,
-            InputAccumulatedValues::Empty,
-        );
+        memo.mark_as_verified(zalsa.current_revision(), InputAccumulatedValues::Empty);
     }
 }

src/ingredient.rs

@@ -65,13 +65,13 @@ pub trait Ingredient: Any + std::fmt::Debug + Send + Sync {
     /// Invoked when the value `output_key` should be marked as valid in the current revision.
     /// This occurs because the value for `executor`, which generated it, was marked as valid
     /// in the current revision.
-    fn mark_validated_output<'db>(
-        &'db self,
-        db: &'db dyn Database,
+    fn mark_validated_output(
+        &self,
+        zalsa: &Zalsa,
         executor: DatabaseKeyIndex,
         output_key: crate::Id,
     ) {
-        let _ = (db, executor, output_key);
+        let _ = (zalsa, executor, output_key);
         unreachable!("only tracked struct and function ingredients can have validatable outputs")
     }
 

src/key.rs

@@ -45,12 +45,11 @@ impl OutputDependencyIndex {
     pub(crate) fn mark_validated_output(
         &self,
         zalsa: &Zalsa,
-        db: &dyn Database,
         database_key_index: DatabaseKeyIndex,
     ) {
         zalsa
             .lookup_ingredient(self.ingredient_index)
-            .mark_validated_output(db, database_key_index, self.key_index)
+            .mark_validated_output(zalsa, database_key_index, self.key_index)
     }
 }
 

src/tracked_struct.rs

@@ -728,9 +728,9 @@ where
         MaybeChangedAfter::from(data.created_at > revision)
     }
 
-    fn mark_validated_output<'db>(
-        &'db self,
-        _db: &'db dyn Database,
+    fn mark_validated_output(
+        &self,
+        _zalsa: &Zalsa,
         _executor: DatabaseKeyIndex,
         _output_key: crate::Id,
     ) {