WIP: Turbopack: Use bincode to store the contents of value cells

Author: bgw

Cargo.lock

@@ -360,7 +360,6 @@ preset_env_base = "5.0.0"
 
 
 # General Deps
-bincode = { version = "2.0.1", features = ["serde"] }
 chromiumoxide = { version = "0.5.4", features = [
   "tokio-runtime",
 ], default-features = false }
@@ -378,6 +377,7 @@ async-compression = { version = "0.3.13", default-features = false, features = [
   "tokio",
 ] }
 async-trait = "0.1.64"
+bincode = { version = "2.0.1", features = ["serde"] }
 bitfield = "0.18.0"
 byteorder = "1.5.0"
 bytes = "1.1.0"
@@ -397,12 +397,13 @@ either = "1.9.0"
 erased-serde = "0.4.5"
 flate2 = "1.0.28"
 futures = "0.3.31"
-futures-util = "0.3.31"
 futures-retry = "0.6.0"
+futures-util = "0.3.31"
 hashbrown = "0.14.5"
 image = { version = "0.25.8", default-features = false }
 indexmap = "2.7.1"
 indoc = "2.0.0"
+inventory = "0.3.21"
 itertools = "0.10.5"
 lightningcss = { version = "1.0.0-alpha.68", features = [
   "serde",
@@ -447,11 +448,10 @@ ringmap = "0.1.3"
 roaring = "0.10.10"
 rstest = "0.16.0"
 rustc-hash = "2.1.1"
-twox-hash = { version = "2.1.0", features = ["xxhash64", "xxhash3_128"] }
 semver = "1.0.16"
 serde = { version = "1.0.217", features = ["derive"] }
-serde_json = "1.0.138"
 serde_bytes = "0.11.15"
+serde_json = "1.0.138"
 serde_path_to_error = "0.1.16"
 serde_qs = "0.13.0"
 serde_with = "3.12.0"
@@ -462,26 +462,27 @@ smallvec = { version = "1.15.1", features = [
   "const_new",
   "impl_bincode",
 ] }
-swc_sourcemap = "9.3.4"
-strsim = "0.11.1"
 shrink-to-fit = "0.2.10"
+strsim = "0.11.1"
+swc_sourcemap = "9.3.4"
 syn = "2.0.100"
 tempfile = "3.20.0"
-thread_local = "1.1.8"
 thiserror = "1.0.48"
+thread_local = "1.1.8"
 tokio = "1.43.0"
 tokio-util = { version = "0.7.13", features = ["io", "rt"] }
 tracing = "0.1.37"
 tracing-subscriber = "0.3.16"
 triomphe = { git = "https://github.com/sokra/triomphe", branch = "sokra/unstable" }
+twox-hash = { version = "2.1.0", features = ["xxhash64", "xxhash3_128"] }
 unsize = "1.1.0"
+unty = "0.0.4"
 url = "2.2.2"
 urlencoding = "2.1.2"
 uuid = "1.18.1"
 vergen = { version = "9.0.6", features = ["cargo"] }
 vergen-gitcl = { version = "1.0.8", features = ["cargo"] }
 webbrowser = "1.0.6"
-inventory = "0.3.21"
 
 [patch.crates-io]
 bincode = { git = "https://github.com/bgw/bincode.git", branch = "bgw/patches" }

Cargo.toml

@@ -17,3 +17,4 @@ indexmap = { workspace = true }
 mime = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+smallvec = { workspace = true }

turbopack/crates/turbo-bincode/Cargo.toml

@@ -1,10 +1,85 @@
+use std::ptr::copy_nonoverlapping;
+
+use ::smallvec::SmallVec;
 use bincode::{
     BorrowDecode, Decode, Encode,
-    de::{BorrowDecoder, Decoder},
-    enc::Encoder,
+    de::{BorrowDecoder, Decoder, DecoderImpl, read::Reader},
+    enc::{Encoder, EncoderImpl, write::Writer},
     error::{DecodeError, EncodeError},
 };
 
+pub const TURBO_BINCODE_CONFIG: bincode::config::Configuration = bincode::config::standard();
+pub type TurboBincodeBuffer = SmallVec<[u8; 16]>;
+pub type TurboBincodeEncoder = EncoderImpl<TurboBincodeWriter, bincode::config::Configuration>;
+pub type TurboBincodeDecoder<'a> =
+    DecoderImpl<TurboBincodeReader<'a>, bincode::config::Configuration, ()>;
+
+pub fn new_turbo_bincode_encoder() -> TurboBincodeEncoder {
+    EncoderImpl::new(TurboBincodeWriter::new(), TURBO_BINCODE_CONFIG)
+}
+
+pub fn new_turbo_bincode_decoder<'a>(buffer: &'a [u8]) -> TurboBincodeDecoder<'a> {
+    DecoderImpl::new(TurboBincodeReader::new(buffer), TURBO_BINCODE_CONFIG, ())
+}
+
+pub struct TurboBincodeWriter {
+    pub buffer: TurboBincodeBuffer,
+}
+
+impl TurboBincodeWriter {
+    pub fn new() -> Self {
+        Self {
+            buffer: SmallVec::new(),
+        }
+    }
+}
+
+impl Writer for TurboBincodeWriter {
+    fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError> {
+        self.buffer.extend_from_slice(bytes);
+        Ok(())
+    }
+}
+
+pub struct TurboBincodeReader<'a> {
+    pub buffer: &'a [u8],
+}
+
+impl<'a> TurboBincodeReader<'a> {
+    pub fn new(buffer: &'a [u8]) -> Self {
+        Self { buffer }
+    }
+}
+
+impl Reader for TurboBincodeReader<'_> {
+    fn read(&mut self, target_buffer: &mut [u8]) -> Result<(), DecodeError> {
+        let len = target_buffer.len();
+        let (head, rest) = self
+            .buffer
+            .split_at_checked(len)
+            .ok_or(DecodeError::UnexpectedEnd {
+                additional: target_buffer.len() - self.buffer.len(),
+            })?;
+        // SAFETY:
+        // - We already checked the bounds.
+        // - These memory ranges can't overlap because it would violate rust aliasing rules.
+        // - `u8` is `Copy`.
+        unsafe {
+            copy_nonoverlapping(head.as_ptr(), target_buffer.as_mut_ptr(), len);
+        }
+        self.buffer = rest;
+        Ok(())
+    }
+
+    fn peek_read(&mut self, n: usize) -> Option<&[u8]> {
+        Some(&self.buffer[..n])
+    }
+
+    fn consume(&mut self, n: usize) {
+        self.buffer = &self.buffer[n..];
+    }
+}
+
 pub mod indexmap {
     use std::hash::{BuildHasher, Hash};
 
@@ -381,3 +456,70 @@ pub mod either {
         }
     }
 }
