Merge branch 'master' into client-ipc-refact

ethcore/Cargo.toml

@@ -45,3 +45,4 @@ json-tests = []
 test-heavy = []
 dev = ["clippy"]
 default = []
+benches = []

ethcore/src/account.rs

@@ -127,7 +127,7 @@ impl Account {
 				SecTrieDBMut would not set it to an invalid state root. Therefore the root is valid and DB creation \
 				using it will not fail.");
 
-			(Filth::Clean, H256::from(db.get(key.bytes()).map_or(U256::zero(), |v| -> U256 {decode(v)})))
+			(Filth::Clean, H256::from(db.get(key).map_or(U256::zero(), |v| -> U256 {decode(v)})))
 		}).1.clone()
 	}
 

ethcore/src/client/client.rs

@@ -18,4 +18,3 @@
 
 #![allow(dead_code, unused_assignments, unused_variables, missing_docs)] // codegen issues
 include!(concat!(env!("OUT_DIR"), "/client.ipc.rs"));
-

ethcore/src/client/client_ipc.rs

@@ -22,7 +22,8 @@ use std::collections::VecDeque;
 use std::sync::*;
 use std::path::Path;
 use std::fmt;
-use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
+use std::time::Instant;
 
 // util
 use util::numbers::*;
@@ -62,7 +63,8 @@ use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
 use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig,
 	DatabaseCompactionProfile, BlockChainClient, MiningBlockChainClient,
-	TraceFilter, CallAnalytics, BlockImportError, TransactionImportError, TransactionImportResult};
+	TraceFilter, CallAnalytics, BlockImportError, TransactionImportError,
+	TransactionImportResult, Mode};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -80,7 +82,9 @@ pub use types::blockchain_info::BlockChainInfo;
 pub use types::block_status::BlockStatus;
 pub use blockchain::CacheSize as BlockChainCacheSize;
 
+
 const MAX_TX_QUEUE_SIZE: usize = 4096;
+const MAX_QUEUE_SIZE_TO_SLEEP_ON: usize = 2;
 
 impl fmt::Display for BlockChainInfo {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -110,9 +114,24 @@ impl ClientReport {
 	}
 }
 
+struct SleepState {
+	last_activity: Option<Instant>,
+	last_autosleep: Option<Instant>,
+}
+
+impl SleepState {
+	fn new(awake: bool) -> Self {
+		SleepState {
+			last_activity: match awake { false => None, true => Some(Instant::now()) },
+			last_autosleep: match awake { false => Some(Instant::now()), true => None },
+		}
+	}
+}
+
 /// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue.
 /// Call `import_block()` to import a block asynchronously; `flush_queue()` flushes the queue.
 pub struct Client {
+	mode: Mode,
 	chain: Arc<BlockChain>,
 	tracedb: Arc<TraceDB<BlockChain>>,
 	engine: Arc<Box<Engine>>,
@@ -125,6 +144,8 @@ pub struct Client {
 	vm_factory: Arc<EvmFactory>,
 	trie_factory: TrieFactory,
 	miner: Arc<Miner>,
+	sleep_state: Mutex<SleepState>,
+	liveness: AtomicBool,
 	io_channel: IoChannel<NetSyncMessage>,
 	queue_transactions: AtomicUsize,
 }
@@ -161,9 +182,8 @@ impl Client {
 		spec: Spec,
 		path: &Path,
 		miner: Arc<Miner>,
-		message_channel: IoChannel<NetSyncMessage>)
-		-> Result<Arc<Client>, ClientError>
-	{
+		message_channel: IoChannel<NetSyncMessage>
+	) -> Result<Arc<Client>, ClientError> {
 		let path = get_db_path(path, config.pruning, spec.genesis_header().hash());
 		let gb = spec.genesis_block();
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, &path));
@@ -194,7 +214,11 @@ impl Client {
 		let panic_handler = PanicHandler::new_in_arc();
 		panic_handler.forward_from(&block_queue);
 
+		let awake = match config.mode { Mode::Dark(..) => false, _ => true };
 		let client = Client {
+			sleep_state: Mutex::new(SleepState::new(awake)),
+			liveness: AtomicBool::new(awake),
+			mode: config.mode,
 			chain: chain,
 			tracedb: tracedb,
 			engine: engine,
@@ -210,7 +234,6 @@ impl Client {
 			io_channel: message_channel,
 			queue_transactions: AtomicUsize::new(0),
 		};
-
 		Ok(Arc::new(client))
 	}
 
@@ -476,9 +499,41 @@ impl Client {
 	}
 
 	/// Tick the client.
+	// TODO: manage by real events.
 	pub fn tick(&self) {
 		self.chain.collect_garbage();
 		self.block_queue.collect_garbage();
+
+		match self.mode {
+			Mode::Dark(timeout) => {
+				let mut ss = self.sleep_state.lock().unwrap();
+				if let Some(t) = ss.last_activity {
+					if Instant::now() > t + timeout {
+						self.sleep();
+						ss.last_activity = None;
+					}
+				}
+			}
+			Mode::Passive(timeout, wakeup_after) => {
+				let mut ss = self.sleep_state.lock().unwrap();
+				let now = Instant::now();
+				if let Some(t) = ss.last_activity {
+					if now > t + timeout {
+						self.sleep();
+						ss.last_activity = None;
+						ss.last_autosleep = Some(now);
+					}
+				}
+				if let Some(t) = ss.last_autosleep {
+					if now > t + wakeup_after {
+						self.wake_up();
+						ss.last_activity = Some(now);
+						ss.last_autosleep = None;
+					}
+				}
+			}
+			_ => {}
+		}
 	}
 
 	/// Set up the cache behaviour.
@@ -514,6 +569,29 @@ impl Client {
 			})
 		}
 	}
+
+	fn wake_up(&self) {
+		if !self.liveness.load(AtomicOrdering::Relaxed) {
+			self.liveness.store(true, AtomicOrdering::Relaxed);
+			self.io_channel.send(NetworkIoMessage::User(SyncMessage::StartNetwork)).unwrap();
+			trace!(target: "mode", "wake_up: Waking.");
+		}
+	}
+
+	fn sleep(&self) {
+		if self.liveness.load(AtomicOrdering::Relaxed) {
+			// only sleep if the import queue is mostly empty.
+			if self.queue_info().total_queue_size() <= MAX_QUEUE_SIZE_TO_SLEEP_ON {
+				self.liveness.store(false, AtomicOrdering::Relaxed);
+				self.io_channel.send(NetworkIoMessage::User(SyncMessage::StopNetwork)).unwrap();
+				trace!(target: "mode", "sleep: Sleeping.");
+			} else {
+				trace!(target: "mode", "sleep: Cannot sleep - syncing ongoing.");
+				// TODO: Consider uncommenting.
+				//*self.last_activity.lock().unwrap() = Some(Instant::now());
+			}
+		}
+	}
 }
 
 #[derive(Ipc)]
@@ -557,6 +635,12 @@ impl BlockChainClient for Client {
 		ret
 	}
 
