count as dirty when self dirty or container dirty

Author: sokra

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

@@ -2347,32 +2347,31 @@ 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),
-            Some(Dirtyness::SessionDependent) => {
-                let clean_in_session = get!(task, CleanInSession).copied();
-                (
-                    true,
-                    clean_in_session == Some(self.session_id),
-                    clean_in_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 };
+        let (old_self_dirty, old_current_session_self_clean, old_clean_in_session) =
+            match old_dirtyness {
+                None => (false, false, None),
+                Some(Dirtyness::Dirty) => (true, false, None),
+                Some(Dirtyness::SessionDependent) => {
+                    let clean_in_session = get!(task, CleanInSession).copied();
+                    (
+                        true,
+                        clean_in_session == Some(self.session_id),
+                        clean_in_session,
+                    )
+                }
+            };
 
         // Compute the new dirty state
-        let (new_dirtyness, new_clean_in_session, new_dirty_value, new_current_session_clean_value) =
+        let (new_dirtyness, new_clean_in_session, new_self_dirty, new_current_session_self_clean) =
             if session_dependent {
                 (
                     Some(Dirtyness::SessionDependent),
                     Some(self.session_id),
-                    1,
-                    1,
+                    true,
+                    true,
                 )
             } else {
-                (None, None, 0, 0)
+                (None, None, false, false)
             };
 
         // Update the dirty state
@@ -2392,8 +2391,8 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         }
 
         // Propagate dirtyness changes
-        let data_update = if old_dirty_value != new_dirty_value
-            || old_current_session_clean_value != new_current_session_clean_value
+        let data_update = if old_self_dirty != new_self_dirty
+            || old_current_session_self_clean != new_current_session_self_clean
         {
             let dirty_container_count = get!(task, AggregatedDirtyContainerCount)
                 .cloned()
@@ -2411,10 +2410,10 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 new_dirty_container_count: dirty_container_count,
                 old_current_session_clean_container_count: current_session_clean_container_count,
                 new_current_session_clean_container_count: current_session_clean_container_count,
-                old_dirty_value,
-                new_dirty_value,
-                old_current_session_clean_value,
-                new_current_session_clean_value,
+                old_self_dirty,
+                new_self_dirty,
+                old_current_session_self_clean,
+                new_current_session_self_clean,
             }
             .compute();
             result

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

