Persistent caching fixes (#982)

* reduce `serde` overhead

* avoid adding dependencies on interned values where garbage collection is disabled

* add compatibility with non-self-describing `serde` formats

* reuse edge traversal allocation

* correctly deserialize singleton inputs

Author: ibraheemdev

src/active_query.rs

@@ -208,9 +208,9 @@ impl ActiveQuery {
         } = self;
 
         let origin = if untracked_read {
-            QueryOrigin::derived_untracked(input_outputs.drain(..))
+            QueryOrigin::derived_untracked(input_outputs.drain(..).collect())
         } else {
-            QueryOrigin::derived(input_outputs.drain(..))
+            QueryOrigin::derived(input_outputs.drain(..).collect())
         };
         disambiguator_map.clear();
 

src/cycle.rs

@@ -104,6 +104,7 @@ pub struct CycleHead {
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Default)]
 #[cfg_attr(feature = "persistence", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "persistence", serde(transparent))]
 pub struct IterationCount(u8);
 
 impl IterationCount {

src/database.rs

@@ -160,7 +160,7 @@ mod persistence {
 
     use std::fmt;
 
-    use serde::de::{self, DeserializeSeed};
+    use serde::de::{self, DeserializeSeed, SeqAccess};
     use serde::ser::SerializeMap;
 
     impl dyn Database {
@@ -275,6 +275,21 @@ mod persistence {
             formatter.write_str("struct Database")
         }
 
+        fn visit_seq<V>(self, mut seq: V) -> Result<(), V::Error>
+        where
+            V: SeqAccess<'de>,
+        {
+            let mut runtime = seq
+                .next_element()?
+                .ok_or_else(|| de::Error::invalid_length(0, &self))?;
+            let () = seq
+                .next_element_seed(DeserializeIngredients(self.0))?
+                .ok_or_else(|| de::Error::invalid_length(1, &self))?;
+
+            self.0.runtime_mut().deserialize_from(&mut runtime);
+            Ok(())
+        }
+
         fn visit_map<V>(self, mut map: V) -> Result<(), V::Error>
         where
             V: serde::de::MapAccess<'de>,

src/durability.rs

@@ -17,9 +17,28 @@
 /// configuration, the source from library crates, or other things
 /// that are unlikely to be edited.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "persistence", derive(serde::Serialize, serde::Deserialize))]
 pub struct Durability(DurabilityVal);
 
+#[cfg(feature = "persistence")]
+impl serde::Serialize for Durability {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serde::Serialize::serialize(&(self.0 as u8), serializer)
+    }
+}
+
+#[cfg(feature = "persistence")]
+impl<'de> serde::Deserialize<'de> for Durability {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        u8::deserialize(deserializer).map(|value| Self(DurabilityVal::from(value)))
+    }
+}
+
 impl std::fmt::Debug for Durability {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if f.alternate() {
@@ -38,7 +57,6 @@ impl std::fmt::Debug for Durability {
 
 // We use an enum here instead of a u8 for niches.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "persistence", derive(serde::Serialize, serde::Deserialize))]
 enum DurabilityVal {
     Low = 0,
     Medium = 1,

src/function.rs

@@ -541,7 +541,26 @@ mod persistence {
         {
             let Self { ingredient, zalsa } = self;
 
-            let mut map = serializer.serialize_map(None)?;
+            let count = <C::SalsaStruct<'_> as SalsaStructInDb>::entries(zalsa)
+                .filter(|entry| {
+                    let memo_ingredient_index = ingredient
+                        .memo_ingredient_indices
+                        .get(entry.ingredient_index());
+
+                    let memo = ingredient.get_memo_from_table_for(
+                        zalsa,
+                        entry.key_index(),
+                        memo_ingredient_index,
+                    );
+
+                    memo.is_some_and(|memo| memo.should_serialize())
+                })
+                .count();
+
+            let mut map = serializer.serialize_map(Some(count))?;
+
+            let mut visited_edges = FxHashSet::default();
+            let mut flattened_edges = FxIndexSet::default();
 
             for entry in <C::SalsaStruct<'_> as SalsaStructInDb>::entries(zalsa) {
                 let memo_ingredient_index = ingredient
@@ -558,10 +577,24 @@ mod persistence {
                     // Flatten the dependencies of this query down to the base inputs.
                     let flattened_origin = match memo.revisions.origin.as_ref() {
                         QueryOriginRef::Derived(edges) => {
-                            QueryOrigin::derived(flatten_edges(zalsa, edges))
+                            collect_minimum_serialized_edges(
+                                zalsa,
+                                edges,
+                                &mut visited_edges,
+                                &mut flattened_edges,
+                            );
+
+                            QueryOrigin::derived(flattened_edges.drain(..).collect())
                         }
                         QueryOriginRef::DerivedUntracked(edges) => {
-                            QueryOrigin::derived_untracked(flatten_edges(zalsa, edges))
+                            collect_minimum_serialized_edges(
+                                zalsa,
+                                edges,
+                                &mut visited_edges,
+                                &mut flattened_edges,
+                            );
+
+                            QueryOrigin::derived_untracked(flattened_edges.drain(..).collect())
                         }
                         QueryOriginRef::Assigned(key) => {
                             let dependency = zalsa.lookup_ingredient(key.ingredient_index());
@@ -588,6 +621,8 @@ mod persistence {
                     );
 
                     map.serialize_entry(&key, &memo)?;
+
+                    visited_edges.clear();
                 }
             }
 
@@ -596,11 +631,12 @@ mod persistence {
     }
 
     // Flatten the dependency edges before serialization.
-    fn flatten_edges(zalsa: &Zalsa, edges: &[QueryEdge]) -> FxIndexSet<QueryEdge> {
-        let mut visited_edges = FxHashSet::default();
-        let mut flattened_edges =
-            FxIndexSet::with_capacity_and_hasher(edges.len(), Default::default());
-
+    fn collect_minimum_serialized_edges(
+        zalsa: &Zalsa,
+        edges: &[QueryEdge],
+        visited_edges: &mut FxHashSet<QueryEdge>,
+        flattened_edges: &mut FxIndexSet<QueryEdge>,
+    ) {
         for &edge in edges {
             let dependency = zalsa.lookup_ingredient(edge.key().ingredient_index());
 
@@ -612,13 +648,11 @@ mod persistence {
                 dependency.collect_minimum_serialized_edges(
                     zalsa,
                     edge,
-                    &mut flattened_edges,
-                    &mut visited_edges,
+                    flattened_edges,
+                    visited_edges,
                 );
             }
         }
-
-        flattened_edges
     }
 
     pub struct DeserializeIngredient<'db, C>
@@ -659,7 +693,7 @@ mod persistence {
         {
             let DeserializeIngredient { zalsa, ingredient } = self;
 
-            while let Some((key, memo)) = access.next_entry::<String, Memo<C>>()? {
+            while let Some((key, memo)) = access.next_entry::<&str, Memo<C>>()? {
                 let (ingredient_index, id) = key
                     .split_once(':')
                     .ok_or_else(|| de::Error::custom("invalid database key"))?;

src/function/memo.rs

@@ -367,9 +367,9 @@ mod persistence {
 
     /// A reference to the fields of a [`Memo`], with its [`QueryRevisions`] transformed.
     pub(crate) struct MappedMemo<'memo, 'db, C: Configuration> {
-        value: Option<&'memo C::Output<'db>>,
-        verified_at: AtomicRevision,
-        revisions: MappedQueryRevisions<'memo>,
+        pub(crate) value: Option<&'memo C::Output<'db>>,
+        pub(crate) verified_at: AtomicRevision,
+        pub(crate) revisions: MappedQueryRevisions<'memo>,
     }
 
     impl<'db, C: Configuration> Memo<'db, C> {
@@ -437,6 +437,7 @@ mod persistence {
             D: serde::Deserializer<'de>,
         {
             #[derive(Deserialize)]
+            #[serde(rename = "Memo")]
             pub struct DeserializeMemo<C: Configuration> {
                 #[serde(bound = "C: Configuration")]
                 value: DeserializeValue<C>,

src/input.rs

@@ -152,16 +152,16 @@ impl<C: Configuration> IngredientImpl<C> {
         durabilities: C::Durabilities,
     ) -> C::Struct {
         let id = self.singleton.with_scope(|| {
-            let (id, _) = zalsa_local.allocate(zalsa, self.ingredient_index, |_| Value::<C> {
-                fields,
-                revisions,
-                durabilities,
-                // SAFETY: We only ever access the memos of a value that we allocated through
-                // our `MemoTableTypes`.
-                memos: unsafe { MemoTable::new(self.memo_table_types()) },
-            });
-
-            id
+            zalsa_local
+                .allocate(zalsa, self.ingredient_index, |_| Value::<C> {
+                    fields,
+                    revisions,
+                    durabilities,
+                    // SAFETY: We only ever access the memos of a value that we allocated through
+                    // our `MemoTableTypes`.
+                    memos: unsafe { MemoTable::new(self.memo_table_types()) },
+                })
+                .0
         });
 
         FromIdWithDb::from_id(id, zalsa)
@@ -440,10 +440,11 @@ where
 mod persistence {
     use std::fmt;
 
-    use serde::ser::SerializeMap;
+    use serde::ser::{SerializeMap, SerializeStruct};
     use serde::{de, Deserialize};
 
     use super::{Configuration, IngredientImpl, Value};
+    use crate::input::singleton::SingletonChoice;
     use crate::plumbing::Ingredient;
     use crate::table::memo::MemoTable;
     use crate::zalsa::Zalsa;
@@ -467,7 +468,8 @@ mod persistence {
         {
             let Self { zalsa, .. } = self;
 
-            let mut map = serializer.serialize_map(None)?;
+            let count = zalsa.table().slots_of::<Value<C>>().count();
+            let mut map = serializer.serialize_map(Some(count))?;
 
             for (id, value) in zalsa.table().slots_of::<Value<C>>() {
                 map.serialize_entry(&id.as_bits(), value)?;
@@ -485,21 +487,7 @@ mod persistence {
         where
             S: serde::Serializer,
         {
-            let mut map = serializer.serialize_map(None)?;
-
-            struct SerializeFields<'db, C: Configuration>(&'db C::Fields);
-
-            impl<C> serde::Serialize for SerializeFields<'_, C>
-            where
-                C: Configuration,
-            {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: serde::Serializer,
-                {
-                    C::serialize(self.0, serializer)
-                }
-            }
+            let mut value = serializer.serialize_struct("Value", 3)?;
 
             let Value {
                 fields,
@@ -508,11 +496,25 @@ mod persistence {
                 memos: _,
             } = self;
 
-            map.serialize_entry(&"durabilities", &durabilities)?;
-            map.serialize_entry(&"revisions", &revisions)?;
-            map.serialize_entry(&"fields", &SerializeFields::<C>(fields))?;
+            value.serialize_field("durabilities", &durabilities)?;
+            value.serialize_field("revisions", &revisions)?;
+            value.serialize_field("fields", &SerializeFields::<C>(fields))?;
 
-            map.end()
+            value.end()
+        }
+    }
+
+    struct SerializeFields<'db, C: Configuration>(&'db C::Fields);
+
+    impl<C> serde::Serialize for SerializeFields<'_, C>
+    where
+        C: Configuration,
+    {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer,
+        {
+            C::serialize(self.0, serializer)
         }
     }
 
@@ -577,13 +579,14 @@ mod persistence {
                 // Initialize the slot.
                 //
                 // SAFETY: We have a mutable reference to the database.
-                let (allocated_id, _) = unsafe {
+                let allocated_id = ingredient.singleton.with_scope(|| unsafe {
                     zalsa
                         .table()
                         .page(page_idx)
                         .allocate(page_idx, |_| value)
                         .unwrap_or_else(|_| panic!("serialized an invalid `Id`: {id:?}"))
-                };
+                        .0
+                });
 
                 assert_eq!(
                     allocated_id, id,
@@ -596,6 +599,7 @@ mod persistence {
     }
 
     #[derive(Deserialize)]
+    #[serde(rename = "Value")]
     pub struct DeserializeValue<C: Configuration> {
         durabilities: C::Durabilities,
         revisions: C::Revisions,