+	fn keep_alive(&self) {
+		if self.mode != Mode::Active {
+			self.wake_up();
+			(*self.sleep_state.lock().unwrap()).last_activity = Some(Instant::now());
+		}
+	}
 
 	fn block_header(&self, id: BlockID) -> Option<Bytes> {
 		Self::block_hash(&self.chain, id).and_then(|hash| self.chain.block(&hash).map(|bytes| BlockView::new(&bytes).rlp().at(0).as_raw().to_vec()))

ethcore/src/client/config.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+pub use std::time::Duration;
 pub use block_queue::BlockQueueConfig;
 pub use blockchain::Config as BlockChainConfig;
 pub use trace::{Config as TraceConfig, Switch};
@@ -35,6 +36,23 @@ impl Default for DatabaseCompactionProfile {
 	fn default() -> Self { DatabaseCompactionProfile::Default }
 }
 
+/// Operating mode for the client.
+#[derive(Debug, Eq, PartialEq)]
+pub enum Mode {
+	/// Always on.
+	Active,
+	/// Goes offline after RLP is inactive for some (given) time, but
+	/// comes back online after a while of inactivity.
+	Passive(Duration, Duration),
+	/// Goes offline after RLP is inactive for some (given) time and
+	/// stays inactive.
+	Dark(Duration),
+}
+
+impl Default for Mode {
+	fn default() -> Self { Mode::Active }
+}
+
 /// Client configuration. Includes configs for all sub-systems.
 #[derive(Debug, Default)]
 pub struct ClientConfig {
@@ -56,6 +74,8 @@ pub struct ClientConfig {
 	pub db_cache_size: Option<usize>,
 	/// State db compaction profile
 	pub db_compaction: DatabaseCompactionProfile,
+	/// Operating mode
+	pub mode: Mode,
 	/// Type of block verifier used by client.
 	pub verifier_type: VerifierType,
 }

ethcore/src/client/mod.rs

@@ -23,7 +23,7 @@ mod test_client;
 mod trace;
 
 pub use self::client::*;
-pub use self::config::{ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType};
+pub use self::config::{Mode, ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType};
 pub use self::error::Error;
 pub use types::ids::*;
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
@@ -53,6 +53,11 @@ pub use transaction_import::{TransactionImportResult, TransactionImportError};
 
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient : Sync + Send {
+	
+	/// Should be called by any external-facing interface when actively using the client.
+	/// To minimise chatter, there's no need to call more than once every 30s.
+	fn keep_alive(&self) {}
+
 	/// Get raw block header data by block id.
 	fn block_header(&self, id: BlockID) -> Option<Bytes>;
 

ethcore/src/evm/benches/mod.rs

@@ -0,0 +1,126 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// 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/>.
+
+//! benchmarking for EVM
+//! should be started with:
+//! ```bash
+//! multirust run nightly cargo bench
+//! ```
+
+extern crate test;
+
+use self::test::{Bencher, black_box};
+
+use common::*;
+use evm::{self, Factory, VMType};
+use evm::tests::FakeExt;
+
+#[bench]
+fn simple_loop_log0_usize(b: &mut Bencher) {
+	simple_loop_log0(U256::from(::std::usize::MAX), b)
+}
+
+#[bench]
+fn simple_loop_log0_u256(b: &mut Bencher) {
+	simple_loop_log0(!U256::zero(), b)
+}
+
+fn simple_loop_log0(gas: U256, b: &mut Bencher) {
+	let mut vm = Factory::new(VMType::Interpreter).create(gas);
+	let mut ext = FakeExt::new();
+
+	let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
+	let code = black_box(
+		"62ffffff5b600190036000600fa0600357".from_hex().unwrap()
+	);
+
+	b.iter(|| {
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.gas = gas;
+		params.code = Some(code.clone());
+
+		result(vm.exec(params, &mut ext))
+	});
+}
+
+#[bench]
+fn mem_gas_calculation_same_usize(b: &mut Bencher) {
+	mem_gas_calculation_same(U256::from(::std::usize::MAX), b)
+}
+
+#[bench]
+fn mem_gas_calculation_same_u256(b: &mut Bencher) {
+	mem_gas_calculation_same(!U256::zero(), b)
+}
+
+fn mem_gas_calculation_same(gas: U256, b: &mut Bencher) {
+	let mut vm = Factory::new(VMType::Interpreter).create(gas);
+	let mut ext = FakeExt::new();
+
+	let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
+
+	b.iter(|| {
+		let code = black_box(
+			"6110006001556001546000555b610fff805560016000540380600055600c57".from_hex().unwrap()
+		);
+
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.gas = gas;
+		params.code = Some(code.clone());
+
+		result(vm.exec(params, &mut ext))
+	});
+}
+
+#[bench]
+fn mem_gas_calculation_increasing_usize(b: &mut Bencher) {
+	mem_gas_calculation_increasing(U256::from(::std::usize::MAX), b)
+}
+
+#[bench]
+fn mem_gas_calculation_increasing_u256(b: &mut Bencher) {
+	mem_gas_calculation_increasing(!U256::zero(), b)
+}
+
+fn mem_gas_calculation_increasing(gas: U256, b: &mut Bencher) {
+	let mut vm = Factory::new(VMType::Interpreter).create(gas);
+	let mut ext = FakeExt::new();
+
+	let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
+
+	b.iter(|| {
+		let code = black_box(
+			"6110006001556001546000555b610fff60005401805560016000540380600055600c57".from_hex().unwrap()
+		);
+
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.gas = gas;
+		params.code = Some(code.clone());
+
+		result(vm.exec(params, &mut ext))
+	});
+}
+
+fn result(r: evm::Result<evm::GasLeft>) -> U256 {
+	match r {
+		Ok(evm::GasLeft::Known(v)) => v,
+		Ok(evm::GasLeft::NeedsReturn(v, _)) => v,
+		_ => U256::zero(),
+	}
+}

ethcore/src/evm/evm.rs

@@ -95,6 +95,61 @@ impl<'a> Finalize for Result<GasLeft<'a>> {
 	}
 }
 
+pub trait CostType: ops::Mul<Output=Self> + ops::Div<Output=Self> + ops::Add<Output=Self> + ops::Sub<Output=Self> + ops::Shr<usize, Output=Self> + ops::Shl<usize, Output=Self> + cmp::Ord + Sized + From<usize> + Copy {
+	fn as_u256(&self) -> U256;
+	fn from_u256(val: U256) -> Result<Self>;
+	fn as_usize(&self) -> usize;
+	fn overflow_add(self, other: Self) -> (Self, bool);
+	fn overflow_mul(self, other: Self) -> (Self, bool);
+}
+
+impl CostType for U256 {
+	fn as_u256(&self) -> U256 {
+		*self
+	}
+
+	fn from_u256(val: U256) -> Result<Self> {
+		Ok(val)
+	}
+
+	fn as_usize(&self) -> usize {
+		self.as_u64() as usize
+	}
+
+	fn overflow_add(self, other: Self) -> (Self, bool) {
+		Uint::overflowing_add(self, other)
+	}
+
+	fn overflow_mul(self, other: Self) -> (Self, bool) {
+		Uint::overflowing_mul(self, other)
+	}
+}
+
+impl CostType for usize {
+	fn as_u256(&self) -> U256 {
+		U256::from(*self)
+	}
+
+	fn from_u256(val: U256) -> Result<Self> {
+		if U256::from(val.low_u64()) != val {
+			return Err(Error::OutOfGas);
+		}
+		Ok(val.low_u64() as usize)
+	}
+
+	fn as_usize(&self) -> usize {
+		*self
+	}
+
+	fn overflow_add(self, other: Self) -> (Self, bool) {
+		self.overflowing_add(other)
+	}
+
+	fn overflow_mul(self, other: Self) -> (Self, bool) {
+		self.overflowing_mul(other)
+	}
+}
+
 /// Evm interface
 pub trait Evm {
 	/// This function should be used to execute transaction.

ethcore/src/evm/factory.rs

@@ -19,6 +19,7 @@
 //! TODO: consider spliting it into two separate files.
 use std::fmt;
 use evm::Evm;
+use util::{U256, Uint};
 
 #[derive(Debug, Clone)]
 /// Type of EVM to use.
@@ -85,24 +86,30 @@ pub struct Factory {
 
 impl Factory {
 	/// Create fresh instance of VM
+	/// Might choose implementation depending on supplied gas.
 	#[cfg(feature = "jit")]
-	pub fn create(&self) -> Box<Evm> {
+	pub fn create(&self, gas: U256) -> Box<Evm> {
 		match self.evm {
 			VMType::Jit => {
 				Box::new(super::jit::JitEvm::default())
 			},
-			VMType::Interpreter => {
-				Box::new(super::interpreter::Interpreter::default())
+			VMType::Interpreter => if Self::can_fit_in_usize(gas) {
+				Box::new(super::interpreter::Interpreter::<usize>::default())
+			} else {
+				Box::new(super::interpreter::Interpreter::<U256>::default())
 			}
 		}
 	}
 
 	/// Create fresh instance of VM
+	/// Might choose implementation depending on supplied gas.
 	#[cfg(not(feature = "jit"))]
-	pub fn create(&self) -> Box<Evm> {
+	pub fn create(&self, gas: U256) -> Box<Evm> {
 		match self.evm {
-			VMType::Interpreter => {
-				Box::new(super::interpreter::Interpreter::default())
+			VMType::Interpreter => if Self::can_fit_in_usize(gas) {
+				Box::new(super::interpreter::Interpreter::<usize>::default())
+			} else {
+				Box::new(super::interpreter::Interpreter::<U256>::default())
 			}
 		}
 	}
@@ -113,6 +120,10 @@ impl Factory {
 			evm: evm
 		}
 	}
+
+	fn can_fit_in_usize(gas: U256) -> bool {
+		gas == U256::from(gas.low_u64() as usize)
+	}
 }
 
 impl Default for Factory {
@@ -135,7 +146,7 @@ impl Default for Factory {
 
 #[test]
 fn test_create_vm() {
-	let _vm = Factory::default().create();
+	let _vm = Factory::default().create(U256::zero());
 }
 
 /// Create tests by injecting different VM factories

ethcore/src/evm/instructions.rs

@@ -79,7 +79,7 @@ fn test_get_log_topics() {
 	assert_eq!(get_log_topics(LOG4), 4);
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Clone, Copy)]
 pub enum GasPriceTier {
 	/// 0 Zero
 	Zero,

ethcore/src/evm/interpreter/gasometer.rs

@@ -0,0 +1,261 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// 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 common::*;
+use super::u256_to_address;
+use evm::{self, CostType};
+use evm::instructions::{self, Instruction, InstructionInfo};
+use evm::interpreter::stack::Stack;
+
+macro_rules! overflowing {
+	($x: expr) => {{
+		let (v, overflow) = $x;
+		if overflow { return Err(evm::Error::OutOfGas); }
+		v
+	}}
+}
+
+#[cfg_attr(feature="dev", allow(enum_variant_names))]
+enum InstructionCost<Cost: CostType> {
+	Gas(Cost),
+	GasMem(Cost, Cost),
+	GasMemCopy(Cost, Cost, Cost)
+}
+
+pub struct Gasometer<Gas: CostType> {
+	pub current_gas: Gas,
+}
+
+impl<Gas: CostType> Gasometer<Gas> {
+
+	pub fn new(current_gas: Gas) -> Self {
+		Gasometer {
+			current_gas: current_gas,
+		}
+	}
+
+	pub fn verify_gas(&self, gas_cost: &Gas) -> evm::Result<()> {
+		match &self.current_gas < gas_cost {
+			true => Err(evm::Error::OutOfGas),
+			false => Ok(())
+		}
+	}
+
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
+	pub fn get_gas_cost_mem(
+		&mut self,
+		ext: &evm::Ext,
+		instruction: Instruction,
+		info: &InstructionInfo,
+		stack: &Stack<U256>,
+		current_mem_size: usize,
+	) -> evm::Result<(Gas, usize)> {
+		let schedule = ext.schedule();
+		let tier = instructions::get_tier_idx(info.tier);
+		let default_gas = Gas::from(schedule.tier_step_gas[tier]);
+
+		let cost = match instruction {
+			instructions::SSTORE => {
+				let address = H256::from(stack.peek(0));
+				let newval = stack.peek(1);
+				let val = U256::from(ext.storage_at(&address).as_slice());
+
+				let gas = if U256::zero() == val && &U256::zero() != newval {
+					schedule.sstore_set_gas
+				} else {
+					// Refund for below case is added when actually executing sstore
+					// !self.is_zero(&val) && self.is_zero(newval)
+					schedule.sstore_reset_gas
+				};
+				InstructionCost::Gas(Gas::from(gas))
+			},
+			instructions::SLOAD => {
+				InstructionCost::Gas(Gas::from(schedule.sload_gas))
+			},
+			instructions::MSTORE | instructions::MLOAD => {
+				InstructionCost::GasMem(default_gas, try!(self.mem_needed_const(stack.peek(0), 32)))
+			},
+			instructions::MSTORE8 => {
+				InstructionCost::GasMem(default_gas, try!(self.mem_needed_const(stack.peek(0), 1)))
+			},
+			instructions::RETURN => {
+				InstructionCost::GasMem(default_gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
+			},
+			instructions::SHA3 => {
+				let w = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(1))), 31));
+				let words = w >> 5;
+				let gas = Gas::from(schedule.sha3_gas) + (Gas::from(schedule.sha3_word_gas) * words);
+				InstructionCost::GasMem(gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
+			},
+			instructions::CALLDATACOPY | instructions::CODECOPY => {
+				InstructionCost::GasMemCopy(default_gas, try!(self.mem_needed(stack.peek(0), stack.peek(2))), try!(Gas::from_u256(*stack.peek(2))))
+			},
+			instructions::EXTCODECOPY => {
+				InstructionCost::GasMemCopy(default_gas, try!(self.mem_needed(stack.peek(1), stack.peek(3))), try!(Gas::from_u256(*stack.peek(3))))
+			},
+			instructions::JUMPDEST => {
+				InstructionCost::Gas(Gas::from(1))
+			},
+			instructions::LOG0...instructions::LOG4 => {
+				let no_of_topics = instructions::get_log_topics(instruction);
+				let log_gas = schedule.log_gas + schedule.log_topic_gas * no_of_topics;
+
+				let data_gas = overflowing!(try!(Gas::from_u256(*stack.peek(1))).overflow_mul(Gas::from(schedule.log_data_gas)));
+				let gas = overflowing!(data_gas.overflow_add(Gas::from(log_gas)));
+				InstructionCost::GasMem(gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
+			},
+			instructions::CALL | instructions::CALLCODE => {
+				let mut gas  = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(0))), schedule.call_gas));
+				let mem = cmp::max(
+					try!(self.mem_needed(stack.peek(5), stack.peek(6))),
+					try!(self.mem_needed(stack.peek(3), stack.peek(4)))
+				);
+
+				let address = u256_to_address(stack.peek(1));
+
+				if instruction == instructions::CALL && !ext.exists(&address) {
+					gas = overflowing!(gas.overflow_add(Gas::from(schedule.call_new_account_gas)));
+				};
+
+				if stack.peek(2) > &U256::zero() {
+					gas = overflowing!(gas.overflow_add(Gas::from(schedule.call_value_transfer_gas)));
+				};
+
+				InstructionCost::GasMem(gas,mem)
+			},
+			instructions::DELEGATECALL => {
+				let gas = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(0))), schedule.call_gas));
+				let mem = cmp::max(
+					try!(self.mem_needed(stack.peek(4), stack.peek(5))),
+					try!(self.mem_needed(stack.peek(2), stack.peek(3)))
+				);
+				InstructionCost::GasMem(gas, mem)
+			},
+			instructions::CREATE => {
+				let gas = Gas::from(schedule.create_gas);
+				let mem = try!(self.mem_needed(stack.peek(1), stack.peek(2)));
+				InstructionCost::GasMem(gas, mem)
+			},
+			instructions::EXP => {
+				let expon = stack.peek(1);
+				let bytes = ((expon.bits() + 7) / 8) as usize;
+				let gas = Gas::from(schedule.exp_gas + schedule.exp_byte_gas * bytes);
+				InstructionCost::Gas(gas)
+			},
+			_ => InstructionCost::Gas(default_gas)
+		};
+
+		match cost {
+			InstructionCost::Gas(gas) => {
+				Ok((gas, 0))
+			},
+			InstructionCost::GasMem(gas, mem_size) => {
+				let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size));
+				let gas = overflowing!(gas.overflow_add(mem_gas));
+				Ok((gas, new_mem_size))
+			},
+			InstructionCost::GasMemCopy(gas, mem_size, copy) => {
+				let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size));
+				let copy = overflowing!(add_gas_usize(copy, 31));
+				let copy_gas = Gas::from(schedule.copy_gas) * (copy / Gas::from(32 as usize));
+				let gas = overflowing!(gas.overflow_add(copy_gas));
+				let gas = overflowing!(gas.overflow_add(mem_gas));
+				Ok((gas, new_mem_size))
+			}
+		}
+	}
+
+	fn is_zero(&self, val: &Gas) -> bool {
+		&Gas::from(0) == val
+	}
+
+	fn mem_needed_const(&self, mem: &U256, add: usize) -> evm::Result<Gas> {
+		Gas::from_u256(overflowing!(mem.overflowing_add(U256::from(add))))
+	}
+
+	fn mem_needed(&self, offset: &U256, size: &U256) -> evm::Result<Gas> {
+		if self.is_zero(&try!(Gas::from_u256(*size))) {
+			return Ok(Gas::from(0));
+		}
+
+		Gas::from_u256(overflowing!(offset.overflowing_add(*size)))
+	}
+
+	fn mem_gas_cost(&self, schedule: &evm::Schedule, current_mem_size: usize, mem_size: &Gas) -> evm::Result<(Gas, usize)> {
+		let gas_for_mem = |mem_size: Gas| {
+			let s = mem_size >> 5;
+			// s * memory_gas + s * s / quad_coeff_div
+			let a = overflowing!(s.overflow_mul(Gas::from(schedule.memory_gas)));
+			// We need to go to U512 to calculate s*s/quad_coeff_div
+			let b = U512::from(s.as_u256()) * U512::from(s.as_u256()) / U512::from(schedule.quad_coeff_div);
+			if b > U512::from(!U256::zero()) {
+				Err(evm::Error::OutOfGas)
+			} else {
+				Ok(overflowing!(a.overflow_add(try!(Gas::from_u256(U256::from(b))))))
+			}
+		};
+		let current_mem_size = Gas::from(current_mem_size);
+		let req_mem_size_rounded = (overflowing!(mem_size.overflow_add(Gas::from(31 as usize))) >> 5) << 5;
+
+		let mem_gas_cost = if req_mem_size_rounded > current_mem_size {
+			let new_mem_gas = try!(gas_for_mem(req_mem_size_rounded));
+			let current_mem_gas = try!(gas_for_mem(current_mem_size));
+			new_mem_gas - current_mem_gas
+		} else {
+			Gas::from(0)
+		};
+
+		Ok((mem_gas_cost, req_mem_size_rounded.as_usize()))
+	}
+}
+
+#[inline]
+fn add_gas_usize<Gas: CostType>(value: Gas, num: usize) -> (Gas, bool) {
+	value.overflow_add(Gas::from(num))
+}
+
+#[test]
+fn test_mem_gas_cost() {
+	// given
+	let gasometer = Gasometer::<U256>::new(U256::zero());
+	let schedule = evm::Schedule::default();
+	let current_mem_size = 5;
+	let mem_size = !U256::zero();
+
+	// when
+	let result = gasometer.mem_gas_cost(&schedule, current_mem_size, &mem_size);
+
+	// then
+	if let Ok(_) = result {
+		assert!(false, "Should fail with OutOfGas");
+	}
+}
+
+#[test]
+fn test_calculate_mem_cost() {
+	// given
+	let gasometer = Gasometer::<usize>::new(0);
+	let schedule = evm::Schedule::default();
+	let current_mem_size = 0;
+	let mem_size = 5;
+
+	// when
+	let (mem_cost, mem_size) = gasometer.mem_gas_cost(&schedule, current_mem_size, &mem_size).unwrap();
+
+	// then
+	assert_eq!(mem_cost, 3);
+	assert_eq!(mem_size, 32);
+}

