Allow execution with both native & wasm

polkadot/cli/src/cli.yml

@@ -74,7 +74,7 @@ args:
   - pruning:
       long: pruning
       value_name: PRUNING_MODE
-      help: Specify the pruning mode. (a number of blocks to keep or "archive"). Default is 256.
+      help: Specify the pruning mode, a number of blocks to keep or "archive". Default is 256.
       takes_value: true
   - name:
       long: name
@@ -95,6 +95,10 @@ args:
       value_name: TELEMETRY_URL
       help: The URL of the telemetry server. Implies --telemetry
       takes_value: true
+  - execution:
+      long: execution
+      value_name: STRATEGY
+      help: The means of execution used when calling into the runtime. Can be either wasm, native or both.
 subcommands:
   - build-spec:
       about: Build a spec.json file, outputing to stdout

polkadot/cli/src/lib.rs

@@ -218,18 +218,32 @@ pub fn run<I, T, W>(args: I, worker: W) -> error::Result<()> where
 		if matches.is_present("collator") {
 			info!("Starting collator");
 			// TODO [rob]: collation node implementation
-			service::Role::FULL
+			// This isn't a thing. Different parachains will have their own collator executables and
+			// maybe link to libpolkadot to get a light-client. 
+			service::Role::LIGHT
 		} else if matches.is_present("light") {
 			info!("Starting (light)");
+			config.execution_strategy = service::ExecutionStrategy::NativeWhenPossible;
 			service::Role::LIGHT
 		} else if matches.is_present("validator") || matches.is_present("dev") {
 			info!("Starting validator");
+			config.execution_strategy = service::ExecutionStrategy::Both;
 			service::Role::AUTHORITY
 		} else {
 			info!("Starting (heavy)");
+			config.execution_strategy = service::ExecutionStrategy::NativeWhenPossible;
 			service::Role::FULL
 		};
 
+	if let Some(s) = matches.value_of("pruning") {
+		config.execution_strategy = match s {
+			"both" => service::ExecutionStrategy::Both,
+			"native" => service::ExecutionStrategy::NativeWhenPossible,
+			"wasm" => service::ExecutionStrategy::AlwaysWasm,
+			_ => return Err(error::ErrorKind::Input("Invalid execution mode specified".to_owned()).into()),
+		};
+	}
+
 	config.roles = role;
 	{
 		config.network.boot_nodes.extend(matches

polkadot/service/src/config.rs

@@ -18,6 +18,7 @@
 
 use transaction_pool;
 use chain_spec::ChainSpec;
+pub use substrate_executor::ExecutionStrategy;
 pub use network::Role;
 pub use network::NetworkConfiguration;
 pub use client_db::PruningMode;
@@ -44,6 +45,8 @@ pub struct Configuration {
 	pub telemetry: Option<String>,
 	/// Node name.
 	pub name: String,
+	/// Execution strategy.
+	pub execution_strategy: ExecutionStrategy,
 }
 
 impl Configuration {
@@ -60,6 +63,7 @@ impl Configuration {
 			keys: Default::default(),
 			telemetry: Default::default(),
 			pruning: PruningMode::ArchiveAll,
+			execution_strategy: ExecutionStrategy::Both,
 		};
 		configuration.network.boot_nodes = configuration.chain_spec.boot_nodes().to_vec();
 		configuration

polkadot/service/src/lib.rs

@@ -73,7 +73,7 @@ use tokio::runtime::TaskExecutor;
 
 pub use self::error::{ErrorKind, Error};
 pub use self::components::{Components, FullComponents, LightComponents};
-pub use config::{Configuration, Role, PruningMode};
+pub use config::{Configuration, Role, PruningMode, ExecutionStrategy};
 pub use chain_spec::ChainSpec;
 
 /// Polkadot service.
@@ -109,7 +109,7 @@ pub fn new_client(config: Configuration) -> Result<Arc<Client<
 		path: config.database_path.into(),
 		pruning: config.pruning,
 	};
-	let executor = polkadot_executor::Executor::new();
+	let executor = polkadot_executor::Executor::with_default_strategy(config.execution_strategy);
 	let is_validator = (config.roles & Role::AUTHORITY) == Role::AUTHORITY;
 	let components = components::FullComponents { is_validator };
 	let (client, _) = components.build_client(db_settings, executor, &config.chain_spec)?;

substrate/client/src/client.rs

@@ -326,6 +326,7 @@ impl<B, E, Block> Client<B, E, Block> where
 					&mut overlay,
 					"execute_block",
 					&<Block as BlockT>::new(header.clone(), body.clone().unwrap_or_default()).encode()
+				// TODO: intercept Err::ConsensusFailure, report failure wrt block and then accept wasm result.
 				)?;
 
 				Some(storage_update)

substrate/executor/src/error.rs

@@ -74,5 +74,11 @@ error_chain! {
 			description("invalid memory reference"),
 			display("Invalid memory reference"),
 		}
+
+		/// Consensus failure.
+		ConsensusFailure(wasm_result: Box<Result<Vec<u8>>>, native_result: Box<Result<Vec<u8>>>) {
+			description("consensus failure"),
+			display("Differing results from Wasm execution and native dispatch"),
+		}
 	}
 }

