Use memmap for dag cache (#6193)

* Rebase and fix compilation errors (tests not yet fixed)

* Use `debug_assert` over `assert`

* Fix tests

* Assert safety, clean up

* Fix up stale cache removal, move one assert to debug_assert

* Remove printlns

* Add licenses

* Fix benches

* Inline some no-ops in a hot loop that weren't being inlined

* Add spooky comment to make sure no-one removes the inlining annotations

* Minor cleanup

* Add option to switch between mmap and ram

* Flag ethash to use less memory when running light client

* Fix tests

* Remove todo comment (it's done)

* Replace assertion with error return

* Fix indentation

* Use union instead of `transmute`

* Fix benches

* Extract to constants

* Clean up and fix soundness holes

* Fix formatting

* Ignore missing-file errors

* Make incorrect cache size an error condition instead of a panic, remove dead code

* Fix compilation errors from rebase

* Fix compilation errors in tests

* Fix compilation errors in tests

ethcore/src/engines/basic_authority.rs

@@ -270,7 +270,7 @@ mod tests {
 	/// Create a new test chain spec with `BasicAuthority` consensus engine.
 	fn new_test_authority() -> Spec {
 		let bytes: &[u8] = include_bytes!("../../res/basic_authority.json");
-		Spec::load(::std::env::temp_dir(), bytes).expect("invalid chain spec")
+		Spec::load(&::std::env::temp_dir(), bytes).expect("invalid chain spec")
 	}
 
 	#[test]

ethcore/src/ethereum/ethash.rs

@@ -19,7 +19,7 @@ use std::cmp;
 use std::collections::{BTreeMap, HashMap};
 use std::sync::{Arc, Weak};
 use hash::{KECCAK_EMPTY_LIST_RLP};
-use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager};
+use ethash::{quick_get_difficulty, slow_hash_block_number, EthashManager, OptimizeFor};
 use bigint::prelude::U256;
 use bigint::hash::{H256, H64};
 use util::*;
@@ -161,18 +161,19 @@ pub struct Ethash {
 
 impl Ethash {
 	/// Create a new instance of Ethash engine
-	pub fn new<T: AsRef<Path>>(
-		cache_dir: T,
+	pub fn new<T: Into<Option<OptimizeFor>>>(
+		cache_dir: &Path,
 		params: CommonParams,
 		ethash_params: EthashParams,
 		builtins: BTreeMap<Address, Builtin>,
+		optimize_for: T,
 	) -> Arc<Self> {
 		Arc::new(Ethash {
 			tx_filter: TransactionFilter::from_params(&params),
 			params,
 			ethash_params,
 			builtins,
-			pow: EthashManager::new(cache_dir),
+			pow: EthashManager::new(cache_dir.as_ref(), optimize_for.into()),
 		})
 	}
 }
@@ -416,7 +417,7 @@ impl Engine for Arc<Ethash> {
 		let result = self.pow.compute_light(header.number() as u64, &header.bare_hash().0, header.nonce().low_u64());
 		let mix = H256(result.mix_hash);
 		let difficulty = Ethash::boundary_to_difficulty(&H256(result.value));
-		trace!(target: "miner", "num: {}, seed: {}, h: {}, non: {}, mix: {}, res: {}" , header.number() as u64, H256(slow_get_seedhash(header.number() as u64)), header.bare_hash(), header.nonce().low_u64(), H256(result.mix_hash), H256(result.value));
+		trace!(target: "miner", "num: {}, seed: {}, h: {}, non: {}, mix: {}, res: {}" , header.number() as u64, H256(slow_hash_block_number(header.number() as u64)), header.bare_hash(), header.nonce().low_u64(), H256(result.mix_hash), H256(result.value));
 		if mix != header.mix_hash() {
 			return Err(From::from(BlockError::MismatchedH256SealElement(Mismatch { expected: mix, found: header.mix_hash() })));
 		}
@@ -849,7 +850,7 @@ mod tests {
 	fn difficulty_frontier() {
 		let spec = new_homestead_test();
 		let ethparams = get_default_ethash_params();
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 
 		let mut parent_header = Header::default();
 		parent_header.set_number(1000000);
@@ -867,7 +868,7 @@ mod tests {
 	fn difficulty_homestead() {
 		let spec = new_homestead_test();
 		let ethparams = get_default_ethash_params();
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 
 		let mut parent_header = Header::default();
 		parent_header.set_number(1500000);
@@ -920,7 +921,7 @@ mod tests {
 			ecip1010_pause_transition: 3000000,
 			..get_default_ethash_params()
 		};
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 
 		let mut parent_header = Header::default();
 		parent_header.set_number(3500000);
@@ -954,7 +955,7 @@ mod tests {
 			ecip1010_continue_transition: 5000000,
 			..get_default_ethash_params()
 		};
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 
 		let mut parent_header = Header::default();
 		parent_header.set_number(5000102);
@@ -1000,7 +1001,7 @@ mod tests {
 	fn gas_limit_is_multiple_of_determinant() {
 		let spec = new_homestead_test();
 		let ethparams = get_default_ethash_params();
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 		let mut parent = Header::new();
 		let mut header = Header::new();
 		header.set_number(1);
@@ -1044,7 +1045,7 @@ mod tests {
 	fn difficulty_max_timestamp() {
 		let spec = new_homestead_test();
 		let ethparams = get_default_ethash_params();
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 
 		let mut parent_header = Header::default();
 		parent_header.set_number(1000000);
@@ -1072,7 +1073,7 @@ mod tests {
 		header.set_number(parent_header.number() + 1);
 		header.set_gas_limit(100_001.into());
 		header.set_difficulty(ethparams.minimum_difficulty);
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 		assert!(ethash.verify_block_family(&header, &parent_header, None).is_ok());
 
 		parent_header.set_number(9);
@@ -1127,7 +1128,7 @@ mod tests {
 			nonce: U256::zero(),
 		}.sign(keypair.secret(), None).into();
 
-		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new());
+		let ethash = Ethash::new(&::std::env::temp_dir(), spec.params().clone(), ethparams, BTreeMap::new(), None);
 		assert!(ethash.verify_transaction_basic(&tx1, &header).is_ok());
 		assert!(ethash.verify_transaction_basic(&tx2, &header).is_ok());
 

ethcore/src/ethereum/mod.rs

@@ -27,7 +27,6 @@ pub mod denominations;
 pub use self::ethash::{Ethash};
 pub use self::denominations::*;
 
-use std::path::Path;
 use super::spec::*;
 
 /// Most recent fork block that we support on Mainnet.
@@ -39,33 +38,47 @@ pub const FORK_SUPPORTED_ROPSTEN: u64 = 10;
 /// Most recent fork block that we support on Kovan.
 pub const FORK_SUPPORTED_KOVAN: u64 = 0;
 
-fn load<'a, T: 'a + Into<Option<&'a Path>>>(cache_dir: T, b: &[u8]) -> Spec {
-	match cache_dir.into() {
-		Some(path) => Spec::load(path, b),
+fn load<'a, T: Into<Option<SpecParams<'a>>>>(params: T, b: &[u8]) -> Spec {
+	match params.into() {
+		Some(params) => Spec::load(params, b),
 		None => Spec::load(&::std::env::temp_dir(), b)
 	}.expect("chain spec is invalid")
 }
 
 /// Create a new Foundation Olympic chain spec.
-pub fn new_olympic(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/olympic.json")) }
+pub fn new_olympic<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/olympic.json"))
+}
 
 /// Create a new Foundation Mainnet chain spec.
-pub fn new_foundation(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/foundation.json")) }
+pub fn new_foundation<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/foundation.json"))
+}
 
 /// Create a new Classic Mainnet chain spec without the DAO hardfork.
-pub fn new_classic(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/classic.json")) }
+pub fn new_classic<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/classic.json"))
+}
 
 /// Create a new Expanse mainnet chain spec.
-pub fn new_expanse(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/expanse.json")) }
+pub fn new_expanse<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/expanse.json"))
+}
 
 /// Create a new Kovan testnet chain spec.
-pub fn new_kovan(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/kovan.json")) }
+pub fn new_kovan<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/kovan.json"))
+}
 
 /// Create a new Foundation Ropsten chain spec.
-pub fn new_ropsten(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/ropsten.json")) }
+pub fn new_ropsten<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/ropsten.json"))
+}
 
 /// Create a new Morden chain spec.
-pub fn new_morden(cache_dir: &Path) -> Spec { load(cache_dir, include_bytes!("../../res/ethereum/morden.json")) }
+pub fn new_morden<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
+	load(params.into(), include_bytes!("../../res/ethereum/morden.json"))
+}
 
 // For tests
 

ethcore/src/json_tests/test_common.rs

@@ -52,7 +52,8 @@ pub fn run_test_file(path: &Path, runner: fn (json_data: &[u8]) -> Vec<String>)
 	let mut file = File::open(&path).expect("Error opening test file");
 	file.read_to_end(&mut data).expect("Error reading test file");
 	let results = runner(&data);
-	assert!(results.is_empty());
+	let empty: [String; 0] = [];
+	assert_eq!(results, empty);
 }
 
 macro_rules! test {

ethcore/src/miner/stratum.rs

@@ -171,7 +171,7 @@ impl StratumJobDispatcher {
 	fn payload(&self, pow_hash: H256, difficulty: U256, number: u64) -> String {
 		// TODO: move this to engine
 		let target = Ethash::difficulty_to_boundary(&difficulty);
-		let seed_hash = &self.seed_compute.lock().get_seedhash(number);
+		let seed_hash = &self.seed_compute.lock().hash_block_number(number);
 		let seed_hash = H256::from_slice(&seed_hash[..]);
 		format!(
 			r#"["0x", "0x{}","0x{}","0x{}","0x{:x}"]"#,

ethcore/src/miner/work_notify.rs

@@ -72,7 +72,7 @@ impl NotifyWork for WorkPoster {
 	fn notify(&self, pow_hash: H256, difficulty: U256, number: u64) {
 		// TODO: move this to engine
 		let target = Ethash::difficulty_to_boundary(&difficulty);
-		let seed_hash = &self.seed_compute.lock().get_seedhash(number);
+		let seed_hash = &self.seed_compute.lock().hash_block_number(number);
 		let seed_hash = H256::from_slice(&seed_hash[..]);
 		let body = format!(
 			r#"{{ "result": ["0x{}","0x{}","0x{}","0x{:x}"] }}"#,

ethcore/src/spec/spec.rs

@@ -16,34 +16,37 @@
 
 //! Parameters for a block chain.
 
-use std::io::Read;
-use std::collections::BTreeMap;
-use std::path::Path;
-use std::sync::Arc;
-use rustc_hex::FromHex;
-use hash::{KECCAK_NULL_RLP, keccak};
 use super::genesis::Genesis;
 use super::seal::Generic as GenericSeal;
+use bigint::hash::{H2048, H256};
+use bigint::prelude::U256;
 
 use builtin::Builtin;
-use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, AuthorityRound, Tendermint, DEFAULT_BLOCKHASH_CONTRACT};
-use vm::{EnvInfo, CallType, ActionValue, ActionParams};
+use bytes::Bytes;
+use engines::{AuthorityRound, BasicAuthority, DEFAULT_BLOCKHASH_CONTRACT, Engine, InstantSeal,
+              NullEngine, Tendermint};
 use error::Error;
+
+pub use ethash::OptimizeFor;
 use ethereum;
 use ethjson;
 use executive::Executive;
 use factory::Factories;
+use hash::{KECCAK_NULL_RLP, keccak};
 use header::{BlockNumber, Header};
+use parking_lot::RwLock;
 use pod_state::*;
 use rlp::{Rlp, RlpStream};
+use rustc_hex::FromHex;
 use state::{Backend, State, Substate};
 use state::backend::Basic as BasicBackend;
+use std::collections::BTreeMap;
+use std::io::Read;
+use std::path::Path;
+use std::sync::Arc;
 use trace::{NoopTracer, NoopVMTracer};
-use bigint::prelude::U256;
-use bigint::hash::{H256, H2048};
-use parking_lot::RwLock;
 use util::*;
-use bytes::Bytes;
+use vm::{ActionParams, ActionValue, CallType, EnvInfo};
 
 /// Parameters common to ethereum-like blockchains.
 /// NOTE: when adding bugfix hard-fork parameters,
@@ -88,7 +91,8 @@ pub struct CommonParams {
 	pub eip210_contract_code: Bytes,
 	/// Gas allocated for EIP-210 blockhash update.
 	pub eip210_contract_gas: U256,
-	/// Number of first block where EIP-211 (Metropolis: RETURNDATASIZE/RETURNDATACOPY) rules begin.
+	/// Number of first block where EIP-211 (Metropolis: RETURNDATASIZE/RETURNDATACOPY) rules
+	/// begin.
 	pub eip211_transition: BlockNumber,
 	/// Number of first block where EIP-214 rules begin.
 	pub eip214_transition: BlockNumber,
@@ -121,7 +125,7 @@ impl CommonParams {
 	}
 
 	/// Apply common spec config parameters to the schedule.
- 	pub fn update_schedule(&self, block_number: u64, schedule: &mut ::vm::Schedule) {
+	pub fn update_schedule(&self, block_number: u64, schedule: &mut ::vm::Schedule) {
 		schedule.have_create2 = block_number >= self.eip86_transition;
 		schedule.have_revert = block_number >= self.eip140_transition;
 		schedule.have_static_call = block_number >= self.eip214_transition;
@@ -139,14 +143,10 @@ impl CommonParams {
 
 	/// Whether these params contain any bug-fix hard forks.
 	pub fn contains_bugfix_hard_fork(&self) -> bool {
-		self.eip98_transition != 0 &&
-			self.eip155_transition != 0 &&
-			self.validate_receipts_transition != 0 &&
-			self.eip86_transition != 0 &&
-			self.eip140_transition != 0 &&
-			self.eip210_transition != 0 &&
-			self.eip211_transition != 0 &&
-			self.eip214_transition != 0 &&
+		self.eip98_transition != 0 && self.eip155_transition != 0 &&
+			self.validate_receipts_transition != 0 && self.eip86_transition != 0 &&
+			self.eip140_transition != 0 && self.eip210_transition != 0 &&
+			self.eip211_transition != 0 && self.eip214_transition != 0 &&
 			self.dust_protection_transition != 0
 	}
 }
@@ -157,25 +157,59 @@ impl From<ethjson::spec::Params> for CommonParams {
 			account_start_nonce: p.account_start_nonce.map_or_else(U256::zero, Into::into),
 			maximum_extra_data_size: p.maximum_extra_data_size.into(),
 			network_id: p.network_id.into(),
-			chain_id: if let Some(n) = p.chain_id { n.into() } else { p.network_id.into() },
+			chain_id: if let Some(n) = p.chain_id {
+				n.into()
+			} else {
+				p.network_id.into()
+			},
 			subprotocol_name: p.subprotocol_name.unwrap_or_else(|| "eth".to_owned()),
 			min_gas_limit: p.min_gas_limit.into(),
-			fork_block: if let (Some(n), Some(h)) = (p.fork_block, p.fork_hash) { Some((n.into(), h.into())) } else { None },
+			fork_block: if let (Some(n), Some(h)) = (p.fork_block, p.fork_hash) {
+				Some((n.into(), h.into()))
+			} else {
+				None
+			},
 			eip98_transition: p.eip98_transition.map_or(0, Into::into),
 			eip155_transition: p.eip155_transition.map_or(0, Into::into),
 			validate_receipts_transition: p.validate_receipts_transition.map_or(0, Into::into),
-			eip86_transition: p.eip86_transition.map_or(BlockNumber::max_value(), Into::into),
-			eip140_transition: p.eip140_transition.map_or(BlockNumber::max_value(), Into::into),
-			eip210_transition: p.eip210_transition.map_or(BlockNumber::max_value(), Into::into),
+			eip86_transition: p.eip86_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
+			eip140_transition: p.eip140_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
+			eip210_transition: p.eip210_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
 			eip210_contract_address: p.eip210_contract_address.map_or(0xf0.into(), Into::into),
 			eip210_contract_code: p.eip210_contract_code.map_or_else(
-				|| DEFAULT_BLOCKHASH_CONTRACT.from_hex().expect("Default BLOCKHASH contract is valid"),
-				Into::into),
+				|| {
+					DEFAULT_BLOCKHASH_CONTRACT.from_hex().expect(
+						"Default BLOCKHASH contract is valid",
+					)
+				},
+				Into::into,
+			),
 			eip210_contract_gas: p.eip210_contract_gas.map_or(1000000.into(), Into::into),
-			eip211_transition: p.eip211_transition.map_or(BlockNumber::max_value(), Into::into),
-			eip214_transition: p.eip214_transition.map_or(BlockNumber::max_value(), Into::into),
-			eip658_transition: p.eip658_transition.map_or(BlockNumber::max_value(), Into::into),
-			dust_protection_transition: p.dust_protection_transition.map_or(BlockNumber::max_value(), Into::into),
+			eip211_transition: p.eip211_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
+			eip214_transition: p.eip214_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
+			eip658_transition: p.eip658_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
+			dust_protection_transition: p.dust_protection_transition.map_or(
+				BlockNumber::max_value(),
+				Into::into,
+			),
 			nonce_cap_increment: p.nonce_cap_increment.map_or(64, Into::into),
 			remove_dust_contracts: p.remove_dust_contracts.unwrap_or(false),
 			wasm: p.wasm.unwrap_or(false),
@@ -188,6 +222,44 @@ impl From<ethjson::spec::Params> for CommonParams {
 	}
 }
 
+/// Runtime parameters for the spec that are related to how the software should run the chain,
+/// rather than integral properties of the chain itself.
+#[derive(Debug, Clone, Copy)]
+pub struct SpecParams<'a> {
+	/// The path to the folder used to cache nodes. This is typically /tmp/ on Unix-like systems
+	pub cache_dir: &'a Path,
+	/// Whether to run slower at the expense of better memory usage, or run faster while using
+	/// more
+	/// memory. This may get more fine-grained in the future but for now is simply a binary
+	/// option.
+	pub optimization_setting: Option<OptimizeFor>,
+}
+
+impl<'a> SpecParams<'a> {
+	/// Create from a cache path, with null values for the other fields
+	pub fn from_path(path: &'a Path) -> Self {
+		SpecParams {
+			cache_dir: path,
+			optimization_setting: None,
+		}
+	}
+
+	/// Create from a cache path and an optimization setting
+	pub fn new(path: &'a Path, optimization: OptimizeFor) -> Self {
+		SpecParams {
+			cache_dir: path,
+			optimization_setting: Some(optimization),
+		}
+	}
+}
+
+impl<'a, T: AsRef<Path>> From<&'a T> for SpecParams<'a> {
+	fn from(path: &'a T) -> Self {
+		Self::from_path(path.as_ref())
+	}
+}
+
+
 /// Parameters for a block chain; includes both those intrinsic to the design of the
 /// chain and those to be interpreted by the active chain engine.
 pub struct Spec {
@@ -258,15 +330,19 @@ impl Clone for Spec {
 }
 
 /// Load from JSON object.
-pub fn load_from<T: AsRef<Path>>(cache_dir: T, s: ethjson::spec::Spec) -> Result<Spec, Error> {
-	let builtins = s.accounts.builtins().into_iter().map(|p| (p.0.into(), From::from(p.1))).collect();
+fn load_from(spec_params: SpecParams, s: ethjson::spec::Spec) -> Result<Spec, Error> {
+	let builtins = s.accounts
+		.builtins()
+		.into_iter()
+		.map(|p| (p.0.into(), From::from(p.1)))
+		.collect();
 	let g = Genesis::from(s.genesis);
 	let GenericSeal(seal_rlp) = g.seal.into();
 	let params = CommonParams::from(s.params);
 
 	let mut s = Spec {
 		name: s.name.clone().into(),
-		engine: Spec::engine(cache_dir, s.engine, params, builtins),
+		engine: Spec::engine(spec_params, s.engine, params, builtins),
 		data_dir: s.data_dir.unwrap_or(s.name).into(),
 		nodes: s.nodes.unwrap_or_else(Vec::new),
 		parent_hash: g.parent_hash,
@@ -279,7 +355,11 @@ pub fn load_from<T: AsRef<Path>>(cache_dir: T, s: ethjson::spec::Spec) -> Result
 		timestamp: g.timestamp,
 		extra_data: g.extra_data,
 		seal_rlp: seal_rlp,
-		constructors: s.accounts.constructors().into_iter().map(|(a, c)| (a.into(), c.into())).collect(),
+		constructors: s.accounts
+			.constructors()
+			.into_iter()
+			.map(|(a, c)| (a.into(), c.into()))
+			.collect(),
 		state_root_memo: RwLock::new(Default::default()), // will be overwritten right after.
 		genesis_state: s.accounts.into(),
 	};
@@ -287,7 +367,12 @@ pub fn load_from<T: AsRef<Path>>(cache_dir: T, s: ethjson::spec::Spec) -> Result
 	// use memoized state root if provided.
 	match g.state_root {
 		Some(root) => *s.state_root_memo.get_mut() = root,
-		None => { let _ = s.run_constructors(&Default::default(), BasicBackend(MemoryDB::new()))?; },
+		None => {
+			let _ = s.run_constructors(
+				&Default::default(),
+				BasicBackend(MemoryDB::new()),
+			)?;
+		}
 	}
 
 	Ok(s)
@@ -305,8 +390,8 @@ macro_rules! load_bundled {
 impl Spec {
 	/// Convert engine spec into a arc'd Engine of the right underlying type.
 	/// TODO avoid this hard-coded nastiness - use dynamic-linked plugin framework instead.
-	fn engine<T: AsRef<Path>>(
-		cache_dir: T,
+	fn engine(
+		spec_params: SpecParams,
 		engine_spec: ethjson::spec::Engine,
 		params: CommonParams,
 		builtins: BTreeMap<Address, Builtin>,
@@ -314,14 +399,43 @@ impl Spec {
 		match engine_spec {
 			ethjson::spec::Engine::Null => Arc::new(NullEngine::new(params, builtins)),
 			ethjson::spec::Engine::InstantSeal => Arc::new(InstantSeal::new(params, builtins)),
-			ethjson::spec::Engine::Ethash(ethash) => Arc::new(ethereum::Ethash::new(cache_dir, params, From::from(ethash.params), builtins)),
-			ethjson::spec::Engine::BasicAuthority(basic_authority) => Arc::new(BasicAuthority::new(params, From::from(basic_authority.params), builtins)),
-			ethjson::spec::Engine::AuthorityRound(authority_round) => AuthorityRound::new(params, From::from(authority_round.params), builtins).expect("Failed to start AuthorityRound consensus engine."),
-			ethjson::spec::Engine::Tendermint(tendermint) => Tendermint::new(params, From::from(tendermint.params), builtins).expect("Failed to start the Tendermint consensus engine."),
+			ethjson::spec::Engine::Ethash(ethash) => Arc::new(ethereum::Ethash::new(
+				spec_params.cache_dir,
+				params,
+				From::from(ethash.params),
+				builtins,
+				spec_params.optimization_setting,
+			)),
+			ethjson::spec::Engine::BasicAuthority(basic_authority) => Arc::new(
+				BasicAuthority::new(
+					params,
+					From::from(
+						basic_authority.params,
+					),
+					builtins,
+				),
+			),
+			ethjson::spec::Engine::AuthorityRound(authority_round) => AuthorityRound::new(
+				params,
+				From::from(
+					authority_round.params,
+				),
+				builtins,
+			).expect(
+				"Failed to start AuthorityRound consensus engine.",
+			),
+			ethjson::spec::Engine::Tendermint(tendermint) => Tendermint::new(
+				params,
+				From::from(tendermint.params),
+				builtins,
+			).expect(
+				"Failed to start the Tendermint consensus engine.",
+			),
 		}
 	}
 
-	// given a pre-constructor state, run all the given constructors and produce a new state and state root.
+	// given a pre-constructor state, run all the given constructors and produce a new state and
+	// state root.
 	fn run_constructors<T: Backend>(&self, factories: &Factories, mut db: T) -> Result<T, Error> {
 		let mut root = KECCAK_NULL_RLP;
 
@@ -337,20 +451,18 @@ impl Spec {
 		for (address, account) in self.genesis_state.get().iter() {
 			db.note_non_null_account(address);
 			account.insert_additional(
-				&mut *factories.accountdb.create(db.as_hashdb_mut(), keccak(address)),
-				&factories.trie
+				&mut *factories.accountdb.create(
+					db.as_hashdb_mut(),
+					keccak(address),
+				),
+				&factories.trie,
 			);
 		}
 
 		let start_nonce = self.engine.account_start_nonce(0);
 
 		let (root, db) = {
-			let mut state = State::from_existing(
-				db,
-				root,
-				start_nonce,
-				factories.clone(),
-			)?;
+			let mut state = State::from_existing(db, root, start_nonce, factories.clone())?;
 
 			// Execute contract constructors.
 			let env_info = EnvInfo {
@@ -385,7 +497,14 @@ impl Spec {
 
 				{
 					let mut exec = Executive::new(&mut state, &env_info, self.engine.as_ref());
-					if let Err(e) = exec.create(params, &mut substate, &mut None, &mut NoopTracer, &mut NoopVMTracer) {
+					if let Err(e) = exec.create(
+						params,
+						&mut substate,
+						&mut None,
+						&mut NoopTracer,
+						&mut NoopVMTracer,
+					)
+					{
 						warn!(target: "spec", "Genesis constructor execution at {} failed: {}.", address, e);
 					}
 				}
@@ -410,22 +529,34 @@ impl Spec {
 	}
 
 	/// Get common blockchain parameters.
-	pub fn params(&self) -> &CommonParams { &self.engine.params() }
+	pub fn params(&self) -> &CommonParams {
+		&self.engine.params()
+	}
 
 	/// Get the known knodes of the network in enode format.
-	pub fn nodes(&self) -> &[String] { &self.nodes }
+	pub fn nodes(&self) -> &[String] {
+		&self.nodes
+	}
 
 	/// Get the configured Network ID.
-	pub fn network_id(&self) -> u64 { self.params().network_id }
+	pub fn network_id(&self) -> u64 {
+		self.params().network_id
+	}
 
 	/// Get the chain ID used for signing.
-	pub fn chain_id(&self) -> u64 { self.params().chain_id }
+	pub fn chain_id(&self) -> u64 {
+		self.params().chain_id
+	}
 
 	/// Get the configured subprotocol name.
-	pub fn subprotocol_name(&self) -> String { self.params().subprotocol_name.clone() }
+	pub fn subprotocol_name(&self) -> String {
+		self.params().subprotocol_name.clone()
+	}
 
 	/// Get the configured network fork block.
-	pub fn fork_block(&self) -> Option<(BlockNumber, H256)> { self.params().fork_block }
+	pub fn fork_block(&self) -> Option<(BlockNumber, H256)> {
+		self.params().fork_block
+	}
 
 	/// Get the header of the genesis block.
 	pub fn genesis_header(&self) -> Header {
@@ -480,7 +611,10 @@ impl Spec {
 	/// Alter the value of the genesis state.
 	pub fn set_genesis_state(&mut self, s: PodState) -> Result<(), Error> {
 		self.genesis_state = s;
-		let _ = self.run_constructors(&Default::default(), BasicBackend(MemoryDB::new()))?;
+		let _ = self.run_constructors(
+			&Default::default(),
+			BasicBackend(MemoryDB::new()),
+		)?;
 
 		Ok(())
 	}
@@ -496,7 +630,7 @@ impl Spec {
 	/// Ensure that the given state DB has the trie nodes in for the genesis state.
 	pub fn ensure_db_good<T: Backend>(&self, db: T, factories: &Factories) -> Result<T, Error> {
 		if db.as_hashdb().contains(&self.state_root()) {
-			return Ok(db)
+			return Ok(db);
 		}
 
 		// TODO: could optimize so we don't re-run, but `ensure_db_good` is barely ever
@@ -507,13 +641,19 @@ impl Spec {
 
 	/// Loads spec from json file. Provide factories for executing contracts and ensuring
 	/// storage goes to the right place.
-	pub fn load<T: AsRef<Path>, R>(cache_dir: T, reader: R) -> Result<Self, String> where R: Read {
+	pub fn load<'a, T: Into<SpecParams<'a>>, R>(params: T, reader: R) -> Result<Self, String>
+	where
+		R: Read,
+	{
 		fn fmt<F: ::std::fmt::Display>(f: F) -> String {
 			format!("Spec json is invalid: {}", f)
 		}
 
-		ethjson::spec::Spec::load(reader).map_err(fmt)
-			.and_then(|x| load_from(cache_dir, x).map_err(fmt))
+		ethjson::spec::Spec::load(reader).map_err(fmt).and_then(
+			|x| {
+				load_from(params.into(), x).map_err(fmt)
+			},
+		)
 	}
 
 	/// initialize genesis epoch data, using in-memory database for
@@ -543,7 +683,7 @@ impl Spec {
 				difficulty: *genesis.difficulty(),
 				gas_limit: *genesis.gas_limit(),
 				last_hashes: Arc::new(Vec::new()),
-				gas_used: 0.into()
+				gas_used: 0.into(),
 			};
 
 			let from = Address::default();
@@ -566,86 +706,139 @@ impl Spec {
 				true,
 			);
 
-			res.map(|(out, proof)| (out, proof.into_iter().map(|x| x.into_vec()).collect()))
-				.ok_or_else(|| "Failed to prove call: insufficient state".into())
+			res.map(|(out, proof)| {
+				(out, proof.into_iter().map(|x| x.into_vec()).collect())
+			}).ok_or_else(|| "Failed to prove call: insufficient state".into())
 		};
 
 		self.engine.genesis_epoch_data(&genesis, &call)
 	}
 
-	/// Create a new Spec which conforms to the Frontier-era Morden chain except that it's a NullEngine consensus.
-	pub fn new_test() -> Spec { load_bundled!("null_morden") }
+	/// Create a new Spec which conforms to the Frontier-era Morden chain except that it's a
+	/// NullEngine consensus.
+	pub fn new_test() -> Spec {
+		load_bundled!("null_morden")
+	}
 
-	/// Create a new Spec which conforms to the Frontier-era Morden chain except that it's a NullEngine consensus with applying reward on block close.
-	pub fn new_test_with_reward() -> Spec { load_bundled!("null_morden_with_reward") }
+	/// Create a new Spec which conforms to the Frontier-era Morden chain except that it's a
+	/// NullEngine consensus with applying reward on block close.
+	pub fn new_test_with_reward() -> Spec {
+		load_bundled!("null_morden_with_reward")
+	}
 
-	/// Create a new Spec which is a NullEngine consensus with a premine of address whose secret is keccak('').
-	pub fn new_null() -> Spec { load_bundled!("null") }
+	/// Create a new Spec which is a NullEngine consensus with a premine of address whose
+	/// secret is keccak('').
+	pub fn new_null() -> Spec {
+		load_bundled!("null")
+	}
 
 	/// Create a new Spec which constructs a contract at address 5 with storage at 0 equal to 1.
-	pub fn new_test_constructor() -> Spec { load_bundled!("constructor") }
+	pub fn new_test_constructor() -> Spec {
+		load_bundled!("constructor")
+	}
 
-	/// Create a new Spec with InstantSeal consensus which does internal sealing (not requiring work).
-	pub fn new_instant() -> Spec { load_bundled!("instant_seal") }
+	/// Create a new Spec with InstantSeal consensus which does internal sealing (not requiring
+	/// work).
+	pub fn new_instant() -> Spec {
+		load_bundled!("instant_seal")
+	}
 
-	/// Create a new Spec with AuthorityRound consensus which does internal sealing (not requiring work).
+	/// Create a new Spec with AuthorityRound consensus which does internal sealing (not
+	/// requiring work).
 	/// Accounts with secrets keccak("0") and keccak("1") are the validators.
-	pub fn new_test_round() -> Self { load_bundled!("authority_round") }
+	pub fn new_test_round() -> Self {
+		load_bundled!("authority_round")
+	}
 
-	/// Create a new Spec with Tendermint consensus which does internal sealing (not requiring work).
+	/// Create a new Spec with Tendermint consensus which does internal sealing (not requiring
+	/// work).
 	/// Account keccak("0") and keccak("1") are a authorities.
-	pub fn new_test_tendermint() -> Self { load_bundled!("tendermint") }
+	pub fn new_test_tendermint() -> Self {
+		load_bundled!("tendermint")
+	}
 
 	/// TestList.sol used in both specs: https://github.com/paritytech/contracts/pull/30/files
 	/// Accounts with secrets keccak("0") and keccak("1") are initially the validators.
-	/// Create a new Spec with BasicAuthority which uses a contract at address 5 to determine the current validators using `getValidators`.
-	/// Second validator can be removed with "0xbfc708a000000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1" and added back in using "0x4d238c8e00000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1".
-	pub fn new_validator_safe_contract() -> Self { load_bundled!("validator_safe_contract") }
+	/// Create a new Spec with BasicAuthority which uses a contract at address 5 to determine
+	/// the current validators using `getValidators`.
+	/// Second validator can be removed with
+	/// "0xbfc708a000000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1" and added
+	/// back in using
+	/// "0x4d238c8e00000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1".
+	pub fn new_validator_safe_contract() -> Self {
+		load_bundled!("validator_safe_contract")
+	}
 
 	/// The same as the `safeContract`, but allows reporting and uses AuthorityRound.
 	/// Account is marked with `reportBenign` it can be checked as disliked with "0xd8f2e0bf".
 	/// Validator can be removed with `reportMalicious`.
-	pub fn new_validator_contract() -> Self { load_bundled!("validator_contract") }
+	pub fn new_validator_contract() -> Self {
+		load_bundled!("validator_contract")
+	}
 
-	/// Create a new Spec with BasicAuthority which uses multiple validator sets changing with height.
-	/// Account with secrets keccak("0") is the validator for block 1 and with keccak("1") onwards.
-	pub fn new_validator_multi() -> Self { load_bundled!("validator_multi") }
+	/// Create a new Spec with BasicAuthority which uses multiple validator sets changing with
+	/// height.
+	/// Account with secrets keccak("0") is the validator for block 1 and with keccak("1")
+	/// onwards.
+	pub fn new_validator_multi() -> Self {
+		load_bundled!("validator_multi")
+	}
 
 	/// Create a new spec for a PoW chain
-	pub fn new_pow_test_spec() -> Self { load_bundled!("ethereum/olympic") }
+	pub fn new_pow_test_spec() -> Self {
+		load_bundled!("ethereum/olympic")
+	}
 }
 
 #[cfg(test)]
 mod tests {
+	use super::*;
+	use state::State;
 	use std::str::FromStr;
+	use tests::helpers::get_temp_state_db;
 	use util::*;
 	use views::*;
-	use tests::helpers::get_temp_state_db;
-	use state::State;
-	use super::*;
 
 	// https://github.com/paritytech/parity/issues/1840
 	#[test]
 	fn test_load_empty() {
-		assert!(Spec::load(::std::env::temp_dir(), &[] as &[u8]).is_err());
+		assert!(Spec::load(&::std::env::temp_dir(), &[] as &[u8]).is_err());
 	}
 
 	#[test]
 	fn test_chain() {
 		let test_spec = Spec::new_test();
 
-		assert_eq!(test_spec.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap());
+		assert_eq!(
+			test_spec.state_root(),
+			H256::from_str(
+				"f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9",
+			).unwrap()
+		);
 		let genesis = test_spec.genesis_block();
-		assert_eq!(BlockView::new(&genesis).header_view().hash(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
+		assert_eq!(
+			BlockView::new(&genesis).header_view().hash(),
+			H256::from_str(
+				"0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303",
+			).unwrap()
+		);
 	}
 
 	#[test]
 	fn genesis_constructor() {
 		::ethcore_logger::init_log();
 		let spec = Spec::new_test_constructor();
-		let db = spec.ensure_db_good(get_temp_state_db(), &Default::default()).unwrap();
-		let state = State::from_existing(db.boxed_clone(), spec.state_root(), spec.engine.account_start_nonce(0), Default::default()).unwrap();
-		let expected = H256::from_str("0000000000000000000000000000000000000000000000000000000000000001").unwrap();
+		let db = spec.ensure_db_good(get_temp_state_db(), &Default::default())
+			.unwrap();
+		let state = State::from_existing(
+			db.boxed_clone(),
+			spec.state_root(),
+			spec.engine.account_start_nonce(0),
+			Default::default(),
+		).unwrap();
+		let expected = H256::from_str(
+			"0000000000000000000000000000000000000000000000000000000000000001",
+		).unwrap();
 		let address = Address::from_str("0000000000000000000000000000000000000005").unwrap();
 
 		assert_eq!(state.storage_at(&address, &H256::zero()).unwrap(), expected);

ethcore/src/tx_filter.rs

@@ -196,7 +196,7 @@ mod test {
 		}
 		"#;
 
-		let spec = Spec::load(::std::env::temp_dir(), spec_data.as_bytes()).unwrap();
+		let spec = Spec::load(&::std::env::temp_dir(), spec_data.as_bytes()).unwrap();
 		let client_db = Arc::new(::util::kvdb::in_memory(::db::NUM_COLUMNS.unwrap_or(0)));
 
 		let client = Client::new(