From f07f6ba09695654d17ea158145487fd5b671e8a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Wed, 20 Jun 2018 14:38:43 +0200 Subject: [PATCH 1/9] Store recently rejected transactions. --- ethcore/src/client/client.rs | 2 +- ethcore/sync/src/chain/mod.rs | 33 +++++++++-------- miner/src/pool/queue.rs | 70 +++++++++++++++++++++++++++++++---- 3 files changed, 81 insertions(+), 24 deletions(-) diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index f1e5d882ead..f9f41116aa0 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -87,7 +87,7 @@ pub use verification::queue::QueueInfo as BlockQueueInfo; use_contract!(registry, "Registry", "res/contracts/registrar.json"); -const MAX_TX_QUEUE_SIZE: usize = 4096; +const MAX_TX_QUEUE_SIZE: usize = 8192; const MAX_ANCIENT_BLOCKS_QUEUE_SIZE: usize = 4096; // Max number of blocks imported at once. const MAX_ANCIENT_BLOCKS_TO_IMPORT: usize = 4; diff --git a/ethcore/sync/src/chain/mod.rs b/ethcore/sync/src/chain/mod.rs index 84e6344e688..50f4c9428a1 100644 --- a/ethcore/sync/src/chain/mod.rs +++ b/ethcore/sync/src/chain/mod.rs @@ -662,20 +662,29 @@ impl ChainSync { None } ).collect(); - let mut peers: Vec<(PeerId, u8)> = confirmed_peers.iter().filter(|&&(peer_id, _)| - self.active_peers.contains(&peer_id) - ).map(|v| *v).collect(); - random::new().shuffle(&mut peers); //TODO: sort by rating - // prefer peers with higher protocol version - peers.sort_by(|&(_, ref v1), &(_, ref v2)| v1.cmp(v2)); trace!( target: "sync", "Syncing with peers: {} active, {} confirmed, {} total", self.active_peers.len(), confirmed_peers.len(), self.peers.len() ); - for (peer_id, _) in peers { - self.sync_peer(io, peer_id, false); + + if self.state == SyncState::Waiting { + trace!(target: "sync", "Waiting for the block queue"); + } else if self.state == SyncState::SnapshotWaiting { + trace!(target: "sync", "Waiting for the snapshot restoration"); + } else { + let mut peers: Vec<(PeerId, u8)> = confirmed_peers.iter().filter(|&&(peer_id, _)| + self.active_peers.contains(&peer_id) + ).map(|v| *v).collect(); + + random::new().shuffle(&mut peers); //TODO: sort by rating + // prefer peers with higher protocol version + peers.sort_by(|&(_, ref v1), &(_, ref v2)| v1.cmp(v2)); + + for (peer_id, _) in peers { + self.sync_peer(io, peer_id, false); + } } if @@ -710,14 +719,6 @@ impl ChainSync { trace!(target: "sync", "Skipping busy peer {}", peer_id); return; } - if self.state == SyncState::Waiting { - trace!(target: "sync", "Waiting for the block queue"); - return; - } - if self.state == SyncState::SnapshotWaiting { - trace!(target: "sync", "Waiting for the snapshot restoration"); - return; - } (peer.latest_hash.clone(), peer.difficulty.clone(), peer.snapshot_number.as_ref().cloned().unwrap_or(0), peer.snapshot_hash.as_ref().cloned()) } else { return; diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index 4351087b29b..66c59966a78 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -19,7 +19,7 @@ use std::{cmp, fmt}; use std::sync::Arc; use std::sync::atomic::{self, AtomicUsize}; -use std::collections::BTreeMap; +use std::collections::{BTreeMap, HashMap}; use ethereum_types::{H256, U256, Address}; use parking_lot::RwLock; @@ -138,6 +138,43 @@ impl CachedPending { } } +#[derive(Debug, Default)] +struct RecentlyRejected { + inner: RwLock>, +} + +impl RecentlyRejected { + fn clear(&self) { + self.inner.write().clear(); + } + + fn get(&self, hash: &H256) -> Option { + self.inner.read().get(hash).cloned() + } + + fn insert(&self, hash: H256, result: &Result) { + let err = match result { + Ok(_) => return, + Err(e) => e.clone(), + }; + + if self.inner.read().contains_key(&hash) { + return; + } + + let mut inner = self.inner.write(); + inner.insert(hash, err); + + // clean up + if inner.len() > 4096 { + let to_remove: Vec<_> = inner.keys().take(2048).cloned().collect(); + for key in to_remove { + inner.remove(&key); + } + } + } +} + /// Ethereum Transaction Queue /// /// Responsible for: @@ -150,6 +187,7 @@ pub struct TransactionQueue { pool: RwLock, options: RwLock, cached_pending: RwLock, + recently_rejected: RecentlyRejected, } impl TransactionQueue { @@ -164,6 +202,7 @@ impl TransactionQueue { pool: RwLock::new(txpool::Pool::new(Default::default(), scoring::NonceAndGasPrice(strategy), limits)), options: RwLock::new(verification_options), cached_pending: RwLock::new(CachedPending::none()), + recently_rejected: RecentlyRejected::default(), } } @@ -187,21 +226,37 @@ impl TransactionQueue { trace_time!("pool::verify_and_import"); let options = self.options.read().clone(); - let verifier = verifier::Verifier::new(client, options, self.insertion_id.clone()); + let verifier = verifier::Verifier::new( + client, + options, + self.insertion_id.clone(), + ); let results = transactions .into_iter() .map(|transaction| { - if self.pool.read().find(&transaction.hash()).is_some() { - bail!(transaction::Error::AlreadyImported) + let hash = transaction.hash(); + if let Some(err) = self.recently_rejected.get(&hash) { + warn!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); + return (Err(err), hash); + } + + if self.pool.read().find(&hash).is_some() { + return (Err(transaction::Error::AlreadyImported), hash) } - verifier.verify_transaction(transaction) + (verifier.verify_transaction(transaction), hash) }) - .map(|result| result.and_then(|verified| { + .map(|(result, hash)| (result.and_then(|verified| { self.pool.write().import(verified) .map(|_imported| ()) .map_err(convert_error) - })) + }), hash)) + .map(|(result, hash)| { + if result.is_err() { + self.recently_rejected.insert(hash, &result); + } + result + }) .collect::>(); // Notify about imported transactions. @@ -329,6 +384,7 @@ impl TransactionQueue { let state_readiness = ready::State::new(client, stale_id, nonce_cap); + self.recently_rejected.clear(); let removed = self.pool.write().cull(None, state_readiness); debug!(target: "txqueue", "Removed {} stalled transactions. {}", removed, self.status()); } From 43eb599cb09beb6f8c322a8e5f9cab82c4519d32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Wed, 27 Jun 2018 14:27:40 +0200 Subject: [PATCH 2/9] Don't cache AlreadyImported rejections. --- miner/src/pool/queue.rs | 64 ++++++++++++++++++++++++----------------- 1 file changed, 37 insertions(+), 27 deletions(-) diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index 66c59966a78..0941ac1a4e8 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -138,12 +138,20 @@ impl CachedPending { } } -#[derive(Debug, Default)] +#[derive(Debug)] struct RecentlyRejected { inner: RwLock>, + limit: usize, } impl RecentlyRejected { + fn new(limit: usize) -> Self { + RecentlyRejected { + limit, + inner: Default::default(), + } + } + fn clear(&self) { self.inner.write().clear(); } @@ -152,22 +160,18 @@ impl RecentlyRejected { self.inner.read().get(hash).cloned() } - fn insert(&self, hash: H256, result: &Result) { - let err = match result { - Ok(_) => return, - Err(e) => e.clone(), - }; - + fn insert(&self, hash: H256, err: &transaction::Error) { if self.inner.read().contains_key(&hash) { return; } let mut inner = self.inner.write(); - inner.insert(hash, err); + inner.insert(hash, err.clone()); // clean up - if inner.len() > 4096 { - let to_remove: Vec<_> = inner.keys().take(2048).cloned().collect(); + if inner.len() > self.limit { + // randomly remove half of the entries + let to_remove: Vec<_> = inner.keys().take(self.limit / 2).cloned().collect(); for key in to_remove { inner.remove(&key); } @@ -175,6 +179,9 @@ impl RecentlyRejected { } } +/// Minimal size of rejection cache, by default it's equal to queue size. +const MIN_REJECTED_CACHE_SIZE: usize = 2048; + /// Ethereum Transaction Queue /// /// Responsible for: @@ -197,12 +204,13 @@ impl TransactionQueue { verification_options: verifier::Options, strategy: PrioritizationStrategy, ) -> Self { + let max_count = limits.max_count; TransactionQueue { insertion_id: Default::default(), pool: RwLock::new(txpool::Pool::new(Default::default(), scoring::NonceAndGasPrice(strategy), limits)), options: RwLock::new(verification_options), cached_pending: RwLock::new(CachedPending::none()), - recently_rejected: RecentlyRejected::default(), + recently_rejected: RecentlyRejected::new(cmp::max(MIN_REJECTED_CACHE_SIZE, max_count)), } } @@ -235,27 +243,29 @@ impl TransactionQueue { .into_iter() .map(|transaction| { let hash = transaction.hash(); - if let Some(err) = self.recently_rejected.get(&hash) { - warn!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); - return (Err(err), hash); - } if self.pool.read().find(&hash).is_some() { - return (Err(transaction::Error::AlreadyImported), hash) + return Err(transaction::Error::AlreadyImported); } - (verifier.verify_transaction(transaction), hash) - }) - .map(|(result, hash)| (result.and_then(|verified| { - self.pool.write().import(verified) - .map(|_imported| ()) - .map_err(convert_error) - }), hash)) - .map(|(result, hash)| { - if result.is_err() { - self.recently_rejected.insert(hash, &result); + if let Some(err) = self.recently_rejected.get(&hash) { + warn!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); + return Err(err); + } + + let imported = verifier + .verify_transaction(transaction) + .and_then(|verified| { + self.pool.write().import(verified).map_err(convert_error) + }); + + match imported { + Ok(_) => Ok(()), + Err(err) => { + self.recently_rejected.insert(hash, &err); + Err(err) + }, } - result }) .collect::>(); From 1d31e4e877282394d4fd5cdd8f0127eab52174c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Wed, 27 Jun 2018 14:54:00 +0200 Subject: [PATCH 3/9] Make the size of transaction verification queue dependent on pool size. --- ethcore/src/client/client.rs | 7 ++----- ethcore/src/client/config.rs | 36 ++++++++++++++++++++++++++------- ethcore/src/verification/mod.rs | 6 ------ parity/blockchain.rs | 2 +- parity/run.rs | 2 ++ parity/snapshot.rs | 2 +- parity/user_defaults.rs | 2 +- util/journaldb/src/lib.rs | 4 ---- 8 files changed, 36 insertions(+), 25 deletions(-) diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index ff5a8ff7f35..ca9cde33af1 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -1,5 +1,3 @@ -// Copyright 2015-2018 Parity Technologies (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 @@ -87,7 +85,6 @@ pub use verification::queue::QueueInfo as BlockQueueInfo; use_contract!(registry, "Registry", "res/contracts/registrar.json"); -const MAX_TX_QUEUE_SIZE: usize = 8192; const MAX_ANCIENT_BLOCKS_QUEUE_SIZE: usize = 4096; // Max number of blocks imported at once. const MAX_ANCIENT_BLOCKS_TO_IMPORT: usize = 4; @@ -760,13 +757,12 @@ impl Client { tracedb: tracedb, engine: engine, pruning: config.pruning.clone(), - config: config, db: RwLock::new(db.clone()), state_db: RwLock::new(state_db), report: RwLock::new(Default::default()), io_channel: Mutex::new(message_channel), notify: RwLock::new(Vec::new()), - queue_transactions: IoChannelQueue::new(MAX_TX_QUEUE_SIZE), + queue_transactions: IoChannelQueue::new(config.transaction_verification_queue_size), queue_ancient_blocks: IoChannelQueue::new(MAX_ANCIENT_BLOCKS_QUEUE_SIZE), queued_ancient_blocks: Default::default(), ancient_blocks_import_lock: Default::default(), @@ -779,6 +775,7 @@ impl Client { registrar_address, exit_handler: Mutex::new(None), importer, + config, }); // prune old states. diff --git a/ethcore/src/client/config.rs b/ethcore/src/client/config.rs index 462a126a00c..748ddb9e897 100644 --- a/ethcore/src/client/config.rs +++ b/ethcore/src/client/config.rs @@ -70,12 +70,6 @@ pub enum Mode { Off, } -impl Default for Mode { - fn default() -> Self { - Mode::Active - } -} - impl Display for Mode { fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> { match *self { @@ -88,7 +82,7 @@ impl Display for Mode { } /// Client configuration. Includes configs for all sub-systems. -#[derive(Debug, PartialEq, Default, Clone)] +#[derive(Debug, PartialEq, Clone)] pub struct ClientConfig { /// Block queue configuration. pub queue: QueueConfig, @@ -126,8 +120,36 @@ pub struct ClientConfig { pub history_mem: usize, /// Check seal valididity on block import pub check_seal: bool, + /// Maximal number of transactions queued for verification in a separate thread. + pub transaction_verification_queue_size: usize, } +impl Default for ClientConfig { + fn default() -> Self { + let mb = 1024 * 1024; + ClientConfig { + queue: Default::default(), + blockchain: Default::default(), + tracing: Default::default(), + vm_type: Default::default(), + fat_db: false, + pruning: journaldb::Algorithm::OverlayRecent, + name: "default".into(), + db_cache_size: None, + db_compaction: Default::default(), + db_wal: true, + mode: Mode::Active, + spec_name: "".into(), + verifier_type: VerifierType::Canon, + state_cache_size: 1 * mb, + jump_table_size: 1 * mb, + history: 64, + history_mem: 32 * mb, + check_seal: true, + transaction_verification_queue_size: 8192, + } + } +} #[cfg(test)] mod test { use super::{DatabaseCompactionProfile, Mode}; diff --git a/ethcore/src/verification/mod.rs b/ethcore/src/verification/mod.rs index ed4227ee21e..56cb2ade773 100644 --- a/ethcore/src/verification/mod.rs +++ b/ethcore/src/verification/mod.rs @@ -42,12 +42,6 @@ pub enum VerifierType { Noop, } -impl Default for VerifierType { - fn default() -> Self { - VerifierType::Canon - } -} - /// Create a new verifier based on type. pub fn new(v: VerifierType) -> Box> { match v { diff --git a/parity/blockchain.rs b/parity/blockchain.rs index af5373b3994..f2bccba4c69 100644 --- a/parity/blockchain.rs +++ b/parity/blockchain.rs @@ -357,7 +357,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { algorithm, cmd.pruning_history, cmd.pruning_memory, - cmd.check_seal + cmd.check_seal, ); client_config.queue.verifier_settings = cmd.verifier_settings; diff --git a/parity/run.rs b/parity/run.rs index da7a715bd29..f4795f98276 100644 --- a/parity/run.rs +++ b/parity/run.rs @@ -518,6 +518,7 @@ fn execute_impl(cmd: RunCmd, logger: Arc, on_client_rq: // fetch service let fetch = fetch::Client::new().map_err(|e| format!("Error starting fetch client: {:?}", e))?; + let txpool_size = cmd.miner_options.pool_limits.max_count; // create miner let miner = Arc::new(Miner::new( cmd.miner_options, @@ -574,6 +575,7 @@ fn execute_impl(cmd: RunCmd, logger: Arc, on_client_rq: ); client_config.queue.verifier_settings = cmd.verifier_settings; + client_config.transaction_verification_queue_size = ::std::cmp::max(2048, txpool_size / 4); // set up bootnodes let mut net_conf = cmd.net_conf; diff --git a/parity/snapshot.rs b/parity/snapshot.rs index 77271925011..949a685bd3d 100644 --- a/parity/snapshot.rs +++ b/parity/snapshot.rs @@ -179,7 +179,7 @@ impl SnapshotCommand { algorithm, self.pruning_history, self.pruning_memory, - true + true, ); let restoration_db_handler = db::restoration_db_handler(&client_path, &client_config); diff --git a/parity/user_defaults.rs b/parity/user_defaults.rs index cb4a0a40a47..5031886f298 100644 --- a/parity/user_defaults.rs +++ b/parity/user_defaults.rs @@ -122,7 +122,7 @@ impl Default for UserDefaults { fn default() -> Self { UserDefaults { is_first_launch: true, - pruning: Algorithm::default(), + pruning: Algorithm::OverlayRecent, tracing: false, fat_db: false, mode: Mode::Active, diff --git a/util/journaldb/src/lib.rs b/util/journaldb/src/lib.rs index 7607271c8d2..0aa8ba79431 100644 --- a/util/journaldb/src/lib.rs +++ b/util/journaldb/src/lib.rs @@ -80,10 +80,6 @@ pub enum Algorithm { RefCounted, } -impl Default for Algorithm { - fn default() -> Algorithm { Algorithm::OverlayRecent } -} - impl str::FromStr for Algorithm { type Err = String; From 080bd76a94b2eb37e23d6ad1dd918a6043ea2ccb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Wed, 27 Jun 2018 15:23:43 +0200 Subject: [PATCH 4/9] Add a test for recently rejected. --- ethcore/src/client/client.rs | 2 ++ miner/src/pool/queue.rs | 2 +- miner/src/pool/tests/mod.rs | 40 ++++++++++++++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 1 deletion(-) diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index ca9cde33af1..05bcb783a38 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -1,3 +1,5 @@ +// Copyright 2015-2018 Parity Technologies (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 diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index 0941ac1a4e8..ceb87bb6a2e 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -249,7 +249,7 @@ impl TransactionQueue { } if let Some(err) = self.recently_rejected.get(&hash) { - warn!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); + trace!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); return Err(err); } diff --git a/miner/src/pool/tests/mod.rs b/miner/src/pool/tests/mod.rs index ef83db4a901..9457d092243 100644 --- a/miner/src/pool/tests/mod.rs +++ b/miner/src/pool/tests/mod.rs @@ -892,3 +892,43 @@ fn should_avoid_verifying_transaction_already_in_pool() { // then assert_eq!(txq.status().status.transaction_count, 1); } + +#[test] +fn should_avoid_reverifying_recently_rejected_transactions() { + // given + let txq = TransactionQueue::new( + txpool::Options { + max_count: 1, + max_per_sender: 2, + max_mem_usage: 50 + }, + verifier::Options { + minimal_gas_price: 1.into(), + block_gas_limit: 1_000_000.into(), + tx_gas_limit: 1_000_000.into(), + }, + PrioritizationStrategy::GasPriceOnly, + ); + let client = TestClient::new(); + let tx1 = Tx::gas_price(10_000).signed().unverified(); + + let res = txq.import(client.clone(), vec![tx1.clone()]); + assert_eq!(res, vec![Err(transaction::Error::InsufficientBalance { + balance: 0xf67c.into(), + cost: 0xc8458e4.into(), + })]); + assert_eq!(txq.status().status.transaction_count, 0); + assert!(client.was_verification_triggered()); + + // when + let client = TestClient::new(); + let res = txq.import(client.clone(), vec![tx1]); + assert_eq!(res, vec![Err(transaction::Error::InsufficientBalance { + balance: 0xf67c.into(), + cost: 0xc8458e4.into(), + })]); + assert!(!client.was_verification_triggered()); + + // then + assert_eq!(txq.status().status.transaction_count, 0); +} From e6d480ab932080a9a4631d704181bd4043e549c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Thu, 28 Jun 2018 13:44:35 +0200 Subject: [PATCH 5/9] Fix logging for recently rejected. --- miner/src/pool/queue.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index ceb87bb6a2e..5a247ab485e 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -249,7 +249,7 @@ impl TransactionQueue { } if let Some(err) = self.recently_rejected.get(&hash) { - trace!(target: "txpool", "[{:?}] Rejecting recently rejected: {:?}", hash, err); + trace!(target: "txqueue", "[{:?}] Rejecting recently rejected: {:?}", hash, err); return Err(err); } From d3fe51eefa96337807dd8b405f4b4cfceafe392e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Thu, 28 Jun 2018 16:29:43 +0200 Subject: [PATCH 6/9] Make rejection cache smaller. --- miner/src/pool/queue.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index 5a247ab485e..49ef83ab96f 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -210,7 +210,7 @@ impl TransactionQueue { pool: RwLock::new(txpool::Pool::new(Default::default(), scoring::NonceAndGasPrice(strategy), limits)), options: RwLock::new(verification_options), cached_pending: RwLock::new(CachedPending::none()), - recently_rejected: RecentlyRejected::new(cmp::max(MIN_REJECTED_CACHE_SIZE, max_count)), + recently_rejected: RecentlyRejected::new(cmp::max(MIN_REJECTED_CACHE_SIZE, max_count / 4)), } } From 5bf70339e59c97fb7ad18220bbf029b059c52795 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 29 Jun 2018 09:26:25 +0300 Subject: [PATCH 7/9] obsolete test removed --- util/journaldb/src/lib.rs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/util/journaldb/src/lib.rs b/util/journaldb/src/lib.rs index 0aa8ba79431..c6dc8400bd7 100644 --- a/util/journaldb/src/lib.rs +++ b/util/journaldb/src/lib.rs @@ -177,11 +177,6 @@ mod tests { assert!(!Algorithm::RefCounted.is_stable()); } - #[test] - fn test_journal_algorithm_default() { - assert_eq!(Algorithm::default(), Algorithm::OverlayRecent); - } - #[test] fn test_journal_algorithm_all_types() { // compiling should fail if some cases are not covered From ee199f4e2d8db5e456da0507e39fd9fdc4e18e16 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 29 Jun 2018 10:03:23 +0300 Subject: [PATCH 8/9] obsolete test removed --- ethcore/src/client/config.rs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/ethcore/src/client/config.rs b/ethcore/src/client/config.rs index 748ddb9e897..1045ea610c3 100644 --- a/ethcore/src/client/config.rs +++ b/ethcore/src/client/config.rs @@ -165,9 +165,4 @@ mod test { assert_eq!(DatabaseCompactionProfile::SSD, "ssd".parse().unwrap()); assert_eq!(DatabaseCompactionProfile::HDD, "hdd".parse().unwrap()); } - - #[test] - fn test_mode_default() { - assert_eq!(Mode::default(), Mode::Active); - } } From 44d24767fb06e16005625520eed8fcdc8bbeca44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Fri, 29 Jun 2018 10:27:02 +0200 Subject: [PATCH 9/9] Construct cache with_capacity. --- miner/src/pool/queue.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/miner/src/pool/queue.rs b/miner/src/pool/queue.rs index 49ef83ab96f..0475e15b3ff 100644 --- a/miner/src/pool/queue.rs +++ b/miner/src/pool/queue.rs @@ -148,7 +148,7 @@ impl RecentlyRejected { fn new(limit: usize) -> Self { RecentlyRejected { limit, - inner: Default::default(), + inner: RwLock::new(HashMap::with_capacity(MIN_REJECTED_CACHE_SIZE)), } }