+
+pub mod smallvec {
+    use ::smallvec::Array;
+
+    use super::*;
+
+    pub fn encode<E: Encoder, A: Array<Item = impl Encode>>(
+        vec: &SmallVec<A>,
+        encoder: &mut E,
+    ) -> Result<(), EncodeError> {
+        usize::encode(&vec.len(), encoder)?;
+        for item in vec {
+            Encode::encode(item, encoder)?;
+        }
+        Ok(())
+    }
+
+    pub fn decode<Context, D: Decoder<Context = Context>, A: Array<Item = impl Decode<Context>>>(
+        decoder: &mut D,
+    ) -> Result<SmallVec<A>, DecodeError> {
+        let len = usize::decode(decoder)?;
+        let mut vec = SmallVec::with_capacity(len);
+        for _ in 0..len {
+            vec.push(Decode::decode(decoder)?);
+        }
+        Ok(vec)
+    }
+
+    pub fn borrow_decode<
+        'de,
+        Context,
+        D: BorrowDecoder<'de, Context = Context>,
+        A: Array<Item = impl BorrowDecode<'de, Context>>,
+    >(
+        decoder: &mut D,
+    ) -> Result<SmallVec<A>, DecodeError> {
+        let len = usize::decode(decoder)?;
+        let mut vec = SmallVec::with_capacity(len);
+        for _ in 0..len {
+            vec.push(BorrowDecode::borrow_decode(decoder)?);
+        }
+        Ok(vec)
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use bincode::{decode_from_slice, encode_to_vec};
+
+        use super::*;
+
+        #[test]
+        fn test_roundtrip() {
+            let cfg = bincode::config::standard();
+
+            #[derive(Encode, Decode)]
+            struct Wrapper(#[bincode(with = "crate::smallvec")] SmallVec<[u32; 4]>);
+
+            let vec1 = Wrapper(SmallVec::from_slice(&[1u32, 2, 3, 4, 5]));
+
+            let vec2: Wrapper = decode_from_slice(&encode_to_vec(&vec1, cfg).unwrap(), cfg)
+                .unwrap()
+                .0;
+
+            assert_eq!(vec1.0, vec2.0);
+        }
+    }
+}

turbopack/crates/turbo-bincode/src/lib.rs

@@ -10,6 +10,7 @@ use std::{
 };
 
 use anyhow::Result;
+use bincode::{Decode, Encode};
 use indexmap::map::Entry;
 use ringmap::RingSet;
 use rustc_hash::{FxBuildHasher, FxHashMap};
@@ -91,9 +92,11 @@ pub fn get_aggregation_number(task: &impl TaskGuard) -> u32 {
         .unwrap_or_default()
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Encode, Decode, Clone, Debug)]
 pub struct InnerOfUppersHasNewFollowersJob {
+    #[bincode(with = "turbo_bincode::smallvec")]
     pub upper_ids: TaskIdVec,
+    #[bincode(with = "turbo_bincode::smallvec")]
     pub new_follower_ids: TaskIdVec,
 }
 
@@ -103,9 +106,11 @@ impl From<InnerOfUppersHasNewFollowersJob> for AggregationUpdateJob {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Encode, Decode, Clone, Debug)]
 pub struct InnerOfUppersLostFollowersJob {
+    #[bincode(with = "turbo_bincode::smallvec")]
     pub upper_ids: TaskIdVec,
+    #[bincode(with = "turbo_bincode::smallvec")]
     pub lost_follower_ids: TaskIdVec,
 }
 
@@ -115,7 +120,7 @@ impl From<InnerOfUppersLostFollowersJob> for AggregationUpdateJob {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Encode, Decode, Clone, Debug)]
 pub struct AggregatedDataUpdateJob {
     pub upper_ids: TaskIdVec,
     pub update: AggregatedDataUpdate,

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

@@ -1,6 +1,6 @@
 use std::mem::take;
 
-use serde::{Deserialize, Serialize};
+use bincode::{Decode, Encode};
 use smallvec::SmallVec;
 #[cfg(not(feature = "verify_determinism"))]
 use turbo_tasks::backend::VerificationMode;
@@ -20,7 +20,7 @@ use crate::{
     data::{CachedDataItem, CachedDataItemKey, CellRef},
 };
 
-#[derive(Serialize, Deserialize, Clone, Default)]
+#[derive(Encode, Decode, Clone, Default)]
 #[allow(clippy::large_enum_variant)]
 pub enum UpdateCellOperation {
     InvalidateWhenCellDependency {