grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Strict memory order (#306)

Browse Source 
* Make MemoryOrdering more strict

* fmt

* Strict mem order for priority_tasks_gate
This commit is contained in:
rakita
2021-03-10 12:36:23 +01:00
committed by GitHub
parent e2024c4b81
commit eca8fb74ae
14 changed files with 56 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
crates/ethcore/src/client/client.rs
View File

@@ -284,7 +284,7 @@ impl Importer {
// t_nb 6.0 This is triggered by a message coming from a block queue when the block is ready for insertion
pub fn import_verified_blocks(&self, client: &Client) -> usize {
// Shortcut out if we know we're incapable of syncing the chain.
if !client.enabled.load(AtomicOrdering::Relaxed) {
if !client.enabled.load(AtomicOrdering::SeqCst) {
return 0;
}
@@ -1445,18 +1445,18 @@ impl Client {
}
fn wake_up(&self) {
if !self.liveness.load(AtomicOrdering::Relaxed) {
self.liveness.store(true, AtomicOrdering::Relaxed);
if !self.liveness.load(AtomicOrdering::SeqCst) {
self.liveness.store(true, AtomicOrdering::SeqCst);
self.notify(|n| n.start());
info!(target: "mode", "wake_up: Waking.");
}
}
fn sleep(&self, force: bool) {
if self.liveness.load(AtomicOrdering::Relaxed) {
if self.liveness.load(AtomicOrdering::SeqCst) {
// only sleep if the import queue is mostly empty.
if force || (self.queue_info().total_queue_size() <= MAX_QUEUE_SIZE_TO_SLEEP_ON) {
self.liveness.store(false, AtomicOrdering::Relaxed);
self.liveness.store(false, AtomicOrdering::SeqCst);
self.notify(|n| n.stop());
info!(target: "mode", "sleep: Sleeping.");
} else {
@@ -2058,13 +2058,13 @@ impl BlockChainClient for Client {
fn disable(&self) {
self.set_mode(Mode::Off);
self.enabled.store(false, AtomicOrdering::Relaxed);
self.enabled.store(false, AtomicOrdering::SeqCst);
self.clear_queue();
}
fn set_mode(&self, new_mode: Mode) {
trace!(target: "mode", "Client::set_mode({:?})", new_mode);
if !self.enabled.load(AtomicOrdering::Relaxed) {
if !self.enabled.load(AtomicOrdering::SeqCst) {
return;
}
{
@@ -2095,7 +2095,7 @@ impl BlockChainClient for Client {
fn set_spec_name(&self, new_spec_name: String) -> Result<(), ()> {
trace!(target: "mode", "Client::set_spec_name({:?})", new_spec_name);
if !self.enabled.load(AtomicOrdering::Relaxed) {
if !self.enabled.load(AtomicOrdering::SeqCst) {
return Err(());
}
if let Some(ref h) = *self.exit_handler.lock() {
@@ -3241,7 +3241,7 @@ impl IoChannelQueue {
where
F: Fn(&Client) + Send + Sync + 'static,
{
let queue_size = self.currently_queued.load(AtomicOrdering::Relaxed);
let queue_size = self.currently_queued.load(AtomicOrdering::SeqCst);
if queue_size >= self.limit {
let err_limit = usize::try_from(self.limit).unwrap_or(usize::max_value());
bail!("The queue is full ({})", err_limit);

8
crates/ethcore/src/client/test_client.rs
View File

@@ -237,7 +237,7 @@ impl TestBlockChainClient {
/// Set block queue size for testing
pub fn set_queue_size(&self, size: usize) {
self.queue_size.store(size, AtomicOrder::Relaxed);
self.queue_size.store(size, AtomicOrder::SeqCst);
}
/// Set timestamp assigned to latest sealed block
@@ -402,7 +402,7 @@ impl TestBlockChainClient {
/// Returns true if the client has been disabled.
pub fn is_disabled(&self) -> bool {
self.disabled.load(AtomicOrder::Relaxed)
self.disabled.load(AtomicOrder::SeqCst)
}
}
@@ -959,7 +959,7 @@ impl BlockChainClient for TestBlockChainClient {
fn queue_info(&self) -> QueueInfo {
QueueInfo {
verified_queue_size: self.queue_size.load(AtomicOrder::Relaxed),
verified_queue_size: self.queue_size.load(AtomicOrder::SeqCst),
unverified_queue_size: 0,
verifying_queue_size: 0,
max_queue_size: 0,
@@ -1019,7 +1019,7 @@ impl BlockChainClient for TestBlockChainClient {
}
fn disable(&self) {
self.disabled.store(true, AtomicOrder::Relaxed);
self.disabled.store(true, AtomicOrder::SeqCst);
}
fn pruning_info(&self) -> PruningInfo {

18
crates/ethcore/src/snapshot/mod.rs
View File

@@ -127,34 +127,34 @@ pub struct Progress {
impl Progress {
/// Reset the progress.
pub fn reset(&self) {
self.accounts.store(0, Ordering::Release);
self.blocks.store(0, Ordering::Release);
self.size.store(0, Ordering::Release);
self.abort.store(false, Ordering::Release);
self.accounts.store(0, Ordering::SeqCst);
self.blocks.store(0, Ordering::SeqCst);
self.size.store(0, Ordering::SeqCst);
self.abort.store(false, Ordering::SeqCst);
// atomic fence here to ensure the others are written first?
// logs might very rarely get polluted if not.
self.done.store(false, Ordering::Release);
self.done.store(false, Ordering::SeqCst);
}
/// Get the number of accounts snapshotted thus far.
pub fn accounts(&self) -> usize {
self.accounts.load(Ordering::Acquire)
self.accounts.load(Ordering::SeqCst)
}
/// Get the number of blocks snapshotted thus far.
pub fn blocks(&self) -> usize {
self.blocks.load(Ordering::Acquire)
self.blocks.load(Ordering::SeqCst)
}
/// Get the written size of the snapshot in bytes.
pub fn size(&self) -> u64 {
self.size.load(Ordering::Acquire)
self.size.load(Ordering::SeqCst)
}
/// Whether the snapshot is complete.
pub fn done(&self) -> bool {
self.done.load(Ordering::Acquire)
self.done.load(Ordering::SeqCst)
}
}
/// Take a snapshot using the given blockchain, starting block hash, and database, writing into the given writer.

32
crates/ethcore/src/verification/queue/mod.rs
View File

@@ -175,18 +175,13 @@ struct QueueSignal {
impl QueueSignal {
fn set_sync(&self) {
// Do not signal when we are about to close
if self.deleting.load(AtomicOrdering::Relaxed) {
if self.deleting.load(AtomicOrdering::SeqCst) {
return;
}
if self
.signalled
.compare_exchange(
false,
true,
AtomicOrdering::Relaxed,
AtomicOrdering::Relaxed,
)
.compare_exchange(false, true, AtomicOrdering::SeqCst, AtomicOrdering::SeqCst)
.is_ok()
{
let channel = self.message_channel.lock().clone();
@@ -198,18 +193,13 @@ impl QueueSignal {
fn set_async(&self) {
// Do not signal when we are about to close
if self.deleting.load(AtomicOrdering::Relaxed) {
if self.deleting.load(AtomicOrdering::SeqCst) {
return;
}
if self
.signalled
.compare_exchange(
false,
true,
AtomicOrdering::Relaxed,
AtomicOrdering::Relaxed,
)
.compare_exchange(false, true, AtomicOrdering::SeqCst, AtomicOrdering::SeqCst)
.is_ok()
{
let channel = self.message_channel.lock().clone();
@@ -220,7 +210,7 @@ impl QueueSignal {
}
fn reset(&self) {
self.signalled.store(false, AtomicOrdering::Relaxed);
self.signalled.store(false, AtomicOrdering::SeqCst);
}
}
@@ -499,9 +489,9 @@ impl<K: Kind> VerificationQueue<K> {
verified.clear();
let sizes = &self.verification.sizes;
sizes.unverified.store(0, AtomicOrdering::Release);
sizes.verifying.store(0, AtomicOrdering::Release);
sizes.verified.store(0, AtomicOrdering::Release);
sizes.unverified.store(0, AtomicOrdering::SeqCst);
sizes.verifying.store(0, AtomicOrdering::SeqCst);
sizes.verified.store(0, AtomicOrdering::SeqCst);
*self.total_difficulty.write() = 0.into();
self.processing.write().clear();
@@ -728,7 +718,7 @@ impl<K: Kind> VerificationQueue<K> {
.verification
.sizes
.unverified
.load(AtomicOrdering::Acquire);
.load(AtomicOrdering::SeqCst);
(len, size + len * size_of::<K::Unverified>())
};
@@ -738,7 +728,7 @@ impl<K: Kind> VerificationQueue<K> {
.verification
.sizes
.verifying
.load(AtomicOrdering::Acquire);
.load(AtomicOrdering::SeqCst);
(len, size + len * size_of::<Verifying<K>>())
};
let (verified_len, verified_bytes) = {
@@ -747,7 +737,7 @@ impl<K: Kind> VerificationQueue<K> {
.verification
.sizes
.verified
.load(AtomicOrdering::Acquire);
.load(AtomicOrdering::SeqCst);
(len, size + len * size_of::<K::Verified>())
};