ethcore: use LruCache for nonce cache

Only clear the nonce cache when a block is retracted

ethcore/private-tx/Cargo.toml

@@ -24,6 +24,7 @@ fetch = { path = "../../util/fetch" }
 futures = "0.1"
 keccak-hash = { path = "../../util/hash" }
 log = "0.3"
+lru-cache = "0.1"
 parking_lot = "0.5"
 patricia-trie = { path = "../../util/patricia_trie" }
 rand = "0.3"

ethcore/private-tx/src/lib.rs

@@ -38,6 +38,7 @@ extern crate ethjson;
 extern crate fetch;
 extern crate futures;
 extern crate keccak_hash as hash;
+extern crate lru_cache;
 extern crate parking_lot;
 extern crate patricia_trie as trie;
 extern crate rlp;
@@ -69,6 +70,7 @@ use std::collections::{HashMap, HashSet};
 use std::time::Duration;
 use ethereum_types::{H128, H256, U256, Address};
 use hash::keccak;
+use lru_cache::LruCache;
 use rlp::*;
 use parking_lot::{Mutex, RwLock};
 use bytes::Bytes;
@@ -94,6 +96,8 @@ use_contract!(private, "PrivateContract", "res/private.json");
 /// Initialization vector length.
 const INIT_VEC_LEN: usize = 16;
 
