perf(vm): Fix VM performance regression on CI loadtest

.github/workflows/ci-core-reusable.yml

@@ -90,8 +90,10 @@ jobs:
 
       - name: Loadtest configuration
         run: |
-          echo EXPECTED_TX_COUNT=${{ matrix.vm_mode == 'new' && 22000 || 16000 }} >> .env
-          echo ACCOUNTS_AMOUNT="150" >> .env
+          echo EXPECTED_TX_COUNT=${{ matrix.vm_mode == 'new' && 21000 || 16000 }} >> .env
+          echo ACCOUNTS_AMOUNT="100" >> .env
+          echo MAX_INFLIGHT_TXS="10" >> .env
+          echo SYNC_API_REQUESTS_LIMIT="15" >> .env
           echo FAIL_FAST=true >> .env
           echo IN_DOCKER=1 >> .env
           echo DATABASE_MERKLE_TREE_MODE=lightweight >> .env
@@ -115,7 +117,8 @@ jobs:
       - name: Run server
         run: |
           EXPERIMENTAL_VM_STATE_KEEPER_FAST_VM_MODE=${{ matrix.vm_mode }} \
-          PASSED_ENV_VARS="EXPERIMENTAL_VM_STATE_KEEPER_FAST_VM_MODE" \
+          CHAIN_MEMPOOL_DELAY_INTERVAL=50 \
+          PASSED_ENV_VARS="EXPERIMENTAL_VM_STATE_KEEPER_FAST_VM_MODE,CHAIN_MEMPOOL_DELAY_INTERVAL" \
             ci_run zk server --uring --components api,tree,eth,state_keeper,housekeeper,commitment_generator,vm_runner_protective_reads &>server.log &
           ci_run sleep 60
 

core/lib/multivm/src/versions/shadow.rs

@@ -77,7 +77,7 @@ where
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         let tx_hash = tx.hash();
         let main_result = self.main.inspect_transaction_with_bytecode_compression(
             tracer,

core/lib/multivm/src/versions/vm_1_3_2/vm.rs

@@ -83,7 +83,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         if let Some(storage_invocations) = tracer.storage_invocations {
             self.vm
                 .execution_mode
@@ -156,7 +156,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
                 result,
             )
         } else {
-            (Ok(compressed_bytecodes), result)
+            (Ok(compressed_bytecodes.into()), result)
         }
     }
 

core/lib/multivm/src/versions/vm_1_4_1/bootloader_state/state.rs

@@ -191,11 +191,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_1_4_1/vm.rs