ethcore/src/evm/interpreter/memory.rs

@@ -0,0 +1,150 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// 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 util::{U256, Uint};
+
+pub trait Memory {
+	/// Retrieve current size of the memory
+	fn size(&self) -> usize;
+	/// Resize (shrink or expand) the memory to specified size (fills 0)
+	fn resize(&mut self, new_size: usize);
+	/// Resize the memory only if its smaller
+	fn expand(&mut self, new_size: usize);
+	/// Write single byte to memory
+	fn write_byte(&mut self, offset: U256, value: U256);
+	/// Write a word to memory. Does not resize memory!
+	fn write(&mut self, offset: U256, value: U256);
+	/// Read a word from memory
+	fn read(&self, offset: U256) -> U256;
+	/// Write slice of bytes to memory. Does not resize memory!
+	fn write_slice(&mut self, offset: U256, &[u8]);
+	/// Retrieve part of the memory between offset and offset + size
+	fn read_slice(&self, offset: U256, size: U256) -> &[u8];
+	/// Retrieve writeable part of memory
+	fn writeable_slice(&mut self, offset: U256, size: U256) -> &mut[u8];
+	fn dump(&self);
+}
+
+/// Checks whether offset and size is valid memory range
+fn is_valid_range(off: usize, size: usize)  -> bool {
+	// When size is zero we haven't actually expanded the memory
+	let overflow = off.overflowing_add(size).1;
+	size > 0 && !overflow
+}
+
+impl Memory for Vec<u8> {
+	fn dump(&self) {
+		println!("MemoryDump:");
+		for i in self.iter() {
+			println!("{:02x} ", i);
+		}
+		println!("");
+	}
+
+	fn size(&self) -> usize {
+		self.len()
+	}
+
+	fn read_slice(&self, init_off_u: U256, init_size_u: U256) -> &[u8] {
+		let off = init_off_u.low_u64() as usize;
+		let size = init_size_u.low_u64() as usize;
+		if !is_valid_range(off, size) {
+			&self[0..0]
+		} else {
+			&self[off..off+size]
+		}
+	}
+
+	fn read(&self, offset: U256) -> U256 {
+		let off = offset.low_u64() as usize;
+		U256::from(&self[off..off+32])
+	}
+
+	fn writeable_slice(&mut self, offset: U256, size: U256) -> &mut [u8] {
+		let off = offset.low_u64() as usize;
+		let s = size.low_u64() as usize;
+		if !is_valid_range(off, s) {
+			&mut self[0..0]
+		} else {
+			&mut self[off..off+s]
+		}
+	}
+
+	fn write_slice(&mut self, offset: U256, slice: &[u8]) {
+		let off = offset.low_u64() as usize;
+
+		// TODO [todr] Optimize?
+		for pos in off..off+slice.len() {
+			self[pos] = slice[pos - off];
+		}
+	}
+
+	fn write(&mut self, offset: U256, value: U256) {
+		let off = offset.low_u64() as usize;
+		let mut val = value;
+
+		let end = off + 32;
+		for pos in 0..32 {
+			self[end - pos - 1] = val.low_u64() as u8;
+			val = val >> 8;
+		}
+	}
+
+	fn write_byte(&mut self, offset: U256, value: U256) {
+		let off = offset.low_u64() as usize;
+		let val = value.low_u64() as u64;
+		self[off] = val as u8;
+	}
+
+	fn resize(&mut self, new_size: usize) {
+		self.resize(new_size, 0);
+	}
+
+	fn expand(&mut self, size: usize) {
+		if size > self.len() {
+			Memory::resize(self, size)
+		}
+	}
+}
+
+
+#[test]
+fn test_memory_read_and_write() {
+	// given
+	let mem: &mut Memory = &mut vec![];
+	mem.resize(0x80 + 32);
+
+	// when
+	mem.write(U256::from(0x80), U256::from(0xabcdef));
+
+	// then
+	assert_eq!(mem.read(U256::from(0x80)), U256::from(0xabcdef));
+}
+
+#[test]
+fn test_memory_read_and_write_byte() {
+	// given
+	let mem: &mut Memory = &mut vec![];
+	mem.resize(32);
+
+	// when
+	mem.write_byte(U256::from(0x1d), U256::from(0xab));
+	mem.write_byte(U256::from(0x1e), U256::from(0xcd));
+	mem.write_byte(U256::from(0x1f), U256::from(0xef));
+
+	// then
+	assert_eq!(mem.read(U256::from(0x00)), U256::from(0xabcdef));
+}

