Fair reusing of wasm runtime instances

core/client/src/genesis.rs

@@ -149,7 +149,8 @@ mod tests {
 		let mut storage = GenesisConfig::new(false,
 			vec![Sr25519Keyring::One.into(), Sr25519Keyring::Two.into()],
 			vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
-			1000
+			1000,
+			None,
 		).genesis_map();
 		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
 		let block = construct_genesis_block::<Block>(state_root);
@@ -178,7 +179,8 @@ mod tests {
 		let mut storage = GenesisConfig::new(false,
 			vec![Sr25519Keyring::One.into(), Sr25519Keyring::Two.into()],
 			vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
-			1000
+			1000,
+			None,
 		).genesis_map();
 		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
 		let block = construct_genesis_block::<Block>(state_root);
@@ -207,7 +209,8 @@ mod tests {
 		let mut storage = GenesisConfig::new(false,
 			vec![Sr25519Keyring::One.into(), Sr25519Keyring::Two.into()],
 			vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
-			68
+			68,
+			None,
 		).genesis_map();
 		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
 		let block = construct_genesis_block::<Block>(state_root);

core/executor/Cargo.toml

@@ -14,7 +14,8 @@ serializer = { package = "substrate-serializer", path = "../serializer" }
 state_machine = { package = "substrate-state-machine", path = "../state-machine"  }
 runtime_version = { package = "sr-version", path = "../sr-version" }
 panic-handler = { package = "substrate-panic-handler", path = "../panic-handler" }
-wasmi = { version = "0.4.3" }
+wasmi = "0.5.0"
+parity-wasm = "0.31"
 byteorder = "1.3"
 lazy_static = "1.3"
 parking_lot = "0.8.0"

core/executor/runtime-test/build.rs

@@ -14,14 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-use wasm_builder_runner::{build_current_project, WasmBuilderSource};
+use wasm_builder_runner::{build_current_project_with_rustflags, WasmBuilderSource};
 
 fn main() {
-	build_current_project(
+	build_current_project_with_rustflags(
 		"wasm_binary.rs",
 		WasmBuilderSource::CratesOrPath {
 			path: "../../utils/wasm-builder",
 			version: "1.0.4",
 		},
+		// This instructs LLD to export __heap_base as a global variable, which is used by the
+		// external memory allocator.
+		"-Clink-arg=--export=__heap_base",
 	);
 }

core/executor/src/allocator.rs

@@ -53,22 +53,13 @@ impl FreeingBumpHeapAllocator {
 	///
 	/// # Arguments
 	///
-	/// * `ptr_offset` - The pointers returned by `allocate()` start from this
-	///   offset on. The pointer offset needs to be aligned to a multiple of 8,
-	///   hence a padding might be added to align `ptr_offset` properly.
-	///
-	/// * `heap_size` - The size available to this heap instance (in bytes) for
-	///   allocating memory.
-	///
-	/// * `heap` - A `MemoryRef` to the available `MemoryInstance` which is
-	///   used as the heap.
-	///
-	pub fn new(mem: MemoryRef) -> Self {
+	/// - `mem` - reference to the linear memory instance on which this allocator operates.
+	/// - `heap_base` - the offset from the beginning of the linear memory where the heap starts.
+	pub fn new(mem: MemoryRef, heap_base: u32) -> Self {
 		let current_size: Bytes = mem.current_size().into();
 		let current_size = current_size.0 as u32;
-		let used_size = mem.used_size().0 as u32;
 
-		let mut ptr_offset = used_size;
+		let mut ptr_offset = heap_base;
 		let padding = ptr_offset % ALIGNMENT;
 		if padding != 0 {
 			ptr_offset += ALIGNMENT - padding;
@@ -195,16 +186,11 @@ mod tests {
 
 	const PAGE_SIZE: u32 = 65536;
 
-	fn set_offset(mem: MemoryRef, offset: usize) {
-		let offset: Vec<u8> = vec![255; offset];
-		mem.set(0, &offset).unwrap();
-	}
-
 	#[test]
 	fn should_allocate_properly() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 
 		// when
 		let ptr = heap.allocate(1).unwrap();
@@ -217,8 +203,7 @@ mod tests {
 	fn should_always_align_pointers_to_multiples_of_8() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		set_offset(mem.clone(), 13);
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 13);
 
 		// when
 		let ptr = heap.allocate(1).unwrap();
@@ -233,7 +218,7 @@ mod tests {
 	fn should_increment_pointers_properly() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 
 		// when
 		let ptr1 = heap.allocate(1).unwrap();
@@ -256,7 +241,7 @@ mod tests {
 	fn should_free_properly() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 		let ptr1 = heap.allocate(1).unwrap();
 		// the prefix of 8 bytes is prepended to the pointer
 		assert_eq!(ptr1, 8);
@@ -278,9 +263,8 @@ mod tests {
 	fn should_deallocate_and_reallocate_properly() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		set_offset(mem.clone(), 13);
 		let padded_offset = 16;
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 13);
 
 		let ptr1 = heap.allocate(1).unwrap();
 		// the prefix of 8 bytes is prepended to the pointer
@@ -306,7 +290,7 @@ mod tests {
 	fn should_build_linked_list_of_free_areas_properly() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 
 		let ptr1 = heap.allocate(8).unwrap();
 		let ptr2 = heap.allocate(8).unwrap();
@@ -333,8 +317,7 @@ mod tests {
 	fn should_not_allocate_if_too_large() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), Some(Pages(1))).unwrap();
-		set_offset(mem.clone(), 13);
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 13);
 
 		// when
 		let ptr = heap.allocate(PAGE_SIZE - 13);
@@ -353,7 +336,7 @@ mod tests {
 	fn should_not_allocate_if_full() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), Some(Pages(1))).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 		let ptr1 = heap.allocate((PAGE_SIZE / 2) - 8).unwrap();
 		assert_eq!(ptr1, 8);
 
@@ -376,7 +359,7 @@ mod tests {
 		// given
 		let pages_needed = (MAX_POSSIBLE_ALLOCATION as usize / PAGE_SIZE as usize) + 1;
 		let mem = MemoryInstance::alloc(Pages(pages_needed), Some(Pages(pages_needed))).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 
 		// when
 		let ptr = heap.allocate(MAX_POSSIBLE_ALLOCATION).unwrap();
@@ -389,7 +372,7 @@ mod tests {
 	fn should_not_allocate_if_requested_size_too_large() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 0);
 
 		// when
 		let ptr = heap.allocate(MAX_POSSIBLE_ALLOCATION + 1);
@@ -408,8 +391,7 @@ mod tests {
 	fn should_include_prefixes_in_total_heap_size() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		set_offset(mem.clone(), 1);
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 1);
 
 		// when
 		// an item size of 16 must be used then
@@ -423,8 +405,7 @@ mod tests {
 	fn should_calculate_total_heap_size_to_zero() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		set_offset(mem.clone(), 13);
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 13);
 
 		// when
 		let ptr = heap.allocate(42).unwrap();
@@ -439,8 +420,7 @@ mod tests {
 	fn should_calculate_total_size_of_zero() {
 		// given
 		let mem = MemoryInstance::alloc(Pages(1), None).unwrap();
-		set_offset(mem.clone(), 19);
-		let mut heap = FreeingBumpHeapAllocator::new(mem);
+		let mut heap = FreeingBumpHeapAllocator::new(mem, 19);
 
 		// when
 		for _ in 1..10 {

core/executor/src/error.rs

@@ -38,8 +38,8 @@ pub enum Error {
 	#[display(fmt="Method not found: '{}'", _0)]
 	MethodNotFound(String),
 	/// Code is invalid (expected single byte)
-	#[display(fmt="Invalid Code: {:?}", _0)]
-	InvalidCode(Vec<u8>),
+	#[display(fmt="Invalid Code")]
+	InvalidCode,
 	/// Could not get runtime version.
 	#[display(fmt="On-chain runtime does not specify version")]
 	VersionInvalid,
@@ -58,6 +58,13 @@ pub enum Error {
 	/// Invalid memory reference.
 	#[display(fmt="Invalid memory reference")]
 	InvalidMemoryReference,
+	/// The runtime must provide a global named `__heap_base` of type i32 for specifying where the
+	/// allocator is allowed to place its data.
+	#[display(fmt="The runtime doesn't provide a global named `__heap_base`")]
+	HeapBaseNotFoundOrInvalid,
+	/// The runtime WebAssembly module is not allowed to have the `start` function.
+	#[display(fmt="The runtime has the `start` function")]
+	RuntimeHasStartFn,
 	/// Some other error occurred
 	Other(&'static str),
 	/// Some error occurred in the allocator

core/executor/src/lib.rs

@@ -35,11 +35,13 @@ mod wasm_executor;
 mod native_executor;
 mod sandbox;
 mod allocator;
+mod wasm_runtimes_cache;
 
 pub mod error;
 pub use wasmi;
 pub use wasm_executor::WasmExecutor;
 pub use native_executor::{with_native_environment, NativeExecutor, NativeExecutionDispatch};
+pub use wasm_runtimes_cache::RuntimesCache;
 pub use state_machine::Externalities;
 pub use runtime_version::{RuntimeVersion, NativeVersion};
 pub use parity_codec::Codec;