BREAKING Overlay transaction support.

core/executor/src/wasm_executor.rs

@@ -1247,6 +1247,18 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		this.sandbox_store.memory_teardown(memory_idx)?;
 		Ok(())
 	},
+	ext_storage_start_transaction() => {
+		this.ext.storage_start_transaction();
+		Ok(())
+	},
+	ext_storage_discard_transaction() => {
+		this.ext.storage_discard_transaction();
+		Ok(())
+	},
+	ext_storage_commit_transaction() => {
+		this.ext.storage_commit_transaction();
+		Ok(())
+	},
 	=> <'e, E: Externalities<Blake2Hasher> + 'e>
 );
 

core/sr-api-macros/tests/runtime_calls.rs

@@ -103,7 +103,6 @@ fn calling_with_both_strategy_and_fail_on_native_should_work() {
 	assert_eq!(runtime_api.fail_on_native(&block_id).unwrap(), 1);
 }
 
-
 #[test]
 fn calling_with_native_else_wasm_and_fail_on_wasm_should_work() {
 	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::NativeElseWasm).build();
@@ -128,6 +127,15 @@ fn use_trie_function() {
 	assert_eq!(runtime_api.use_trie(&block_id).unwrap(), 2);
 }
 
+#[test]
+fn test_transactions() {
+	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::AlwaysWasm).build();
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().chain.best_number);
+	assert_eq!(runtime_api.use_transactions(&block_id).unwrap(), 1);
+}
+
+
 #[test]
 fn initialize_block_works() {
 	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::Both).build();

core/sr-io/src/lib.rs

@@ -151,6 +151,15 @@ export_api! {
 		/// "Commit" all existing operations and get the resultant storage change root.
 		fn storage_changes_root(parent_hash: [u8; 32]) -> Option<[u8; 32]>;
 
+		/// Start a new transaction.
+		fn storage_start_transaction();
+
+		/// Discard a transactional layer.
+		fn storage_discard_transaction();
+
+		/// Commit a transactional layer.
+		fn storage_commit_transaction();
+
 		/// A trie root formed from the enumerated items.
 		/// TODO [#2382] remove (just use `ordered_trie_root` (NOTE currently not implemented for without_std))
 		fn enumerated_trie_root<H>(input: &[&[u8]]) -> H::Out

core/sr-io/with_std.rs

@@ -164,6 +164,18 @@ impl StorageApi for () {
 		).unwrap_or(Ok(None)).expect("Invalid parent hash passed to storage_changes_root")
 	}
 
+	fn storage_start_transaction() {
+		ext::with(|ext| ext.storage_start_transaction());
+	}
+
+	fn storage_discard_transaction() {
+		ext::with(|ext| ext.storage_discard_transaction());
+	}
+
+	fn storage_commit_transaction() {
+		ext::with(|ext| ext.storage_commit_transaction());
+	}
+
 	fn enumerated_trie_root<H>(input: &[&[u8]]) -> H::Out
 	where
 		H: Hasher,

core/sr-io/without_std.rs

