testing

Author: lukesandberg

turbopack/crates/turbo-persistence/src/db.rs

@@ -469,6 +469,10 @@ impl<S: ParallelScheduler, const FAMILIES: usize> TurboPersistence<S, FAMILIES>
                  operations is allowed at a time)"
             );
         }
+        // Free decompressed block caches before the write cycle begins. Writes are
+        // memory-intensive (building new SST files), and cached blocks from old SSTs
+        // will be superseded by new sequence numbers after commit anyway.
+        self.clear_block_caches();
         let current = self.inner.read().current_sequence_number;
         Ok(WriteBatch::new(
             self.path.clone(),
@@ -480,8 +484,7 @@ impl<S: ParallelScheduler, const FAMILIES: usize> TurboPersistence<S, FAMILIES>
 
     /// Clears all caches of the database.
     pub fn clear_cache(&self) {
-        self.key_block_cache.clear();
-        self.value_block_cache.clear();
+        self.clear_block_caches();
         for meta in self.inner.write().meta_files.iter_mut() {
             meta.clear_cache();
         }

turbopack/crates/turbo-tasks-backend/src/backend/mod.rs

@@ -91,7 +91,7 @@ static IDLE_TIMEOUT: LazyLock<Duration> = LazyLock::new(|| {
         .ok()
         .and_then(|v| v.parse::<u64>().ok())
         .map(Duration::from_millis)
-        .unwrap_or(Duration::from_secs(10))
+        .unwrap_or(Duration::from_secs(2))
 });
 
 struct SnapshotRequest {
@@ -382,7 +382,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 return (false, EvictionCounts::default());
             }
         };
-        let counts = self.storage.evict_after_snapshot();
+        let counts = self.storage.evict_after_snapshot(None);
         (had_new_data, counts)
     }
 
@@ -1578,19 +1578,19 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         let mut ctx = self.execute_context(turbo_tasks);
 
         let mut is_new = false;
-        let (task_id, task_type) = if let Some(task_id) = ctx.task_by_type(&task_type) {
-            // Task exists in backing storage
-            // So we only need to insert it into the in-memory cache
+        let (task_id, task_type) = if let Some((task_id, arc)) = ctx.task_by_type(&task_type) {
+            // Task exists in backing storage — re-insert into task_cache using the task's
+            // own Arc so task_cache and persistent_task_type share the same allocation.
+            // This maintains the invariant that Arc::strong_count on persistent_task_type
+            // reflects whether a task_cache entry holds a reference.
             self.track_cache_hit(&task_type);
-            let task_type = match raw_entry(&self.storage.task_cache, &task_type) {
-                RawEntry::Occupied(_) => ArcOrOwned::Owned(task_type),
+            match raw_entry(&self.storage.task_cache, &task_type) {
+                RawEntry::Occupied(_) => {}
                 RawEntry::Vacant(e) => {
-                    let task_type = Arc::new(task_type);
-                    e.insert(task_type.clone(), task_id);
-                    ArcOrOwned::Arc(task_type)
+                    e.insert(arc.clone(), task_id);
                 }
-            };
-            (task_id, task_type)
+            }
+            (task_id, ArcOrOwned::Arc(arc))
         } else {
             // Task doesn't exist in memory cache or backing storage
             // So we might need to create a new task
@@ -2889,18 +2889,6 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                         if let Some((snapshot_start, new_data)) = snapshot {
                             last_snapshot = snapshot_start;
 
-                            // Evict persisted tasks from memory to reclaim space.
-                            // Like compaction, this runs after snapshot_and_persist
-                            // as a separate concern.
-                            //
-                            // TODO: improve eviction policy — current approach is a full sweep
-                            // after every snapshot. Better strategies to consider:
-                            //   - Memory pressure signals: only evict when RSS exceeds a threshold
-                            //     rather than unconditionally.
-                            //   - Recency data: track last-access time per task and evict
-                            //     least-recently-used entries first rather than all at once.
-                            //   - Eviction intensity: partial sweeps (evict a fraction of eligible
-                            //     tasks per cycle) to reduce latency spikes.
                             // Polls the idle-end event without blocking. Returns
                             // `true` and refreshes the listener if idle has ended,
                             // `false` if we are still idle.
@@ -2916,10 +2904,21 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                                     }
                                 }};
                             }
