blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

removes RwLock+Once in favor of OnceCell in caching staked-nodes (#26313) 

VoteAccounts uses std::sync::{RwLock, Once} to lazily compute and cache
staked_nodes:
https://github.com/solana-labs/solana/blob/032bee13a/runtime/src/vote_account.rs#L89-L104

This commit instead switches to using once_cell::sync::OnceCell which
provides this exact intended functionality by design.
This commit is contained in:
behzad nouri 2022-06-29 22:22:22 +00:00 committed by GitHub
parent 557bf6e656
commit d053ce79d4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 75 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/src/bank.rs
View File

@ -2533,7 +2533,7 @@ impl Bank {
.stakes_cache .stakes_cache
.stakes() .stakes()
.vote_accounts() .vote_accounts()
.delegated_stakes_iter() .delegated_stakes()
.map(|(pubkey, stake)| (*pubkey, stake)) .map(|(pubkey, stake)| (*pubkey, stake))
.collect(); .collect();
info!( info!(

27
runtime/src/stakes.rs
View File

@ -57,7 +57,7 @@ impl StakesCache {
self.0.read().unwrap() self.0.read().unwrap()
} }
pub fn check_and_store(&self, pubkey: &Pubkey, account: &impl ReadableAccount) { pub(crate) fn check_and_store(&self, pubkey: &Pubkey, account: &impl ReadableAccount) {
// TODO: If the account is already cached as a vote or stake account // TODO: If the account is already cached as a vote or stake account
// but the owner changes, then this needs to evict the account from // but the owner changes, then this needs to evict the account from
// the cache. see: // the cache. see:
@ -110,12 +110,12 @@ impl StakesCache {
} }
} }
pub fn activate_epoch(&self, next_epoch: Epoch, thread_pool: &ThreadPool) { pub(crate) fn activate_epoch(&self, next_epoch: Epoch, thread_pool: &ThreadPool) {
let mut stakes = self.0.write().unwrap(); let mut stakes = self.0.write().unwrap();
stakes.activate_epoch(next_epoch, thread_pool) stakes.activate_epoch(next_epoch, thread_pool)
} }
pub fn handle_invalid_keys( pub(crate) fn handle_invalid_keys(
&self, &self,
invalid_stake_keys: DashMap<Pubkey, InvalidCacheEntryReason>, invalid_stake_keys: DashMap<Pubkey, InvalidCacheEntryReason>,
invalid_vote_keys: DashMap<Pubkey, InvalidCacheEntryReason>, invalid_vote_keys: DashMap<Pubkey, InvalidCacheEntryReason>,
@ -231,7 +231,7 @@ impl Stakes<StakeAccount> {
}) })
} }
pub fn history(&self) -> &StakeHistory { pub(crate) fn history(&self) -> &StakeHistory {
&self.stake_history &self.stake_history
} }
@ -303,7 +303,7 @@ impl Stakes<StakeAccount> {
} }
/// Sum the lamports of the vote accounts and the delegated stake /// Sum the lamports of the vote accounts and the delegated stake
pub fn vote_balance_and_staked(&self) -> u64 { pub(crate) fn vote_balance_and_staked(&self) -> u64 {
let get_stake = |stake_account: &StakeAccount| stake_account.delegation().stake; let get_stake = |stake_account: &StakeAccount| stake_account.delegation().stake;
let get_lamports = |(_, vote_account): (_, &VoteAccount)| vote_account.lamports(); let get_lamports = |(_, vote_account): (_, &VoteAccount)| vote_account.lamports();
@ -465,7 +465,7 @@ pub(crate) mod serde_stakes_enum_compat {
} }
#[cfg(test)] #[cfg(test)]
pub mod tests { pub(crate) mod tests {
use { use {
super::*, super::*,
rand::Rng, rand::Rng,
@ -476,7 +476,7 @@ pub mod tests {
}; };
// set up some dummies for a staked node (( vote ) ( stake )) // set up some dummies for a staked node (( vote ) ( stake ))
pub fn create_staked_node_accounts( pub(crate) fn create_staked_node_accounts(
stake: u64, stake: u64,
) -> ((Pubkey, AccountSharedData), (Pubkey, AccountSharedData)) { ) -> ((Pubkey, AccountSharedData), (Pubkey, AccountSharedData)) {
let vote_pubkey = solana_sdk::pubkey::new_rand(); let vote_pubkey = solana_sdk::pubkey::new_rand();
@ -489,7 +489,10 @@ pub mod tests {
} }
// add stake to a vote_pubkey ( stake ) // add stake to a vote_pubkey ( stake )
pub fn create_stake_account(stake: u64, vote_pubkey: &Pubkey) -> (Pubkey, AccountSharedData) { pub(crate) fn create_stake_account(
stake: u64,
vote_pubkey: &Pubkey,
) -> (Pubkey, AccountSharedData) {
let stake_pubkey = solana_sdk::pubkey::new_rand(); let stake_pubkey = solana_sdk::pubkey::new_rand();
( (
stake_pubkey, stake_pubkey,
@ -503,7 +506,7 @@ pub mod tests {
) )
} }
pub fn create_warming_staked_node_accounts( fn create_warming_staked_node_accounts(
stake: u64, stake: u64,
epoch: Epoch, epoch: Epoch,
) -> ((Pubkey, AccountSharedData), (Pubkey, AccountSharedData)) { ) -> ((Pubkey, AccountSharedData), (Pubkey, AccountSharedData)) {
@ -517,7 +520,7 @@ pub mod tests {
} }
// add stake to a vote_pubkey ( stake ) // add stake to a vote_pubkey ( stake )
pub fn create_warming_stake_account( fn create_warming_stake_account(
stake: u64, stake: u64,
epoch: Epoch, epoch: Epoch,
vote_pubkey: &Pubkey, vote_pubkey: &Pubkey,
@ -847,7 +850,7 @@ pub mod tests {
fn test_vote_balance_and_staked_normal() { fn test_vote_balance_and_staked_normal() {
let stakes_cache = StakesCache::default(); let stakes_cache = StakesCache::default();
impl Stakes<StakeAccount> { impl Stakes<StakeAccount> {
pub fn vote_balance_and_warmed_staked(&self) -> u64 { fn vote_balance_and_warmed_staked(&self) -> u64 {
let vote_balance: u64 = self let vote_balance: u64 = self
.vote_accounts .vote_accounts
.iter() .iter()
@ -855,7 +858,7 @@ pub mod tests {
.sum(); .sum();
let warmed_stake: u64 = self let warmed_stake: u64 = self
.vote_accounts .vote_accounts
.delegated_stakes_iter() .delegated_stakes()
.map(|(_pubkey, stake)| stake) .map(|(_pubkey, stake)| stake)
.sum(); .sum();
vote_balance + warmed_stake vote_balance + warmed_stake

137
runtime/src/vote_account.rs
View File

@ -12,7 +12,7 @@ use {
cmp::Ordering, cmp::Ordering,
collections::{hash_map::Entry, HashMap}, collections::{hash_map::Entry, HashMap},
iter::FromIterator, iter::FromIterator,
sync::{Arc, Once, RwLock}, sync::Arc,
}, },
thiserror::Error, thiserror::Error,
}; };
@ -37,13 +37,12 @@ struct VoteAccountInner {
pub type VoteAccountsHashMap = HashMap<Pubkey, (/*stake:*/ u64, VoteAccount)>; pub type VoteAccountsHashMap = HashMap<Pubkey, (/*stake:*/ u64, VoteAccount)>;
#[derive(Debug, AbiExample, Deserialize)] #[derive(Clone, Debug, AbiExample, Deserialize)]
#[serde(from = "Arc<VoteAccountsHashMap>")] #[serde(from = "Arc<VoteAccountsHashMap>")]
pub struct VoteAccounts { pub struct VoteAccounts {
vote_accounts: Arc<VoteAccountsHashMap>, vote_accounts: Arc<VoteAccountsHashMap>,
// Inner Arc is meant to implement copy-on-write semantics as opposed to // Inner Arc is meant to implement copy-on-write semantics.
// sharing mutations (hence RwLock<Arc<...>> instead of Arc<RwLock<...>>). staked_nodes: OnceCell<
staked_nodes: RwLock<
Arc< Arc<
HashMap< HashMap<
Pubkey, // VoteAccount.vote_state.node_pubkey. Pubkey, // VoteAccount.vote_state.node_pubkey.
@ -51,7 +50,6 @@ pub struct VoteAccounts {
>, >,
>, >,
>, >,
staked_nodes_once: Once,
} }
impl VoteAccount { impl VoteAccount {
@ -86,33 +84,34 @@ impl VoteAccounts {
self.vote_accounts.len() self.vote_accounts.len()
} }
pub fn staked_nodes(&self) -> Arc<HashMap<Pubkey, u64>> { pub fn staked_nodes(&self) -> Arc<HashMap</*node_pubkey:*/ Pubkey, /*stake:*/ u64>> {
self.staked_nodes_once.call_once(|| { self.staked_nodes
let staked_nodes = self .get_or_init(|| {
.vote_accounts Arc::new(
.values() self.vote_accounts
.filter(|(stake, _)| *stake != 0) .values()
.filter_map(|(stake, vote_account)| { .filter(|(stake, _)| *stake != 0u64)
let node_pubkey = vote_account.node_pubkey()?; .filter_map(|(stake, vote_account)| {
Some((node_pubkey, stake)) Some((vote_account.node_pubkey()?, stake))
}) })
.into_grouping_map() .into_grouping_map()
.aggregate(|acc, _node_pubkey, stake| Some(acc.unwrap_or_default() + stake)); .aggregate(|acc, _node_pubkey, stake| {
*self.staked_nodes.write().unwrap() = Arc::new(staked_nodes) Some(acc.unwrap_or_default() + stake)
}); }),
self.staked_nodes.read().unwrap().clone() )
})
.clone()
} }
pub fn get(&self, pubkey: &Pubkey) -> Option<&VoteAccount> { pub(crate) fn get(&self, pubkey: &Pubkey) -> Option<&VoteAccount> {
self.vote_accounts let (_stake, vote_account) = self.vote_accounts.get(pubkey)?;
.get(pubkey) Some(vote_account)
.map(|(_stake, vote_account)| vote_account)
} }
pub fn get_delegated_stake(&self, pubkey: &Pubkey) -> u64 { pub fn get_delegated_stake(&self, pubkey: &Pubkey) -> u64 {
self.vote_accounts self.vote_accounts
.get(pubkey) .get(pubkey)
.map(|(stake, ..)| *stake) .map(|(stake, _vote_account)| *stake)
.unwrap_or_default() .unwrap_or_default()
} }
@ -122,10 +121,10 @@ impl VoteAccounts {
.map(|(vote_pubkey, (_stake, vote_account))| (vote_pubkey, vote_account)) .map(|(vote_pubkey, (_stake, vote_account))| (vote_pubkey, vote_account))
} }
pub(crate) fn delegated_stakes_iter(&self) -> impl Iterator<Item = (&Pubkey, u64)> { pub(crate) fn delegated_stakes(&self) -> impl Iterator<Item = (&Pubkey, u64)> {
self.vote_accounts self.vote_accounts
.iter() .iter()
.map(|(vote_pubkey, (stake, ..))| (vote_pubkey, *stake)) .map(|(vote_pubkey, (stake, _vote_account))| (vote_pubkey, *stake))
} }
pub(crate) fn find_max_by_delegated_stake(&self) -> Option<&VoteAccount> { pub(crate) fn find_max_by_delegated_stake(&self) -> Option<&VoteAccount> {
@ -172,33 +171,39 @@ impl VoteAccounts {
} }
fn add_node_stake(&mut self, stake: u64, vote_account: &VoteAccount) { fn add_node_stake(&mut self, stake: u64, vote_account: &VoteAccount) {
if stake != 0 && self.staked_nodes_once.is_completed() { if stake == 0u64 {
if let Some(node_pubkey) = vote_account.node_pubkey() { return;
let mut staked_nodes = self.staked_nodes.write().unwrap(); }
let staked_nodes = Arc::make_mut(&mut staked_nodes); let staked_nodes = match self.staked_nodes.get_mut() {
staked_nodes None => return,
.entry(node_pubkey) Some(staked_nodes) => staked_nodes,
.and_modify(|s| *s += stake) };
.or_insert(stake); if let Some(node_pubkey) = vote_account.node_pubkey() {
} Arc::make_mut(staked_nodes)
.entry(node_pubkey)
.and_modify(|s| *s += stake)
.or_insert(stake);
} }
} }
fn sub_node_stake(&mut self, stake: u64, vote_account: &VoteAccount) { fn sub_node_stake(&mut self, stake: u64, vote_account: &VoteAccount) {
if stake != 0 && self.staked_nodes_once.is_completed() { if stake == 0u64 {
if let Some(node_pubkey) = vote_account.node_pubkey() { return;
let mut staked_nodes = self.staked_nodes.write().unwrap(); }
let staked_nodes = Arc::make_mut(&mut staked_nodes); let staked_nodes = match self.staked_nodes.get_mut() {
match staked_nodes.entry(node_pubkey) { None => return,
Entry::Vacant(_) => panic!("this should not happen!"), Some(staked_nodes) => staked_nodes,
Entry::Occupied(mut entry) => match entry.get().cmp(&stake) { };
Ordering::Less => panic!("subtraction value exceeds node's stake"), if let Some(node_pubkey) = vote_account.node_pubkey() {
Ordering::Equal => { match Arc::make_mut(staked_nodes).entry(node_pubkey) {
entry.remove_entry(); Entry::Vacant(_) => panic!("this should not happen!"),
} Entry::Occupied(mut entry) => match entry.get().cmp(&stake) {
Ordering::Greater => *entry.get_mut() -= stake, Ordering::Less => panic!("subtraction value exceeds node's stake"),
}, Ordering::Equal => {
} entry.remove_entry();
}
Ordering::Greater => *entry.get_mut() -= stake,
},
} }
} }
} }
@ -260,29 +265,7 @@ impl Default for VoteAccounts {
fn default() -> Self { fn default() -> Self {
Self { Self {
vote_accounts: Arc::default(), vote_accounts: Arc::default(),
staked_nodes: RwLock::default(), staked_nodes: OnceCell::new(),
staked_nodes_once: Once::new(),
}
}
}
impl Clone for VoteAccounts {
fn clone(&self) -> Self {
if self.staked_nodes_once.is_completed() {
let staked_nodes = self.staked_nodes.read().unwrap().clone();
let other = Self {
vote_accounts: self.vote_accounts.clone(),
staked_nodes: RwLock::new(staked_nodes),
staked_nodes_once: Once::new(),
};
other.staked_nodes_once.call_once(|| {});
other
} else {
Self {
vote_accounts: self.vote_accounts.clone(),
staked_nodes: RwLock::default(),
staked_nodes_once: Once::new(),
}
} }
} }
} }
@ -292,7 +275,6 @@ impl PartialEq<VoteAccounts> for VoteAccounts {
let Self { let Self {
vote_accounts, vote_accounts,
staked_nodes: _, staked_nodes: _,
staked_nodes_once: _,
} = self; } = self;
vote_accounts == &other.vote_accounts vote_accounts == &other.vote_accounts
} }
@ -302,8 +284,7 @@ impl From<Arc<VoteAccountsHashMap>> for VoteAccounts {
fn from(vote_accounts: Arc<VoteAccountsHashMap>) -> Self { fn from(vote_accounts: Arc<VoteAccountsHashMap>) -> Self {
Self { Self {
vote_accounts, vote_accounts,
staked_nodes: RwLock::default(), staked_nodes: OnceCell::new(),
staked_nodes_once: Once::new(),
} }
} }
} }
@ -548,7 +529,7 @@ mod tests {
assert_eq!(staked_nodes(&accounts), *vote_accounts.staked_nodes()); assert_eq!(staked_nodes(&accounts), *vote_accounts.staked_nodes());
} }
} }
assert!(vote_accounts.staked_nodes.read().unwrap().is_empty()); assert!(vote_accounts.staked_nodes.get().unwrap().is_empty());
} }
// Asserts that returned staked-nodes are copy-on-write references. // Asserts that returned staked-nodes are copy-on-write references.