+const MAX_NONCE_CACHE_SIZE: usize = 4096;
+
 /// Configurtion for private transaction provider
 #[derive(Default, PartialEq, Debug, Clone)]
 pub struct ProviderConfig {
@@ -243,7 +247,7 @@ impl Provider where {
 		Ok(original_transaction)
 	}
 
-	fn pool_client<'a>(&'a self, nonce_cache: &'a RwLock<HashMap<Address, U256>>) -> miner::pool_client::PoolClient<'a, Client> {
+	fn pool_client<'a>(&'a self, nonce_cache: &'a RwLock<LruCache<Address, U256>>) -> miner::pool_client::PoolClient<'a, Client> {
 		let engine = self.client.engine();
 		let refuse_service_transactions = true;
 		miner::pool_client::PoolClient::new(
@@ -262,7 +266,7 @@ impl Provider where {
 	/// can be replaced with a single `drain()` method instead.
 	/// Thanks to this we also don't really need to lock the entire verification for the time of execution.
 	fn process_queue(&self) -> Result<(), Error> {
-		let nonce_cache = Default::default();
+		let nonce_cache = RwLock::new(LruCache::new(MAX_NONCE_CACHE_SIZE));
 		let mut verification_queue = self.transactions_for_verification.lock();
 		let ready_transactions = verification_queue.ready_transactions(self.pool_client(&nonce_cache));
 		for transaction in ready_transactions {
@@ -583,7 +587,7 @@ impl Importer for Arc<Provider> {
 				trace!("Validating transaction: {:?}", original_tx);
 				// Verify with the first account available
 				trace!("The following account will be used for verification: {:?}", validation_account);
-				let nonce_cache = Default::default();
+				let nonce_cache = RwLock::new(LruCache::new(MAX_NONCE_CACHE_SIZE));
 				self.transactions_for_verification.lock().add_transaction(
 					original_tx,
 					contract,

ethcore/src/miner/miner.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::time::{Instant, Duration};
-use std::collections::{BTreeMap, HashSet, HashMap};
+use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 
 use ansi_term::Colour;
@@ -26,6 +26,7 @@ use ethcore_miner::gas_pricer::GasPricer;
 use ethcore_miner::pool::{self, TransactionQueue, VerifiedTransaction, QueueStatus, PrioritizationStrategy};
 use ethcore_miner::work_notify::NotifyWork;
 use ethereum_types::{H256, U256, Address};
+use lru_cache::LruCache;
 use parking_lot::{Mutex, RwLock};
 use rayon::prelude::*;
 use transaction::{
@@ -95,6 +96,8 @@ const DEFAULT_MINIMAL_GAS_PRICE: u64 = 20_000_000_000;
 /// in case we have only a fraction of available block gas limit left.
 const MAX_SKIPPED_TRANSACTIONS: usize = 8;
 
+const MAX_NONCE_CACHE_SIZE: usize = 4096;
+
 /// Configures the behaviour of the miner.
 #[derive(Debug, PartialEq)]
 pub struct MinerOptions {
@@ -200,7 +203,7 @@ pub struct Miner {
 	sealing: Mutex<SealingWork>,
 	params: RwLock<AuthoringParams>,
 	listeners: RwLock<Vec<Box<NotifyWork>>>,
-	nonce_cache: RwLock<HashMap<Address, U256>>,
+	nonce_cache: RwLock<LruCache<Address, U256>>,
 	gas_pricer: Mutex<GasPricer>,
 	options: MinerOptions,
 	// TODO [ToDr] Arc is only required because of price updater
@@ -239,7 +242,7 @@ impl Miner {
 			params: RwLock::new(AuthoringParams::default()),
 			listeners: RwLock::new(vec![]),
 			gas_pricer: Mutex::new(gas_pricer),
-			nonce_cache: RwLock::new(HashMap::with_capacity(1024)),
+			nonce_cache: RwLock::new(LruCache::new(MAX_NONCE_CACHE_SIZE)),
 			options,
 			transaction_queue: Arc::new(TransactionQueue::new(limits, verifier_options, tx_queue_strategy)),
 			accounts,
@@ -1064,13 +1067,15 @@ impl miner::MinerService for Miner {
 		// 2. We ignore blocks that are `invalid` because it doesn't have any meaning in terms of the transactions that
 		//    are in those blocks
 
-		// Clear nonce cache
-		self.nonce_cache.write().clear();
-
 		// First update gas limit in transaction queue and minimal gas price.
 		let gas_limit = *chain.best_block_header().gas_limit();
 		self.update_transaction_queue_limits(gas_limit);
 
+		if retracted.len() != 0 {
+			// Clear nonce cache
+			self.nonce_cache.write().clear();
+		}
+
 		// Then import all transactions...
 		let client = self.pool_client(chain);
 		{

ethcore/src/miner/pool_client.rs

@@ -17,11 +17,11 @@
 //! Blockchain access for transaction pool.
 
 use std::fmt;
-use std::collections::HashMap;
 
-use ethereum_types::{H256, U256, Address};
-use ethcore_miner::pool;
 use ethcore_miner::pool::client::NonceClient;
+use ethcore_miner::pool;
+use ethereum_types::{H256, U256, Address};
+use lru_cache::LruCache;
 use transaction::{
 	self,
 	UnverifiedTransaction,
@@ -36,10 +36,7 @@ use header::Header;
 use miner;
 use miner::service_transaction_checker::ServiceTransactionChecker;
 
-type NoncesCache = RwLock<HashMap<Address, U256>>;
-
-const MAX_NONCE_CACHE_SIZE: usize = 4096;
-const EXPECTED_NONCE_CACHE_SIZE: usize = 2048;
+type NoncesCache = RwLock<LruCache<Address, U256>>;
 
 /// Blockchain accesss for transaction pool.
 pub struct PoolClient<'a, C: 'a> {
@@ -194,7 +191,7 @@ impl<'a, C: 'a> NonceClient for CachedNonceClient<'a, C> where
 	C: Nonce + Sync,
 {
   fn account_nonce(&self, address: &Address) -> U256 {
-	  if let Some(nonce) = self.cache.read().get(address) {
+	  if let Some(nonce) = self.cache.write().get_mut(address) {
 		  return *nonce;
 	  }
 
@@ -204,17 +201,6 @@ impl<'a, C: 'a> NonceClient for CachedNonceClient<'a, C> where
 	  let nonce = self.client.latest_nonce(address);
 	  cache.insert(*address, nonce);
 
-	  if cache.len() < MAX_NONCE_CACHE_SIZE {
-		  return nonce
-	  }
-
-	  // Remove excessive amount of entries from the cache
-	  while cache.len() > EXPECTED_NONCE_CACHE_SIZE {
-		  // Just remove random entry
-		  if let Some(key) = cache.keys().next().cloned() {
-			  cache.remove(&key);
-		  }
-	  }
 	  nonce
   }
 }