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

Invoke cost tracker from its bank (backport #20627) (#20800)

Browse Source 
* - make cost_tracker a member of bank, remove shared instance from TPU; (#20627)

- decouple cost_model from cost_tracker; allowing one cost_model
  instance being shared within a validator;
- update cost_model api to calculate_cost(&self...)->transaction_cost

(cherry picked from commit 7496b5784b)

# Conflicts:
#	core/src/banking_stage.rs
#	ledger-tool/src/main.rs
#	runtime/src/bank.rs
#	runtime/src/cost_model.rs
#	runtime/src/cost_tracker.rs

* manual fix merge conflicts

Co-authored-by: Tao Zhu <82401714+taozhu-chicago@users.noreply.github.com>
Co-authored-by: Tao Zhu <tao@solana.com>
This commit is contained in:
mergify[bot]
2021-10-20 00:22:38 +00:00
committed by GitHub
parent de32ab4d57
commit 28eb6ff796
8 changed files with 216 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
banking-bench/src/main.rs
View File

@ -16,7 +16,7 @@ use solana_perf::packet::to_packets_chunked;
use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry}; use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry};
use solana_runtime::{ use solana_runtime::{
accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks, accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
cost_model::CostModel, cost_tracker::CostTracker, cost_model::CostModel,
}; };
use solana_sdk::{ use solana_sdk::{
hash::Hash, hash::Hash,
@ -232,9 +232,7 @@ fn main() {
vote_receiver, vote_receiver,
None, None,
replay_vote_sender, replay_vote_sender,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
); );
poh_recorder.lock().unwrap().set_bank(&bank); poh_recorder.lock().unwrap().set_bank(&bank);

14
core/benches/banking_stage.rs
View File

@ -19,7 +19,6 @@ use solana_perf::test_tx::test_tx;
use solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry}; use solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry};
use solana_runtime::bank::Bank; use solana_runtime::bank::Bank;
use solana_runtime::cost_model::CostModel; use solana_runtime::cost_model::CostModel;
use solana_runtime::cost_tracker::CostTracker;
use solana_runtime::cost_tracker_stats::CostTrackerStats; use solana_runtime::cost_tracker_stats::CostTrackerStats;
use solana_sdk::genesis_config::GenesisConfig; use solana_sdk::genesis_config::GenesisConfig;
use solana_sdk::hash::Hash; use solana_sdk::hash::Hash;
@ -95,9 +94,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
None::<Box<dyn Fn()>>, None::<Box<dyn Fn()>>,
&BankingStageStats::default(), &BankingStageStats::default(),
&recorder, &recorder,
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &Arc::new(RwLock::new(CostModel::default())),
CostModel::new(std::u64::MAX, std::u64::MAX),
))))),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
}); });
@ -172,6 +169,11 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
bank.ns_per_slot = std::u128::MAX; bank.ns_per_slot = std::u128::MAX;
let bank = Arc::new(Bank::new(&genesis_config)); let bank = Arc::new(Bank::new(&genesis_config));
// set cost tracker limits to MAX so it will not filter out TXs
bank.write_cost_tracker()
.unwrap()
.set_limits(std::u64::MAX, std::u64::MAX);
debug!("threads: {} txs: {}", num_threads, txes); debug!("threads: {} txs: {}", num_threads, txes);
let transactions = match tx_type { let transactions = match tx_type {
@ -225,9 +227,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
vote_receiver, vote_receiver,
None, None,
s, s,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::new(std::u64::MAX, std::u64::MAX),
))))),
); );
poh_recorder.lock().unwrap().set_bank(&bank); poh_recorder.lock().unwrap().set_bank(&bank);

289
core/src/banking_stage.rs
View File

