gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make rewards tracer async friendly (backport #20452) (#20456)

Browse Source 
* Make rewards tracer async friendly (#20452)

(cherry picked from commit 250a8503fe)

# Conflicts:
#	Cargo.lock
#	ledger-tool/Cargo.toml
#	runtime/src/bank.rs

* fix conflicts

Co-authored-by: Justin Starry <justin@solana.com>
This commit is contained in:
mergify[bot]
2021-10-06 11:20:50 +00:00
committed by GitHub
parent 1ca4f7d110
commit 95ac00d30a
6 changed files with 105 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -4796,6 +4796,7 @@ dependencies = [
"bytecount",
"clap",
"csv",
"dashmap",
"futures 0.3.8",
"futures-util",
"histogram",

1
ledger-tool/Cargo.toml
View File

@ -14,6 +14,7 @@ bs58 = "0.3.1"
bytecount = "0.6.0"
clap = "2.33.1"
csv = "1.1.3"
dashmap = "4.0.2"
futures = "0.3.8"
futures-util = "0.3.5"
histogram = "*"

48
ledger-tool/src/main.rs
View File

@ -3,6 +3,7 @@ use clap::{
crate_description, crate_name, value_t, value_t_or_exit, values_t_or_exit, App, AppSettings,
Arg, ArgMatches, SubCommand,
};
use dashmap::DashMap;
use itertools::Itertools;
use log::*;
use regex::Regex;
@ -57,7 +58,7 @@ use std::{
path::{Path, PathBuf},
process::{exit, Command, Stdio},
str::FromStr,
sync::Arc,
sync::{Arc, RwLock},
};
mod bigtable;
@ -2345,15 +2346,16 @@ fn main() {
skipped_reasons: String,
}
use solana_stake_program::stake_state::InflationPointCalculationEvent;
let mut stake_calcuration_details: HashMap<Pubkey, CalculationDetail> =
HashMap::new();
let mut last_point_value = None;
let stake_calculation_details: DashMap<Pubkey, CalculationDetail> =
DashMap::new();
let last_point_value = Arc::new(RwLock::new(None));
let tracer = |event: &RewardCalculationEvent| {
// Currently RewardCalculationEvent enum has only Staking variant
// because only staking tracing is supported!
#[allow(irrefutable_let_patterns)]
if let RewardCalculationEvent::Staking(pubkey, event) = event {
let detail = stake_calcuration_details.entry(**pubkey).or_default();
let mut detail =
stake_calculation_details.entry(**pubkey).or_default();
match event {
InflationPointCalculationEvent::CalculatedPoints(
epoch,
@ -2378,12 +2380,11 @@ fn main() {
detail.point_value = Some(point_value.clone());
// we have duplicate copies of `PointValue`s for possible
// miscalculation; do some minimum sanity check
let point_value = detail.point_value.clone();
if point_value.is_some() {
if last_point_value.is_some() {
assert_eq!(last_point_value, point_value,);
}
last_point_value = point_value;
let mut last_point_value = last_point_value.write().unwrap();
if let Some(last_point_value) = last_point_value.as_ref() {
assert_eq!(last_point_value, point_value);
} else {
*last_point_value = Some(point_value.clone());
}
}
InflationPointCalculationEvent::EffectiveStakeAtRewardedEpoch(stake) => {
@ -2488,16 +2489,17 @@ fn main() {
},
);
let mut unchanged_accounts = stake_calcuration_details
.keys()
let mut unchanged_accounts = stake_calculation_details
.iter()
.map(|entry| *entry.key())
.collect::<HashSet<_>>()
.difference(
&rewarded_accounts
.iter()
.map(|(pubkey, ..)| *pubkey)
.map(|(pubkey, ..)| **pubkey)
.collect(),
)
.map(|pubkey| (**pubkey, warped_bank.get_account(pubkey).unwrap()))
.map(|pubkey| (*pubkey, warped_bank.get_account(pubkey).unwrap()))
.collect::<Vec<_>>();
unchanged_accounts.sort_unstable_by_key(|(pubkey, account)| {
(*account.owner(), account.lamports(), *pubkey)
@ -2518,7 +2520,9 @@ fn main() {
if let Some(base_account) = base_bank.get_account(&pubkey) {
let delta = warped_account.lamports() - base_account.lamports();
let detail = stake_calcuration_details.get(&pubkey);
let detail_ref = stake_calculation_details.get(&pubkey);
let detail: Option<&CalculationDetail> =
detail_ref.as_ref().map(|detail_ref| detail_ref.value());
println!(
"{:<45}({}): {} => {} (+{} {:>4.9}%) {:?}",
format!("{}", pubkey), // format! is needed to pad/justify correctly.
@ -2641,10 +2645,18 @@ fn main() {
),
commission: format_or_na(detail.map(|d| d.commission)),
cluster_rewards: format_or_na(
last_point_value.as_ref().map(|pv| pv.rewards),
last_point_value
.read()
.unwrap()
.clone()
.map(|pv| pv.rewards),
),
cluster_points: format_or_na(
last_point_value.as_ref().map(|pv| pv.points),
last_point_value
.read()
.unwrap()
.clone()
.map(|pv| pv.points),
),
old_capitalization: base_bank.capitalization(),
new_capitalization: warped_bank.capitalization(),

60
programs/stake/src/stake_state.rs
View File

@ -59,7 +59,7 @@ pub enum InflationPointCalculationEvent {
Skipped(SkippedReason),
}
pub(crate) fn null_tracer() -> Option<impl FnMut(&InflationPointCalculationEvent)> {
pub(crate) fn null_tracer() -> Option<impl Fn(&InflationPointCalculationEvent)> {
None::<fn(&_)>
}
@ -161,10 +161,10 @@ fn redeem_stake_rewards(
point_value: &PointValue,
vote_state: &VoteState,
stake_history: Option<&StakeHistory>,
inflation_point_calc_tracer: &mut Option<impl FnMut(&InflationPointCalculationEvent)>,
inflation_point_calc_tracer: Option<impl Fn(&InflationPointCalculationEvent)>,
fix_activating_credits_observed: bool,
) -> Option<(u64, u64)> {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer.as_ref() {
inflation_point_calc_tracer(&InflationPointCalculationEvent::CreditsObserved(
stake.credits_observed,
None,
@ -176,7 +176,7 @@ fn redeem_stake_rewards(
point_value,
vote_state,
stake_history,
inflation_point_calc_tracer,
inflation_point_calc_tracer.as_ref(),
fix_activating_credits_observed,
)
.map(|(stakers_reward, voters_reward, credits_observed)| {
@ -196,7 +196,7 @@ fn calculate_stake_points(
stake: &Stake,
vote_state: &VoteState,
stake_history: Option<&StakeHistory>,
inflation_point_calc_tracer: &mut Option<impl FnMut(&InflationPointCalculationEvent)>,
inflation_point_calc_tracer: Option<impl Fn(&InflationPointCalculationEvent)>,
) -> u128 {
calculate_stake_points_and_credits(
stake,
@ -214,11 +214,11 @@ fn calculate_stake_points_and_credits(
stake: &Stake,
new_vote_state: &VoteState,
stake_history: Option<&StakeHistory>,
inflation_point_calc_tracer: &mut Option<impl FnMut(&InflationPointCalculationEvent)>,
inflation_point_calc_tracer: Option<impl Fn(&InflationPointCalculationEvent)>,
) -> (u128, u64) {
// if there is no newer credits since observed, return no point
if new_vote_state.credits() <= stake.credits_observed {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer.as_ref() {
inflation_point_calc_tracer(&SkippedReason::ZeroCreditsAndReturnCurrent.into());
}
return (0, stake.credits_observed);
@ -254,7 +254,7 @@ fn calculate_stake_points_and_credits(
let earned_points = stake_amount * earned_credits;
points += earned_points;
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer.as_ref() {
inflation_point_calc_tracer(&InflationPointCalculationEvent::CalculatedPoints(
epoch,
stake_amount,
@ -279,14 +279,14 @@ fn calculate_stake_rewards(
point_value: &PointValue,
vote_state: &VoteState,
stake_history: Option<&StakeHistory>,
inflation_point_calc_tracer: &mut Option<impl FnMut(&InflationPointCalculationEvent)>,
inflation_point_calc_tracer: Option<impl Fn(&InflationPointCalculationEvent)>,
fix_activating_credits_observed: bool,
) -> Option<(u64, u64, u64)> {
let (points, credits_observed) = calculate_stake_points_and_credits(
stake,
vote_state,
stake_history,
inflation_point_calc_tracer,
inflation_point_calc_tracer.as_ref(),
);
// Drive credits_observed forward unconditionally when rewards are disabled
@ -1105,11 +1105,11 @@ pub fn redeem_rewards(
vote_state: &VoteState,
point_value: &PointValue,
stake_history: Option<&StakeHistory>,
inflation_point_calc_tracer: &mut Option<impl FnMut(&InflationPointCalculationEvent)>,
inflation_point_calc_tracer: Option<impl Fn(&InflationPointCalculationEvent)>,
fix_activating_credits_observed: bool,
) -> Result<(u64, u64), InstructionError> {
if let StakeState::Stake(meta, mut stake) = stake_account.state()? {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer {
if let Some(inflation_point_calc_tracer) = inflation_point_calc_tracer.as_ref() {
inflation_point_calc_tracer(
&InflationPointCalculationEvent::EffectiveStakeAtRewardedEpoch(
stake.stake(rewarded_epoch, stake_history),
@ -1160,7 +1160,7 @@ pub fn calculate_points(
&stake,
&vote_state,
stake_history,
&mut null_tracer(),
null_tracer(),
))
} else {
Err(InstructionError::InvalidAccountData)
@ -3373,7 +3373,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3394,7 +3394,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3432,7 +3432,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3447,7 +3447,7 @@ mod tests {
// no overflow on points
assert_eq!(
u128::from(stake.delegation.stake) * epoch_slots,
calculate_stake_points(&stake, &vote_state, None, &mut null_tracer())
calculate_stake_points(&stake, &vote_state, None, null_tracer())
);
}
@ -3476,7 +3476,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3497,7 +3497,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3515,7 +3515,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3536,7 +3536,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3555,7 +3555,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3580,7 +3580,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3599,7 +3599,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3615,7 +3615,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3634,7 +3634,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3653,7 +3653,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3661,7 +3661,7 @@ mod tests {
// assert the previous behavior is preserved where fix_stake_deactivate=false
assert_eq!(
(0, 4),
calculate_stake_points_and_credits(&stake, &vote_state, None, &mut null_tracer())
calculate_stake_points_and_credits(&stake, &vote_state, None, null_tracer())
);
// get rewards and credits observed when not the activation epoch
@ -3683,7 +3683,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);
@ -3703,7 +3703,7 @@ mod tests {
},
&vote_state,
None,
&mut null_tracer(),
null_tracer(),
true,
)
);

45
runtime/src/bank.rs
View File

@ -808,7 +808,7 @@ pub enum RewardCalculationEvent<'a, 'b> {
Staking(&'a Pubkey, &'b InflationPointCalculationEvent),
}
fn null_tracer() -> Option<impl FnMut(&RewardCalculationEvent)> {
fn null_tracer() -> Option<impl Fn(&RewardCalculationEvent) + Send + Sync> {
None::<fn(&RewardCalculationEvent)>
}
@ -1121,7 +1121,7 @@ impl Bank {
/// Create a new bank that points to an immutable checkpoint of another bank.
pub fn new_from_parent(parent: &Arc<Bank>, collector_id: &Pubkey, slot: Slot) -> Self {
Self::_new_from_parent(parent, collector_id, slot, &mut null_tracer(), false)
Self::_new_from_parent(parent, collector_id, slot, null_tracer(), false)
}
pub fn new_from_parent_with_vote_only(
@ -1130,35 +1130,23 @@ impl Bank {
slot: Slot,
vote_only_bank: bool,
) -> Self {
Self::_new_from_parent(
parent,
collector_id,
slot,
&mut null_tracer(),
vote_only_bank,
)
Self::_new_from_parent(parent, collector_id, slot, null_tracer(), vote_only_bank)
}
pub fn new_from_parent_with_tracer(
parent: &Arc<Bank>,
collector_id: &Pubkey,
slot: Slot,
reward_calc_tracer: impl FnMut(&RewardCalculationEvent),
reward_calc_tracer: impl Fn(&RewardCalculationEvent) + Send + Sync,
) -> Self {
Self::_new_from_parent(
parent,
collector_id,
slot,
&mut Some(reward_calc_tracer),
false,
)
Self::_new_from_parent(parent, collector_id, slot, Some(reward_calc_tracer), false)
}
fn _new_from_parent(
parent: &Arc<Bank>,
collector_id: &Pubkey,
slot: Slot,
reward_calc_tracer: &mut Option<impl FnMut(&RewardCalculationEvent)>,
reward_calc_tracer: Option<impl Fn(&RewardCalculationEvent) + Send + Sync>,
vote_only_bank: bool,
) -> Self {
parent.freeze();
@ -1840,7 +1828,7 @@ impl Bank {
fn update_rewards(
&mut self,
prev_epoch: Epoch,
reward_calc_tracer: &mut Option<impl FnMut(&RewardCalculationEvent)>,
reward_calc_tracer: Option<impl Fn(&RewardCalculationEvent) + Send + Sync>,
) {
if prev_epoch == self.epoch() {
return;
@ -1944,7 +1932,7 @@ impl Bank {
/// Filters out invalid pairs
fn stake_delegation_accounts(
&self,
reward_calc_tracer: &mut Option<impl FnMut(&RewardCalculationEvent)>,
reward_calc_tracer: Option<impl Fn(&RewardCalculationEvent) + Send + Sync>,
) -> HashMap<Pubkey, (Vec<(Pubkey, AccountSharedData)>, AccountSharedData)> {
let mut accounts = HashMap::new();
@ -1960,7 +1948,7 @@ impl Bank {
) {
(Some(stake_account), Some(vote_account)) => {
// call tracer to catch any illegal data if any
if let Some(reward_calc_tracer) = reward_calc_tracer {
if let Some(reward_calc_tracer) = reward_calc_tracer.as_ref() {
reward_calc_tracer(&RewardCalculationEvent::Staking(
stake_pubkey,
&InflationPointCalculationEvent::Delegation(
@ -2005,12 +1993,13 @@ impl Bank {
&mut self,
rewarded_epoch: Epoch,
rewards: u64,
reward_calc_tracer: &mut Option<impl FnMut(&RewardCalculationEvent)>,
reward_calc_tracer: Option<impl Fn(&RewardCalculationEvent) + Send + Sync>,
fix_activating_credits_observed: bool,
) -> f64 {
let stake_history = self.stakes.read().unwrap().history().clone();
let mut stake_delegation_accounts = self.stake_delegation_accounts(reward_calc_tracer);
let mut stake_delegation_accounts =
self.stake_delegation_accounts(reward_calc_tracer.as_ref());
let points: u128 = stake_delegation_accounts
.iter()
@ -2050,7 +2039,7 @@ impl Bank {
for (stake_pubkey, stake_account) in stake_group.iter_mut() {
// curry closure to add the contextual stake_pubkey
let mut reward_calc_tracer = reward_calc_tracer.as_mut().map(|outer| {
let reward_calc_tracer = reward_calc_tracer.as_ref().map(|outer| {
let stake_pubkey = *stake_pubkey;
// inner
move |inner_event: &_| {
@ -2064,7 +2053,7 @@ impl Bank {
&vote_state,
&point_value,
Some(&stake_history),
&mut reward_calc_tracer.as_mut(),
reward_calc_tracer,
fix_activating_credits_observed,
);
if let Ok((stakers_reward, _voters_reward)) = redeemed {
@ -7463,7 +7452,7 @@ pub(crate) mod tests {
bank0.store_account_and_update_capitalization(&vote_id, &vote_account);
let validator_points: u128 = bank0
.stake_delegation_accounts(&mut null_tracer())
.stake_delegation_accounts(null_tracer())
.iter()
.flat_map(|(_vote_pubkey, (stake_group, vote_account))| {
stake_group
@ -13246,7 +13235,7 @@ pub(crate) mod tests {
vec![10_000; 2],
);
let bank = Arc::new(Bank::new(&genesis_config));
let stake_delegation_accounts = bank.stake_delegation_accounts(&mut null_tracer());
let stake_delegation_accounts = bank.stake_delegation_accounts(null_tracer());
assert_eq!(stake_delegation_accounts.len(), 2);
let mut vote_account = bank
@ -13285,7 +13274,7 @@ pub(crate) mod tests {
);
// Accounts must be valid stake and vote accounts
let stake_delegation_accounts = bank.stake_delegation_accounts(&mut null_tracer());
let stake_delegation_accounts = bank.stake_delegation_accounts(null_tracer());
assert_eq!(stake_delegation_accounts.len(), 0);
}

26
sdk/bpf/syscalls.txt Normal file
View File

@ -0,0 +1,26 @@
abort
sol_panic_
sol_log_
sol_log_64_
sol_log_compute_units_
sol_log_pubkey
sol_create_program_address
sol_try_find_program_address
sol_sha256
sol_keccak256
sol_secp256k1_recover
sol_blake3
sol_get_clock_sysvar
sol_get_epoch_schedule_sysvar
sol_get_fees_sysvar
sol_get_rent_sysvar
sol_memcpy_
sol_memmove_
sol_memcmp_
sol_memset_
sol_invoke_signed_c
sol_invoke_signed_rust
sol_alloc_free_
sol_set_return_data
sol_get_return_data
sol_log_data