substrate/executor/src/lib.rs

@@ -66,7 +66,7 @@ mod sandbox;
 
 pub mod error;
 pub use wasm_executor::WasmExecutor;
-pub use native_executor::{with_native_environment, NativeExecutor, NativeExecutionDispatch};
+pub use native_executor::{with_native_environment, NativeExecutor, NativeExecutionDispatch, ExecutionStrategy};
 pub use state_machine::Externalities;
 pub use runtime_version::RuntimeVersion;
 pub use codec::Slicable;

substrate/executor/src/native_executor.rs

@@ -27,14 +27,14 @@ use parking_lot::{Mutex, MutexGuard};
 use RuntimeInfo;
 
 // For the internal Runtime Cache:
-// Do we run this natively or use the given WasmModule
-enum RunWith {
+// Is it compatible enough to run this natively or do we need to fall back on the WasmModule
+enum Compatibility {
 	InvalidVersion(WasmModule),
-	NativeRuntime(RuntimeVersion),
-	WasmRuntime(RuntimeVersion, WasmModule)
+	IsCompatible(RuntimeVersion),
+	NotCompatible(RuntimeVersion, WasmModule)
 }
 
-type CacheType = HashMap<u64, RunWith>;
+type CacheType = HashMap<u64, Compatibility>;
 
 lazy_static! {
 	static ref RUNTIMES_CACHE: Mutex<CacheType> = Mutex::new(HashMap::new());
@@ -51,29 +51,28 @@ fn gen_cache_key(code: &[u8]) -> u64 {
 }
 
 /// fetch a runtime version from the cache or if there is no cached version yet, create
-/// the runtime version entry for `code`, determines whether `RunWith::NativeRuntime`
+/// the runtime version entry for `code`, determines whether `Compatibility::IsCompatible`
 /// can be used by by comparing returned RuntimeVersion to `ref_version`
 fn fetch_cached_runtime_version<'a, E: Externalities>(
 	cache: &'a mut MutexGuard<CacheType>,
 	ext: &mut E,
 	code: &[u8],
 	ref_version: RuntimeVersion
-) -> &'a RunWith {
+) -> &'a Compatibility {
 	cache.entry(gen_cache_key(code))
 		.or_insert_with(|| {
 			let module = WasmModule::from_buffer(code).expect("all modules compiled with rustc are valid wasm code; qed");
 			let version = WasmExecutor.call_in_wasm_module(ext, &module, "version", &[]).ok()
 				.and_then(|v| RuntimeVersion::decode(&mut v.as_slice()));
 
-
 			if let Some(v) = version {
 				if ref_version.can_call_with(&v) {
-					RunWith::NativeRuntime(v)
+					Compatibility::IsCompatible(v)
 				} else {
-					RunWith::WasmRuntime(v, module)
+					Compatibility::NotCompatible(v, module)
 				}
 			} else {
-				RunWith::InvalidVersion(module)
+				Compatibility::InvalidVersion(module)
 			}
 	})
 }
@@ -106,31 +105,78 @@ pub trait NativeExecutionDispatch {
 	const VERSION: RuntimeVersion;
 }
 
