Runtime worker threads

Cargo.toml

@@ -77,6 +77,7 @@ members = [
 	"frame/evm",
 	"frame/example",
 	"frame/example-offchain-worker",
+	"frame/example-parallel",
 	"frame/executive",
 	"frame/grandpa",
 	"frame/identity",

client/executor/common/src/error.rs

@@ -81,6 +81,25 @@ pub enum Error {
 	/// Execution of a host function failed.
 	#[display(fmt="Host function {} execution failed with: {}", _0, _1)]
 	FunctionExecution(String, String),
+	/// No table is present.
+	///
+	/// Call was requested that requires table but none was present in the instance.
+	#[display(fmt="No table exported by wasm blob")]
+	NoTable,
+	/// No table entry is present.
+	///
+	/// Call was requested that requires specific entry in the table to be present.
+	#[display(fmt="No table entry with index {} in wasm blob exported table", _0)]
+	#[from(ignore)]
+	NoTableEntryWithIndex(u32),
+	/// Table entry is not a function.
+	#[display(fmt="Table element with index {} is not a function in wasm blob exported table", _0)]
+	#[from(ignore)]
+	TableElementIsNotAFunction(u32),
+	/// Function in table is null and thus cannot be called.
+	#[display(fmt="Table entry with index {} in wasm blob is null", _0)]
+	#[from(ignore)]
+	FunctionRefIsNull(u32),
 }
 
 impl std::error::Error for Error {

client/executor/common/src/wasm_runtime.rs

@@ -19,6 +19,46 @@
 use crate::error::Error;
 use sp_wasm_interface::Value;
 
+/// A method to be used to find the entrypoint when calling into the runtime
+///
+/// Contains variants on how to resolve wasm function that will be invoked.
+pub enum InvokeMethod<'a> {
+	/// Call function exported with this name.
+	///
+	/// Located function should have (u32, u32) -> u64 signature.
+	Export(&'a str),
+	/// Call a function found in the exported table found under the given index.
+	///
+	/// Located function should have (u32, u32) -> u64 signature.
+	Table(u32),
+	/// Call function by reference from table through a wrapper.
+	///
+	/// Invoked function (`dispatcher_ref`) function
+	/// should have (u32, u32, u32) -> u64 signature.
+	///
+	/// `func` will be passed to the invoked function as a first argument.
+	TableWithWrapper {
+		/// Wrapper for the call.
+		///
+		/// Function pointer, index into runtime exported table.
+		dispatcher_ref: u32,
+		/// Extra argument for dispatch.
+		///
+		/// Common usage would be to use it as an actual wasm function pointer
+		/// that should be invoked, but can be used as any extra argument on the
+		/// callee side.
+		///
+		/// This is typically generated and invoked by the runtime itself.
+		func: u32,
+	},
+}
+
+impl<'a> From<&'a str> for InvokeMethod<'a> {
+	fn from(val: &'a str) -> InvokeMethod<'a> {
+		InvokeMethod::Export(val)
+	}
+}
+
 /// A trait that defines an abstract WASM runtime module.
 ///
 /// This can be implemented by an execution engine.
@@ -31,11 +71,24 @@ pub trait WasmModule: Sync + Send {
 ///
 /// This can be implemented by an execution engine.
 pub trait WasmInstance: Send {
-	/// Call a method on this WASM instance and reset it afterwards.
+	/// Call a method on this WASM instance.
+	///
+	/// Before execution, instance is reset.
+	///
+	/// Returns the encoded result on success.
+	fn call(&self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error>;
+
+	/// Call an exported method on this WASM instance.
+	///
+	/// Before execution, instance is reset.
+	///
 	/// Returns the encoded result on success.
-	fn call(&self, method: &str, data: &[u8]) -> Result<Vec<u8>, Error>;
+	fn call_export(&self, method: &str, data: &[u8]) -> Result<Vec<u8>, Error> {
+		self.call(method.into(), data)
+	}
 
 	/// Get the value from a global with the given `name`.
+	///
 	/// This method is only suitable for getting immutable globals.
 	fn get_global_const(&self, name: &str) -> Result<Option<Value>, Error>;
 }

client/executor/runtime-test/src/lib.rs

@@ -309,6 +309,43 @@ sp_core::wasm_export_functions! {
 		assert_ne!(test_message, message_slice);
 		message_slice.copy_from_slice(test_message);
 	}
+
+	fn test_spawn() {
+		let data = vec![1u8, 2u8];
+		let data_new = sp_io::tasks::spawn(tasks::incrementer, data).join();
+
+		assert_eq!(data_new, vec![2u8, 3u8]);
+	}
+
+	fn test_nested_spawn() {
+		let data = vec![7u8, 13u8];
+		let data_new = sp_io::tasks::spawn(tasks::parallel_incrementer, data).join();
+
+		assert_eq!(data_new, vec![10u8, 16u8]);
+	}
+
+	fn test_panic_in_spawned() {
+		sp_io::tasks::spawn(tasks::panicker, vec![]).join();
+	}
+ }
+
+ #[cfg(not(feature = "std"))]
+ mod tasks {
+	use sp_std::prelude::*;
+
+	pub fn incrementer(data: Vec<u8>) -> Vec<u8> {
+	   data.into_iter().map(|v| v + 1).collect()
+	}
+
+	pub fn panicker(_: Vec<u8>) -> Vec<u8> {
+		panic!()
+	}
+
+	pub fn parallel_incrementer(data: Vec<u8>) -> Vec<u8> {
+	   let first = data.into_iter().map(|v| v + 2).collect::<Vec<_>>();
+	   let second = sp_io::tasks::spawn(incrementer, first).join();
+	   second
+	}
  }
 
 #[cfg(not(feature = "std"))]

client/executor/src/integration_tests/mod.rs

@@ -555,13 +555,13 @@ fn returns_mutable_static(wasm_method: WasmExecutionMethod) {
 	).expect("Creates runtime");
 
 	let instance = runtime.new_instance().unwrap();
-	let res = instance.call("returns_mutable_static", &[0]).unwrap();
+	let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
 	assert_eq!(33, u64::decode(&mut &res[..]).unwrap());
 
 	// We expect that every invocation will need to return the initial
 	// value plus one. If the value increases more than that then it is
 	// a sign that the wasm runtime preserves the memory content.
-	let res = instance.call("returns_mutable_static", &[0]).unwrap();
+	let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
 	assert_eq!(33, u64::decode(&mut &res[..]).unwrap());
 }
 
@@ -590,11 +590,11 @@ fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
 	let instance = runtime.new_instance().unwrap();
 
 	// On the first invocation we allocate approx. 768KB (75%) of stack and then trap.
-	let res = instance.call("allocates_huge_stack_array", &true.encode());
+	let res = instance.call_export("allocates_huge_stack_array", &true.encode());
 	assert!(res.is_err());
 
 	// On the second invocation we allocate yet another 768KB (75%) of stack
-	let res = instance.call("allocates_huge_stack_array", &false.encode());
+	let res = instance.call_export("allocates_huge_stack_array", &false.encode());
 	assert!(res.is_ok());
 }
 
@@ -616,10 +616,10 @@ fn heap_is_reset_between_calls(wasm_method: WasmExecutionMethod) {
 		.expect("`__heap_base` is an `i32`");
 
 	let params = (heap_base as u32, 512u32 * 64 * 1024).encode();
-	instance.call("check_and_set_in_heap", &params).unwrap();
+	instance.call_export("check_and_set_in_heap", &params).unwrap();
 
 	// Cal it a second time to check that the heap was freed.
-	instance.call("check_and_set_in_heap", &params).unwrap();
+	instance.call_export("check_and_set_in_heap", &params).unwrap();
 }
 
 #[test_case(WasmExecutionMethod::Interpreted)]
@@ -720,3 +720,51 @@ fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
 	assert_eq!(span_datum.name, "");
 	assert_eq!(values.bool_values.get("wasm").unwrap(), &true);
 }
