Remove wasmi backend from sc-executor

bin/node/cli/benches/transaction_pool.rs

@@ -28,7 +28,7 @@ use sc_executor::WasmtimeInstantiationStrategy;
 use sc_service::{
 	config::{
 		BlocksPruning, DatabaseSource, KeystoreConfig, NetworkConfiguration, OffchainWorkerConfig,
-		PruningMode, TransactionPoolOptions, WasmExecutionMethod,
+		PruningMode, TransactionPoolOptions,
 	},
 	BasePath, Configuration, Role,
 };
@@ -70,9 +70,7 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
 		state_pruning: Some(PruningMode::ArchiveAll),
 		blocks_pruning: BlocksPruning::KeepAll,
 		chain_spec: spec,
-		wasm_method: WasmExecutionMethod::Compiled {
-			instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
-		},
+		wasm_method: Default::default(),
 		// NOTE: we enforce the use of the native runtime to make the errors more debuggable
 		execution_strategies: ExecutionStrategies {
 			syncing: sc_client_api::ExecutionStrategy::NativeWhenPossible,

bin/node/executor/benches/bench.rs

@@ -182,7 +182,6 @@ fn bench_execute_block(c: &mut Criterion) {
 	let mut group = c.benchmark_group("execute blocks");
 	let execution_methods = vec![
 		ExecutionMethod::Native,
-		ExecutionMethod::Wasm(WasmExecutionMethod::Interpreted),
 		ExecutionMethod::Wasm(WasmExecutionMethod::Compiled {
 			instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
 		}),
@@ -191,9 +190,9 @@ fn bench_execute_block(c: &mut Criterion) {
 	for strategy in execution_methods {
 		group.bench_function(format!("{:?}", strategy), |b| {
 			let genesis_config = node_testing::genesis::config(Some(compact_code_unwrap()));
-			let (use_native, wasm_method) = match strategy {
-				ExecutionMethod::Native => (true, WasmExecutionMethod::Interpreted),
-				ExecutionMethod::Wasm(wasm_method) => (false, wasm_method),
+			let use_native = match strategy {
+				ExecutionMethod::Native => true,
+				ExecutionMethod::Wasm(..) => false,
 			};
 
 			let executor =

bin/node/executor/tests/common.rs

@@ -18,7 +18,7 @@
 use codec::{Decode, Encode};
 use frame_support::Hashable;
 use frame_system::offchain::AppCrypto;
-use sc_executor::{error::Result, NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor};
+use sc_executor::{error::Result, NativeElseWasmExecutor, WasmExecutor};
 use sp_consensus_babe::{
 	digests::{PreDigest, SecondaryPlainPreDigest},
 	Slot, BABE_ENGINE_ID,

bin/node/testing/src/bench.rs

@@ -393,10 +393,11 @@ impl BenchDb {
 
 		let backend = sc_service::new_db_backend(db_config).expect("Should not fail");
 		let executor = NativeElseWasmExecutor::new_with_wasm_executor(
-			sc_executor::WasmExecutor::builder(WasmExecutionMethod::Compiled {
-				instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
-			})
-			.build(),
+			sc_executor::WasmExecutor::builder()
+				.with_execution_method(WasmExecutionMethod::Compiled {
+					instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+				})
+				.build(),
 		);
 
 		let client_config = sc_service::ClientConfig::default();

client/executor/benches/bench.rs

@@ -195,7 +195,6 @@ fn bench_call_instance(c: &mut Criterion) {
 				precompile: true,
 			},
 		),
-		("interpreted", Method::Interpreted),
 	];
 
 	let runtimes = [("kusama_runtime", kusama_runtime()), ("test_runtime", test_runtime())];

client/executor/src/executor.rs

@@ -111,9 +111,7 @@ impl<H> WasmExecutorBuilder<H> {
 		}
 	}
 
-	/// The wasm execution method that should be used by the executor.
-	///
-	/// Default to
+	/// Create the wasm executor with execution method that should be used by the executor.
 	pub fn with_execution_method(mut self, method: WasmExecutionMethod) -> Self {
 		self.method = method;
 		self
@@ -569,13 +567,16 @@ impl<D: NativeExecutionDispatch> NativeElseWasmExecutor<D> {
 		max_runtime_instances: usize,
 		runtime_cache_size: u8,
 	) -> Self {
-		let wasm = WasmExecutor::new(
-			fallback_method,
-			default_heap_pages,
-			max_runtime_instances,
-			None,
-			runtime_cache_size,
-		);
+		let heap_pages = default_heap_pages.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| {
+			HeapAllocStrategy::Static { extra_pages: h as _ }
+		});
+		let wasm = WasmExecutor::builder()
+			.with_execution_method(fallback_method)
+			.with_onchain_heap_alloc_strategy(heap_pages)
+			.with_offchain_heap_alloc_strategy(heap_pages)
+			.with_max_runtime_instances(max_runtime_instances)
+			.with_runtime_cache_size(runtime_cache_size)
+			.build();
 
 		NativeElseWasmExecutor { native_version: D::native_version(), wasm }
 	}

client/executor/src/integration_tests/linux.rs

@@ -23,29 +23,10 @@ mod smaps;
 use super::mk_test_runtime;
 use crate::WasmExecutionMethod;
 use codec::Encode as _;
-use sc_executor_common::wasm_runtime::{HeapAllocStrategy, DEFAULT_HEAP_ALLOC_STRATEGY};
+use sc_executor_common::wasm_runtime::DEFAULT_HEAP_ALLOC_STRATEGY;
 
 use self::smaps::Smaps;
 
-#[test]
-fn memory_consumption_interpreted() {
-	let _ = sp_tracing::try_init_simple();
-
-	if std::env::var("RUN_TEST").is_ok() {
-		memory_consumption(WasmExecutionMethod::Interpreted);
-	} else {
-		// We need to run the test in isolation, to not getting interfered by the other tests.
-		let executable = std::env::current_exe().unwrap();
-		let output = std::process::Command::new(executable)
-			.env("RUN_TEST", "1")
-			.args(&["--nocapture", "memory_consumption_interpreted"])
-			.output()
-			.unwrap();
-
-		assert!(output.status.success());
-	}
-}
-
 #[test]
 fn memory_consumption_compiled() {
 	let _ = sp_tracing::try_init_simple();

client/executor/wasmtime/src/tests.rs

@@ -20,9 +20,7 @@ use codec::{Decode as _, Encode as _};
 use sc_executor_common::{
 	error::Error,
 	runtime_blob::RuntimeBlob,
-	wasm_runtime::{
-		HeapAllocStrategy, WasmModule, DEFAULT_HEAP_ALLOC_PAGES, DEFAULT_HEAP_ALLOC_STRATEGY,
-	},
+	wasm_runtime::{HeapAllocStrategy, WasmModule, DEFAULT_HEAP_ALLOC_STRATEGY},
 };
 use sc_runtime_test::wasm_binary_unwrap;
 

client/service/src/builder.rs

@@ -38,7 +38,7 @@ use sc_client_db::{Backend, DatabaseSettings};
 use sc_consensus::import_queue::ImportQueue;
 use sc_executor::{
 	sp_wasm_interface::HostFunctions, HeapAllocStrategy, NativeElseWasmExecutor,
-	NativeExecutionDispatch, RuntimeVersionOf, WasmExecutor, DEFAULT_HEAP_ALLOC_PAGES,
+	NativeExecutionDispatch, RuntimeVersionOf, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY,
 };
 use sc_keystore::LocalKeystore;
 use sc_network::{config::SyncMode, NetworkService, NetworkStateInfo, NetworkStatusProvider};
@@ -239,9 +239,9 @@ pub fn new_native_executor<D: NativeExecutionDispatch>(
 
 /// Creates a [`WasmExecutor`] according to [`Configuration`].
 pub fn new_wasm_executor<H: HostFunctions>(config: &Configuration) -> WasmExecutor<H> {
-	let extra_pages =
-		config.default_heap_pages.map(|p| p as u32).unwrap_or(DEFAULT_HEAP_ALLOC_PAGES);
-	let strategy = HeapAllocStrategy::Static { extra_pages };
+	let strategy = config
+		.default_heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
 	WasmExecutor::<H>::builder()
 		.with_execution_method(config.wasm_method)
 		.with_onchain_heap_alloc_strategy(strategy)

client/service/src/client/wasm_override.rs

@@ -264,9 +264,7 @@ pub fn dummy_overrides() -> WasmOverride {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sc_executor::{
-		HeapAllocStrategy, NativeElseWasmExecutor, WasmExecutor,
-	};
+	use sc_executor::{HeapAllocStrategy, NativeElseWasmExecutor, WasmExecutor};
 	use std::fs::{self, File};
 	use substrate_test_runtime_client::LocalExecutorDispatch;
 

primitives/runtime-interface/test/src/lib.rs

@@ -42,7 +42,7 @@ fn call_wasm_method_with_result<HF: HostFunctionsT>(
 
 	let executor = sc_executor::WasmExecutor::<
 		ExtendedHostFunctions<sp_io::SubstrateHostFunctions, HF>,
-	>::builder(sc_executor::WasmExecutionMethod::Interpreted)
+	>::builder()
 	.build();
 
 	let (result, allocation_stats) = executor.uncached_call_with_allocation_stats(

test-utils/runtime/src/system.rs

@@ -350,7 +350,7 @@ mod tests {
 	use super::*;
 
 	use crate::{wasm_binary_unwrap, Header, Transfer};
-	use sc_executor::{NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor};
+	use sc_executor::{NativeElseWasmExecutor, WasmExecutor};
 	use sp_core::{
 		map,
 		traits::{CallContext, CodeExecutor, RuntimeCode},

utils/frame/try-runtime/cli/src/lib.rs

@@ -369,7 +369,7 @@ use sc_cli::{
 	DEFAULT_WASM_EXECUTION_METHOD,
 };
 use sc_executor::{
-	sp_wasm_interface::HostFunctions, HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_PAGES,
+	sp_wasm_interface::HostFunctions, HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY,
 };
 use sp_api::HashT;
 use sp_core::{
@@ -829,17 +829,18 @@ pub(crate) fn full_extensions() -> Extensions {
 
 /// Build wasm executor by default config.
 pub(crate) fn build_executor<H: HostFunctions>(shared: &SharedParams) -> WasmExecutor<H> {
-	let heap_pages = HeapAllocStrategy::Static {
-		extra_pages: shared.heap_pages.map(|p| p as u32).unwrap_or(DEFAULT_HEAP_ALLOC_PAGES),
-	};
-
-	WasmExecutor::builder(execution_method_from_cli(
-		shared.wasm_method,
-		shared.wasmtime_instantiation_strategy,
-	))
-	.with_onchain_heap_alloc_strategy(heap_pages)
-	.with_offchain_heap_alloc_strategy(heap_pages)
-	.build()
+	let heap_pages = shared
+		.heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
+
+	WasmExecutor::builder()
+		.with_execution_method(execution_method_from_cli(
+			shared.wasm_method,
+			shared.wasmtime_instantiation_strategy,
+		))
+		.with_onchain_heap_alloc_strategy(heap_pages)
+		.with_offchain_heap_alloc_strategy(heap_pages)
+		.build()
 }
 
 /// Ensure that the given `ext` is compiled with `try-runtime`