+/// Strategy for executing a call into the runtime.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum ExecutionStrategy {
+	/// Execute with the native equivalent if it is compatible with the given wasm module; otherwise fall back to the wasm.
+	NativeWhenPossible,
+	/// Use the given wasm module.
+	AlwaysWasm,
+	/// Run with both the wasm and the native variant (if compatible). Report any discrepency as an error.
+	Both,
+}
+
 /// A generic `CodeExecutor` implementation that uses a delegate to determine wasm code equivalence
 /// and dispatch to native code when possible, falling back on `WasmExecutor` when not.
 #[derive(Debug)]
 pub struct NativeExecutor<D: NativeExecutionDispatch + Sync + Send> {
+	/// The strategy for execution.
+	strategy: ExecutionStrategy,
 	/// Dummy field to avoid the compiler complaining about us not using `D`.
 	_dummy: ::std::marker::PhantomData<D>,
 }
 
 impl<D: NativeExecutionDispatch + Sync + Send> NativeExecutor<D> {
 	/// Create new instance.
-	pub fn new() -> Self {
+	pub fn new(strategy: ExecutionStrategy) -> Self {
 		// FIXME: set this entry at compile time
 		RUNTIMES_CACHE.lock().insert(
 			gen_cache_key(D::native_equivalent()),
-			RunWith::NativeRuntime(D::VERSION));
+			Compatibility::IsCompatible(D::VERSION));
 
 		NativeExecutor {
+			strategy,
 			_dummy: Default::default(),
 		}
 	}
+
+	fn call_with_strategy<E: Externalities>(
+		&self,
+		ext: &mut E,
+		code: &[u8],
+		method: &str,
+		data: &[u8],
+		strategy: ExecutionStrategy,
+	) -> Result<Vec<u8>> {
+		let mut c = RUNTIMES_CACHE.lock();
+		match (strategy, fetch_cached_runtime_version(&mut c, ext, code, D::VERSION)) {
+			(_, Compatibility::NotCompatible(_, m)) => WasmExecutor.call_in_wasm_module(ext, m, method, data),
+			(_, Compatibility::InvalidVersion(m)) => WasmExecutor.call_in_wasm_module(ext, m, method, data),
+			(ExecutionStrategy::AlwaysWasm, _) => WasmExecutor.call(ext, code, method, data),
+			(ExecutionStrategy::NativeWhenPossible, _) => D::dispatch(ext, method, data),
+			_ => {
+				// both
+				let w = WasmExecutor.call(ext, code, method, data);
+				let n = D::dispatch(ext, method, data);
+				let same_ok = if let (&Ok(ref w), &Ok(ref n)) = (&w, &n) {
+					w == n
+				} else { false };
+				if same_ok {
+					return w
+				}
+				if w.is_err() && n.is_err() && format!("{:?}", w) == format!("{:?}", n) {
+					return w
+				}
+				Err(ErrorKind::ConsensusFailure(Box::new(w), Box::new(n)).into())
+			}
+		}
+	}
 }
 
 impl<D: NativeExecutionDispatch + Sync + Send> Clone for NativeExecutor<D> {
 	fn clone(&self) -> Self {
 		NativeExecutor {
+			strategy: self.strategy,
 			_dummy: Default::default(),
 		}
 	}
@@ -146,8 +192,8 @@ impl<D: NativeExecutionDispatch + Sync + Send> RuntimeInfo for NativeExecutor<D>
 	) -> Option<RuntimeVersion> {
 		let mut c = RUNTIMES_CACHE.lock();
 		match fetch_cached_runtime_version(&mut c, ext, code, D::VERSION) {
-			RunWith::NativeRuntime(v) | RunWith::WasmRuntime(v, _) => Some(v.clone()),
-			RunWith::InvalidVersion(_m) => None
+			Compatibility::IsCompatible(v) | Compatibility::NotCompatible(v, _) => Some(v.clone()),
+			Compatibility::InvalidVersion(_m) => None
 		}
 	}
 }
@@ -162,11 +208,7 @@ impl<D: NativeExecutionDispatch + Sync + Send> CodeExecutor for NativeExecutor<D
 		method: &str,
 		data: &[u8],
 	) -> Result<Vec<u8>> {
-		let mut c = RUNTIMES_CACHE.lock();
-		match fetch_cached_runtime_version(&mut c, ext, code, D::VERSION) {
-			RunWith::NativeRuntime(_v) => D::dispatch(ext, method, data),
-			RunWith::WasmRuntime(_, m) | RunWith::InvalidVersion(m) => WasmExecutor.call_in_wasm_module(ext, m, method, data)
-		}
+		self.call_with_strategy(ext, code, method, data, self.strategy)
 	}
 }
 
@@ -198,7 +240,10 @@ macro_rules! native_executor_instance {
 
 		impl $name {
 			pub fn new() -> $crate::NativeExecutor<$name> {
-				$crate::NativeExecutor::new()
+				$crate::NativeExecutor::new($crate::ExecutionStrategy::NativeWhenPossible)
+			}
+			pub fn with_default_strategy(strategy: $crate::ExecutionStrategy) -> $crate::NativeExecutor<$name> {
+				$crate::NativeExecutor::new(strategy)
 			}
 		}
 	}