configurable state cache size

ethcore/src/client/client.rs

@@ -177,7 +177,7 @@ impl Client {
 		};
 
 		let journal_db = journaldb::new(db.clone(), config.pruning, ::db::COL_STATE);
-		let mut state_db = StateDB::new(journal_db);
+		let mut state_db = StateDB::new(journal_db, config.state_cache_size);
 		if state_db.journal_db().is_empty() && try!(spec.ensure_db_good(&mut state_db)) {
 			let mut batch = DBTransaction::new(&db);
 			try!(state_db.commit(&mut batch, 0, &spec.genesis_header().hash(), None));
@@ -691,7 +691,8 @@ impl snapshot::DatabaseRestore for Client {
 		let db = self.db.write();
 		try!(db.restore(new_db));
 
-		*state_db = StateDB::new(journaldb::new(db.clone(), self.pruning, ::db::COL_STATE));
+		let cache_size = state_db.cache_size();
+		*state_db = StateDB::new(journaldb::new(db.clone(), self.pruning, ::db::COL_STATE), cache_size);
 		*chain = Arc::new(BlockChain::new(self.config.blockchain.clone(), &[], db.clone()));
 		*tracedb = TraceDB::new(self.config.tracing.clone(), db.clone(), chain.clone());
 		Ok(())

ethcore/src/client/config.rs

@@ -96,7 +96,7 @@ pub struct ClientConfig {
 	pub pruning: journaldb::Algorithm,
 	/// The name of the client instance.
 	pub name: String,
-	/// State db cache-size if not default
+	/// RocksDB state column cache-size if not default
 	pub db_cache_size: Option<usize>,
 	/// State db compaction profile
 	pub db_compaction: DatabaseCompactionProfile,
@@ -106,6 +106,8 @@ pub struct ClientConfig {
 	pub mode: Mode,
 	/// Type of block verifier used by client.
 	pub verifier_type: VerifierType,
+	/// State db cache-size.
+	pub state_cache_size: usize,
 }
 
 #[cfg(test)]

ethcore/src/client/test_client.rs

@@ -289,7 +289,7 @@ pub fn get_temp_state_db() -> GuardedTempResult<StateDB> {
 	let temp = RandomTempPath::new();
 	let db = Database::open(&DatabaseConfig::with_columns(NUM_COLUMNS), temp.as_str()).unwrap();
 	let journal_db = journaldb::new(Arc::new(db), journaldb::Algorithm::EarlyMerge, COL_STATE);
-	let state_db = StateDB::new(journal_db);
+	let state_db = StateDB::new(journal_db, 1024 * 1024);
 	GuardedTempResult {
 		_temp: temp,
 		result: Some(state_db)

ethcore/src/evm/interpreter/shared_cache.rs

@@ -23,13 +23,13 @@ use super::super::instructions;
 
 const CACHE_CODE_ITEMS: usize = 4096;
 
-/// GLobal cache for EVM interpreter
+/// Global cache for EVM interpreter
 pub struct SharedCache {
 	jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>
 }
 
 impl SharedCache {
-	/// Get jump destincations bitmap for a contract.
+	/// Get jump destinations bitmap for a contract.
 	pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> {
 		if code_hash == &SHA3_EMPTY {
 			return Self::find_jump_destinations(code);

ethcore/src/state_db.rs

@@ -24,8 +24,6 @@ use bloom_journal::{Bloom, BloomJournal};
 use db::COL_ACCOUNT_BLOOM;
 use byteorder::{LittleEndian, ByteOrder};
 
-const STATE_CACHE_ITEMS: usize = 65536;
-
 pub const ACCOUNT_BLOOM_SPACE: usize = 1048576;
 pub const DEFAULT_ACCOUNT_PRESET: usize = 1000000;
 
@@ -33,6 +31,8 @@ pub const ACCOUNT_BLOOM_HASHCOUNT_KEY: &'static [u8] = b"account_hash_count";
 
 struct AccountCache {
 	/// DB Account cache. `None` indicates that account is known to be missing.
+	// When changing the type of the values here, be sure to update `mem_used` and
+	// `new`.
 	accounts: LruCache<Address, Option<Account>>,
 }
 
@@ -48,19 +48,26 @@ pub struct StateDB {
 	cache_overlay: Vec<(Address, Option<Account>)>,
 	is_canon: bool,
 	account_bloom: Arc<Mutex<Bloom>>,
+	cache_size: usize,
 }
 
 impl StateDB {
 
-	/// Create a new instance wrapping `JournalDB`
-	pub fn new(db: Box<JournalDB>) -> StateDB {
+	/// Create a new instance wrapping `JournalDB` and the maximum allowed size
+	/// of the LRU cache in bytes. Actual used memory may (read: will) be higher due to bookkeeping.
+	// TODO: make the cache size actually accurate by moving the account storage cache
+	// into the `AccountCache` structure as its own `LruCache<(Address, H256), H256>`.
+	pub fn new(db: Box<JournalDB>, cache_size: usize) -> StateDB {
 		let bloom = Self::load_bloom(db.backing());
+		let cache_items = cache_size / ::std::mem::size_of::<Option<Account>>();
+
 		StateDB {
 			db: db,
-			account_cache: Arc::new(Mutex::new(AccountCache { accounts: LruCache::new(STATE_CACHE_ITEMS) })),
+			account_cache: Arc::new(Mutex::new(AccountCache { accounts: LruCache::new(cache_items) })),
 			cache_overlay: Vec::new(),
 			is_canon: false,
 			account_bloom: Arc::new(Mutex::new(bloom)),
+			cache_size: cache_size,
 		}
 	}
 
@@ -151,6 +158,7 @@ impl StateDB {
 			cache_overlay: Vec::new(),
 			is_canon: false,
 			account_bloom: self.account_bloom.clone(),
+			cache_size: self.cache_size,
 		}
 	}
 
@@ -162,6 +170,7 @@ impl StateDB {
 			cache_overlay: Vec::new(),
 			is_canon: true,
 			account_bloom: self.account_bloom.clone(),
+			cache_size: self.cache_size,
 		}
 	}
 
@@ -172,7 +181,8 @@ impl StateDB {
 
 	/// Heap size used.
 	pub fn mem_used(&self) -> usize {
-		self.db.mem_used() //TODO: + self.account_cache.lock().heap_size_of_children()
+		// TODO: account for LRU-cache overhead; this is a close approximation.
+		self.db.mem_used() + self.account_cache.lock().accounts.len() * ::std::mem::size_of::<Option<Account>>()
 	}
 
 	/// Returns underlying `JournalDB`.
@@ -228,5 +238,10 @@ impl StateDB {
 		let mut cache = self.account_cache.lock();
 		cache.accounts.get_mut(a).map(|c| f(c.as_mut()))
 	}
+
+	/// Query how much memory is set aside for the accounts cache (in bytes).
+	pub fn cache_size(&self) -> usize {
+		self.cache_size
+	}
 }
 

ethcore/src/tests/helpers.rs

@@ -346,7 +346,7 @@ pub fn get_temp_state() -> GuardedTempResult<State> {
 pub fn get_temp_state_db_in(path: &Path) -> StateDB {
 	let db = new_db(path.to_str().expect("Only valid utf8 paths for tests."));
 	let journal_db = journaldb::new(db.clone(), journaldb::Algorithm::EarlyMerge, COL_STATE);
-	StateDB::new(journal_db)
+	StateDB::new(journal_db, 5 * 1024 * 1024)
 }
 
 pub fn get_temp_state_in(path: &Path) -> State {