@@ -90,7 +90,7 @@ pub mod ext {
 		/// # Returns
 		///
 		/// Returns the original implementation wrapped in [`RestoreImplementation`].
-		pub fn replace_implementation(&'static self, new_impl: T)  -> RestoreImplementation<T> {
+		pub fn replace_implementation(&'static self, new_impl: T) -> RestoreImplementation<T> {
 			if let ExchangeableFunctionState::Replaced = self.0.get().1 {
 				panic!("Trying to replace an already replaced implementation!")
 			}
@@ -624,7 +624,22 @@ pub mod ext {
 			buffer_len: u32,
 			deadline: u64
 		) -> u32;
+
+		//================================
+		// Transactional Context
+		//================================
+
+		/// Open a new transactional storage layer.
+		fn ext_storage_start_transaction();
+
+		/// Close and dismiss current transactional storage layer.
+		fn ext_storage_discard_transaction();
+
+		/// Close and commit current transactional storage layer.
+		fn ext_storage_commit_transaction();
+
 	}
+
 }
 
 pub use self::ext::*;
@@ -805,6 +820,25 @@ impl StorageApi for () {
 	>(_input: I) -> H::Out {
 		unimplemented!()
 	}
+
+	fn storage_start_transaction() {
+		unsafe {
+			ext_storage_start_transaction.get()()
+		}
+	}
+
+	fn storage_discard_transaction() {
+		unsafe {
+			ext_storage_discard_transaction.get()()
+		}
+	}
+
+	fn storage_commit_transaction() {
+		unsafe {
+			ext_storage_commit_transaction.get()()
+		}
+	}
+
 }
 
 impl OtherApi for () {

core/state-machine/Cargo.toml

@@ -19,3 +19,9 @@ num-traits = "0.2"
 
 [dev-dependencies]
 hex-literal = "0.2.0"
+criterion = "0.2"
+rand = "0.6"
+
+[[bench]]
+name = "bench"
+harness = false

core/state-machine/benches/bench.rs

@@ -0,0 +1,118 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use criterion::{Criterion, black_box, Bencher};
+use criterion::{criterion_group, criterion_main};
+use substrate_state_machine::OverlayedChanges;
+
+const CONTENT_KEY_SIZE: usize = 32;
+
+fn get_content(seed: u64, len: usize) -> Vec<u8> {
+	use rand::SeedableRng;
+	use rand::RngCore;
+	let mut rng = rand::rngs::SmallRng::seed_from_u64(seed);
+	let mut data = vec![0u8; len];
+	rng.fill_bytes(&mut data[..]);
+	data
+}
+
+fn key_val(
+	mut inp: &[u8],
+	len_key: usize,
+	len_val: usize,
+) -> Vec<(Vec<u8>, Vec<u8>)> {
+	let mut result = Vec::new();
+	loop {
+		let key = if inp.len() >= len_key {
+			inp[..len_key].to_vec()
+		} else { break };
+		inp = &inp[len_key..];
+		let val = if inp.len() >= len_val {
+			inp[..len_val].to_vec()
+		} else { break };
+		inp = &inp[len_val..];
+		result.push((key, val));
+	}
+	result
+}
+
+fn commit_drop_commit(b: &mut Bencher, input: &Vec<u8>) {
+	let key_vals = key_val(&input[..], 32, 32);
+	b.iter(move || {
+		let mut overlayed = OverlayedChanges::default();
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		overlayed.commit_prospective();
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		overlayed.discard_prospective();
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		overlayed.commit_prospective();
+	});
+}
+
+fn commit_drop_commit_and_get(b: &mut Bencher, input: &Vec<u8>) {
+	let key_vals = key_val(&input[..], 32, 32);
+	b.iter(move || {
+		let mut overlayed = OverlayedChanges::default();
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		for i in key_vals.iter() {
+			black_box(overlayed.storage(&i.0));
+		}
+		overlayed.commit_prospective();
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		for i in key_vals.iter() {
+			black_box(overlayed.storage(&i.0));
+		}
+		overlayed.discard_prospective();
+		for i in key_vals.iter() {
+			black_box(overlayed.storage(&i.0));
+		}
+		for i in key_vals.iter() {
+			overlayed.set_storage(i.0.clone(), Some(i.1.clone()));
+		}
+		overlayed.commit_prospective();
+	});
+}
+
+
+
+
+fn bench_overlay_commit_drop_commit(c: &mut Criterion) {
+	let inp = get_content(12, CONTENT_KEY_SIZE * 100);
+	let inps = vec![inp];
+	c.bench_function_over_inputs("commit_drop_commit", commit_drop_commit, inps);
+}
+fn bench_overlay_commit_drop_commit_get(c: &mut Criterion) {
+	let inp = get_content(12, CONTENT_KEY_SIZE * 100);
+	let inps = vec![inp];
+	c.bench_function_over_inputs("commit_drop_commit_get", commit_drop_commit_and_get, inps);
+}
+
+
+criterion_group!(benches,
+	bench_overlay_commit_drop_commit,
+	bench_overlay_commit_drop_commit_get,
+);
+criterion_main!(benches);

core/state-machine/src/basic.rs

@@ -170,6 +170,19 @@ impl<H: Hasher> Externalities<H> for BasicExternalities where H::Out: Ord {
 		warn!("Call to non-existent out offchain externalities set.");
 		None
 	}
+
+	fn storage_start_transaction(&mut self) {
+		warn!("No support for storage transaction");
+	}
+
+	fn storage_discard_transaction(&mut self) {
+		panic!("No support for storage transaction");
+	}
+
+	fn storage_commit_transaction(&mut self) {
+		// no need to fail in this case
+	}
+
 }
 
 #[cfg(test)]