Use of the Arc<Box<[u8]>> for the CompressedBytecode. (#4418)

## Motivation

We are using the `Vec<u8>` in the `CompressedBytecode`. But the vector
is never modified so this makes
a copy that is not needed.

## Proposal

The compressed bytecode is now a `Arc<Box<[u8]>>`. An alternative could
have been to use `BlobContent`.
However, we would need to track the `BlobType`, which would be hard.

## Test Plan

The CI.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

linera-base/src/data_types.rs

@@ -23,6 +23,7 @@ use async_graphql::{InputObject, SimpleObject};
 use custom_debug_derive::Debug;
 use linera_witty::{WitLoad, WitStore, WitType};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_with::{serde_as, Bytes};
 use thiserror::Error;
 
 #[cfg(with_metrics)]
@@ -1124,10 +1125,12 @@ impl Bytecode {
     pub fn compress(&self) -> CompressedBytecode {
         #[cfg(with_metrics)]
         let _compression_latency = metrics::BYTECODE_COMPRESSION_LATENCY.measure_latency();
-        let compressed_bytes = zstd::stream::encode_all(&*self.bytes, 19)
+        let compressed_bytes_vec = zstd::stream::encode_all(&*self.bytes, 19)
             .expect("Compressing bytes in memory should not fail");
 
-        CompressedBytecode { compressed_bytes }
+        CompressedBytecode {
+            compressed_bytes: Arc::new(compressed_bytes_vec.into_boxed_slice()),
+        }
     }
 
     /// Compresses the [`Bytecode`] into a [`CompressedBytecode`].
@@ -1138,13 +1141,15 @@ impl Bytecode {
         #[cfg(with_metrics)]
         let _compression_latency = metrics::BYTECODE_COMPRESSION_LATENCY.measure_latency();
 
-        let mut compressed_bytes = Vec::new();
+        let mut compressed_bytes_vec = Vec::new();
         let mut compressor = FrameCompressor::new(CompressionLevel::Fastest);
         compressor.set_source(&*self.bytes);
-        compressor.set_drain(&mut compressed_bytes);
+        compressor.set_drain(&mut compressed_bytes_vec);
         compressor.compress();
 
-        CompressedBytecode { compressed_bytes }
+        CompressedBytecode {
+            compressed_bytes: Arc::new(compressed_bytes_vec.into_boxed_slice()),
+        }
     }
 }
 
@@ -1163,13 +1168,14 @@ pub enum DecompressionError {
 }
 
 /// A compressed module bytecode (WebAssembly or EVM).
+#[serde_as]
 #[derive(Clone, Debug, Deserialize, Hash, Serialize, WitType, WitStore)]
 #[cfg_attr(with_testing, derive(Eq, PartialEq))]
 pub struct CompressedBytecode {
     /// Compressed bytes of the bytecode.
-    #[serde(with = "serde_bytes")]
-    #[debug(with = "hex_debug")]
-    pub compressed_bytes: Vec<u8>,
+    #[serde_as(as = "Arc<Bytes>")]
+    #[debug(skip)]
+    pub compressed_bytes: Arc<Box<[u8]>>,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -1195,7 +1201,7 @@ impl CompressedBytecode {
     pub fn decompress(&self) -> Result<Bytecode, DecompressionError> {
         #[cfg(with_metrics)]
         let _decompression_latency = metrics::BYTECODE_DECOMPRESSION_LATENCY.measure_latency();
-        let bytes = zstd::stream::decode_all(&*self.compressed_bytes)?;
+        let bytes = zstd::stream::decode_all(&**self.compressed_bytes)?;
 
         Ok(Bytecode { bytes })
     }
@@ -1232,7 +1238,7 @@ impl CompressedBytecode {
 
         let compressed_bytes = &*self.compressed_bytes;
         let mut bytes = Vec::new();
-        let mut decoder = StreamingDecoder::new(compressed_bytes).map_err(io::Error::other)?;
+        let mut decoder = StreamingDecoder::new(&**compressed_bytes).map_err(io::Error::other)?;
 
         // TODO(#2710): Decode multiple frames, if present
         while !decoder.get_ref().is_empty() {
@@ -1247,8 +1253,6 @@ impl CompressedBytecode {
 
 impl BcsHashable<'_> for BlobContent {}
 
-use serde_with::*;
-
 /// A blob of binary data.
 #[serde_as]
 #[derive(Hash, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -1278,23 +1282,26 @@ impl BlobContent {
 
     /// Creates a new contract bytecode [`BlobContent`] from the provided bytes.
     pub fn new_contract_bytecode(compressed_bytecode: CompressedBytecode) -> Self {
-        BlobContent::new(
-            BlobType::ContractBytecode,
-            compressed_bytecode.compressed_bytes,
-        )
+        BlobContent {
+            blob_type: BlobType::ContractBytecode,
+            bytes: compressed_bytecode.compressed_bytes,
+        }
     }
 
     /// Creates a new contract bytecode [`BlobContent`] from the provided bytes.
     pub fn new_evm_bytecode(compressed_bytecode: CompressedBytecode) -> Self {
-        BlobContent::new(BlobType::EvmBytecode, compressed_bytecode.compressed_bytes)
+        BlobContent {
+            blob_type: BlobType::EvmBytecode,
+            bytes: compressed_bytecode.compressed_bytes,
+        }
     }
 
     /// Creates a new service bytecode [`BlobContent`] from the provided bytes.
     pub fn new_service_bytecode(compressed_bytecode: CompressedBytecode) -> Self {
-        BlobContent::new(
-            BlobType::ServiceBytecode,
-            compressed_bytecode.compressed_bytes,
-        )
+        BlobContent {
+            blob_type: BlobType::ServiceBytecode,
+            bytes: compressed_bytecode.compressed_bytes,
+        }
     }
 
     /// Creates a new application description [`BlobContent`] from a [`ApplicationDescription`].
@@ -1326,6 +1333,11 @@ impl BlobContent {
         bytes.into_vec()
     }
 
+    /// Get the Arc<Box<[u8]>> directly without cloning.
+    pub fn into_arc_bytes(self) -> Arc<Box<[u8]>> {
+        self.bytes
+    }
+
     /// Returns the type of data represented by this blob's bytes.
     pub fn blob_type(&self) -> BlobType {
         self.blob_type

linera-execution/src/test_utils/mod.rs

@@ -90,10 +90,10 @@ pub fn create_dummy_user_application_description(
     contract_bytes.push(index as u8);
     service_bytes.push(index as u8);
     let contract_blob = Blob::new_contract_bytecode(CompressedBytecode {
-        compressed_bytes: contract_bytes,
+        compressed_bytes: Arc::new(contract_bytes.into_boxed_slice()),
     });
     let service_blob = Blob::new_service_bytecode(CompressedBytecode {
-        compressed_bytes: service_bytes,
+        compressed_bytes: Arc::new(service_bytes.into_boxed_slice()),
     });
 
     let vm_runtime = VmRuntime::Wasm;

linera-execution/tests/contract_runtime_apis.rs

@@ -5,6 +5,7 @@
 
 use std::{
     collections::{BTreeMap, BTreeSet},
+    sync::Arc,
     vec,
 };
 
@@ -672,15 +673,15 @@ impl TransferTestEndpoint {
     /// sender as an application.
     fn sender_application_contract_blob() -> Blob {
         Blob::new_contract_bytecode(CompressedBytecode {
-            compressed_bytes: b"sender contract".to_vec(),
+            compressed_bytes: Arc::new(b"sender contract".to_vec().into_boxed_slice()),
         })
     }
 
     /// Returns the [`Blob`] that represents the service bytecode used when representing the sender
     /// as an application.
     fn sender_application_service_blob() -> Blob {
         Blob::new_service_bytecode(CompressedBytecode {
-            compressed_bytes: b"sender service".to_vec(),
+            compressed_bytes: Arc::new(b"sender service".to_vec().into_boxed_slice()),
         })
     }
 

linera-storage/src/lib.rs

@@ -276,7 +276,7 @@ pub trait Storage: Sized {
                 .into_content(),
         };
         let compressed_contract_bytecode = CompressedBytecode {
-            compressed_bytes: content.into_vec_or_clone(),
+            compressed_bytes: content.into_arc_bytes(),
         };
         #[cfg_attr(not(any(with_wasm_runtime, with_revm)), allow(unused_variables))]
         let contract_bytecode =
@@ -343,7 +343,7 @@ pub trait Storage: Sized {
                 .into_content(),
         };
         let compressed_service_bytecode = CompressedBytecode {
-            compressed_bytes: content.into_vec_or_clone(),
+            compressed_bytes: content.into_arc_bytes(),
         };
         #[cfg_attr(not(any(with_wasm_runtime, with_revm)), allow(unused_variables))]
         let service_bytecode = linera_base::task::Blocking::<linera_base::task::NoInput, _>::spawn(