-
+                            // Evict persisted tasks from memory to reclaim space.
+                            // Like compaction, this runs after snapshot_and_persist
+                            // as a separate concern.
+                            //
+                            // TODO: improve eviction policy — current approach is a full sweep
+                            // after every snapshot. Better strategies to consider:
+                            //   - Memory pressure signals: only evict when RSS exceeds a threshold
+                            //     rather than unconditionally.
+                            //   - Recency data: track last-access time per task and evict
+                            //     least-recently-used entries first rather than all at once.
+                            //   - Eviction intensity: partial sweeps (evict a fraction of eligible
+                            //     tasks per cycle) to reduce latency spikes.
                             if this.should_evict() {
                                 if !check_idle_ended!() {
-                                    this.storage.evict_after_snapshot();
+                                    this.storage.evict_after_snapshot(background_span.id());
                                 }
                             }
 

turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs

@@ -99,8 +99,10 @@ pub trait ExecuteContext<'e>: Sized {
     ///
     /// Uses hash-based lookup which may return multiple candidates due to hash collisions,
     /// then verifies each candidate by comparing the stored `persistent_task_type`.
-    /// Returns `Some(task_id)` if a matching task is found, `None` otherwise.
-    fn task_by_type(&mut self, task_type: &CachedTaskType) -> Option<TaskId>;
+    /// Returns `Some((task_id, arc))` where `arc` is the task's own `Arc<CachedTaskType>`
+    /// (same allocation as `TaskStorage.persistent_task_type`), or `None` if not found.
+    fn task_by_type(&mut self, task_type: &CachedTaskType)
+    -> Option<(TaskId, Arc<CachedTaskType>)>;
 }
 
 pub trait ChildExecuteContext<'e>: Send + Sized {
@@ -964,7 +966,10 @@ impl<'e, B: BackingStorage> ExecuteContext<'e> for ExecuteContextImpl<'e, B> {
         self.turbo_tasks.pin()
     }
 