+
+#[test_case(WasmExecutionMethod::Interpreted)]
+#[cfg_attr(feature = "wasmtime", test_case(WasmExecutionMethod::Compiled))]
+fn spawning_runtime_instance_should_work(wasm_method: WasmExecutionMethod) {
+
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	call_in_wasm(
+		"test_spawn",
+		&[],
+		wasm_method,
+		&mut ext,
+	).unwrap();
+}
+
+#[test_case(WasmExecutionMethod::Interpreted)]
+#[cfg_attr(feature = "wasmtime", test_case(WasmExecutionMethod::Compiled))]
+fn spawning_runtime_instance_nested_should_work(wasm_method: WasmExecutionMethod) {
+
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	call_in_wasm(
+		"test_nested_spawn",
+		&[],
+		wasm_method,
+		&mut ext,
+	).unwrap();
+}
+
+#[test_case(WasmExecutionMethod::Interpreted)]
+#[cfg_attr(feature = "wasmtime", test_case(WasmExecutionMethod::Compiled))]
+fn panic_in_spawned_instance_panics_on_joining_its_result(wasm_method: WasmExecutionMethod) {
+
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	let error_result = call_in_wasm(
+		"test_panic_in_spawned",
+		&[],
+		wasm_method,
+		&mut ext,
+	).unwrap_err();
+
+	dbg!(&error_result);
+	assert!(format!("{}", error_result).contains("Spawned task"));
+}