@@ -99,10 +99,10 @@ pub struct ComputeDirtyAndCleanUpdate {
     pub new_dirty_container_count: i32,
     pub old_current_session_clean_container_count: i32,
     pub new_current_session_clean_container_count: i32,
-    pub old_dirty_value: i32,
-    pub new_dirty_value: i32,
-    pub old_current_session_clean_value: i32,
-    pub new_current_session_clean_value: i32,
+    pub old_self_dirty: bool,
+    pub new_self_dirty: bool,
+    pub old_current_session_self_clean: bool,
+    pub new_current_session_self_clean: bool,
 }
 
 pub struct ComputeDirtyAndCleanUpdateResult {
@@ -117,23 +117,19 @@ impl ComputeDirtyAndCleanUpdate {
             new_dirty_container_count,
             old_current_session_clean_container_count,
             new_current_session_clean_container_count,
-            old_dirty_value,
-            new_dirty_value,
-            old_current_session_clean_value,
-            new_current_session_clean_value,
+            old_self_dirty,
+            new_self_dirty,
+            old_current_session_self_clean,
+            new_current_session_self_clean,
         } = self;
-        let was_dirty_without_clean = old_dirty_container_count + old_dirty_value > 0;
-        let is_dirty_without_clean = new_dirty_container_count + new_dirty_value > 0;
-        let was_dirty = was_dirty_without_clean
-            && old_dirty_container_count + old_dirty_value
-                - old_current_session_clean_container_count
-                - old_current_session_clean_value
-                > 0;
-        let is_dirty = is_dirty_without_clean
-            && new_dirty_container_count + new_dirty_value
-                - new_current_session_clean_container_count
-                - new_current_session_clean_value
-                > 0;
+        let was_dirty_without_clean = old_self_dirty || old_dirty_container_count > 0;
+        let is_dirty_without_clean = new_self_dirty || new_dirty_container_count > 0;
+        let was_dirty = old_self_dirty && !old_current_session_self_clean
+            || old_dirty_container_count > 0
+                && old_dirty_container_count > old_current_session_clean_container_count;
+        let is_dirty = new_self_dirty && !new_current_session_self_clean
+            || new_dirty_container_count > 0
+                && new_dirty_container_count > new_current_session_clean_container_count;
         let was_flagged_clean = was_dirty_without_clean && !was_dirty;
         let is_flagged_clean = is_dirty_without_clean && !is_dirty;
 
@@ -501,9 +497,7 @@ impl AggregatedDataUpdate {
                 before_after_to_diff_value(was_single_container_clean, is_single_container_clean);
 
             if dirty_container_count_update != 0 || current_session_clean_update != 0 {
-                let (is_dirty, current_session_clean) = task.dirty(current_session_id);
-                let dirty_value = if is_dirty { 1 } else { 0 };
-                let clean_value = if current_session_clean { 1 } else { 0 };
+                let (is_self_dirty, current_session_self_clean) = task.dirty(current_session_id);
 
                 let task_id = task.id();
 
@@ -525,8 +519,8 @@ impl AggregatedDataUpdate {
                     old_dirty_container_count = new_dirty_container_count;
                 };
 
-                let was_dirty_without_clean = old_dirty_container_count + dirty_value > 0;
-                let is_dirty_without_clean = new_dirty_container_count + dirty_value > 0;
+                let was_dirty_without_clean = is_self_dirty || old_dirty_container_count > 0;
+                let is_dirty_without_clean = is_self_dirty || new_dirty_container_count > 0;
 
                 let upper_count_update =
                     before_after_to_diff_value(was_dirty_without_clean, is_dirty_without_clean);
@@ -557,16 +551,14 @@ impl AggregatedDataUpdate {
                         new_current_session_clean_container_count;
                 };
 
-                let was_dirty = was_dirty_without_clean
-                    && old_dirty_container_count + dirty_value
-                        - old_current_session_clean_container_count
-                        - clean_value
-                        > 0;
-                let is_dirty = is_dirty_without_clean
-                    && new_dirty_container_count + dirty_value
-                        - new_current_session_clean_container_count
-                        - clean_value
-                        > 0;
+                let was_dirty = is_self_dirty && !current_session_self_clean
+                    || old_dirty_container_count > 0
+                        && old_dirty_container_count - old_current_session_clean_container_count
+                            > 0;
+                let is_dirty = is_self_dirty && !current_session_self_clean
+                    || new_dirty_container_count > 0
+                        && new_dirty_container_count - new_current_session_clean_container_count
+                            > 0;
 
                 let was_flagged_clean = was_dirty_without_clean && !was_dirty;
                 let is_flagged_clean = is_dirty_without_clean && !is_dirty;
@@ -578,10 +570,10 @@ impl AggregatedDataUpdate {
                     new_dirty_container_count,
                     old_current_session_clean_container_count,
                     new_current_session_clean_container_count,
-                    old_dirty_value: dirty_value,
-                    new_dirty_value: dirty_value,
-                    old_current_session_clean_value: clean_value,
-                    new_current_session_clean_value: clean_value,
+                    old_self_dirty: is_self_dirty,
+                    new_self_dirty: is_self_dirty,
+                    old_current_session_self_clean: current_session_self_clean,
+                    new_current_session_self_clean: current_session_self_clean,
                 }
                 .compute();
                 assert_eq!(compute_result.dirty_count_update, upper_count_update);

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

@@ -234,7 +234,7 @@ pub fn make_task_dirty_internal(
     let old = task.insert(CachedDataItem::Dirty {
         value: Dirtyness::Dirty,
     });
-    let (old_dirty_value, old_current_session_clean_value) = match old {
+    let (old_self_dirty, old_current_session_self_clean) = match old {
         Some(CachedDataItemValue::Dirty {
             value: Dirtyness::Dirty,
         }) => {
@@ -259,7 +259,7 @@ pub fn make_task_dirty_internal(
             {
                 // There was a clean count for a session. If it was the current session, we need to
                 // propagate that change.
-                (1, 1)
+                (true, true)
             } else {
                 #[cfg(feature = "trace_task_dirty")]
                 let _span = tracing::trace_span!(
@@ -274,13 +274,13 @@ pub fn make_task_dirty_internal(
         }
         None => {
             // It was clean before, so we need to increase the dirty count
-            (0, 0)
+            (false, false)
         }
         _ => unreachable!(),
     };
 
-    let new_dirty_value = 1;
-    let new_current_session_clean_value = 0;
+    let new_self_dirty = true;
+    let new_current_session_self_clean = false;
 
     let dirty_container_count = get!(task, AggregatedDirtyContainerCount)
         .copied()
@@ -308,10 +308,10 @@ pub fn make_task_dirty_internal(
         new_dirty_container_count: dirty_container_count,
         old_current_session_clean_container_count: current_session_clean_container_count,
         new_current_session_clean_container_count: current_session_clean_container_count,
-        old_dirty_value,
-        new_dirty_value,
-        old_current_session_clean_value,
-        new_current_session_clean_value,
+        old_self_dirty,
+        new_self_dirty,
+        old_current_session_self_clean,
+        new_current_session_self_clean,
     }
     .compute();