-    fn task_by_type(&mut self, task_type: &CachedTaskType) -> Option<TaskId> {
+    fn task_by_type(
+        &mut self,
+        task_type: &CachedTaskType,
+    ) -> Option<(TaskId, Arc<CachedTaskType>)> {
         if !self.backend.should_restore() {
             return None;
         }
@@ -983,7 +988,11 @@ impl<'e, B: BackingStorage> ExecuteContext<'e> for ExecuteContextImpl<'e, B> {
             if let Some(stored_type) = task.get_persistent_task_type()
                 && stored_type.as_ref() == task_type
             {
-                return Some(candidate_id);
+                // Clone the Arc from the task's own persistent_task_type so the caller
+                // can re-insert into task_cache using the same allocation, maintaining
+                // the invariant that task_cache and persistent_task_type share one Arc.
+                let arc = stored_type.clone();
+                return Some((candidate_id, arc));
             }
         }
         None

turbopack/crates/turbo-tasks-backend/src/backend/storage.rs

@@ -10,6 +10,7 @@ use std::{
 
 use rustc_hash::{FxHashMap, FxHasher};
 use thread_local::ThreadLocal;
+use tracing::span::Id;
 use turbo_bincode::TurboBincodeBuffer;
 use turbo_tasks::{FxDashMap, TaskId, backend::CachedTaskType, event::Event, parallel};
 
@@ -388,15 +389,23 @@ impl Storage {
     /// - `No`: skip
     ///
     /// Must be called when NOT in snapshot mode (i.e., after `end_snapshot()`).
-    pub fn evict_after_snapshot(&self) {
+    pub fn evict_after_snapshot(&self, parent_span: Option<Id>) -> EvictionCounts {
         let span = tracing::trace_span!(
+            parent: parent_span,
             "evict_after_snapshot",
-            task_cache = tracing::field::Empty,
+            total_task_cache_keys = self.task_cache.len(),
+            total_map_keys = self.map.len(),
+            task_cache_evictions = tracing::field::Empty,
             full = tracing::field::Empty,
             data_and_meta = tracing::field::Empty,
             data_only = tracing::field::Empty,
             meta_only = tracing::field::Empty,
             skipped = tracing::field::Empty,
+            skipped_in_progress = tracing::field::Empty,
+            skipped_restoring = tracing::field::Empty,
+            skipped_modified = tracing::field::Empty,
+            skipped_transient_or_stateful = tracing::field::Empty,
+            skipped_nothing_to_evict = tracing::field::Empty,
         )
         .entered();
         debug_assert!(
@@ -418,14 +427,20 @@ impl Storage {
                     }
                     let (key, data) = task.get().evictability();
                     if matches!(key, KeyEvictability::Evictable) {
-                        evicted.key_evictions += 1;
                         // The task type is persisted to backing storage (new_task = false),
                         // so task_cache is a pure perf cache. Remove it now; it will be
                         // re-populated by task_by_type() on the next cache miss.
-                        if let Some(task_type) = task.get().get_persistent_task_type() {
-                            self.task_cache.remove(task_type.as_ref());
+
+                        if self
+                            .task_cache
+                            .remove(task.get().get_persistent_task_type().unwrap().as_ref())
+                            .is_some()
+                        {
+                            evicted.key_evictions += 1;
                         }
                     }
+                    // KeyEvictability::AlreadyEvicted: strong_count == 1 means no
+                    // task_cache entry holds a reference — skip the hash lookup.
                     match data {
                         DataEvictability::Full => {
                             unsafe {
@@ -464,6 +479,7 @@ impl Storage {
                 }
                 (evicted, reason_counts)
             });
+
         let mut totals = EvictionCounts::default();
         let mut reasons: FxHashMap<UnevictableReason, usize> = FxHashMap::default();
         for (evicted, r) in counts {
@@ -483,12 +499,49 @@ impl Storage {
             self.task_cache.shrink_to_fit();
         }
         let skipped: usize = reasons.values().sum();
-        span.record("task_cache", totals.key_evictions);
+        span.record("task_cache_evictions", totals.key_evictions);
         span.record("full", totals.full);
         span.record("data_and_meta", totals.data_and_meta);
         span.record("data_only", totals.data_only);
         span.record("meta_only", totals.meta_only);
         span.record("skipped", skipped);
+        span.record(
+            "skipped_in_progress",
+            reasons
+                .get(&UnevictableReason::InProgress)
+                .copied()
+                .unwrap_or(0),
+        );
+        span.record(
+            "skipped_restoring",
+            reasons
+                .get(&UnevictableReason::Restoring)
+                .copied()
+                .unwrap_or(0),
+        );
+        span.record(
+            "skipped_modified",
+            reasons
+                .get(&UnevictableReason::Modified)
+                .copied()
+                .unwrap_or(0),
+        );
+        span.record(
+            "skipped_transient_or_stateful",
+            reasons
+                .get(&UnevictableReason::TransientOrStateful)
+                .copied()
+                .unwrap_or(0),
+        );
+        span.record(
+            "skipped_nothing_to_evict",
+            reasons
+                .get(&UnevictableReason::NothingToEvict)
+                .copied()
+                .unwrap_or(0),
+        );
+
+        totals
     }
 }
 

turbopack/crates/turbo-tasks-backend/src/backend/storage_schema.rs

@@ -436,12 +436,11 @@ impl TaskFlags {
 pub enum UnevictableReason {
     InProgress,
     Restoring,
-    TransientDependents,
-    TransientData,
-    TransientUppers,
-    SessionState,
-    SessionStateful,
+    /// Modified flags are set, or data/meta has not been restored yet.
     Modified,
+    /// Transient references or session-stateful cells are present (detected without
+    /// re-running the expensive per-field checks).
+    TransientOrStateful,
     NothingToEvict,
 }
 
@@ -464,6 +463,9 @@ pub enum DataEvictability {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyEvictability {
     Evictable,
+    /// The task was already removed from `task_cache` in a prior eviction cycle.
+    /// No hash lookup is needed; the caller can skip the remove entirely.
+    AlreadyEvicted,
     /// This means the task is new, so we cannot evict it
     Unevictable,
 }
@@ -482,10 +484,20 @@ impl TaskStorage {
     pub fn evictability(&self) -> (KeyEvictability, DataEvictability) {
         let flags = &self.flags;
 
-        let key_evictability = if flags.new_task() || self.persistent_task_type.is_none() {
+        let key_evictability = if flags.new_task() {
             KeyEvictability::Unevictable
         } else {
-            KeyEvictability::Evictable
+            match &self.persistent_task_type {
+                None => KeyEvictability::Unevictable,
+                // strong_count == 1: only TaskStorage holds this Arc, so no task_cache
+                // entry references it — already evicted in a prior cycle. This covers
+                // tasks that are key-evictable but not data-evictable (data stays in
+                // the shard, persistent_task_type is never dropped).
+                Some(arc) if std::sync::Arc::strong_count(arc) == 1 => {
+                    KeyEvictability::AlreadyEvicted
+                }
+                Some(_) => KeyEvictability::Evictable,
+            }
         };
         // === Absolute blockers ===
         if flags.new_task()
@@ -588,7 +600,22 @@ impl TaskStorage {
                 }
                 (true, false) => DataEvictability::DataOnly,
                 (false, true) => DataEvictability::MetaOnly,
-                (false, false) => DataEvictability::No(UnevictableReason::Modified),
+                (false, false) => {
+                    // Cheap flags checked first; if those are clear the blocker must
+                    // be one of the expensive transient/stateful checks above.
+                    let reason = if flags.data_modified()
+                        || flags.data_modified_during_snapshot()
+                        || flags.meta_modified()
+                        || flags.meta_modified_during_snapshot()
+                    {
+                        UnevictableReason::Modified
+                    } else {
+                        // Transient references, transient cell data, or session-stateful
+                        // cells are blocking — don't repeat the expensive checks.
+                        UnevictableReason::TransientOrStateful
+                    };
+                    DataEvictability::No(reason)
+                }
             },
         )
     }

turbopack/crates/turbo-tasks-backend/src/database/key_value_database.rs

@@ -119,4 +119,8 @@ pub trait KeyValueDatabase {
     fn shutdown(&self) -> Result<()> {
         Ok(())
     }
+
+    fn flush_caches(&self) -> Result<()> {
+        Ok(())
+    }
 }

turbopack/crates/turbo-tasks-backend/src/database/turbo/mod.rs

@@ -156,6 +156,10 @@ impl KeyValueDatabase for TurboKeyValueDatabase {
         // Shutdown the database
         self.db.shutdown()
     }
+
+    fn flush_caches(&self) -> Result<()> {
+        Ok(())
+    }
 }
 
 fn do_compact(

turbopack/crates/turbo-tasks-macros/src/derive/task_storage_macro.rs

@@ -2590,10 +2590,6 @@ fn generate_drop_methods(grouped_fields: &GroupedFields) -> TokenStream {
     let mut drop_data_inline = Vec::new();
     for field in grouped_fields.persistent_inline(Category::Data) {
         let field_name = &field.field_name;
-        // Skip persistent_task_type — needed for task_cache mappings
-        if field_name == "persistent_task_type" {
-            continue;
-        }
         drop_data_inline.push(quote! {
             self.#field_name = Default::default();
         });
@@ -2621,7 +2617,6 @@ fn generate_drop_methods(grouped_fields: &GroupedFields) -> TokenStream {
             /// so the next access triggers a restore from the backing storage.
             pub fn drop_data(&mut self) {
                 // Reset data-category inline fields to defaults
-                // (persistent_task_type is intentionally preserved)
                 #(#drop_data_inline)*
 
                 // Remove all persistent data-category lazy fields
@@ -2664,7 +2659,6 @@ fn generate_drop_methods(grouped_fields: &GroupedFields) -> TokenStream {
             /// are cleared, along with `prefetched`.
             pub fn drop_data_and_meta(&mut self) {
                 // Reset all persistent inline fields to defaults
-                // (persistent_task_type is intentionally preserved)
                 #(#drop_data_inline)*
                 #(#drop_meta_inline)*