Use thinvec

Author: MichaReiser

src/function.rs

@@ -191,9 +191,13 @@ where
         &'db self,
         zalsa: &'db Zalsa,
         id: Id,
-        memo: memo::Memo<C::Output<'db>>,
+        mut memo: memo::Memo<C::Output<'db>>,
         memo_ingredient_index: MemoIngredientIndex,
     ) -> &'db memo::Memo<C::Output<'db>> {
+        if let Some(tracked_struct_ids) = memo.revisions.tracked_struct_ids_mut() {
+            tracked_struct_ids.shrink_to_fit();
+        }
+
         // We convert to a `NonNull` here as soon as possible because we are going to alias
         // into the `Box`, which is a `noalias` type.
         // FIXME: Use `Box::into_non_null` once stable

src/function/diff_outputs.rs

@@ -46,15 +46,14 @@ where
             ));
         }
 
-        if old_outputs.is_empty() {
+        let Some(tracked_struct_ids) = revisions.tracked_struct_ids_mut() else {
             return;
-        }
+        };
 
         // Remove the outputs that are no longer present in the current revision
         // to prevent that the next revision is seeded with an id mapping that no longer exists.
-        revisions.retain_tracked_struct_ids(|(k, value)| {
-            !old_outputs.contains(&(k.ingredient_index(), value.index()))
-        });
+        tracked_struct_ids
+            .retain(|(k, value)| !old_outputs.contains(&(k.ingredient_index(), value.index())));
 
         for (ingredient_index, key_index) in old_outputs {
             // SAFETY: key_index acquired from valid output

src/tracked_struct.rs

@@ -7,6 +7,7 @@ use std::ops::Index;
 use std::{fmt, mem};
 
 use crossbeam_queue::SegQueue;
+use thin_vec::ThinVec;
 use tracked_field::FieldIngredientImpl;
 
 use crate::cycle::CycleHeads;
@@ -258,7 +259,7 @@ impl IdentityMap {
         self.table.clear()
     }
 
-    pub(crate) fn into_boxed_slice(self) -> Box<[(Identity, Id)]> {
+    pub(crate) fn into_thin_vec(self) -> ThinVec<(Identity, Id)> {
         self.table.into_iter().collect()
     }
 }

src/zalsa_local.rs

@@ -3,6 +3,7 @@ use std::panic::UnwindSafe;
 use std::ptr::{self, NonNull};
 
 use rustc_hash::FxHashMap;
+use thin_vec::ThinVec;
 use tracing::debug;
 
 use crate::accumulator::accumulated_map::{AccumulatedMap, AtomicInputAccumulatedValues};
@@ -371,7 +372,7 @@ impl QueryRevisionsExtra {
             Some(Box::new(QueryRevisionsExtraInner {
                 accumulated,
                 cycle_heads,
-                tracked_struct_ids: tracked_struct_ids.into_boxed_slice(),
+                tracked_struct_ids: tracked_struct_ids.into_thin_vec(),
                 iteration,
             }))
         };
@@ -401,7 +402,7 @@ struct QueryRevisionsExtraInner {
     ///   previous revision. To handle this, `diff_outputs` compares
     ///   the structs from the old/new revision and retains
     ///   only entries that appeared in the new revision.
-    tracked_struct_ids: Box<[(Identity, Id)]>,
+    tracked_struct_ids: ThinVec<(Identity, Id)>,
 
     /// This result was computed based on provisional values from
     /// these cycle heads. The "cycle head" is the query responsible
@@ -423,7 +424,7 @@ const _: [(); std::mem::size_of::<QueryRevisions>()] = [(); std::mem::size_of::<
 #[cfg(not(feature = "shuttle"))]
 #[cfg(target_pointer_width = "64")]
 const _: [(); std::mem::size_of::<QueryRevisionsExtraInner>()] =
-    [(); std::mem::size_of::<[usize; 8]>()];
+    [(); std::mem::size_of::<[usize; 7]>()];
 
 impl QueryRevisions {
     pub(crate) fn fixpoint_initial(query: DatabaseKeyIndex) -> Self {
@@ -507,18 +508,12 @@ impl QueryRevisions {
     }
 
     /// Returns a mutable reference to the `IdentityMap` for this query, or `None` if the map is empty.
-    pub fn retain_tracked_struct_ids<F>(&mut self, f: F)
-    where
-        F: FnMut(&(Identity, Id)) -> bool,
-    {
-        let Some(extra) = self.extra.0.as_mut() else {
-            return;
-        };
-
-        let tracked_struct_ids = std::mem::take(&mut extra.tracked_struct_ids);
-        let mut tracked_struct_ids = tracked_struct_ids.into_vec();
-        tracked_struct_ids.retain(f);
-        extra.tracked_struct_ids = tracked_struct_ids.into_boxed_slice()
+    pub fn tracked_struct_ids_mut(&mut self) -> Option<&mut ThinVec<(Identity, Id)>> {
+        self.extra
+            .0
+            .as_mut()
+            .map(|extra| &mut extra.tracked_struct_ids)
+            .filter(|tracked_struct_ids| !tracked_struct_ids.is_empty())
     }
 }