feat: Implement Immutable durability level

This durability has slightly special semantics. Values for it are considered unchanging and as such, queries that only rely on inputs of this durability can discard their edges as the query can't possibily be invalidated again (unless LRU cleared).

Author: Veykril

src/active_query.rs

@@ -203,13 +203,6 @@ impl ActiveQuery {
             accumulated_inputs,
         } = self;
 
-        let origin = if untracked_read {
-            QueryOrigin::derived_untracked(input_outputs.drain(..).collect())
-        } else {
-            QueryOrigin::derived(input_outputs.drain(..).collect())
-        };
-        disambiguator_map.clear();
-
         #[cfg(feature = "accumulator")]
         let accumulated_inputs = AtomicInputAccumulatedValues::new(accumulated_inputs);
         let verified_final = cycle_heads.is_empty();
@@ -222,6 +215,23 @@ impl ActiveQuery {
             mem::take(cycle_heads),
             iteration_count,
         );
+        #[cfg(not(feature = "accumulator"))]
+        let has_accumulated_inputs = || false;
+        #[cfg(feature = "accumulator")]
+        let has_accumulated_inputs = || accumulated_inputs.load().is_any();
+        let origin =
+            if durability == Durability::IMMUTABLE && extra.is_empty() && !has_accumulated_inputs()
+            {
+                // We only depend on immutable inputs, we can discard our dependencies
+                // as we will never be invalidated again
+                input_outputs.clear();
+                QueryOrigin::derived_immutable()
+            } else if untracked_read {
+                QueryOrigin::derived_untracked(input_outputs.drain(..).collect())
+            } else {
+                QueryOrigin::derived(input_outputs.drain(..).collect())
+            };
+        disambiguator_map.clear();
 
         let revisions = QueryRevisions {
             changed_at,

src/database.rs

@@ -53,6 +53,10 @@ pub trait Database: Send + ZalsaDatabase + AsDynDatabase {
     /// cancellation. If you invoke it while a snapshot exists, it
     /// will block until that snapshot is dropped -- if that snapshot
     /// is owned by the current thread, this could trigger deadlock.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `durability` is `Durability::IMMUTABLE`.
     fn synthetic_write(&mut self, durability: Durability) {
         let zalsa_mut = self.zalsa_mut();
         zalsa_mut.new_revision();

src/durability.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 /// Describes how likely a value is to change—how "durable" it is.
 ///
 /// By default, inputs have `Durability::LOW` and interned values have
@@ -42,11 +44,7 @@ impl<'de> serde::Deserialize<'de> for Durability {
 impl std::fmt::Debug for Durability {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if f.alternate() {
-            match self.0 {
-                DurabilityVal::Low => f.write_str("Durability::LOW"),
-                DurabilityVal::Medium => f.write_str("Durability::MEDIUM"),
-                DurabilityVal::High => f.write_str("Durability::HIGH"),
-            }
+            fmt::Display::fmt(self, f)
         } else {
             f.debug_tuple("Durability")
                 .field(&(self.0 as usize))
@@ -55,12 +53,26 @@ impl std::fmt::Debug for Durability {
     }
 }
 
+impl fmt::Display for Durability {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Durability::")?;
+        match self.0 {
+            DurabilityVal::Low => write!(f, "Low"),
+            DurabilityVal::Medium => write!(f, "Medium"),
+            DurabilityVal::High => write!(f, "High"),
+            DurabilityVal::Immutable => write!(f, "Immutable"),
+        }
+    }
+}
+
 // We use an enum here instead of a u8 for niches.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+// Note that the order is important here
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
 enum DurabilityVal {
     Low = 0,
     Medium = 1,
     High = 2,
+    Immutable = 3,
 }
 
 impl From<u8> for DurabilityVal {
@@ -69,7 +81,8 @@ impl From<u8> for DurabilityVal {
             0 => DurabilityVal::Low,
             1 => DurabilityVal::Medium,
             2 => DurabilityVal::High,
-            _ => panic!("invalid durability"),
+            3 => DurabilityVal::Immutable,
+            _ => unreachable!("invalid durability"),
         }
     }
 }
@@ -91,6 +104,19 @@ impl Durability {
     /// Example: the standard library or something from crates.io
     pub const HIGH: Durability = Durability(DurabilityVal::High);
 
+    /// Immutable durability: things that are not expected to change.
+    ///
+    /// Example: the standard library or something from crates.io
+    pub const IMMUTABLE: Durability = Durability(DurabilityVal::Immutable);
+}
+
+impl Default for Durability {
+    fn default() -> Self {
+        Durability::LOW
+    }
+}
+
+impl Durability {
     /// The minimum possible durability; equivalent to LOW but
     /// "conceptually" distinct (i.e., if we add more durability
     /// levels, this could change).
@@ -102,15 +128,9 @@ impl Durability {
     pub(crate) const MAX: Durability = Self::HIGH;
 
     /// Number of durability levels.
-    pub(crate) const LEN: usize = Self::HIGH.0 as usize + 1;
+    pub(crate) const LEN: usize = Self::IMMUTABLE.0 as usize + 1;
 
     pub(crate) fn index(self) -> usize {
         self.0 as usize
     }
 }
-
-impl Default for Durability {
-    fn default() -> Self {
-        Durability::LOW
-    }
-}

src/function/maybe_changed_after.rs

@@ -30,8 +30,8 @@ pub enum VerifyResult {
 }
 
 impl VerifyResult {
-    pub(crate) const fn changed_if(changed: bool) -> Self {
-        if changed {
+    pub(crate) fn changed_after(revision: Revision, after: Revision) -> Self {
+        if revision > after {
             Self::changed()
         } else {
             Self::unchanged()
@@ -557,6 +557,8 @@ where
         debug_assert!(!cycle_heads.contains_head(database_key_index));
 
         match old_memo.revisions.origin.as_ref() {
+            // Shouldn't end up here, shallow verify ought to always pass
+            QueryOriginRef::DerivedImmutable => VerifyResult::unchanged(),
             QueryOriginRef::Derived(edges) => {
                 #[cfg(feature = "accumulator")]
                 let mut inputs = InputAccumulatedValues::Empty;

src/function/memo.rs

@@ -68,7 +68,8 @@ impl<C: Configuration> IngredientImpl<C> {
             match memo.revisions.origin.as_ref() {
                 QueryOriginRef::Assigned(_)
                 | QueryOriginRef::DerivedUntracked(_)
-                | QueryOriginRef::FixpointInitial => {
+                | QueryOriginRef::FixpointInitial
+                | QueryOriginRef::DerivedImmutable => {
                     // Careful: Cannot evict memos whose values were
                     // assigned as output of another query
                     // or those with untracked inputs

src/input.rs

@@ -176,6 +176,10 @@ impl<C: Configuration> IngredientImpl<C> {
     /// * `field_index`, index of the field that will be changed
     /// * `durability`, durability of the new value. If omitted, uses the durability of the previous value.
     /// * `setter`, function that modifies the fields tuple; should only modify the element for `field_index`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `durability` is [`Durability::IMMUTABLE`].
     pub fn set_field<R>(
         &mut self,
         runtime: &mut Runtime,
@@ -195,9 +199,7 @@ impl<C: Configuration> IngredientImpl<C> {
         data.revisions[field_index] = runtime.current_revision();
 
         let field_durability = &mut data.durabilities[field_index];
-        if *field_durability != Durability::MIN {
-            runtime.report_tracked_write(*field_durability);
-        }
+        runtime.report_tracked_write(*field_durability);
         *field_durability = durability.unwrap_or(*field_durability);
 
         setter(&mut data.fields)

src/input/input_field.rs

@@ -60,7 +60,7 @@ where
         _cycle_heads: &mut VerifyCycleHeads,
     ) -> VerifyResult {
         let value = <IngredientImpl<C>>::data(zalsa, input);
-        VerifyResult::changed_if(value.revisions[self.field_index] > revision)
+        VerifyResult::changed_after(value.revisions[self.field_index], revision)
     }
 
     fn collect_minimum_serialized_edges(

src/input/setter.rs

@@ -6,7 +6,13 @@ use crate::{Durability, Runtime};
 /// Setter for a field of an input.
 pub trait Setter: Sized {
     type FieldTy;
+    /// Sets a new durability for the field.
     fn with_durability(self, durability: Durability) -> Self;
+    /// Sets the value of the field.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `with_durability` was called with [`Durability::IMMUTABLE`].
     fn to(self, value: Self::FieldTy) -> Self::FieldTy;
 }
 

src/interned.rs

@@ -475,7 +475,7 @@ where
                 .map(|(_, stamp)| (stamp.durability, current_revision))
                 // If there is no active query this durability does not actually matter.
                 // `last_interned_at` needs to be `Revision::MAX`, see the `intern_access_in_different_revision` test.
-                .unwrap_or((Durability::MAX, Revision::max()));
+                .unwrap_or((Durability::IMMUTABLE, Revision::max()));
 
             let old_id = value_shared.id;
 

src/runtime.rs

@@ -19,9 +19,9 @@ pub struct Runtime {
     #[cfg_attr(feature = "persistence", serde(skip))]
     revision_canceled: AtomicBool,
 
-    /// Stores the "last change" revision for values of each duration.
-    /// This vector is always of length at least 1 (for Durability 0)
-    /// but its total length depends on the number of durations. The
+    /// Stores the "last change" revision for values of each [`Durability`].
+    /// This vector is always of length at least 1 (for [`Durability::MIN`])
+    /// but its total length depends on the number of durabilities. The
     /// element at index 0 is special as it represents the "current
     /// revision".  In general, we have the invariant that revisions
     /// in here are *declining* -- that is, `revisions[i] >=
@@ -209,7 +209,16 @@ impl Runtime {
     /// Reports that an input with durability `durability` changed.
     /// This will update the 'last changed at' values for every durability
     /// less than or equal to `durability` to the current revision.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `durability` is `Durability::IMMUTABLE`.
     pub(crate) fn report_tracked_write(&mut self, durability: Durability) {
+        assert_ne!(
+            durability,
+            Durability::IMMUTABLE,
+            "can't write revision of immutable durability"
+        );
         let new_revision = self.current_revision();
         self.revisions[1..=durability.index()].fill(new_revision);
     }