Pass query revisions into add_read directly

Author: Veykril

src/accumulator/accumulated_map.rs

@@ -76,6 +76,14 @@ impl InputAccumulatedValues {
     pub const fn is_empty(self) -> bool {
         matches!(self, Self::Empty)
     }
+
+    pub fn or_shortcircuiting(self, other: impl FnOnce() -> Self) -> Self {
+        if self.is_any() {
+            Self::Any
+        } else {
+            other()
+        }
+    }
 }
 
 impl ops::BitOr for InputAccumulatedValues {

src/active_query.rs

@@ -70,15 +70,18 @@ impl ActiveQuery {
     pub(super) fn add_read(
         &mut self,
         input: DatabaseKeyIndex,
-        durability: Durability,
-        revision: Revision,
-        accumulated: InputAccumulatedValues,
+        revisions: &QueryRevisions,
         cycle_heads: &CycleHeads,
     ) {
-        self.durability = self.durability.min(durability);
-        self.changed_at = self.changed_at.max(revision);
+        self.durability = self.durability.min(revisions.durability);
+        self.changed_at = self.changed_at.max(revisions.changed_at);
         self.input_outputs.insert(QueryEdge::Input(input));
-        self.accumulated_inputs |= accumulated;
+        self.accumulated_inputs =
+            self.accumulated_inputs
+                .or_shortcircuiting(|| match &revisions.accumulated {
+                    Some(_) => InputAccumulatedValues::Any,
+                    None => revisions.accumulated_inputs.load(),
+                });
         self.cycle_heads.extend(cycle_heads);
     }
 

src/function/fetch.rs

@@ -1,8 +1,6 @@
 use super::{memo::Memo, Configuration, IngredientImpl, VerifyResult};
 use crate::zalsa::MemoIngredientIndex;
 use crate::{
-    accumulator::accumulated_map::InputAccumulatedValues,
-    runtime::StampedValue,
     table::sync::ClaimResult,
     zalsa::{Zalsa, ZalsaDatabase},
     zalsa_local::QueryRevisions,
@@ -20,26 +18,16 @@ where
         let memo = self.refresh_memo(db, 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() };
-        let StampedValue {
-            value,
-            durability,
-            changed_at,
-        } = memo.revisions.stamped_value(memo_value);
 
         self.lru.record_use(id);
 
         zalsa_local.report_tracked_read(
             self.database_key_index(id),
-            durability,
-            changed_at,
-            match &memo.revisions.accumulated {
-                Some(_) => InputAccumulatedValues::Any,
-                None => memo.revisions.accumulated_inputs.load(),
-            },
+            &memo.revisions,
             memo.cycle_heads(),
         );
 
-        value
+        memo_value
     }
 
     #[inline]

src/zalsa_local.rs

@@ -1,14 +1,12 @@
 use rustc_hash::FxHashMap;
 use tracing::debug;
 
-use crate::accumulator::accumulated_map::{
-    AccumulatedMap, AtomicInputAccumulatedValues, InputAccumulatedValues,
-};
+use crate::accumulator::accumulated_map::{AccumulatedMap, AtomicInputAccumulatedValues};
 use crate::active_query::QueryStack;
 use crate::cycle::CycleHeads;
 use crate::durability::Durability;
 use crate::key::DatabaseKeyIndex;
-use crate::runtime::{Stamp, StampedValue};
+use crate::runtime::Stamp;
 use crate::table::PageIndex;
 use crate::table::Slot;
 use crate::table::Table;
@@ -19,7 +17,7 @@ use crate::Cancelled;
 use crate::Id;
 use crate::Revision;
 use std::cell::RefCell;
-use std::panic::UnwindSafe;
+use std::panic::{AssertUnwindSafe, UnwindSafe};
 use std::sync::atomic::AtomicBool;
 
 /// State that is specific to a single execution thread.
@@ -162,18 +160,18 @@ impl ZalsaLocal {
     pub(crate) fn report_tracked_read(
         &self,
         input: DatabaseKeyIndex,
-        durability: Durability,
-        changed_at: Revision,
-        accumulated: InputAccumulatedValues,
+        revisions: &QueryRevisions,
         cycle_heads: &CycleHeads,
     ) {
         debug!(
             "report_tracked_read(input={:?}, durability={:?}, changed_at={:?})",
-            input, durability, changed_at
+            input, revisions.durability, revisions.changed_at
         );
+        // We don't access the accumulator anyways
+        let revisions = AssertUnwindSafe(revisions);
         self.with_query_stack(|stack| {
             if let Some(top_query) = stack.last_mut() {
-                top_query.add_read(input, durability, changed_at, accumulated, cycle_heads);
+                top_query.add_read(input, { revisions }.0, cycle_heads);
             }
         })
     }
@@ -345,33 +343,6 @@ impl QueryRevisions {
             cycle_heads: CycleHeads::from(query),
         }
     }
-
-    pub(crate) fn stamped_value<V>(&self, value: V) -> StampedValue<V> {
-        self.stamp_template().stamp(value)
-    }
-
-    pub(crate) fn stamp_template(&self) -> StampTemplate {
-        StampTemplate {
-            durability: self.durability,
-            changed_at: self.changed_at,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub(crate) struct StampTemplate {
-    durability: Durability,
-    changed_at: Revision,
-}
-
-impl StampTemplate {
-    pub(crate) fn stamp<V>(self, value: V) -> StampedValue<V> {
-        StampedValue {
-            value,
-            durability: self.durability,
-            changed_at: self.changed_at,
-        }
-    }
 }
 
 /// Tracks the way that a memoized value for a query was created.