Remove session id from data entries and make them transient for the current session

Author: sokra

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

@@ -557,10 +557,10 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 }
             }
 
-            let is_dirty = task.is_dirty(self.session_id);
+            let is_dirty = task.is_dirty();
 
             // Check the dirty count of the root node
-            let dirty_tasks = task.dirty_container_count(self.session_id);
+            let dirty_tasks = task.dirty_container_count();
             if dirty_tasks > 0 || is_dirty {
                 let activeness = get_mut!(task, Activeness);
                 let mut task_ids_to_schedule: Vec<_> = Vec::new();
@@ -579,7 +579,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                         .set_active_until_clean();
                     if ctx.should_track_activeness() {
                         // A newly added Activeness need to make sure to schedule the tasks
-                        task_ids_to_schedule = task.dirty_containers(self.session_id).collect();
+                        task_ids_to_schedule = task.dirty_containers().collect();
                         task_ids_to_schedule.push(task_id);
                     }
                     get!(task, Activeness).unwrap()
@@ -603,7 +603,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                             visited: &mut FxHashSet<TaskId>,
                         ) -> String {
                             let task = ctx.task(task_id, TaskDataCategory::Data);
-                            let is_dirty = task.is_dirty(ctx.session_id());
+                            let is_dirty = task.is_dirty();
                             let in_progress =
                                 get!(task, InProgress).map_or("not in progress", |p| match p {
                                     InProgressState::InProgress(_) => "in progress",
@@ -624,7 +624,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                             };
 
                             // Check the dirty count of the root node
-                            let dirty_tasks = task.dirty_container_count(ctx.session_id());
+                            let dirty_tasks = task.dirty_container_count();
 
                             let task_description = ctx.get_task_description(task_id);
                             let is_dirty = if is_dirty { ", dirty" } else { "" };
@@ -637,8 +637,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                                 "{task_id} {task_description}{count} (aggr={aggregation_number}, \
                                  {in_progress}, {activeness}{is_dirty})",
                             );
-                            let children: Vec<_> =
-                                task.dirty_containers_with_count(ctx.session_id()).collect();
+                            let children: Vec<_> = task.dirty_containers_with_count().collect();
                             drop(task);
 
                             if missing_upper {
@@ -2288,33 +2287,28 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         // Grab the old dirty state
         let old_dirtyness = get!(task, Dirty).cloned();
-        let (was_dirty, was_current_session_clean, old_clean_in_session) = match old_dirtyness {
-            None => (false, false, None),
-            Some(Dirtyness::Dirty) => (true, false, None),
+        let (was_dirty, was_current_session_clean) = match old_dirtyness {
+            None => (false, false),
+            Some(Dirtyness::Dirty) => (true, false),
             Some(Dirtyness::SessionDependent) => {
-                let clean_in_session = get!(task, CleanInSession).copied();
-                (
-                    true,
-                    clean_in_session == Some(self.session_id),
-                    clean_in_session,
-                )
+                let clean_in_current_session = get!(task, CurrentSessionClean).is_some();
+                (true, clean_in_current_session)
             }
         };
         let old_dirty_value = if was_dirty { 1 } else { 0 };
         let old_current_session_clean_value = if was_current_session_clean { 1 } else { 0 };
 
         // Compute the new dirty state
-        let (new_dirtyness, new_clean_in_session, new_dirty_value, new_current_session_clean_value) =
-            if session_dependent {
-                (
-                    Some(Dirtyness::SessionDependent),
-                    Some(self.session_id),
-                    1,
-                    1,
-                )
-            } else {
-                (None, None, 0, 0)
-            };
+        let (
+            new_dirtyness,
+            new_clean_in_current_session,
+            new_dirty_value,
+            new_current_session_clean_value,
+        ) = if session_dependent {
+            (Some(Dirtyness::SessionDependent), true, 1, 1)
+        } else {
+            (None, false, 0, 0)
+        };
 
         // Update the dirty state
         if old_dirtyness != new_dirtyness {
@@ -2324,11 +2318,11 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 task.remove(&CachedDataItemKey::Dirty {});
             }
         }
-        if old_clean_in_session != new_clean_in_session {
-            if let Some(session_id) = new_clean_in_session {
-                task.insert(CachedDataItem::CleanInSession { value: session_id });
-            } else if old_clean_in_session.is_some() {
-                task.remove(&CachedDataItemKey::CleanInSession {});
+        if was_current_session_clean != new_clean_in_current_session {
+            if new_clean_in_current_session {
+                task.insert(CachedDataItem::CurrentSessionClean { value: () });
+            } else if was_current_session_clean {
+                task.remove(&CachedDataItemKey::CurrentSessionClean {});
             }
         }
 
@@ -2339,14 +2333,10 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
             let dirty_container_count = get!(task, AggregatedDirtyContainerCount)
                 .cloned()
                 .unwrap_or_default();
-            let current_session_clean_container_count = get!(
-                task,
-                AggregatedSessionDependentCleanContainerCount {
-                    session_id: self.session_id
-                }
-            )
-            .copied()
-            .unwrap_or_default();
+            let current_session_clean_container_count =
+                get!(task, AggregatedCurrentSessionCleanContainerCount)
+                    .copied()
+                    .unwrap_or_default();
             let result = ComputeDirtyAndCleanUpdate {
                 old_dirty_container_count: dirty_container_count,
                 new_dirty_container_count: dirty_container_count,
@@ -2837,8 +2827,8 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         let mut ctx = self.execute_context(turbo_tasks);
         let mut task = ctx.task(task_id, TaskDataCategory::All);
-        let is_dirty = task.is_dirty(self.session_id);
-        let has_dirty_containers = task.dirty_container_count(self.session_id) > 0;
+        let is_dirty = task.is_dirty();
+        let has_dirty_containers = task.dirty_container_count() > 0;
         if is_dirty || has_dirty_containers {
             if let Some(activeness_state) = get_mut!(task, Activeness) {
                 // We will finish the task, but it would be removed after the task is done
@@ -2928,7 +2918,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 }
 
                 let is_dirty = get!(task, Dirty).is_some();
-                let has_dirty_container = task.dirty_container_count(self.session_id) > 0;
+                let has_dirty_container = task.dirty_container_count() > 0;
                 let should_be_in_upper = is_dirty || has_dirty_container;
 
                 let aggregation_number = get_aggregation_number(&task);