build(deps): update bincode requirement from 1.3.3 to 2.0.1

firewood/Cargo.toml

@@ -26,7 +26,7 @@ sha2 = "0.10.8"
 test-case = "3.3.1"
 thiserror = "2.0.3"
 typed-builder = "0.21.0"
-bincode = "1.3.3"
+bincode = "2.0.1"
 integer-encoding = "4.0.0"
 smallvec = "1.6.1"
 fastrace = { version = "0.7.4" }

storage/Cargo.toml

@@ -7,7 +7,7 @@ rust-version = "1.85.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bincode = "1.3.3"
+bincode = { version = "2.0.1", features = ["serde"] }
 bitflags = "2.5.0"
 enum-as-inner = "0.6.0"
 hex = "0.4.3"

storage/benches/serializer.rs

@@ -6,7 +6,6 @@ use std::fs::File;
 use std::num::NonZeroU64;
 use std::os::raw::c_int;
 
-use bincode::Options;
 use criterion::profiler::Profiler;
 use criterion::{Criterion, criterion_group, criterion_main};
 use pprof::ProfilerGuard;
@@ -61,10 +60,10 @@ fn leaf(c: &mut Criterion) {
         partial_path: Path(SmallVec::from_slice(&[0, 1])),
         value: Box::new([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
     });
-    let serializer = bincode::DefaultOptions::new().with_varint_encoding();
+    let serializer = bincode::config::legacy().with_variable_int_encoding();
     group.bench_with_input("serde", &input, |b, input| {
         b.iter(|| {
-            serializer.serialize(input).unwrap();
+            bincode::serde::encode_to_vec(input, serializer).unwrap();
         })
     });
 
@@ -93,10 +92,10 @@ fn branch(c: &mut Criterion) {
             }
         }),
     }));
-    let serializer = bincode::DefaultOptions::new().with_varint_encoding();
+    let serializer = bincode::config::legacy().with_variable_int_encoding();
     let serde_serializer = |b: &mut criterion::Bencher, input: &storage::Node| {
         b.iter(|| {
-            serializer.serialize(input).unwrap();
+            bincode::serde::encode_to_vec(input, serializer).unwrap();
         })
     };
 

storage/src/nodestore.rs

@@ -4,7 +4,6 @@
 use crate::logger::trace;
 use arc_swap::ArcSwap;
 use arc_swap::access::DynAccess;
-use bincode::{DefaultOptions, Options as _};
 use bytemuck_derive::{AnyBitPattern, NoUninit};
 use coarsetime::Instant;
 use fastrace::local::LocalSpan;
@@ -96,8 +95,8 @@ const AREA_SIZES: [u64; 23] = [
     1024 << 14,
 ];
 
-fn serializer() -> impl bincode::Options {
-    DefaultOptions::new().with_varint_encoding()
+fn serializer() -> bincode::config::Configuration {
+    bincode::config::legacy().with_variable_int_encoding()
 }
 
 fn area_size_hash() -> TrieHash {
@@ -206,8 +205,7 @@ impl<T: ReadInMemoryNode, S: ReadableStorage> NodeStore<T, S> {
     fn area_index_and_size(&self, addr: LinearAddress) -> Result<(AreaIndex, u64), Error> {
         let mut area_stream = self.storage.stream_from(addr.get())?;
 
-        let index: AreaIndex = serializer()
-            .deserialize_from(&mut area_stream)
+        let index: AreaIndex = bincode::decode_from_std_read(&mut area_stream, serializer())
             .map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
 
         let size = *AREA_SIZES.get(index as usize).ok_or(Error::new(
@@ -479,10 +477,10 @@ impl<S: ReadableStorage> NodeStore<Arc<ImmutableProposal>, S> {
                 *free_stored_area_addr = free_head;
             } else {
                 let free_area_addr = address.get();
-                let free_head_stream = self.storage.stream_from(free_area_addr)?;
-                let free_head: StoredArea<Area<Node, FreeArea>> = serializer()
-                    .deserialize_from(free_head_stream)
-                    .map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
+                let mut free_head_stream = self.storage.stream_from(free_area_addr)?;
+                let free_head: StoredArea<Area<Node, FreeArea>> =
+                    bincode::serde::decode_from_std_read(&mut free_head_stream, serializer())
+                        .map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
                 let StoredArea {
                     area: Area::Free(free_head),
                     area_size_index: read_index,
@@ -576,8 +574,7 @@ impl<S: WritableStorage> NodeStore<Committed, S> {
             area,
         };
 
-        let stored_area_bytes = serializer()
-            .serialize(&stored_area)
+        let stored_area_bytes = bincode::serde::encode_to_vec(&stored_area, serializer())
             .map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
 
         self.storage.write(addr.into(), &stored_area_bytes)?;