@@ -105,7 +105,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect_inner(tracer, VmExecutionMode::OneTx, None);
         if self.has_unpublished_bytecodes() {
@@ -115,7 +115,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/versions/vm_1_4_2/bootloader_state/state.rs

@@ -191,11 +191,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_1_4_2/vm.rs

@@ -105,7 +105,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect_inner(tracer, VmExecutionMode::OneTx, None);
         if self.has_unpublished_bytecodes() {
@@ -115,7 +115,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/versions/vm_boojum_integration/bootloader_state/state.rs

@@ -191,11 +191,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_boojum_integration/vm.rs

@@ -106,7 +106,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect_inner(tracer, VmExecutionMode::OneTx);
         if self.has_unpublished_bytecodes() {
@@ -116,7 +116,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/versions/vm_fast/bootloader_state/state.rs

@@ -189,11 +189,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_fast/vm.rs

@@ -30,7 +30,7 @@ use super::{
 use crate::{
     glue::GlueInto,
     interface::{
-        storage::ReadStorage, BytecodeCompressionError, CompressedBytecodeInfo,
+        storage::ReadStorage, BytecodeCompressionError, BytecodeCompressionResult,
         CurrentExecutionState, ExecutionResult, FinishedL1Batch, Halt, L1BatchEnv, L2BlockEnv,
         Refunds, SystemEnv, TxRevertReason, VmEvent, VmExecutionLogs, VmExecutionMode,
         VmExecutionResultAndLogs, VmExecutionStatistics, VmInterface, VmInterfaceHistoryEnabled,
@@ -548,17 +548,17 @@ impl<S: ReadStorage> VmInterface for Vm<S> {
         (): Self::TracerDispatcher,
         tx: zksync_types::Transaction,
         with_compression: bool,
-    ) -> (
-        Result<Vec<CompressedBytecodeInfo>, BytecodeCompressionError>,
-        VmExecutionResultAndLogs,
-    ) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_inner(tx, 0, with_compression);
         let result = self.inspect((), VmExecutionMode::OneTx);
 
         let compression_result = if self.has_unpublished_bytecodes() {
             Err(BytecodeCompressionError::BytecodeCompressionFailed)
         } else {
-            Ok(self.bootloader_state.get_last_tx_compressed_bytecodes())
+            Ok(self
+                .bootloader_state
+                .get_last_tx_compressed_bytecodes()
+                .into())
         };
         (compression_result, result)
     }

core/lib/multivm/src/versions/vm_latest/bootloader_state/state.rs

@@ -191,11 +191,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_latest/vm.rs

@@ -141,7 +141,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect_inner(tracer, VmExecutionMode::OneTx, None);
         if self.has_unpublished_bytecodes() {
@@ -151,7 +151,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/versions/vm_m5/vm.rs

@@ -93,14 +93,14 @@ impl<S: Storage, H: HistoryMode> VmInterface for Vm<S, H> {
         _tracer: Self::TracerDispatcher,
         tx: Transaction,
         _with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         crate::vm_m5::vm_with_bootloader::push_transaction_to_bootloader_memory(
             &mut self.vm,
             &tx,
             self.system_env.execution_mode.glue_into(),
         );
         // Bytecode compression isn't supported
-        (Ok(vec![]), self.inspect((), VmExecutionMode::OneTx))
+        (Ok(vec![].into()), self.inspect((), VmExecutionMode::OneTx))
     }
 
     fn record_vm_memory_metrics(&self) -> VmMemoryMetrics {

core/lib/multivm/src/versions/vm_m6/vm.rs

@@ -109,7 +109,7 @@ impl<S: Storage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         if let Some(storage_invocations) = tracer.storage_invocations {
             self.vm
                 .execution_mode
@@ -182,7 +182,7 @@ impl<S: Storage, H: HistoryMode> VmInterface for Vm<S, H> {
                 result,
             )
         } else {
-            (Ok(compressed_bytecodes), result)
+            (Ok(compressed_bytecodes.into()), result)
         }
     }
 

core/lib/multivm/src/versions/vm_refunds_enhancement/bootloader_state/state.rs

@@ -167,11 +167,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_refunds_enhancement/vm.rs

@@ -99,7 +99,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         dispatcher: Self::TracerDispatcher,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect(dispatcher, VmExecutionMode::OneTx);
         if self.has_unpublished_bytecodes() {
@@ -109,7 +109,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/versions/vm_virtual_blocks/bootloader_state/state.rs

@@ -167,11 +167,11 @@ impl BootloaderState {
         l2_block.first_tx_index + l2_block.txs.len()
     }
 
-    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> Vec<CompressedBytecodeInfo> {
+    pub(crate) fn get_last_tx_compressed_bytecodes(&self) -> &[CompressedBytecodeInfo] {
         if let Some(tx) = self.last_l2_block().txs.last() {
-            tx.compressed_bytecodes.clone()
+            &tx.compressed_bytecodes
         } else {
-            vec![]
+            &[]
         }
     }
 

core/lib/multivm/src/versions/vm_virtual_blocks/vm.rs

@@ -99,7 +99,7 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
         tracer: TracerDispatcher<S, H::VmVirtualBlocksMode>,
         tx: Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         self.push_transaction_with_compression(tx, with_compression);
         let result = self.inspect_inner(tracer, VmExecutionMode::OneTx);
         if self.has_unpublished_bytecodes() {
@@ -109,7 +109,10 @@ impl<S: WriteStorage, H: HistoryMode> VmInterface for Vm<S, H> {
             )
         } else {
             (
-                Ok(self.bootloader_state.get_last_tx_compressed_bytecodes()),
+                Ok(self
+                    .bootloader_state
+                    .get_last_tx_compressed_bytecodes()
+                    .into()),
                 result,
             )
         }

core/lib/multivm/src/vm_instance.rs

@@ -74,7 +74,7 @@ impl<S: ReadStorage, H: HistoryMode> VmInterface for VmInstance<S, H> {
         dispatcher: Self::TracerDispatcher,
         tx: zksync_types::Transaction,
         with_compression: bool,
-    ) -> (BytecodeCompressionResult, VmExecutionResultAndLogs) {
+    ) -> (BytecodeCompressionResult<'_>, VmExecutionResultAndLogs) {
         dispatch_vm!(self.inspect_transaction_with_bytecode_compression(
             dispatcher.into(),
             tx,

core/lib/vm_executor/src/batch/factory.rs

@@ -250,7 +250,7 @@ impl<S: ReadStorage + 'static> CommandReceiver<S> {
                 .unwrap_or_default();
             return Ok(BatchTransactionExecutionResult {
                 tx_result: Box::new(tx_result),
-                compressed_bytecodes,
+                compressed_bytecodes: compressed_bytecodes.into_owned(),
                 call_traces,
             });
         }
@@ -269,8 +269,9 @@ impl<S: ReadStorage + 'static> CommandReceiver<S> {
 
         let (compression_result, tx_result) =
             vm.inspect_transaction_with_bytecode_compression(tracer.into(), tx.clone(), false);
-        let compressed_bytecodes =
-            compression_result.context("compression failed when it wasn't applied")?;
+        let compressed_bytecodes = compression_result
+            .context("compression failed when it wasn't applied")?
+            .into_owned();
 
         // TODO implement tracer manager which will be responsible
         //   for collecting result from all tracers and save it to the database
@@ -308,7 +309,7 @@ impl<S: ReadStorage + 'static> CommandReceiver<S> {
                 .unwrap_or_default();
             Ok(BatchTransactionExecutionResult {
                 tx_result: Box::new(tx_result),
-                compressed_bytecodes,
+                compressed_bytecodes: compressed_bytecodes.into_owned(),
                 call_traces,
             })
         } else {

core/lib/vm_interface/src/types/errors/bytecode_compression.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::CompressedBytecodeInfo;
 
 /// Errors related to bytecode compression.
@@ -9,4 +11,5 @@ pub enum BytecodeCompressionError {
 }
 
 /// Result of compressing bytecodes used by a transaction.
-pub type BytecodeCompressionResult = Result<Vec<CompressedBytecodeInfo>, BytecodeCompressionError>;
+pub type BytecodeCompressionResult<'a> =
+    Result<Cow<'a, [CompressedBytecodeInfo]>, BytecodeCompressionError>;