perf: Persistent executor

Signed-off-by: Dmitry Murzin <diralik@yandex.ru>

crates/iroha_core/benches/validation.rs

@@ -6,7 +6,7 @@ use iroha_core::{
     block::*,
     prelude::*,
     query::store::LiveQueryStore,
-    smartcontracts::{isi::Registrable as _, Execute},
+    smartcontracts::{isi::Registrable as _, wasm::cache::WasmCache, Execute},
     state::{State, World},
 };
 use iroha_data_model::{
@@ -132,10 +132,11 @@ fn validate_transaction(criterion: &mut Criterion) {
     .expect("Failed to accept transaction.");
     let mut success_count = 0;
     let mut failure_count = 0;
+    let mut wasm_cache = WasmCache::new();
     let _ = criterion.bench_function("validate", move |b| {
         b.iter(|| {
             let mut state_block = state.block();
-            match state_block.validate(transaction.clone()) {
+            match state_block.validate(transaction.clone(), &mut wasm_cache) {
                 Ok(_) => success_count += 1,
                 Err(_) => failure_count += 1,
             }

crates/iroha_core/src/block.rs

@@ -122,7 +122,7 @@ mod pending {
     use nonzero_ext::nonzero;
 
     use super::*;
-    use crate::state::StateBlock;
+    use crate::{smartcontracts::wasm::cache::WasmCache, state::StateBlock};
 
     /// First stage in the life-cycle of a [`Block`].
     /// In the beginning the block is assumed to be verified and to contain only accepted transactions.
@@ -217,9 +217,10 @@ mod pending {
             transactions: Vec<AcceptedTransaction>,
             state_block: &mut StateBlock<'_>,
         ) -> Vec<CommittedTransaction> {
+            let mut wasm_cache = WasmCache::new();
             transactions
                 .into_iter()
-                .map(|tx| match state_block.validate(tx) {
+                .map(|tx| match state_block.validate(tx, &mut wasm_cache) {
                     Ok(tx) => CommittedTransaction {
                         value: tx,
                         error: None,
@@ -286,7 +287,9 @@ mod valid {
     use mv::storage::StorageReadOnly;
 
     use super::*;
-    use crate::{state::StateBlock, sumeragi::network_topology::Role};
+    use crate::{
+        smartcontracts::wasm::cache::WasmCache, state::StateBlock, sumeragi::network_topology::Role,
+    };
 
     /// Block that was validated and accepted
     #[derive(Debug, Clone)]
@@ -595,6 +598,7 @@ mod valid {
                 (params.sumeragi().max_clock_drift(), params.transaction)
             };
 
+            let mut wasm_cache = WasmCache::new();
             block
                 .transactions()
                 // TODO: Unnecessary clone?
@@ -617,13 +621,13 @@ mod valid {
                     }?;
 
                     if error.is_some() {
-                        match state_block.validate(tx) {
+                        match state_block.validate(tx, &mut wasm_cache) {
                             Err(rejected_transaction) => Ok(rejected_transaction),
                             Ok(_) => Err(TransactionValidationError::RejectedIsValid),
                         }?;
                     } else {
                         state_block
-                            .validate(tx)
+                            .validate(tx, &mut wasm_cache)
                             .map_err(|(_tx, error)| TransactionValidationError::NotValid(error))?;
                     }
 

crates/iroha_core/src/executor.rs

@@ -18,7 +18,7 @@ use serde::{
 };
 
 use crate::{
-    smartcontracts::{wasm, Execute as _},
+    smartcontracts::{wasm, wasm::cache::WasmCache, Execute as _},
     state::{deserialize::WasmSeed, StateReadOnly, StateTransaction},
     WorldReadOnly as _,
 };
@@ -122,6 +122,7 @@ impl Executor {
         state_transaction: &mut StateTransaction<'_, '_>,
         authority: &AccountId,
         transaction: SignedTransaction,
+        wasm_cache: &mut WasmCache<'_, '_, '_>,
     ) -> Result<(), ValidationFail> {
         trace!("Running transaction validation");
 
@@ -140,18 +141,16 @@ impl Executor {
                 Ok(())
             }
             Self::UserProvided(loaded_executor) => {
-                let runtime =
-                    wasm::RuntimeBuilder::<wasm::state::executor::ValidateTransaction>::new()
-                        .with_engine(state_transaction.engine.clone()) // Cloning engine is cheap, see [`wasmtime::Engine`] docs
-                        .with_config(state_transaction.world.parameters().executor)
-                        .build()?;
-
-                runtime.execute_executor_validate_transaction(
+                let wasm_cache = WasmCache::change_lifetime(wasm_cache);
+                let mut runtime =
+                    wasm_cache.create_runtime_cached(state_transaction, &loaded_executor.module)?;
+                let result = runtime.execute_executor_validate_transaction(
                     state_transaction,
                     authority,
-                    &loaded_executor.module,
                     transaction,
-                )?
+                )?;
+                wasm_cache.save_cached_runtime(runtime);
+                result
             }
         }
     }