ethcore/src/evm/interpreter/mod.rs

@@ -16,12 +16,6 @@
 
 ///! Rust VM implementation
 
-use common::*;
-use super::instructions as instructions;
-use super::instructions::{Instruction, get_info};
-use std::marker::Copy;
-use evm::{self, MessageCallResult, ContractCreateResult, GasLeft};
-
 #[cfg(not(feature = "evm-debug"))]
 macro_rules! evm_debug {
 	($x: expr) => {}
@@ -34,6 +28,19 @@ macro_rules! evm_debug {
 	}
 }
 
+mod gasometer;
+mod stack;
+mod memory;
+
+use self::gasometer::Gasometer;
+use self::stack::{Stack, VecStack};
+use self::memory::Memory;
+
+use std::marker::PhantomData;
+use common::*;
+use super::instructions::{self, Instruction, InstructionInfo};
+use evm::{self, MessageCallResult, ContractCreateResult, GasLeft, CostType};
+
 #[cfg(feature = "evm-debug")]
 fn color(instruction: Instruction, name: &'static str) -> String {
 	let c = instruction as usize % 6;
@@ -41,209 +48,9 @@ fn color(instruction: Instruction, name: &'static str) -> String {
 	format!("\x1B[1;{}m{}\x1B[0m", colors[c], name)
 }
 
-macro_rules! overflowing {
-	($x: expr) => {{
-		let (v, overflow) = $x;
-		if overflow { return Err(evm::Error::OutOfGas); }
-		v
-	}}
-}
-
 type CodePosition = usize;
-type Gas = U256;
 type ProgramCounter = usize;
 
-/// Stack trait with VM-friendly API
-trait Stack<T> {
-	/// Returns `Stack[len(Stack) - no_from_top]`
-	fn peek(&self, no_from_top: usize) -> &T;
-	/// Swaps Stack[len(Stack)] and Stack[len(Stack) - no_from_top]
-	fn swap_with_top(&mut self, no_from_top: usize);
-	/// Returns true if Stack has at least `no_of_elems` elements
-	fn has(&self, no_of_elems: usize) -> bool;
-	/// Get element from top and remove it from Stack. Panics if stack is empty.
-	fn pop_back(&mut self) -> T;
-	/// Get (up to `instructions::MAX_NO_OF_TOPICS`) elements from top and remove them from Stack. Panics if stack is empty.
-	fn pop_n(&mut self, no_of_elems: usize) -> &[T];
-	/// Add element on top of the Stack
-	fn push(&mut self, elem: T);
-	/// Get number of elements on Stack
-	fn size(&self) -> usize;
-	/// Returns all data on stack.
-	fn peek_top(&mut self, no_of_elems: usize) -> &[T];
-}
-
-struct VecStack<S> {
-	stack: Vec<S>,
-	logs: [S; instructions::MAX_NO_OF_TOPICS]
-}
-
-impl<S : Copy> VecStack<S> {
-	fn with_capacity(capacity: usize, zero: S) -> Self {
-		VecStack {
-			stack: Vec::with_capacity(capacity),
-			logs: [zero; instructions::MAX_NO_OF_TOPICS]
-		}
-	}
-}
-
-impl<S : fmt::Display> Stack<S> for VecStack<S> {
-	fn peek(&self, no_from_top: usize) -> &S {
-		&self.stack[self.stack.len() - no_from_top - 1]
-	}
-
-	fn swap_with_top(&mut self, no_from_top: usize) {
-		let len = self.stack.len();
-		self.stack.swap(len - no_from_top - 1, len - 1);
-	}
-
-	fn has(&self, no_of_elems: usize) -> bool {
-		self.stack.len() >= no_of_elems
-	}
-
-	fn pop_back(&mut self) -> S {
-		let val = self.stack.pop();
-		match val {
-			Some(x) => {
-				evm_debug!({
-					println!("   POP: {}", x)
-				});
-				x
-			},
-			None => panic!("Tried to pop from empty stack.")
-		}
-	}
-
-	fn pop_n(&mut self, no_of_elems: usize) -> &[S] {
-		assert!(no_of_elems <= instructions::MAX_NO_OF_TOPICS);
-
-		for i in 0..no_of_elems {
-			self.logs[i] = self.pop_back();
-		}
-		&self.logs[0..no_of_elems]
-	}
-
-	fn push(&mut self, elem: S) {
-		evm_debug!({
-			println!("  PUSH: {}", elem)
-		});
-		self.stack.push(elem);
-	}
-
-	fn size(&self) -> usize {
-		self.stack.len()
-	}
-
-	fn peek_top(&mut self, no_from_top: usize) -> &[S] {
-		assert!(self.stack.len() >= no_from_top, "peek_top asked for more items than exist.");
-		&self.stack[self.stack.len() - no_from_top .. self.stack.len()]
-	}
-}
-
-trait Memory {
-	/// Retrieve current size of the memory
-	fn size(&self) -> usize;
-	/// Resize (shrink or expand) the memory to specified size (fills 0)
-	fn resize(&mut self, new_size: usize);
-	/// Resize the memory only if its smaller
-	fn expand(&mut self, new_size: usize);
-	/// Write single byte to memory
-	fn write_byte(&mut self, offset: U256, value: U256);
-	/// Write a word to memory. Does not resize memory!
-	fn write(&mut self, offset: U256, value: U256);
-	/// Read a word from memory
-	fn read(&self, offset: U256) -> U256;
-	/// Write slice of bytes to memory. Does not resize memory!
-	fn write_slice(&mut self, offset: U256, &[u8]);
-	/// Retrieve part of the memory between offset and offset + size
-	fn read_slice(&self, offset: U256, size: U256) -> &[u8];
-	/// Retrieve writeable part of memory
-	fn writeable_slice(&mut self, offset: U256, size: U256) -> &mut[u8];
-	fn dump(&self);
-}
-
-/// Checks whether offset and size is valid memory range
-fn is_valid_range(off: usize, size: usize)  -> bool {
-	// When size is zero we haven't actually expanded the memory
-	let overflow = off.overflowing_add(size).1;
-	size > 0 && !overflow
-}
-
-impl Memory for Vec<u8> {
-	fn dump(&self) {
-		println!("MemoryDump:");
-		for i in self.iter() {
-			println!("{:02x} ", i);
-		}
-		println!("");
-	}
-
-	fn size(&self) -> usize {
-		self.len()
-	}
-
-	fn read_slice(&self, init_off_u: U256, init_size_u: U256) -> &[u8] {
-		let off = init_off_u.low_u64() as usize;
-		let size = init_size_u.low_u64() as usize;
-		if !is_valid_range(off, size) {
-			&self[0..0]
-		} else {
-			&self[off..off+size]
-		}
-	}
-
-	fn read(&self, offset: U256) -> U256 {
-		let off = offset.low_u64() as usize;
-		U256::from(&self[off..off+32])
-	}
-
-	fn writeable_slice(&mut self, offset: U256, size: U256) -> &mut [u8] {
-		let off = offset.low_u64() as usize;
-		let s = size.low_u64() as usize;
-		if !is_valid_range(off, s) {
-			&mut self[0..0]
-		} else {
-			&mut self[off..off+s]
-		}
-	}
-
-	fn write_slice(&mut self, offset: U256, slice: &[u8]) {
-		let off = offset.low_u64() as usize;
-
-		// TODO [todr] Optimize?
-		for pos in off..off+slice.len() {
-			self[pos] = slice[pos - off];
-		}
-	}
-
-	fn write(&mut self, offset: U256, value: U256) {
-		let off = offset.low_u64() as usize;
-		let mut val = value;
-
-		let end = off + 32;
-		for pos in 0..32 {
-			self[end - pos - 1] = val.low_u64() as u8;
-			val = val >> 8;
-		}
-	}
-
-	fn write_byte(&mut self, offset: U256, value: U256) {
-		let off = offset.low_u64() as usize;
-		let val = value.low_u64() as u64;
-		self[off] = val as u8;
-	}
-
-	fn resize(&mut self, new_size: usize) {
-		self.resize(new_size, 0);
-	}
-
-	fn expand(&mut self, size: usize) {
-		if size > self.len() {
-			Memory::resize(self, size)
-		}
-	}
-}
-
 /// Abstraction over raw vector of Bytes. Easier state management of PC.
 struct CodeReader<'a> {
 	position: ProgramCounter,
@@ -265,38 +72,33 @@ impl<'a> CodeReader<'a> {
 	}
 }
 
