use SharedReference to reduce size

Author: sokra

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

@@ -823,7 +823,6 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         let content = if final_read_hint {
             task.remove_cell_data(is_transient_cell, cell)
         } else if let Some(content) = task.get_cell_data(is_transient_cell, cell) {
-            let content = content.clone();
             Some(content)
         } else {
             None
@@ -2544,7 +2543,8 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         let mut ctx = self.execute_context(turbo_tasks);
         let task = ctx.task(task_id, TaskDataCategory::Data);
         if let Some(content) = task.get_cell_data(options.is_transient_cell, cell) {
-            Ok(CellContent(Some(content.reference.clone())).into_typed(cell.type_id))
+            debug_assert!(content.type_id == cell.type_id, "Cell type ID mismatch");
+            Ok(CellContent(Some(content.reference)).into_typed(cell.type_id))
         } else {
             Ok(CellContent(None).into_typed(cell.type_id))
         }

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

@@ -475,20 +475,23 @@ pub trait TaskGuard: Debug {
         cell: CellId,
     ) -> Option<TypedSharedReference> {
         if is_transient_cell {
-            remove!(self, TransientCellData { cell })
+            remove!(self, TransientCellData { cell }).map(|sr| sr.into_typed(cell.type_id))
         } else {
             remove!(self, CellData { cell })
         }
     }
-    fn get_cell_data(
-        &self,
-        is_transient_cell: bool,
-        cell: CellId,
-    ) -> Option<&TypedSharedReference> {
+    fn get_cell_data(&self, is_transient_cell: bool, cell: CellId) -> Option<TypedSharedReference> {
+        if is_transient_cell {
+            get!(self, TransientCellData { cell }).map(|sr| sr.clone().into_typed(cell.type_id))
+        } else {
+            get!(self, CellData { cell }).cloned()
+        }
+    }
+    fn has_cell_data(&self, is_transient_cell: bool, cell: CellId) -> bool {
         if is_transient_cell {
-            get!(self, TransientCellData { cell })
+            self.has_key(&CachedDataItemKey::TransientCellData { cell })
         } else {
-            get!(self, CellData { cell })
+            self.has_key(&CachedDataItemKey::CellData { cell })
         }
     }
 }

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

@@ -67,18 +67,17 @@ impl UpdateCellOperation {
         let assume_unchanged =
             !ctx.should_track_dependencies() || !task.has_key(&CachedDataItemKey::Dirty {});
 
-        let old_content = task.get_cell_data(is_transient_cell, cell);
-
         if assume_unchanged {
-            if old_content.is_some() {
+            let has_old_content = task.has_cell_data(is_transient_cell, cell);
+            if has_old_content {
                 // Never update cells when recomputing if they already have a value.
                 // It's not expected that content changes during recomputation.
 
                 // Check if this assumption holds.
                 #[cfg(feature = "verify_determinism")]
                 if !is_stateful
                     && matches!(verification_mode, VerificationMode::EqualityCheck)
-                    && content.as_ref() != old_content
+                    && content != task.get_cell_data(is_transient_cell, cell)
                 {
                     let task_description = ctx.get_task_description(task_id);
                     let cell_type = turbo_tasks::registry::get_value_type(cell.type_id).global_name;

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

@@ -1,8 +1,8 @@
 use rustc_hash::FxHashSet;
 use serde::{Deserialize, Serialize};
 use turbo_tasks::{
-    CellId, KeyValuePair, TaskExecutionReason, TaskId, TraitTypeId, TypedSharedReference,
-    ValueTypeId,
+    CellId, KeyValuePair, SharedReference, TaskExecutionReason, TaskId, TraitTypeId,
+    TypedSharedReference, ValueTypeId,
     backend::TurboTasksExecutionError,
     event::{Event, EventListener},
 };
@@ -243,9 +243,10 @@ pub enum CachedDataItem {
         cell: CellId,
         value: TypedSharedReference,
     },
+    #[serde(skip)]
     TransientCellData {
         cell: CellId,
-        value: TypedSharedReference,
+        value: SharedReference,
     },
     CellTypeMaxIndex {
         cell_type: ValueTypeId,
@@ -369,7 +370,10 @@ pub enum CachedDataItem {
 impl CachedDataItem {
     pub fn cell_data(is_transient: bool, cell: CellId, value: TypedSharedReference) -> Self {
         if is_transient {
-            CachedDataItem::TransientCellData { cell, value }
+            CachedDataItem::TransientCellData {
+                cell,
+                value: value.into_untyped(),
+            }
         } else {
             CachedDataItem::CellData { cell, value }
         }