@ -24,6 +24,7 @@ use solana_runtime::{
TransactionExecutionResult, TransactionExecutionResult,
}, },
bank_utils, bank_utils,
cost_model::CostModel,
cost_tracker::CostTracker, cost_tracker::CostTracker,
cost_tracker_stats::CostTrackerStats, cost_tracker_stats::CostTrackerStats,
hashed_transaction::HashedTransaction, hashed_transaction::HashedTransaction,
@ -55,7 +56,7 @@ use std::{
net::{SocketAddr, UdpSocket}, net::{SocketAddr, UdpSocket},
ops::DerefMut, ops::DerefMut,
sync::atomic::{AtomicU64, AtomicUsize, Ordering}, sync::atomic::{AtomicU64, AtomicUsize, Ordering},
sync::{Arc, Mutex, RwLock}, sync::{Arc, Mutex, RwLock, RwLockReadGuard},
thread::{self, Builder, JoinHandle}, thread::{self, Builder, JoinHandle},
time::Duration, time::Duration,
time::Instant, time::Instant,
@ -96,7 +97,6 @@ pub struct BankingStageStats {
current_buffered_packet_batches_count: AtomicUsize, current_buffered_packet_batches_count: AtomicUsize,
rebuffered_packets_count: AtomicUsize, rebuffered_packets_count: AtomicUsize,
consumed_buffered_packets_count: AtomicUsize, consumed_buffered_packets_count: AtomicUsize,
reset_cost_tracker_count: AtomicUsize,
cost_tracker_check_count: AtomicUsize, cost_tracker_check_count: AtomicUsize,
cost_forced_retry_transactions_count: AtomicUsize, cost_forced_retry_transactions_count: AtomicUsize,
@ -175,11 +175,6 @@ impl BankingStageStats {
.swap(0, Ordering::Relaxed) as i64, .swap(0, Ordering::Relaxed) as i64,
i64 i64
), ),
(
"reset_cost_tracker_count",
self.reset_cost_tracker_count.swap(0, Ordering::Relaxed) as i64,
i64
),
( (
"cost_tracker_check_count", "cost_tracker_check_count",
self.cost_tracker_check_count.swap(0, Ordering::Relaxed) as i64, self.cost_tracker_check_count.swap(0, Ordering::Relaxed) as i64,
@ -288,7 +283,7 @@ impl BankingStage {
verified_vote_receiver: CrossbeamReceiver<Vec<Packets>>, verified_vote_receiver: CrossbeamReceiver<Vec<Packets>>,
transaction_status_sender: Option<TransactionStatusSender>, transaction_status_sender: Option<TransactionStatusSender>,
gossip_vote_sender: ReplayVoteSender, gossip_vote_sender: ReplayVoteSender,
cost_tracker: Arc<RwLock<CostTracker>>, cost_model: Arc<RwLock<CostModel>>,
) -> Self { ) -> Self {
Self::new_num_threads( Self::new_num_threads(
cluster_info, cluster_info,
@ -299,7 +294,7 @@ impl BankingStage {
Self::num_threads(), Self::num_threads(),
transaction_status_sender, transaction_status_sender,
gossip_vote_sender, gossip_vote_sender,
cost_tracker, cost_model,
) )
} }
@ -312,7 +307,7 @@ impl BankingStage {
num_threads: u32, num_threads: u32,
transaction_status_sender: Option<TransactionStatusSender>, transaction_status_sender: Option<TransactionStatusSender>,
gossip_vote_sender: ReplayVoteSender, gossip_vote_sender: ReplayVoteSender,
cost_tracker: Arc<RwLock<CostTracker>>, cost_model: Arc<RwLock<CostModel>>,
) -> Self { ) -> Self {
let batch_limit = TOTAL_BUFFERED_PACKETS / ((num_threads - 1) as usize * PACKETS_PER_BATCH); let batch_limit = TOTAL_BUFFERED_PACKETS / ((num_threads - 1) as usize * PACKETS_PER_BATCH);
// Single thread to generate entries from many banks. // Single thread to generate entries from many banks.
@ -348,7 +343,7 @@ impl BankingStage {
let gossip_vote_sender = gossip_vote_sender.clone(); let gossip_vote_sender = gossip_vote_sender.clone();
let duplicates = duplicates.clone(); let duplicates = duplicates.clone();
let data_budget = data_budget.clone(); let data_budget = data_budget.clone();
let cost_tracker = cost_tracker.clone(); let cost_model = cost_model.clone();
Builder::new() Builder::new()
.name("solana-banking-stage-tx".to_string()) .name("solana-banking-stage-tx".to_string())
.spawn(move || { .spawn(move || {
@ -365,7 +360,7 @@ impl BankingStage {
gossip_vote_sender, gossip_vote_sender,
&duplicates, &duplicates,
&data_budget, &data_budget,
&cost_tracker, cost_model,
); );
}) })
.unwrap() .unwrap()
@ -423,24 +418,6 @@ impl BankingStage {
has_more_unprocessed_transactions has_more_unprocessed_transactions
} }
fn reset_cost_tracker_if_new_bank(
cost_tracker: &Arc<RwLock<CostTracker>>,
bank: Arc<Bank>,
banking_stage_stats: &BankingStageStats,
cost_tracker_stats: &mut CostTrackerStats,
) {
if cost_tracker
.write()
.unwrap()
.reset_if_new_bank(bank.slot(), cost_tracker_stats)
{
// only increase counter when bank changed
banking_stage_stats
.reset_cost_tracker_count
.fetch_add(1, Ordering::Relaxed);
}
}
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn consume_buffered_packets( pub fn consume_buffered_packets(
my_pubkey: &Pubkey, my_pubkey: &Pubkey,
@ -452,7 +429,7 @@ impl BankingStage {
test_fn: Option<impl Fn()>, test_fn: Option<impl Fn()>,
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
recorder: &TransactionRecorder, recorder: &TransactionRecorder,
cost_tracker: &Arc<RwLock<CostTracker>>, cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) { ) {
let mut rebuffered_packets_len = 0; let mut rebuffered_packets_len = 0;
@ -471,8 +448,8 @@ impl BankingStage {
original_unprocessed_indexes, original_unprocessed_indexes,
my_pubkey, my_pubkey,
*next_leader, *next_leader,
cost_tracker,
banking_stage_stats, banking_stage_stats,
cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
Self::update_buffered_packets_with_new_unprocessed( Self::update_buffered_packets_with_new_unprocessed(
@ -482,12 +459,6 @@ impl BankingStage {
} else { } else {
let bank_start = poh_recorder.lock().unwrap().bank_start(); let bank_start = poh_recorder.lock().unwrap().bank_start();
if let Some((bank, bank_creation_time)) = bank_start { if let Some((bank, bank_creation_time)) = bank_start {
Self::reset_cost_tracker_if_new_bank(
cost_tracker,
bank.clone(),
banking_stage_stats,
cost_tracker_stats,
);
let (processed, verified_txs_len, new_unprocessed_indexes) = let (processed, verified_txs_len, new_unprocessed_indexes) =
Self::process_packets_transactions( Self::process_packets_transactions(
&bank, &bank,
@ -498,7 +469,7 @@ impl BankingStage {
transaction_status_sender.clone(), transaction_status_sender.clone(),
gossip_vote_sender, gossip_vote_sender,
banking_stage_stats, banking_stage_stats,
cost_tracker, cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
if processed < verified_txs_len if processed < verified_txs_len
@ -603,7 +574,7 @@ impl BankingStage {
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
recorder: &TransactionRecorder, recorder: &TransactionRecorder,
data_budget: &DataBudget, data_budget: &DataBudget,
cost_tracker: &Arc<RwLock<CostTracker>>, cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) -> BufferedPacketsDecision { ) -> BufferedPacketsDecision {
let bank_start; let bank_start;
@ -615,14 +586,6 @@ impl BankingStage {
) = { ) = {
let poh = poh_recorder.lock().unwrap(); let poh = poh_recorder.lock().unwrap();
bank_start = poh.bank_start(); bank_start = poh.bank_start();
if let Some((ref bank, _)) = bank_start {
Self::reset_cost_tracker_if_new_bank(
cost_tracker,
bank.clone(),
banking_stage_stats,
cost_tracker_stats,
);
};
( (
poh.leader_after_n_slots(FORWARD_TRANSACTIONS_TO_LEADER_AT_SLOT_OFFSET), poh.leader_after_n_slots(FORWARD_TRANSACTIONS_TO_LEADER_AT_SLOT_OFFSET),
PohRecorder::get_bank_still_processing_txs(&bank_start), PohRecorder::get_bank_still_processing_txs(&bank_start),
@ -653,7 +616,7 @@ impl BankingStage {
None::<Box<dyn Fn()>>, None::<Box<dyn Fn()>>,
banking_stage_stats, banking_stage_stats,
recorder, recorder,
cost_tracker, cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
} }
@ -734,7 +697,7 @@ impl BankingStage {
gossip_vote_sender: ReplayVoteSender, gossip_vote_sender: ReplayVoteSender,
duplicates: &Arc<Mutex<(LruCache<u64, ()>, PacketHasher)>>, duplicates: &Arc<Mutex<(LruCache<u64, ()>, PacketHasher)>>,
data_budget: &DataBudget, data_budget: &DataBudget,
cost_tracker: &Arc<RwLock<CostTracker>>, cost_model: Arc<RwLock<CostModel>>,
) { ) {
let recorder = poh_recorder.lock().unwrap().recorder(); let recorder = poh_recorder.lock().unwrap().recorder();
let socket = UdpSocket::bind("0.0.0.0:0").unwrap(); let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
@ -755,7 +718,7 @@ impl BankingStage {
&banking_stage_stats, &banking_stage_stats,
&recorder, &recorder,
data_budget, data_budget,
cost_tracker, &cost_model,
&mut cost_tracker_stats, &mut cost_tracker_stats,
); );
if matches!(decision, BufferedPacketsDecision::Hold) if matches!(decision, BufferedPacketsDecision::Hold)
@ -791,7 +754,7 @@ impl BankingStage {
&banking_stage_stats, &banking_stage_stats,
duplicates, duplicates,
&recorder, &recorder,
cost_tracker, &cost_model,
&mut cost_tracker_stats, &mut cost_tracker_stats,
) { ) {
Ok(()) | Err(RecvTimeoutError::Timeout) => (), Ok(()) | Err(RecvTimeoutError::Timeout) => (),
@ -896,7 +859,6 @@ impl BankingStage {
}; };
let mut execute_timings = ExecuteTimings::default(); let mut execute_timings = ExecuteTimings::default();
let ( let (
mut loaded_accounts, mut loaded_accounts,
results, results,
@ -1131,10 +1093,11 @@ impl BankingStage {
msgs: &Packets, msgs: &Packets,
transaction_indexes: &[usize], transaction_indexes: &[usize],
feature_set: &Arc<feature_set::FeatureSet>, feature_set: &Arc<feature_set::FeatureSet>,
votes_only: bool, read_cost_tracker: &RwLockReadGuard<CostTracker>,
cost_tracker: &Arc<RwLock<CostTracker>>,
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
demote_program_write_locks: bool, demote_program_write_locks: bool,
votes_only: bool,
cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) -> (Vec<HashedTransaction<'static>>, Vec<usize>, Vec<usize>) { ) -> (Vec<HashedTransaction<'static>>, Vec<usize>, Vec<usize>) {
let mut retryable_transaction_packet_indexes: Vec<usize> = vec![]; let mut retryable_transaction_packet_indexes: Vec<usize> = vec![];
@ -1160,7 +1123,6 @@ impl BankingStage {
let mut cost_tracker_check_time = Measure::start("cost_tracker_check_time"); let mut cost_tracker_check_time = Measure::start("cost_tracker_check_time");
let filtered_transactions_with_packet_indexes: Vec<_> = { let filtered_transactions_with_packet_indexes: Vec<_> = {
let cost_tracker_readonly = cost_tracker.read().unwrap();
verified_transactions_with_packet_indexes verified_transactions_with_packet_indexes
.into_iter() .into_iter()
.filter_map(|(tx, tx_index)| { .filter_map(|(tx, tx_index)| {
@ -1170,10 +1132,13 @@ impl BankingStage {
// excluding vote TX from cost_model, for now // excluding vote TX from cost_model, for now
if !is_vote if !is_vote
&& cost_tracker_readonly && read_cost_tracker
.would_transaction_fit( .would_transaction_fit(
&tx, &tx,
demote_program_write_locks, &cost_model
.read()
.unwrap()
.calculate_cost(&tx, demote_program_write_locks),
cost_tracker_stats, cost_tracker_stats,
) )
.is_err() .is_err()
@ -1262,7 +1227,7 @@ impl BankingStage {
transaction_status_sender: Option<TransactionStatusSender>, transaction_status_sender: Option<TransactionStatusSender>,
gossip_vote_sender: &ReplayVoteSender, gossip_vote_sender: &ReplayVoteSender,
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
cost_tracker: &Arc<RwLock<CostTracker>>, cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) -> (usize, usize, Vec<usize>) { ) -> (usize, usize, Vec<usize>) {
let mut packet_conversion_time = Measure::start("packet_conversion"); let mut packet_conversion_time = Measure::start("packet_conversion");
@ -1271,10 +1236,11 @@ impl BankingStage {
msgs, msgs,
&packet_indexes, &packet_indexes,
&bank.feature_set, &bank.feature_set,
bank.vote_only_bank(), &bank.read_cost_tracker().unwrap(),
cost_tracker,
banking_stage_stats, banking_stage_stats,
bank.demote_program_write_locks(), bank.demote_program_write_locks(),
bank.vote_only_bank(),
cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
packet_conversion_time.stop(); packet_conversion_time.stop();
@ -1312,9 +1278,12 @@ impl BankingStage {
let mut cost_tracking_time = Measure::start("cost_tracking_time"); let mut cost_tracking_time = Measure::start("cost_tracking_time");
transactions.iter().enumerate().for_each(|(index, tx)| { transactions.iter().enumerate().for_each(|(index, tx)| {
if unprocessed_tx_indexes.iter().all(|&i| i != index) { if unprocessed_tx_indexes.iter().all(|&i| i != index) {
cost_tracker.write().unwrap().add_transaction_cost( bank.write_cost_tracker().unwrap().add_transaction_cost(
tx.transaction(), tx.transaction(),
bank.demote_program_write_locks(), &cost_model
.read()
.unwrap()
.calculate_cost(tx.transaction(), bank.demote_program_write_locks()),
cost_tracker_stats, cost_tracker_stats,
); );
} }
@ -1361,8 +1330,8 @@ impl BankingStage {
transaction_indexes: &[usize], transaction_indexes: &[usize],
my_pubkey: &Pubkey, my_pubkey: &Pubkey,
next_leader: Option<Pubkey>, next_leader: Option<Pubkey>,
cost_tracker: &Arc<RwLock<CostTracker>>,
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) -> Vec<usize> { ) -> Vec<usize> {
// Check if we are the next leader. If so, let's not filter the packets // Check if we are the next leader. If so, let's not filter the packets
@ -1381,10 +1350,11 @@ impl BankingStage {
msgs, msgs,
&transaction_indexes, &transaction_indexes,
&bank.feature_set, &bank.feature_set,
bank.vote_only_bank(), &bank.read_cost_tracker().unwrap(),
cost_tracker,
banking_stage_stats, banking_stage_stats,
bank.demote_program_write_locks(), bank.demote_program_write_locks(),
bank.vote_only_bank(),
cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
unprocessed_packet_conversion_time.stop(); unprocessed_packet_conversion_time.stop();
@ -1446,7 +1416,7 @@ impl BankingStage {
banking_stage_stats: &BankingStageStats, banking_stage_stats: &BankingStageStats,
duplicates: &Arc<Mutex<(LruCache<u64, ()>, PacketHasher)>>, duplicates: &Arc<Mutex<(LruCache<u64, ()>, PacketHasher)>>,
recorder: &TransactionRecorder, recorder: &TransactionRecorder,
cost_tracker: &Arc<RwLock<CostTracker>>, cost_model: &Arc<RwLock<CostModel>>,
cost_tracker_stats: &mut CostTrackerStats, cost_tracker_stats: &mut CostTrackerStats,
) -> Result<(), RecvTimeoutError> { ) -> Result<(), RecvTimeoutError> {
let mut recv_time = Measure::start("process_packets_recv"); let mut recv_time = Measure::start("process_packets_recv");
@ -1488,12 +1458,6 @@ impl BankingStage {
continue; continue;
} }
let (bank, bank_creation_time) = bank_start.unwrap(); let (bank, bank_creation_time) = bank_start.unwrap();
Self::reset_cost_tracker_if_new_bank(
cost_tracker,
bank.clone(),
banking_stage_stats,
cost_tracker_stats,
);
let (processed, verified_txs_len, unprocessed_indexes) = let (processed, verified_txs_len, unprocessed_indexes) =
Self::process_packets_transactions( Self::process_packets_transactions(
@ -1505,7 +1469,7 @@ impl BankingStage {
transaction_status_sender.clone(), transaction_status_sender.clone(),
gossip_vote_sender, gossip_vote_sender,
banking_stage_stats, banking_stage_stats,
cost_tracker, cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
@ -1538,8 +1502,8 @@ impl BankingStage {
&packet_indexes, &packet_indexes,
my_pubkey, my_pubkey,
next_leader, next_leader,
cost_tracker,
banking_stage_stats, banking_stage_stats,
cost_model,
cost_tracker_stats, cost_tracker_stats,
); );
Self::push_unprocessed( Self::push_unprocessed(
@ -1768,9 +1732,7 @@ mod tests {
gossip_verified_vote_receiver, gossip_verified_vote_receiver,
None, None,
vote_forward_sender, vote_forward_sender,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
); );
drop(verified_sender); drop(verified_sender);
drop(gossip_verified_vote_sender); drop(gossip_verified_vote_sender);
@ -1819,9 +1781,7 @@ mod tests {
verified_gossip_vote_receiver, verified_gossip_vote_receiver,
None, None,
vote_forward_sender, vote_forward_sender,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
); );
trace!("sending bank"); trace!("sending bank");
drop(verified_sender); drop(verified_sender);
@ -1894,9 +1854,7 @@ mod tests {
gossip_verified_vote_receiver, gossip_verified_vote_receiver,
None, None,
gossip_vote_sender, gossip_vote_sender,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
); );
// fund another account so we can send 2 good transactions in a single batch. // fund another account so we can send 2 good transactions in a single batch.
@ -2047,9 +2005,7 @@ mod tests {
3, 3,
None, None,
gossip_vote_sender, gossip_vote_sender,
Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
); );
// wait for banking_stage to eat the packets // wait for banking_stage to eat the packets
@ -2871,9 +2827,7 @@ mod tests {
None::<Box<dyn Fn()>>, None::<Box<dyn Fn()>>,
&BankingStageStats::default(), &BankingStageStats::default(),
&recorder, &recorder,
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(buffered_packets[0].1.len(), num_conflicting_transactions); assert_eq!(buffered_packets[0].1.len(), num_conflicting_transactions);
@ -2891,9 +2845,7 @@ mod tests {
None::<Box<dyn Fn()>>, None::<Box<dyn Fn()>>,
&BankingStageStats::default(), &BankingStageStats::default(),
&recorder, &recorder,
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
if num_expected_unprocessed == 0 { if num_expected_unprocessed == 0 {
@ -2960,9 +2912,7 @@ mod tests {
test_fn, test_fn,
&BankingStageStats::default(), &BankingStageStats::default(),
&recorder, &recorder,
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &Arc::new(RwLock::new(CostModel::default())),
CostModel::default(),
))))),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
@ -3204,7 +3154,6 @@ mod tests {
&keypair, &keypair,
None, None,
); );
let features = Arc::new(feature_set::FeatureSet::default());
// packets with no votes // packets with no votes
{ {
@ -3213,35 +3162,34 @@ mod tests {
make_test_packets(vec![transfer_tx.clone(), transfer_tx.clone()], vote_indexes); make_test_packets(vec![transfer_tx.clone(), transfer_tx.clone()], vote_indexes);
let mut votes_only = false; let mut votes_only = false;
let (txs, tx_packet_index, _retryable_packet_indexes) =
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( BankingStage::transactions_from_packets(
&packets, &packets,
&packet_indexes, &packet_indexes,
&features, &Arc::new(feature_set::FeatureSet::default()),
votes_only, &RwLock::new(CostTracker::default()).read().unwrap(),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &BankingStageStats::default(),
CostModel::default(), false,
))))), votes_only,
&BankingStageStats::default(), &Arc::new(RwLock::new(CostModel::default())),
false, &mut CostTrackerStats::default(),
&mut CostTrackerStats::default(), );
);
assert_eq!(2, txs.len()); assert_eq!(2, txs.len());
assert_eq!(vec![0, 1], tx_packet_index); assert_eq!(vec![0, 1], tx_packet_index);
votes_only = true; votes_only = true;
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( let (txs, tx_packet_index, _retryable_packet_indexes) =
&packets, BankingStage::transactions_from_packets(
&packet_indexes, &packets,
&features, &packet_indexes,
votes_only, &Arc::new(feature_set::FeatureSet::default()),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &RwLock::new(CostTracker::default()).read().unwrap(),
CostModel::default(), &BankingStageStats::default(),
))))), false,
&BankingStageStats::default(), votes_only,
false, &Arc::new(RwLock::new(CostModel::default())),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(0, txs.len()); assert_eq!(0, txs.len());
assert_eq!(0, tx_packet_index.len()); assert_eq!(0, tx_packet_index.len());
} }
@ -3255,34 +3203,34 @@ mod tests {
); );
let mut votes_only = false; let mut votes_only = false;
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( let (txs, tx_packet_index, _retryable_packet_indexes) =
&packets, BankingStage::transactions_from_packets(
&packet_indexes, &packets,
&features, &packet_indexes,
votes_only, &Arc::new(feature_set::FeatureSet::default()),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &RwLock::new(CostTracker::default()).read().unwrap(),
CostModel::default(), &BankingStageStats::default(),
))))), false,
&BankingStageStats::default(), votes_only,
false, &Arc::new(RwLock::new(CostModel::default())),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(3, txs.len()); assert_eq!(3, txs.len());
assert_eq!(vec![0, 1, 2], tx_packet_index); assert_eq!(vec![0, 1, 2], tx_packet_index);
votes_only = true; votes_only = true;
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( let (txs, tx_packet_index, _retryable_packet_indexes) =
&packets, BankingStage::transactions_from_packets(
&packet_indexes, &packets,
&features, &packet_indexes,
votes_only, &Arc::new(feature_set::FeatureSet::default()),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &RwLock::new(CostTracker::default()).read().unwrap(),
CostModel::default(), &BankingStageStats::default(),
))))), false,
&BankingStageStats::default(), votes_only,
false, &Arc::new(RwLock::new(CostModel::default())),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(2, txs.len()); assert_eq!(2, txs.len());
assert_eq!(vec![0, 2], tx_packet_index); assert_eq!(vec![0, 2], tx_packet_index);
} }
@ -3294,37 +3242,36 @@ mod tests {
vec![vote_tx.clone(), vote_tx.clone(), vote_tx], vec![vote_tx.clone(), vote_tx.clone(), vote_tx],
vote_indexes, vote_indexes,
); );
let features = Arc::new(feature_set::FeatureSet::default());
let mut votes_only = false; let mut votes_only = false;
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( let (txs, tx_packet_index, _retryable_packet_indexes) =
&packets, BankingStage::transactions_from_packets(
&packet_indexes, &packets,
&features, &packet_indexes,
votes_only, &Arc::new(feature_set::FeatureSet::default()),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &RwLock::new(CostTracker::default()).read().unwrap(),
CostModel::default(), &BankingStageStats::default(),
))))), false,
&BankingStageStats::default(), votes_only,
false, &Arc::new(RwLock::new(CostModel::default())),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(3, txs.len()); assert_eq!(3, txs.len());
assert_eq!(vec![0, 1, 2], tx_packet_index); assert_eq!(vec![0, 1, 2], tx_packet_index);
votes_only = true; votes_only = true;
let (txs, tx_packet_index, _) = BankingStage::transactions_from_packets( let (txs, tx_packet_index, _retryable_packet_indexes) =
&packets, BankingStage::transactions_from_packets(
&packet_indexes, &packets,
&features, &packet_indexes,
votes_only, &Arc::new(feature_set::FeatureSet::default()),
&Arc::new(RwLock::new(CostTracker::new(Arc::new(RwLock::new( &RwLock::new(CostTracker::default()).read().unwrap(),
CostModel::default(), &BankingStageStats::default(),
))))), false,
&BankingStageStats::default(), votes_only,
false, &Arc::new(RwLock::new(CostModel::default())),
&mut CostTrackerStats::default(), &mut CostTrackerStats::default(),
); );
assert_eq!(3, txs.len()); assert_eq!(3, txs.len());
assert_eq!(vec![0, 1, 2], tx_packet_index); assert_eq!(vec![0, 1, 2], tx_packet_index);
} }

4
core/src/tpu.rs
View File

@ -23,7 +23,6 @@ use solana_rpc::{
use solana_runtime::{ use solana_runtime::{
bank_forks::BankForks, bank_forks::BankForks,
cost_model::CostModel, cost_model::CostModel,
cost_tracker::CostTracker,
vote_sender_types::{ReplayVoteReceiver, ReplayVoteSender}, vote_sender_types::{ReplayVoteReceiver, ReplayVoteSender},
}; };
use std::{ use std::{
@ -123,7 +122,6 @@ impl Tpu {
cluster_confirmed_slot_sender, cluster_confirmed_slot_sender,
); );
let cost_tracker = Arc::new(RwLock::new(CostTracker::new(cost_model.clone())));
let banking_stage = BankingStage::new( let banking_stage = BankingStage::new(
cluster_info, cluster_info,
poh_recorder, poh_recorder,
@ -132,7 +130,7 @@ impl Tpu {
verified_gossip_vote_packets_receiver, verified_gossip_vote_packets_receiver,
transaction_status_sender, transaction_status_sender,
replay_vote_sender, replay_vote_sender,
cost_tracker, cost_model.clone(),
); );
let broadcast_stage = broadcast_type.new_broadcast_stage( let broadcast_stage = broadcast_type.new_broadcast_stage(

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

@ -745,18 +745,16 @@ fn compute_slot_cost(blockstore: &Blockstore, slot: Slot) -> Result<(), String>
let mut program_ids = HashMap::new(); let mut program_ids = HashMap::new();
let mut cost_model = CostModel::default(); let mut cost_model = CostModel::default();
cost_model.initialize_cost_table(&blockstore.read_program_costs().unwrap()); cost_model.initialize_cost_table(&blockstore.read_program_costs().unwrap());
let cost_model = Arc::new(RwLock::new(cost_model)); let mut cost_tracker = CostTracker::default();
let mut cost_tracker = CostTracker::new(cost_model.clone());
let mut cost_tracker_stats = CostTrackerStats::default(); let mut cost_tracker_stats = CostTrackerStats::default();
for entry in &entries { for entry in &entries {
transactions += entry.transactions.len(); transactions += entry.transactions.len();
let mut cost_model = cost_model.write().unwrap();
for transaction in &entry.transactions { for transaction in &entry.transactions {
programs += transaction.message().instructions.len(); programs += transaction.message().instructions.len();
let tx_cost = cost_model.calculate_cost(transaction, true); let tx_cost = cost_model.calculate_cost(transaction, true);
if cost_tracker if cost_tracker
.try_add(tx_cost, &mut cost_tracker_stats) .try_add(transaction, &tx_cost, &mut cost_tracker_stats)
.is_err() .is_err()
{ {
println!( println!(

13
runtime/src/bank.rs
View File

@ -44,6 +44,7 @@ use crate::{
ancestors::{Ancestors, AncestorsForSerialization}, ancestors::{Ancestors, AncestorsForSerialization},
blockhash_queue::BlockhashQueue, blockhash_queue::BlockhashQueue,
builtins::{self, ActivationType}, builtins::{self, ActivationType},
cost_tracker::CostTracker,
epoch_stakes::{EpochStakes, NodeVoteAccounts}, epoch_stakes::{EpochStakes, NodeVoteAccounts},
hashed_transaction::{HashedTransaction, HashedTransactionSlice}, hashed_transaction::{HashedTransaction, HashedTransactionSlice},
inline_spl_token_v2_0, inline_spl_token_v2_0,
@ -1038,6 +1039,8 @@ pub struct Bank {
pub freeze_started: AtomicBool, pub freeze_started: AtomicBool,
vote_only_bank: bool, vote_only_bank: bool,
pub cost_tracker: RwLock<CostTracker>,
} }
impl Default for BlockhashQueue { impl Default for BlockhashQueue {
@ -1306,6 +1309,7 @@ impl Bank {
.map(|drop_callback| drop_callback.clone_box()), .map(|drop_callback| drop_callback.clone_box()),
)), )),
freeze_started: AtomicBool::new(false), freeze_started: AtomicBool::new(false),
cost_tracker: RwLock::new(CostTracker::default()),
}; };
datapoint_info!( datapoint_info!(
@ -1496,6 +1500,7 @@ impl Bank {
drop_callback: RwLock::new(OptionalDropCallback(None)), drop_callback: RwLock::new(OptionalDropCallback(None)),
freeze_started: AtomicBool::new(fields.hash != Hash::default()), freeze_started: AtomicBool::new(fields.hash != Hash::default()),
vote_only_bank: false, vote_only_bank: false,
cost_tracker: RwLock::new(CostTracker::default()),
}; };
bank.finish_init( bank.finish_init(
genesis_config, genesis_config,
@ -5634,6 +5639,14 @@ impl Bank {
.is_active(&feature_set::send_to_tpu_vote_port::id()) .is_active(&feature_set::send_to_tpu_vote_port::id())
} }
pub fn read_cost_tracker(&self) -> LockResult<RwLockReadGuard<CostTracker>> {
self.cost_tracker.read()
}
pub fn write_cost_tracker(&self) -> LockResult<RwLockWriteGuard<CostTracker>> {
self.cost_tracker.write()
}
// Check if the wallclock time from bank creation to now has exceeded the allotted // Check if the wallclock time from bank creation to now has exceeded the allotted
// time for transaction processing // time for transaction processing
pub fn should_bank_still_be_processing_txs( pub fn should_bank_still_be_processing_txs(

58
runtime/src/cost_model.rs
View File

@ -11,19 +11,7 @@ use std::collections::HashMap;
const MAX_WRITABLE_ACCOUNTS: usize = 256; const MAX_WRITABLE_ACCOUNTS: usize = 256;
#[derive(Debug, Clone)] // costs are stored in number of 'compute unit's
pub enum CostModelError {
/// transaction that would fail sanitize, cost model is not able to process
/// such transaction.
InvalidTransaction,
/// would exceed block max limit
WouldExceedBlockMaxLimit,
/// would exceed account max limit
WouldExceedAccountMaxLimit,
}
#[derive(AbiExample, Default, Debug)] #[derive(AbiExample, Default, Debug)]
pub struct TransactionCost { pub struct TransactionCost {
pub writable_accounts: Vec<Pubkey>, pub writable_accounts: Vec<Pubkey>,
@ -59,9 +47,6 @@ pub struct CostModel {
account_cost_limit: u64, account_cost_limit: u64,
block_cost_limit: u64, block_cost_limit: u64,
instruction_execution_cost_table: ExecuteCostTable, instruction_execution_cost_table: ExecuteCostTable,
// reusable variables
transaction_cost: TransactionCost,
} }
impl Default for CostModel { impl Default for CostModel {
@ -71,12 +56,11 @@ impl Default for CostModel {
} }
impl CostModel { impl CostModel {
pub fn new(chain_max: u64, block_max: u64) -> Self { pub fn new(account_max: u64, block_max: u64) -> Self {
Self { Self {
account_cost_limit: chain_max, account_cost_limit: account_max,
block_cost_limit: block_max, block_cost_limit: block_max,
instruction_execution_cost_table: ExecuteCostTable::default(), instruction_execution_cost_table: ExecuteCostTable::default(),
transaction_cost: TransactionCost::new_with_capacity(MAX_WRITABLE_ACCOUNTS),
} }
} }
@ -119,22 +103,19 @@ impl CostModel {
} }
pub fn calculate_cost( pub fn calculate_cost(
&mut self, &self,
transaction: &Transaction, transaction: &Transaction,
demote_program_write_locks: bool, demote_program_write_locks: bool,
) -> &TransactionCost { ) -> TransactionCost {
self.transaction_cost.reset(); let mut tx_cost = TransactionCost::new_with_capacity(MAX_WRITABLE_ACCOUNTS);
self.transaction_cost.signature_cost = self.get_signature_cost(transaction); tx_cost.signature_cost = self.get_signature_cost(transaction);
self.get_write_lock_cost(transaction, demote_program_write_locks); self.get_write_lock_cost(&mut tx_cost, transaction, demote_program_write_locks);
self.transaction_cost.data_bytes_cost = self.get_data_bytes_cost(transaction); tx_cost.data_bytes_cost = self.get_data_bytes_cost(transaction);
self.transaction_cost.execution_cost = self.get_transaction_cost(transaction); tx_cost.execution_cost = self.get_transaction_cost(transaction);
debug!( debug!("transaction {:?} has cost {:?}", transaction, tx_cost);
"transaction {:?} has cost {:?}", tx_cost
transaction, self.transaction_cost
);
&self.transaction_cost
} }
pub fn upsert_instruction_cost( pub fn upsert_instruction_cost(
@ -158,14 +139,19 @@ impl CostModel {
transaction.signatures.len() as u64 * SIGNATURE_COST transaction.signatures.len() as u64 * SIGNATURE_COST
} }
fn get_write_lock_cost(&mut self, transaction: &Transaction, demote_program_write_locks: bool) { fn get_write_lock_cost(
&self,
tx_cost: &mut TransactionCost,
transaction: &Transaction,
demote_program_write_locks: bool,
) {
let message = transaction.message(); let message = transaction.message();
message.account_keys.iter().enumerate().for_each(|(i, k)| { message.account_keys.iter().enumerate().for_each(|(i, k)| {
let is_writable = message.is_writable(i, demote_program_write_locks); let is_writable = message.is_writable(i, demote_program_write_locks);
if is_writable { if is_writable {
self.transaction_cost.writable_accounts.push(*k); tx_cost.writable_accounts.push(*k);
self.transaction_cost.write_lock_cost += WRITE_LOCK_UNITS; tx_cost.write_lock_cost += WRITE_LOCK_UNITS;
} }
}); });
} }
@ -366,7 +352,7 @@ mod tests {
instructions, instructions,
); );
let mut cost_model = CostModel::default(); let cost_model = CostModel::default();
let tx_cost = cost_model.calculate_cost(&tx, /*demote_program_write_locks=*/ true); let tx_cost = cost_model.calculate_cost(&tx, /*demote_program_write_locks=*/ true);
assert_eq!(2 + 2, tx_cost.writable_accounts.len()); assert_eq!(2 + 2, tx_cost.writable_accounts.len());
assert_eq!(signer1.pubkey(), tx_cost.writable_accounts[0]); assert_eq!(signer1.pubkey(), tx_cost.writable_accounts[0]);
@ -472,7 +458,7 @@ mod tests {
}) })
} else { } else {
thread::spawn(move || { thread::spawn(move || {
let mut cost_model = cost_model.write().unwrap(); let cost_model = cost_model.write().unwrap();
let tx_cost = cost_model let tx_cost = cost_model
.calculate_cost(&tx, /*demote_program_write_locks=*/ true); .calculate_cost(&tx, /*demote_program_write_locks=*/ true);
assert_eq!(3, tx_cost.writable_accounts.len()); assert_eq!(3, tx_cost.writable_accounts.len());

180
runtime/src/cost_tracker.rs
View File

@ -1,22 +1,27 @@
//! `cost_tracker` keeps tracking transaction cost per chained accounts as well as for entire block //! `cost_tracker` keeps tracking transaction cost per chained accounts as well as for entire block
//! It aggregates `cost_model`, which provides service of calculating transaction cost.
//! The main functions are: //! The main functions are:
//! - would_transaction_fit(&tx), immutable function to test if `tx` would fit into current block //! - would_transaction_fit(&tx_cost), immutable function to test if tx with tx_cost would fit into current block
//! - add_transaction_cost(&tx), mutable function to accumulate `tx` cost to tracker. //! - add_transaction_cost(&tx_cost), mutable function to accumulate tx_cost to tracker.
//! //!
use crate::cost_model::{CostModel, TransactionCost}; use crate::block_cost_limits::*;
use crate::cost_model::TransactionCost;
use crate::cost_tracker_stats::CostTrackerStats; use crate::cost_tracker_stats::CostTrackerStats;
use solana_sdk::{clock::Slot, pubkey::Pubkey, transaction::Transaction}; use solana_sdk::{clock::Slot, pubkey::Pubkey, transaction::Transaction};
use std::{ use std::collections::HashMap;
collections::HashMap,
sync::{Arc, RwLock},
};
const WRITABLE_ACCOUNTS_PER_BLOCK: usize = 512; const WRITABLE_ACCOUNTS_PER_BLOCK: usize = 512;
#[derive(Debug, Clone)]
pub enum CostTrackerError {
/// would exceed block max limit
WouldExceedBlockMaxLimit,
/// would exceed account max limit
WouldExceedAccountMaxLimit,
}
#[derive(AbiExample, Debug)] #[derive(AbiExample, Debug)]
pub struct CostTracker { pub struct CostTracker {
cost_model: Arc<RwLock<CostModel>>,
account_cost_limit: u64, account_cost_limit: u64,
block_cost_limit: u64, block_cost_limit: u64,
current_bank_slot: Slot, current_bank_slot: Slot,
@ -26,22 +31,14 @@ pub struct CostTracker {
impl Default for CostTracker { impl Default for CostTracker {
fn default() -> Self { fn default() -> Self {
CostTracker::new(Arc::new(RwLock::new(CostModel::default()))) CostTracker::new(MAX_WRITABLE_ACCOUNT_UNITS, MAX_BLOCK_UNITS)
} }
} }
impl CostTracker { impl CostTracker {
pub fn new(cost_model: Arc<RwLock<CostModel>>) -> Self { pub fn new(account_cost_limit: u64, block_cost_limit: u64) -> Self {
let (account_cost_limit, block_cost_limit) = {
let cost_model = cost_model.read().unwrap();
(
cost_model.get_account_cost_limit(),
cost_model.get_block_cost_limit(),
)
};
assert!(account_cost_limit <= block_cost_limit); assert!(account_cost_limit <= block_cost_limit);
Self { Self {
cost_model,
account_cost_limit, account_cost_limit,
block_cost_limit, block_cost_limit,
current_bank_slot: 0, current_bank_slot: 0,
@ -50,65 +47,43 @@ impl CostTracker {
} }
} }
// bench tests needs to reset limits
pub fn set_limits(&mut self, account_cost_limit: u64, block_cost_limit: u64) {
self.account_cost_limit = account_cost_limit;
self.block_cost_limit = block_cost_limit;
}
pub fn would_transaction_fit( pub fn would_transaction_fit(
&self, &self,
transaction: &Transaction, _transaction: &Transaction,
demote_program_write_locks: bool, tx_cost: &TransactionCost,
stats: &mut CostTrackerStats, stats: &mut CostTrackerStats,
) -> Result<(), &'static str> { ) -> Result<(), CostTrackerError> {
let mut cost_model = self.cost_model.write().unwrap();
let tx_cost = cost_model.calculate_cost(transaction, demote_program_write_locks);
self.would_fit(&tx_cost.writable_accounts, &tx_cost.sum(), stats) self.would_fit(&tx_cost.writable_accounts, &tx_cost.sum(), stats)
} }
pub fn add_transaction_cost( pub fn add_transaction_cost(
&mut self, &mut self,
transaction: &Transaction, _transaction: &Transaction,
demote_program_write_locks: bool, tx_cost: &TransactionCost,
stats: &mut CostTrackerStats, stats: &mut CostTrackerStats,
) { ) {
let mut cost_model = self.cost_model.write().unwrap();
let tx_cost = cost_model.calculate_cost(transaction, demote_program_write_locks);
let cost = tx_cost.sum(); let cost = tx_cost.sum();
for account_key in tx_cost.writable_accounts.iter() { self.add_transaction(&tx_cost.writable_accounts, &cost);
*self
.cost_by_writable_accounts
.entry(*account_key)
.or_insert(0) += cost;
}
self.block_cost += cost;
stats.transaction_count += 1; stats.transaction_count += 1;
stats.block_cost += cost; stats.block_cost += cost;
} }
pub fn reset_if_new_bank(&mut self, slot: Slot, stats: &mut CostTrackerStats) -> bool {
// report stats when slot changes
if slot != stats.bank_slot {
stats.report();
*stats = CostTrackerStats::new(stats.id, slot);
}
if slot != self.current_bank_slot {
self.current_bank_slot = slot;
self.cost_by_writable_accounts.clear();
self.block_cost = 0;
true
} else {
false
}
}
pub fn try_add( pub fn try_add(
&mut self, &mut self,
transaction_cost: &TransactionCost, _transaction: &Transaction,
tx_cost: &TransactionCost,
stats: &mut CostTrackerStats, stats: &mut CostTrackerStats,
) -> Result<u64, &'static str> { ) -> Result<u64, CostTrackerError> {
let cost = transaction_cost.sum(); let cost = tx_cost.sum();
self.would_fit(&transaction_cost.writable_accounts, &cost, stats)?; self.would_fit(&tx_cost.writable_accounts, &cost, stats)?;
self.add_transaction(&tx_cost.writable_accounts, &cost);
self.add_transaction(&transaction_cost.writable_accounts, &cost);
Ok(self.block_cost) Ok(self.block_cost)
} }
@ -117,17 +92,17 @@ impl CostTracker {
keys: &[Pubkey], keys: &[Pubkey],
cost: &u64, cost: &u64,
stats: &mut CostTrackerStats, stats: &mut CostTrackerStats,
) -> Result<(), &'static str> { ) -> Result<(), CostTrackerError> {
stats.transaction_cost_histogram.increment(*cost).unwrap(); stats.transaction_cost_histogram.increment(*cost).unwrap();
// check against the total package cost // check against the total package cost
if self.block_cost + cost > self.block_cost_limit { if self.block_cost + cost > self.block_cost_limit {
return Err("would exceed block cost limit"); return Err(CostTrackerError::WouldExceedBlockMaxLimit);
} }
// check if the transaction itself is more costly than the account_cost_limit // check if the transaction itself is more costly than the account_cost_limit
if *cost > self.account_cost_limit { if *cost > self.account_cost_limit {
return Err("Transaction is too expansive, exceeds account cost limit"); return Err(CostTrackerError::WouldExceedAccountMaxLimit);
} }
// check each account against account_cost_limit, // check each account against account_cost_limit,
@ -140,7 +115,7 @@ impl CostTracker {
.unwrap(); .unwrap();
if chained_cost + cost > self.account_cost_limit { if chained_cost + cost > self.account_cost_limit {
return Err("would exceed account cost limit"); return Err(CostTrackerError::WouldExceedAccountMaxLimit);
} else { } else {
continue; continue;
} }
@ -234,7 +209,7 @@ mod tests {
#[test] #[test]
fn test_cost_tracker_initialization() { fn test_cost_tracker_initialization() {
let testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new(10, 11)))); let testee = CostTracker::new(10, 11);
assert_eq!(10, testee.account_cost_limit); assert_eq!(10, testee.account_cost_limit);
assert_eq!(11, testee.block_cost_limit); assert_eq!(11, testee.block_cost_limit);
assert_eq!(0, testee.cost_by_writable_accounts.len()); assert_eq!(0, testee.cost_by_writable_accounts.len());
@ -247,7 +222,7 @@ mod tests {
let (_tx, keys, cost) = build_simple_transaction(&mint_keypair, &start_hash); let (_tx, keys, cost) = build_simple_transaction(&mint_keypair, &start_hash);
// build testee to have capacity for one simple transaction // build testee to have capacity for one simple transaction
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new(cost, cost)))); let mut testee = CostTracker::new(cost, cost);
assert!(testee assert!(testee
.would_fit(&keys, &cost, &mut CostTrackerStats::default()) .would_fit(&keys, &cost, &mut CostTrackerStats::default())
.is_ok()); .is_ok());
@ -263,10 +238,7 @@ mod tests {
let (_tx2, keys2, cost2) = build_simple_transaction(&mint_keypair, &start_hash); let (_tx2, keys2, cost2) = build_simple_transaction(&mint_keypair, &start_hash);
// build testee to have capacity for two simple transactions, with same accounts // build testee to have capacity for two simple transactions, with same accounts
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new( let mut testee = CostTracker::new(cost1 + cost2, cost1 + cost2);
cost1 + cost2,
cost1 + cost2,
))));
{ {
assert!(testee assert!(testee
.would_fit(&keys1, &cost1, &mut CostTrackerStats::default()) .would_fit(&keys1, &cost1, &mut CostTrackerStats::default())
@ -292,10 +264,7 @@ mod tests {
let (_tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash); let (_tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
// build testee to have capacity for two simple transactions, with same accounts // build testee to have capacity for two simple transactions, with same accounts
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new( let mut testee = CostTracker::new(cmp::max(cost1, cost2), cost1 + cost2);
cmp::max(cost1, cost2),
cost1 + cost2,
))));
{ {
assert!(testee assert!(testee
.would_fit(&keys1, &cost1, &mut CostTrackerStats::default()) .would_fit(&keys1, &cost1, &mut CostTrackerStats::default())
@ -320,10 +289,7 @@ mod tests {
let (_tx2, keys2, cost2) = build_simple_transaction(&mint_keypair, &start_hash); let (_tx2, keys2, cost2) = build_simple_transaction(&mint_keypair, &start_hash);
// build testee to have capacity for two simple transactions, but not for same accounts // build testee to have capacity for two simple transactions, but not for same accounts
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new( let mut testee = CostTracker::new(cmp::min(cost1, cost2), cost1 + cost2);
cmp::min(cost1, cost2),
cost1 + cost2,
))));
// should have room for first transaction // should have room for first transaction
{ {
assert!(testee assert!(testee
@ -348,10 +314,7 @@ mod tests {
let (_tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash); let (_tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
// build testee to have capacity for each chain, but not enough room for both transactions // build testee to have capacity for each chain, but not enough room for both transactions
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new( let mut testee = CostTracker::new(cmp::max(cost1, cost2), cost1 + cost2 - 1);
cmp::max(cost1, cost2),
cost1 + cost2 - 1,
))));
// should have room for first transaction // should have room for first transaction
{ {
assert!(testee assert!(testee
@ -367,49 +330,11 @@ mod tests {
} }
} }
#[test]
fn test_cost_tracker_reset() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with same signed account
let (_tx1, keys1, cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let (_tx2, keys2, cost2) = build_simple_transaction(&mint_keypair, &start_hash);
// build testee to have capacity for two simple transactions, but not for same accounts
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new(
cmp::min(cost1, cost2),
cost1 + cost2,
))));
// should have room for first transaction
{
assert!(testee
.would_fit(&keys1, &cost1, &mut CostTrackerStats::default())
.is_ok());
testee.add_transaction(&keys1, &cost1);
assert_eq!(1, testee.cost_by_writable_accounts.len());
assert_eq!(cost1, testee.block_cost);
}
// but no more sapce on the same chain (same signer account)
{
assert!(testee
.would_fit(&keys2, &cost2, &mut CostTrackerStats::default())
.is_err());
}
// reset the tracker
{
testee.reset_if_new_bank(100, &mut CostTrackerStats::default());
assert_eq!(0, testee.cost_by_writable_accounts.len());
assert_eq!(0, testee.block_cost);
}
//now the second transaction can be added
{
assert!(testee
.would_fit(&keys2, &cost2, &mut CostTrackerStats::default())
.is_ok());
}
}
#[test] #[test]
fn test_cost_tracker_try_add_is_atomic() { fn test_cost_tracker_try_add_is_atomic() {
let (mint_keypair, start_hash) = test_setup();
let (tx, _keys, _cost) = build_simple_transaction(&mint_keypair, &start_hash);
let acct1 = Pubkey::new_unique(); let acct1 = Pubkey::new_unique();
let acct2 = Pubkey::new_unique(); let acct2 = Pubkey::new_unique();
let acct3 = Pubkey::new_unique(); let acct3 = Pubkey::new_unique();
@ -417,10 +342,7 @@ mod tests {
let account_max = cost * 2; let account_max = cost * 2;
let block_max = account_max * 3; // for three accts let block_max = account_max * 3; // for three accts
let mut testee = CostTracker::new(Arc::new(RwLock::new(CostModel::new( let mut testee = CostTracker::new(account_max, block_max);
account_max,
block_max,
))));
// case 1: a tx writes to 3 accounts, should success, we will have: // case 1: a tx writes to 3 accounts, should success, we will have:
// | acct1 | $cost | // | acct1 | $cost |
@ -434,7 +356,7 @@ mod tests {
..TransactionCost::default() ..TransactionCost::default()
}; };
assert!(testee assert!(testee
.try_add(&tx_cost, &mut CostTrackerStats::default()) .try_add(&tx, &tx_cost, &mut CostTrackerStats::default())
.is_ok()); .is_ok());
let stat = testee.get_stats(); let stat = testee.get_stats();
assert_eq!(cost, stat.total_cost); assert_eq!(cost, stat.total_cost);
@ -454,7 +376,7 @@ mod tests {
..TransactionCost::default() ..TransactionCost::default()
}; };
assert!(testee assert!(testee
.try_add(&tx_cost, &mut CostTrackerStats::default()) .try_add(&tx, &tx_cost, &mut CostTrackerStats::default())
.is_ok()); .is_ok());
let stat = testee.get_stats(); let stat = testee.get_stats();
assert_eq!(cost * 2, stat.total_cost); assert_eq!(cost * 2, stat.total_cost);
@ -476,7 +398,7 @@ mod tests {
..TransactionCost::default() ..TransactionCost::default()
}; };
assert!(testee assert!(testee
.try_add(&tx_cost, &mut CostTrackerStats::default()) .try_add(&tx, &tx_cost, &mut CostTrackerStats::default())
.is_err()); .is_err());
let stat = testee.get_stats(); let stat = testee.get_stats();
assert_eq!(cost * 2, stat.total_cost); assert_eq!(cost * 2, stat.total_cost);