-#[cfg_attr(feature="dev", allow(enum_variant_names))]
-enum InstructionCost {
-	Gas(U256),
-	GasMem(U256, U256),
-	GasMemCopy(U256, U256, U256)
-}
-
-enum InstructionResult {
+enum InstructionResult<Gas> {
 	Ok,
 	UseAllGas,
-	GasLeft(U256),
-	UnusedGas(U256),
+	GasLeft(Gas),
+	UnusedGas(Gas),
 	JumpToPosition(U256),
 	// gas left, init_orf, init_size
-	StopExecutionNeedsReturn(U256, U256, U256),
+	StopExecutionNeedsReturn(Gas, U256, U256),
 	StopExecution,
 }
 
+
 /// Intepreter EVM implementation
 #[derive(Default)]
-pub struct Interpreter {
+pub struct Interpreter<Cost: CostType> {
 	mem: Vec<u8>,
+	_type: PhantomData<Cost>,
 }
 
-impl evm::Evm for Interpreter {
+impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
 	fn exec(&mut self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result<GasLeft> {
 		self.mem.clear();
 
 		let code = &params.code.as_ref().unwrap();
 		let valid_jump_destinations = self.find_jump_destinations(&code);
 
-		let mut current_gas = params.gas;
+		let mut gasometer = Gasometer::<Cost>::new(try!(Cost::from_u256(params.gas)));
 		let mut stack = VecStack::with_capacity(ext.schedule().stack_limit, U256::zero());
 		let mut reader = CodeReader {
 			position: 0,
@@ -305,26 +107,27 @@ impl evm::Evm for Interpreter {
 
 		while reader.position < code.len() {
 			let instruction = code[reader.position];
-
-			// Calculate gas cost
-			let (gas_cost, mem_size) = try!(self.get_gas_cost_mem(ext, instruction, &stack));
-
-			// TODO: make compile-time removable if too much of a performance hit.
-			let trace_executed = ext.trace_prepare_execute(reader.position, instruction, &gas_cost);
-
 			reader.position += 1;
 
-			try!(self.verify_gas(&current_gas, &gas_cost));
+			let info = instructions::get_info(instruction);
+			try!(self.verify_instruction(ext, instruction, &info, &stack));
+
+			// Calculate gas cost
+			let (gas_cost, mem_size) = try!(gasometer.get_gas_cost_mem(ext, instruction, &info, &stack, self.mem.size()));
+			// TODO: make compile-time removable if too much of a performance hit.
+			let trace_executed = ext.trace_prepare_execute(reader.position - 1, instruction, &gas_cost.as_u256());
+
+			try!(gasometer.verify_gas(&gas_cost));
 			self.mem.expand(mem_size);
-			current_gas = current_gas - gas_cost; //TODO: use operator -=
+			gasometer.current_gas = gasometer.current_gas - gas_cost;
 
 			evm_debug!({
 				println!("[0x{:x}][{}(0x{:x}) Gas: {:x}\n  Gas Before: {:x}",
 					reader.position,
-					color(instruction, instructions::get_info(instruction).name),
+					color(instruction, info.name),
 					instruction,
 					gas_cost,
-					current_gas + gas_cost
+					gasometer.current_gas + gas_cost
 				);
 			});
 
@@ -335,50 +138,44 @@ impl evm::Evm for Interpreter {
 
 			// Execute instruction
 			let result = try!(self.exec_instruction(
-				current_gas, &params, ext, instruction, &mut reader, &mut stack
+				gasometer.current_gas, &params, ext, instruction, &mut reader, &mut stack
 			));
 
 			if trace_executed {
-				ext.trace_executed(current_gas, stack.peek_top(get_info(instruction).ret), mem_written.map(|(o, s)| (o, &(self.mem[o..(o + s)]))), store_written);
+				ext.trace_executed(gasometer.current_gas.as_u256(), stack.peek_top(info.ret), mem_written.map(|(o, s)| (o, &(self.mem[o..(o + s)]))), store_written);
 			}
 
 			// Advance
 			match result {
 				InstructionResult::Ok => {},
 				InstructionResult::UnusedGas(gas) => {
-					current_gas = current_gas + gas; //TODO: use operator +=
+					gasometer.current_gas = gasometer.current_gas + gas;
 				},
 				InstructionResult::UseAllGas => {
-					current_gas = U256::zero();
+					gasometer.current_gas = Cost::from(0);
 				},
 				InstructionResult::GasLeft(gas_left) => {
-					current_gas = gas_left;
+					gasometer.current_gas = gas_left;
 				},
 				InstructionResult::JumpToPosition(position) => {
 					let pos = try!(self.verify_jump(position, &valid_jump_destinations));
 					reader.position = pos;
 				},
 				InstructionResult::StopExecutionNeedsReturn(gas, off, size) => {
-					return Ok(GasLeft::NeedsReturn(gas, self.mem.read_slice(off, size)));
+					return Ok(GasLeft::NeedsReturn(gas.as_u256(), self.mem.read_slice(off, size)));
 				},
 				InstructionResult::StopExecution => break,
 			}
 		}
 
-		Ok(GasLeft::Known(current_gas))
+		Ok(GasLeft::Known(gasometer.current_gas.as_u256()))
 	}
 }
 
-impl Interpreter {
-	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
-	fn get_gas_cost_mem(
-		&mut self,
-		ext: &evm::Ext,
-		instruction: Instruction,
-		stack: &Stack<U256>
-	) -> evm::Result<(U256, usize)> {
+impl<Cost: CostType> Interpreter<Cost> {
+
+	fn verify_instruction(&self, ext: &evm::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack<U256>) -> evm::Result<()> {
 		let schedule = ext.schedule();
-		let info = instructions::get_info(instruction);
 
 		if !schedule.have_delegate_call && instruction == instructions::DELEGATECALL {
 			return Err(evm::Error::BadInstruction {
@@ -391,119 +188,20 @@ impl Interpreter {
 			});
 		}
 
-		try!(self.verify_instructions_requirements(&info, schedule.stack_limit, stack));
-
-		let tier = instructions::get_tier_idx(info.tier);
-		let default_gas = U256::from(schedule.tier_step_gas[tier]);
-
-		let cost = match instruction {
-			instructions::SSTORE => {
-				let address = H256::from(stack.peek(0));
-				let newval = stack.peek(1);
-				let val = U256::from(ext.storage_at(&address).as_slice());
-
-				let gas = if self.is_zero(&val) && !self.is_zero(newval) {
-					schedule.sstore_set_gas
-				} else {
-					// Refund for below case is added when actually executing sstore
-					// !self.is_zero(&val) && self.is_zero(newval)
-					schedule.sstore_reset_gas
-				};
-				InstructionCost::Gas(U256::from(gas))
-			},
-			instructions::SLOAD => {
-				InstructionCost::Gas(U256::from(schedule.sload_gas))
-			},
-			instructions::MSTORE | instructions::MLOAD => {
-				InstructionCost::GasMem(default_gas, try!(self.mem_needed_const(stack.peek(0), 32)))
-			},
-			instructions::MSTORE8 => {
-				InstructionCost::GasMem(default_gas, try!(self.mem_needed_const(stack.peek(0), 1)))
-			},
-			instructions::RETURN => {
-				InstructionCost::GasMem(default_gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
-			},
-			instructions::SHA3 => {
-				let w = overflowing!(add_u256_usize(stack.peek(1), 31));
-				let words = w >> 5;
-				let gas = U256::from(schedule.sha3_gas) + (U256::from(schedule.sha3_word_gas) * words);
-				InstructionCost::GasMem(gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
-			},
-			instructions::CALLDATACOPY | instructions::CODECOPY => {
-				InstructionCost::GasMemCopy(default_gas, try!(self.mem_needed(stack.peek(0), stack.peek(2))), stack.peek(2).clone())
-			},
-			instructions::EXTCODECOPY => {
-				InstructionCost::GasMemCopy(default_gas, try!(self.mem_needed(stack.peek(1), stack.peek(3))), stack.peek(3).clone())
-			},
-			instructions::JUMPDEST => {
-				InstructionCost::Gas(U256::one())
-			},
-			instructions::LOG0...instructions::LOG4 => {
-				let no_of_topics = instructions::get_log_topics(instruction);
-				let log_gas = schedule.log_gas + schedule.log_topic_gas * no_of_topics;
-
-				let data_gas = overflowing!(stack.peek(1).overflowing_mul(U256::from(schedule.log_data_gas)));
-				let gas = overflowing!(data_gas.overflowing_add(U256::from(log_gas)));
-				InstructionCost::GasMem(gas, try!(self.mem_needed(stack.peek(0), stack.peek(1))))
-			},
-			instructions::CALL | instructions::CALLCODE => {
-				let mut gas  = overflowing!(add_u256_usize(stack.peek(0), schedule.call_gas));
-				let mem = cmp::max(
-					try!(self.mem_needed(stack.peek(5), stack.peek(6))),
-					try!(self.mem_needed(stack.peek(3), stack.peek(4)))
-				);
-
-				let address = u256_to_address(stack.peek(1));
-
-				if instruction == instructions::CALL && !ext.exists(&address) {
-					gas = overflowing!(gas.overflowing_add(U256::from(schedule.call_new_account_gas)));
-				};
-
-				if stack.peek(2).clone() > U256::zero() {
-					gas = overflowing!(gas.overflowing_add(U256::from(schedule.call_value_transfer_gas)));
-				};
-
-				InstructionCost::GasMem(gas,mem)
-			},
-			instructions::DELEGATECALL => {
-				let gas = overflowing!(add_u256_usize(stack.peek(0), schedule.call_gas));
-				let mem = cmp::max(
-					try!(self.mem_needed(stack.peek(4), stack.peek(5))),
-					try!(self.mem_needed(stack.peek(2), stack.peek(3)))
-				);
-				InstructionCost::GasMem(gas, mem)
-			},
-			instructions::CREATE => {
-				let gas = U256::from(schedule.create_gas);
-				let mem = try!(self.mem_needed(stack.peek(1), stack.peek(2)));
-				InstructionCost::GasMem(gas, mem)
-			},
-			instructions::EXP => {
-				let expon = stack.peek(1);
-				let bytes = ((expon.bits() + 7) / 8) as usize;
-				let gas = U256::from(schedule.exp_gas + schedule.exp_byte_gas * bytes);
-				InstructionCost::Gas(gas)
-			},
-			_ => InstructionCost::Gas(default_gas)
-		};
-
-		match cost {
-			InstructionCost::Gas(gas) => {
-				Ok((gas, 0))
-			},
-			InstructionCost::GasMem(gas, mem_size) => {
-				let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, self.mem.size(), &mem_size));
-				let gas = overflowing!(gas.overflowing_add(mem_gas));
-				Ok((gas, new_mem_size))
-			},
-			InstructionCost::GasMemCopy(gas, mem_size, copy) => {
-				let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, self.mem.size(), &mem_size));
-				let copy = overflowing!(add_u256_usize(&copy, 31));
-				let copy_gas = U256::from(schedule.copy_gas) * (copy / U256::from(32));
-				let gas = overflowing!(gas.overflowing_add(copy_gas));
-				let gas = overflowing!(gas.overflowing_add(mem_gas));
-				Ok((gas, new_mem_size))
-			}
+		if !stack.has(info.args) {
+			Err(evm::Error::StackUnderflow {
+				instruction: info.name,
+				wanted: info.args,
+				on_stack: stack.size()
+			})
+		} else if stack.size() - info.args + info.ret > schedule.stack_limit {
+			Err(evm::Error::OutOfStack {
+				instruction: info.name,
+				wanted: info.ret - info.args,
+				limit: schedule.stack_limit
+			})
+		} else {
+			Ok(())
 		}
 	}
 
@@ -532,53 +230,16 @@ impl Interpreter {
 		}
 	}
 
-	fn mem_gas_cost(&self, schedule: &evm::Schedule, current_mem_size: usize, mem_size: &U256) -> evm::Result<(U256, usize)> {
-		let gas_for_mem = |mem_size: U256| {
-			let s = mem_size >> 5;
-			// s * memory_gas + s * s / quad_coeff_div
-			let a = overflowing!(s.overflowing_mul(U256::from(schedule.memory_gas)));
-			// We need to go to U512 to calculate s*s/quad_coeff_div
-			let b = U512::from(s) * U512::from(s) / U512::from(schedule.quad_coeff_div);
-			if b > U512::from(!U256::zero()) {
-				Err(evm::Error::OutOfGas)
-			} else {
-				Ok(overflowing!(a.overflowing_add(U256::from(b))))
-			}
-		};
-		let current_mem_size = U256::from(current_mem_size);
-		let req_mem_size_rounded = (overflowing!(mem_size.overflowing_add(U256::from(31))) >> 5) << 5;
-		let new_mem_gas = try!(gas_for_mem(U256::from(req_mem_size_rounded)));
-		let current_mem_gas = try!(gas_for_mem(current_mem_size));
-
-		Ok((if req_mem_size_rounded > current_mem_size {
-			new_mem_gas - current_mem_gas
-		} else {
-			U256::zero()
-		}, req_mem_size_rounded.low_u64() as usize))
-	}
-
-	fn mem_needed_const(&self, mem: &U256, add: usize) -> evm::Result<U256> {
-		Ok(overflowing!(mem.overflowing_add(U256::from(add))))
-	}
-
-	fn mem_needed(&self, offset: &U256, size: &U256) -> evm::Result<U256> {
-		if self.is_zero(size) {
-			return Ok(U256::zero());
-		}
-
-		Ok(overflowing!(offset.overflowing_add(size.clone())))
-	}
-
 	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn exec_instruction(
 		&mut self,
-		gas: Gas,
+		gas: Cost,
 		params: &ActionParams,
 		ext: &mut evm::Ext,
 		instruction: Instruction,
 		code: &mut CodeReader,
 		stack: &mut Stack<U256>
-	) -> evm::Result<InstructionResult> {
+	) -> evm::Result<InstructionResult<Cost>> {
 		match instruction {
 			instructions::JUMP => {
 				let jump = stack.pop_back();
@@ -611,11 +272,11 @@ impl Interpreter {
 					return Ok(InstructionResult::Ok);
 				}
 
-				let create_result = ext.create(&gas, &endowment, &contract_code);
+				let create_result = ext.create(&gas.as_u256(), &endowment, &contract_code);
 				return match create_result {
 					ContractCreateResult::Created(address, gas_left) => {
 						stack.push(address_to_u256(address));
-						Ok(InstructionResult::GasLeft(gas_left))
+						Ok(InstructionResult::GasLeft(Cost::from_u256(gas_left).expect("Gas left cannot be greater.")))
 					},
 					ContractCreateResult::Failed => {
 						stack.push(U256::zero());
@@ -626,7 +287,7 @@ impl Interpreter {
 			},
 			instructions::CALL | instructions::CALLCODE | instructions::DELEGATECALL => {
 				assert!(ext.schedule().call_value_transfer_gas > ext.schedule().call_stipend, "overflow possible");
-				let call_gas = stack.pop_back();
+				let call_gas = Cost::from_u256(stack.pop_back()).expect("Gas is already validated.");
 				let code_address = stack.pop_back();
 				let code_address = u256_to_address(&code_address);
 
@@ -642,9 +303,9 @@ impl Interpreter {
 				let out_size = stack.pop_back();
 
 				// Add stipend (only CALL|CALLCODE when value > 0)
-				let call_gas = call_gas + value.map_or_else(U256::zero, |val| match val > U256::zero() {
-					true => U256::from(ext.schedule().call_stipend),
-					false => U256::zero()
+				let call_gas = call_gas + value.map_or_else(|| Cost::from(0), |val| match val > U256::zero() {
+					true => Cost::from(ext.schedule().call_stipend),
+					false => Cost::from(0)
 				});
 
 				// Get sender & receive addresses, check if we have balance
@@ -672,13 +333,13 @@ impl Interpreter {
 					// and we don't want to copy
 					let input = unsafe { ::std::mem::transmute(self.mem.read_slice(in_off, in_size)) };
 					let output = self.mem.writeable_slice(out_off, out_size);
-					ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output)
+					ext.call(&call_gas.as_u256(), sender_address, receive_address, value, input, &code_address, output)
 				};
 
 				return match call_result {
 					MessageCallResult::Success(gas_left) => {
 						stack.push(U256::one());
-						Ok(InstructionResult::UnusedGas(gas_left))
+						Ok(InstructionResult::UnusedGas(Cost::from_u256(gas_left).expect("Gas left cannot be greater then current one")))
 					},
 					MessageCallResult::Failed  => {
 						stack.push(U256::zero());
@@ -759,7 +420,7 @@ impl Interpreter {
 				stack.push(U256::from(code.position - 1));
 			},
 			instructions::GAS => {
-				stack.push(gas.clone());
+				stack.push(gas.as_u256());
 			},
 			instructions::ADDRESS => {
 				stack.push(address_to_u256(params.address.clone()));
@@ -876,36 +537,6 @@ impl Interpreter {
 		}
 	}
 
-	fn verify_instructions_requirements(
-		&self,
-		info: &instructions::InstructionInfo,
-		stack_limit: usize,
-		stack: &Stack<U256>
-	) -> evm::Result<()> {
-		if !stack.has(info.args) {
-			Err(evm::Error::StackUnderflow {
-				instruction: info.name,
-				wanted: info.args,
-				on_stack: stack.size()
-			})
-		} else if stack.size() - info.args + info.ret > stack_limit {
-			Err(evm::Error::OutOfStack {
-				instruction: info.name,
-				wanted: info.ret - info.args,
-				limit: stack_limit
-			})
-		} else {
-			Ok(())
-		}
-	}
-
-	fn verify_gas(&self, current_gas: &U256, gas_cost: &U256) -> evm::Result<()> {
-		match current_gas < gas_cost {
-			true => Err(evm::Error::OutOfGas),
-			false => Ok(())
-		}
-	}
-
 	fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &HashSet<usize>) -> evm::Result<usize> {
 		let jump = jump_u.low_u64() as usize;
 
@@ -1163,11 +794,6 @@ fn set_sign(value: U256, sign: bool) -> U256 {
 	}
 }
 
-#[inline]
-fn add_u256_usize(value: &U256, num: usize) -> (U256, bool) {
-	value.clone().overflowing_add(U256::from(num))
-}
-
 #[inline]
 fn u256_to_address(value: &U256) -> Address {
 	Address::from(H256::from(value))
@@ -1179,82 +805,14 @@ fn address_to_u256(value: Address) -> U256 {
 }
 
 #[test]
-fn test_mem_gas_cost() {
+fn test_find_jump_destinations() {
 	// given
-	let interpreter = Interpreter::default();
-	let schedule = evm::Schedule::default();
-	let current_mem_size = 5;
-	let mem_size = !U256::zero();
+	let interpreter = Interpreter::<U256>::default();
+	let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap();
 
 	// when
-	let result = interpreter.mem_gas_cost(&schedule, current_mem_size, &mem_size);
+	let valid_jump_destinations = interpreter.find_jump_destinations(&code);
 
 	// then
-	if let Ok(_) = result {
-		assert!(false, "Should fail with OutOfGas");
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use common::*;
-	use super::*;
-	use evm;
-
-	#[test]
-	fn test_find_jump_destinations() {
-		// given
-		let interpreter = Interpreter::default();
-		let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap();
-
-		// when
-		let valid_jump_destinations = interpreter.find_jump_destinations(&code);
-
-		// then
-		assert!(valid_jump_destinations.contains(&66));
-	}
-
-	#[test]
-	fn test_calculate_mem_cost() {
-		// given
-		let interpreter = Interpreter::default();
-		let schedule = evm::Schedule::default();
-		let current_mem_size = 0;
-		let mem_size = U256::from(5);
-
-		// when
-		let (mem_cost, mem_size) = interpreter.mem_gas_cost(&schedule, current_mem_size, &mem_size).unwrap();
-
-		// then
-		assert_eq!(mem_cost, U256::from(3));
-		assert_eq!(mem_size, 32);
-	}
-
-	#[test]
-	fn test_memory_read_and_write() {
-		// given
-		let mem: &mut super::Memory = &mut vec![];
-		mem.resize(0x80 + 32);
-
-		// when
-		mem.write(U256::from(0x80), U256::from(0xabcdef));
-
-		// then
-		assert_eq!(mem.read(U256::from(0x80)), U256::from(0xabcdef));
-	}
-
-	#[test]
-	fn test_memory_read_and_write_byte() {
-		// given
-		let mem: &mut super::Memory = &mut vec![];
-		mem.resize(32);
-
-		// when
-		mem.write_byte(U256::from(0x1d), U256::from(0xab));
-		mem.write_byte(U256::from(0x1e), U256::from(0xcd));
-		mem.write_byte(U256::from(0x1f), U256::from(0xef));
-
-		// then
-		assert_eq!(mem.read(U256::from(0x00)), U256::from(0xabcdef));
-	}
+	assert!(valid_jump_destinations.contains(&66));
 }

ethcore/src/evm/interpreter/stack.rs

@@ -0,0 +1,106 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// 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 std::fmt;
+use evm::instructions;
+
+/// Stack trait with VM-friendly API
+pub trait Stack<T> {
+	/// Returns `Stack[len(Stack) - no_from_top]`
+	fn peek(&self, no_from_top: usize) -> &T;
+	/// Swaps Stack[len(Stack)] and Stack[len(Stack) - no_from_top]
+	fn swap_with_top(&mut self, no_from_top: usize);
+	/// Returns true if Stack has at least `no_of_elems` elements
+	fn has(&self, no_of_elems: usize) -> bool;
+	/// Get element from top and remove it from Stack. Panics if stack is empty.
+	fn pop_back(&mut self) -> T;
+	/// Get (up to `instructions::MAX_NO_OF_TOPICS`) elements from top and remove them from Stack. Panics if stack is empty.
+	fn pop_n(&mut self, no_of_elems: usize) -> &[T];
+	/// Add element on top of the Stack
+	fn push(&mut self, elem: T);
+	/// Get number of elements on Stack
+	fn size(&self) -> usize;
+	/// Returns all data on stack.
+	fn peek_top(&mut self, no_of_elems: usize) -> &[T];
+}
+
+pub struct VecStack<S> {
+	stack: Vec<S>,
+	logs: [S; instructions::MAX_NO_OF_TOPICS]
+}
+
+impl<S : Copy> VecStack<S> {
+	pub fn with_capacity(capacity: usize, zero: S) -> Self {
+		VecStack {
+			stack: Vec::with_capacity(capacity),
+			logs: [zero; instructions::MAX_NO_OF_TOPICS]
+		}
+	}
+}
+
+impl<S : fmt::Display> Stack<S> for VecStack<S> {
+	fn peek(&self, no_from_top: usize) -> &S {
+		&self.stack[self.stack.len() - no_from_top - 1]
+	}
+
+	fn swap_with_top(&mut self, no_from_top: usize) {
+		let len = self.stack.len();
+		self.stack.swap(len - no_from_top - 1, len - 1);
+	}
+
+	fn has(&self, no_of_elems: usize) -> bool {
+		self.stack.len() >= no_of_elems
+	}
+
+	fn pop_back(&mut self) -> S {
+		let val = self.stack.pop();
+		match val {
+			Some(x) => {
+				evm_debug!({
+					println!("   POP: {}", x)
+				});
+				x
+			},
+			None => panic!("Tried to pop from empty stack.")
+		}
+	}
+
+	fn pop_n(&mut self, no_of_elems: usize) -> &[S] {
+		assert!(no_of_elems <= instructions::MAX_NO_OF_TOPICS);
+
+		for i in 0..no_of_elems {
+			self.logs[i] = self.pop_back();
+		}
+		&self.logs[0..no_of_elems]
+	}
+
+	fn push(&mut self, elem: S) {
+		evm_debug!({
+			println!("  PUSH: {}", elem)
+		});
+		self.stack.push(elem);
+	}
+
+	fn size(&self) -> usize {
+		self.stack.len()
+	}
+
+	fn peek_top(&mut self, no_from_top: usize) -> &[S] {
+		assert!(self.stack.len() >= no_from_top, "peek_top asked for more items than exist.");
+		&self.stack[self.stack.len() - no_from_top .. self.stack.len()]
+	}
+}
+

ethcore/src/evm/mod.rs

@@ -28,8 +28,10 @@ mod jit;
 
 #[cfg(test)]
 mod tests;
+#[cfg(all(feature="benches", test))]
+mod benches;
 
-pub use self::evm::{Evm, Error, Finalize, GasLeft, Result};
+pub use self::evm::{Evm, Error, Finalize, GasLeft, Result, CostType};
 pub use self::ext::{Ext, ContractCreateResult, MessageCallResult};
 pub use self::factory::{Factory, VMType};
 pub use self::schedule::Schedule;

ethcore/src/evm/tests.rs

@@ -18,18 +18,18 @@ use common::*;
 use evm::{self, Ext, Schedule, Factory, GasLeft, VMType, ContractCreateResult, MessageCallResult};
 use std::fmt::Debug;
 
-struct FakeLogEntry {
+pub struct FakeLogEntry {
 	topics: Vec<H256>,
 	data: Bytes
 }
 
 #[derive(PartialEq, Eq, Hash, Debug)]
-enum FakeCallType {
+pub enum FakeCallType {
 	Call, Create
 }
 
 #[derive(PartialEq, Eq, Hash, Debug)]
-struct FakeCall {
+pub struct FakeCall {
 	call_type: FakeCallType,
 	gas: U256,
 	sender_address: Option<Address>,
@@ -43,7 +43,7 @@ struct FakeCall {
 ///
 /// Can't do recursive calls.
 #[derive(Default)]
-struct FakeExt {
+pub struct FakeExt {
 	sstore_clears: usize,
 	depth: usize,
 	store: HashMap<H256, H256>,
@@ -67,7 +67,7 @@ fn test_finalize(res: Result<GasLeft, evm::Error>) -> Result<U256, evm::Error> {
 }
 
 impl FakeExt {
-	fn new() -> Self {
+	pub fn new() -> Self {
 		FakeExt::default()
 	}
 }
@@ -181,7 +181,7 @@ fn test_stack_underflow() {
 	let mut ext = FakeExt::new();
 
 	let err = {
-		let mut vm : Box<evm::Evm> = Box::new(super::interpreter::Interpreter::default());
+		let mut vm : Box<evm::Evm> = Box::new(super::interpreter::Interpreter::<usize>::default());
 		test_finalize(vm.exec(params, &mut ext)).unwrap_err()
 	};
 
@@ -208,7 +208,7 @@ fn test_add(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -228,7 +228,7 @@ fn test_sha3(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -248,7 +248,7 @@ fn test_address(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -270,7 +270,7 @@ fn test_origin(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -292,7 +292,7 @@ fn test_sender(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -327,7 +327,7 @@ fn test_extcodecopy(factory: super::Factory) {
 	ext.codes.insert(sender, sender_code);
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -347,7 +347,7 @@ fn test_log_empty(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -379,7 +379,7 @@ fn test_log_sender(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -404,7 +404,7 @@ fn test_blockhash(factory: super::Factory) {
 	ext.blockhashes.insert(U256::zero(), blockhash.clone());
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -426,7 +426,7 @@ fn test_calldataload(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -447,7 +447,7 @@ fn test_author(factory: super::Factory) {
 	ext.info.author = author;
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -467,7 +467,7 @@ fn test_timestamp(factory: super::Factory) {
 	ext.info.timestamp = timestamp;
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -487,7 +487,7 @@ fn test_number(factory: super::Factory) {
 	ext.info.number = number;
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -507,7 +507,7 @@ fn test_difficulty(factory: super::Factory) {
 	ext.info.difficulty = difficulty;
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -527,7 +527,7 @@ fn test_gas_limit(factory: super::Factory) {
 	ext.info.gas_limit = gas_limit;
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -545,7 +545,7 @@ fn test_mul(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -563,7 +563,7 @@ fn test_sub(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -581,7 +581,7 @@ fn test_div(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -599,7 +599,7 @@ fn test_div_zero(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -617,7 +617,7 @@ fn test_mod(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -636,7 +636,7 @@ fn test_smod(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -655,7 +655,7 @@ fn test_sdiv(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -674,7 +674,7 @@ fn test_exp(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -694,7 +694,7 @@ fn test_comparison(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -715,7 +715,7 @@ fn test_signed_comparison(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -736,7 +736,7 @@ fn test_bitops(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -759,7 +759,7 @@ fn test_addmod_mulmod(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -780,7 +780,7 @@ fn test_byte(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -799,7 +799,7 @@ fn test_signextend(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -819,7 +819,7 @@ fn test_badinstruction_int() {
 	let mut ext = FakeExt::new();
 
 	let err = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap_err()
 	};
 
@@ -839,7 +839,7 @@ fn test_pop(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -859,7 +859,7 @@ fn test_extops(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -882,7 +882,7 @@ fn test_jumps(factory: super::Factory) {
 	let mut ext = FakeExt::new();
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 
@@ -911,7 +911,7 @@ fn test_calls(factory: super::Factory) {
 	};
 
 	let gas_left = {
-		let mut vm = factory.create();
+		let mut vm = factory.create(params.gas);
 		test_finalize(vm.exec(params, &mut ext)).unwrap()
 	};
 

ethcore/src/executive.rs

@@ -211,7 +211,7 @@ impl<'a> Executive<'a> {
 			let vm_factory = self.vm_factory;
 			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy, tracer, vm_tracer);
 			trace!(target: "executive", "ext.schedule.have_delegate_call: {}", ext.schedule().have_delegate_call);
-			return vm_factory.create().exec(params, &mut ext).finalize(ext);
+			return vm_factory.create(params.gas).exec(params, &mut ext).finalize(ext);
 		}
 
 		// Start in new thread to reset stack
@@ -222,7 +222,7 @@ impl<'a> Executive<'a> {
 			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy, tracer, vm_tracer);
 
 			scope.spawn(move || {
-				vm_factory.create().exec(params, &mut ext).finalize(ext)
+				vm_factory.create(params.gas).exec(params, &mut ext).finalize(ext)
 			})
 		}).join()
 	}

ethcore/src/header.rs

@@ -92,10 +92,10 @@ impl PartialEq for Header {
 impl Default for Header {
 	fn default() -> Self {
 		Header {
-			parent_hash: ZERO_H256.clone(),
+			parent_hash: H256::default(),
 			timestamp: 0,
 			number: 0,
-			author: ZERO_ADDRESS.clone(),
+			author: Address::default(),
 
 			transactions_root: SHA3_NULL_RLP,
 			uncles_hash: SHA3_EMPTY_LIST_RLP,
@@ -104,10 +104,10 @@ impl Default for Header {
 			state_root: SHA3_NULL_RLP,
 			receipts_root: SHA3_NULL_RLP,
 			log_bloom: ZERO_LOGBLOOM.clone(),
-			gas_used: ZERO_U256,
-			gas_limit: ZERO_U256,
+			gas_used: U256::default(),
+			gas_limit: U256::default(),
 
-			difficulty: ZERO_U256,
+			difficulty: U256::default(),
 			seal: vec![],
 			hash: RefCell::new(None),
 			bare_hash: RefCell::new(None),

ethcore/src/json_tests/executive.rs

@@ -208,7 +208,7 @@ fn do_json_test_for(vm_type: &VMType, json_data: &[u8]) -> Vec<String> {
 				&mut tracer,
 				&mut vm_tracer,
 			);
-			let mut evm = vm_factory.create();
+			let mut evm = vm_factory.create(params.gas);
 			let res = evm.exec(params, &mut ex);
 			// a return in finalize will not alter callcreates
 			let callcreates = ex.callcreates.clone();

ethcore/src/json_tests/mod.rs

@@ -23,3 +23,4 @@ mod state;
 mod chain;
 mod homestead_state;
 mod homestead_chain;
+mod trie;

ethcore/src/json_tests/trie.rs

@@ -0,0 +1,69 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// 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 ethjson;
+use util::{H256, MemoryDB, TrieMut, TrieSpec, TrieFactory};
+
+fn test_trie(json: &[u8], trie: TrieSpec) -> Vec<String> {
+	let tests = ethjson::trie::Test::load(json).unwrap();
+	let factory = TrieFactory::new(trie);
+	let mut result = vec![];
+
+	for (name, test) in tests.into_iter() {
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::default();
+		let mut t = factory.create(&mut memdb, &mut root);
+
+		for (key, value) in test.input.data.into_iter() {
+			let key: Vec<u8> = key.into();
+			let value: Vec<u8> = value.map_or_else(Vec::new, Into::into);
+			t.insert(&key, &value);
+		}
+
+		if *t.root() != test.root.into() {
+			result.push(format!("Trie test '{:?}' failed.", name));
+		}
+	}
+
+	for i in &result {
+		println!("FAILED: {}", i);
+	}
+
+	result
+}
+
+mod generic {
+	use util::TrieSpec;
+
+	fn do_json_test(json: &[u8]) -> Vec<String> {
+		super::test_trie(json, TrieSpec::Generic)
+	}
+
+	declare_test!{TrieTests_trietest, "TrieTests/trietest"}
+	declare_test!{TrieTests_trieanyorder, "TrieTests/trieanyorder"}
+}
+
+mod secure {
+	use util::TrieSpec;
+
+	fn do_json_test(json: &[u8]) -> Vec<String> {
+		super::test_trie(json, TrieSpec::Secure)
+	}
+
+	declare_test!{TrieTests_hex_encoded_secure, "TrieTests/hex_encoded_securetrie_test"}
+	declare_test!{TrieTests_trietest_secure, "TrieTests/trietest_secureTrie"}
+	declare_test!{TrieTests_trieanyorder_secure, "TrieTests/trieanyorder_secureTrie"}
+}

ethcore/src/lib.rs

@@ -31,6 +31,7 @@
 #![cfg_attr(feature="dev", allow(needless_borrow))]
 #![cfg_attr(feature="dev", allow(assign_op_pattern))]
 
+#![cfg_attr(feature="benches", feature(test))]
 
 //! Ethcore library
 //!

ethcore/src/miner/miner.rs

@@ -19,6 +19,7 @@ use std::sync::atomic::AtomicBool;
 use std::time::{Instant, Duration};
 
 use util::*;
+use util::using_queue::{UsingQueue, GetAction};
 use util::Colour::White;
 use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
@@ -200,17 +201,23 @@ impl Miner {
 			let hash = tx.hash();
 			match open_block.push_transaction(tx, None) {
 				Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, .. })) => {
-					trace!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
+					debug!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
 					// Exit early if gas left is smaller then min_tx_gas
 					let min_tx_gas: U256 = 21000.into();	// TODO: figure this out properly.
 					if gas_limit - gas_used < min_tx_gas {
 						break;
 					}
 				},
-				Err(Error::Transaction(TransactionError::AlreadyImported)) => {}	// already have transaction - ignore
+				// Invalid nonce error can happen only if previous transaction is skipped because of gas limit.
+				// If there is errornous state of transaction queue it will be fixed when next block is imported.
+				Err(Error::Execution(ExecutionError::InvalidNonce { .. })) => {
+					debug!(target: "miner", "Skipping adding transaction to block because of invalid nonce: {:?}", hash);
+				},
+				// already have transaction - ignore
+				Err(Error::Transaction(TransactionError::AlreadyImported)) => {},
 				Err(e) => {
 					invalid_transactions.insert(hash);
-					trace!(target: "miner",
+					debug!(target: "miner",
 						   "Error adding transaction to block: number={}. transaction_hash={:?}, Error: {:?}",
 						   block_number, hash, e);
 				},

ethcore/src/miner/transaction_queue.rs

@@ -87,7 +87,7 @@ use std::cmp;
 use std::collections::{HashMap, BTreeSet};
 use util::numbers::{Uint, U256};
 use util::hash::{Address, H256};
-use util::table::*;
+use util::table::Table;
 use transaction::*;
 use error::{Error, TransactionError};
 use client::TransactionImportResult;
@@ -432,10 +432,10 @@ impl TransactionQueue {
 	pub fn add<T>(&mut self, tx: SignedTransaction, fetch_account: &T, origin: TransactionOrigin) -> Result<TransactionImportResult, Error>
 	where T: Fn(&Address) -> AccountDetails {
 
-		trace!(target: "miner", "Importing: {:?}", tx.hash());
+		trace!(target: "txqueue", "Importing: {:?}", tx.hash());
 
 		if tx.gas_price < self.minimal_gas_price && origin != TransactionOrigin::Local {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction below minimal gas price threshold: {:?} (gp: {} < {})",
 				tx.hash(),
 				tx.gas_price,
@@ -451,7 +451,7 @@ impl TransactionQueue {
 		try!(tx.check_low_s());
 
 		if tx.gas > self.gas_limit || tx.gas > self.tx_gas_limit {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction above gas limit: {:?} ({} > min({}, {}))",
 				tx.hash(),
 				tx.gas,
@@ -470,7 +470,7 @@ impl TransactionQueue {
 
 		let cost = vtx.transaction.value + vtx.transaction.gas_price * vtx.transaction.gas;
 		if client_account.balance < cost {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction without sufficient balance: {:?} ({} < {})",
 				vtx.hash(),
 				client_account.balance,
@@ -558,7 +558,7 @@ impl TransactionQueue {
 			if k >= current_nonce {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
-				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
+				trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				// Remove the transaction completely
 				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
@@ -579,7 +579,7 @@ impl TransactionQueue {
 			if k >= current_nonce {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
-				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
+				trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
@@ -667,7 +667,7 @@ impl TransactionQueue {
 
 		if self.by_hash.get(&tx.hash()).is_some() {
 			// Transaction is already imported.
-			trace!(target: "miner", "Dropping already imported transaction: {:?}", tx.hash());
+			trace!(target: "txqueue", "Dropping already imported transaction: {:?}", tx.hash());
 			return Err(TransactionError::AlreadyImported);
 		}
 
@@ -684,7 +684,7 @@ impl TransactionQueue {
 		// nonce height would result in overflow.
 		if nonce < state_nonce {
 			// Droping transaction
-			trace!(target: "miner", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
+			trace!(target: "txqueue", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
 			return Err(TransactionError::Old);
 		} else if nonce > next_nonce {
 			// We have a gap - put to future.
@@ -720,7 +720,7 @@ impl TransactionQueue {
 		// Trigger error if the transaction we are importing was removed.
 		try!(check_if_removed(&address, &nonce, removed));
 
-		trace!(target: "miner", "status: {:?}", self.status());
+		trace!(target: "txqueue", "status: {:?}", self.status());
 		Ok(TransactionImportResult::Current)
 	}