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

- Only commit successfully executed transactions' cost to cost_tracker;

Browse Source 
- In-fly transactions are pended in cost_tracker until being committed
  or cancelled;
This commit is contained in:
Tao Zhu
2022-04-07 15:42:39 -05:00
committed by Tao Zhu
parent 2e5042d8bd
commit 9e07272af8
6 changed files with 249 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
runtime/src/cost_tracker.rs
View File

@@ -1,11 +1,13 @@
//! `cost_tracker` keeps tracking transaction cost per chained accounts as well as for entire block
//! The main functions are:
//! - would_transaction_fit(&tx_cost), immutable function to test if tx with tx_cost would fit into current block
//! - add_transaction_cost(&tx_cost), mutable function to accumulate tx_cost to tracker.
//! - would_fit(&tx_cost), immutable function to test if tx with tx_cost would fit into current block
//! - add_transaction(&tx_cost), mutable function to accumulate tx_cost to tracker.
//!
use {
crate::{block_cost_limits::*, cost_model::TransactionCost},
solana_sdk::{clock::Slot, pubkey::Pubkey, transaction::SanitizedTransaction},
solana_sdk::{
clock::Slot, pubkey::Pubkey, signature::Signature, transaction::SanitizedTransaction,
},
std::collections::HashMap,
};
@@ -43,6 +45,12 @@ pub struct CostTracker {
/// The amount of total account data size remaining. If `Some`, then do not add transactions
/// that would cause `account_data_size` to exceed this limit.
account_data_size_limit: Option<u64>,
// Transactions have passed would_fit check, is being executed.
// If the execution is successful, it's actual Units can be committed
// to cost_tracker; otherwise, it should be removed without impacting
// cost_tracker.
pending_transactions: HashMap<Signature, TransactionCost>,
}
impl Default for CostTracker {
@@ -63,6 +71,7 @@ impl Default for CostTracker {
transaction_count: 0,
account_data_size: 0,
account_data_size_limit: None,
pending_transactions: HashMap::new(),
}
}
}
@@ -89,53 +98,35 @@ impl CostTracker {
self.vote_cost_limit = vote_cost_limit;
}
pub fn would_transaction_fit(
&self,
transaction: &SanitizedTransaction,
tx_cost: &TransactionCost,
) -> Result<(), CostTrackerError> {
self.would_fit(
&tx_cost.writable_accounts,
tx_cost.sum(),
tx_cost.account_data_size,
transaction,
)
}
pub fn add_transaction_cost(
&mut self,
transaction: &SanitizedTransaction,
tx_cost: &TransactionCost,
) {
self.add_transaction(
&tx_cost.writable_accounts,
tx_cost.sum(),
tx_cost.account_data_size,
transaction,
);
}
pub fn try_add(
&mut self,
transaction: &SanitizedTransaction,
tx_cost: &TransactionCost,
) -> Result<u64, CostTrackerError> {
let cost = tx_cost.sum();
self.would_fit(
&tx_cost.writable_accounts,
cost,
tx_cost.account_data_size,
transaction,
)?;
self.add_transaction(
&tx_cost.writable_accounts,
cost,
tx_cost.account_data_size,
transaction,
);
self.would_fit(tx_cost)?;
self.pending_transactions
.insert(*transaction.signature(), tx_cost.clone());
Ok(self.block_cost)
}
pub fn commit_transaction(
&mut self,
transaction: &SanitizedTransaction,
actual_units: Option<u64>,
) {
if let Some(mut tx_cost) = self.pending_transactions.remove(transaction.signature()) {
if let Some(actual_units) = actual_units {
// using actual units to update cost tracker if available
tx_cost.execution_cost = actual_units;
}
self.add_transaction(&tx_cost);
}
}
pub fn cancel_transaction(&mut self, transaction: &SanitizedTransaction) {
self.pending_transactions.remove(transaction.signature());
}
pub fn report_stats(&self, bank_slot: Slot) {
// skip reporting if block is empty
if self.transaction_count == 0 {
@@ -174,12 +165,34 @@ impl CostTracker {
(costliest_account, costliest_account_cost)
}
fn would_fit(
fn would_fit(&self, tx_cost: &TransactionCost) -> Result<(), CostTrackerError> {
let mut writable_account = vec![];
writable_account.extend(&tx_cost.writable_accounts);
let mut cost = tx_cost.sum();
let mut account_data_size = tx_cost.account_data_size;
let mut vote_cost = if tx_cost.is_simple_vote { cost } else { 0 };
for tx_cost in self.pending_transactions.values() {
writable_account.extend(&tx_cost.writable_accounts);
cost = cost.saturating_add(tx_cost.sum());
account_data_size = account_data_size.saturating_add(tx_cost.account_data_size);
vote_cost = vote_cost.saturating_add(if tx_cost.is_simple_vote { cost } else { 0 });
}
self.would_aggregated_transactions_fit(
&writable_account,
cost,
account_data_size,
vote_cost,
)
}
fn would_aggregated_transactions_fit(
&self,
keys: &[Pubkey],
cost: u64,
account_data_len: u64,
transaction: &SanitizedTransaction,
vote_cost: u64,
) -> Result<(), CostTrackerError> {
// check against the total package cost
if self.block_cost.saturating_add(cost) > self.block_cost_limit {
@@ -187,9 +200,7 @@ impl CostTracker {
}
// if vote transaction, check if it exceeds vote_transaction_limit
if transaction.is_simple_vote_transaction()
&& self.vote_cost.saturating_add(cost) > self.vote_cost_limit
{
if self.vote_cost.saturating_add(vote_cost) > self.vote_cost_limit {
return Err(CostTrackerError::WouldExceedVoteMaxLimit);
}
@@ -228,14 +239,9 @@ impl CostTracker {
Ok(())
}
fn add_transaction(
&mut self,
keys: &[Pubkey],
cost: u64,
account_data_size: u64,
transaction: &SanitizedTransaction,
) {
for account_key in keys.iter() {
fn add_transaction(&mut self, tx_cost: &TransactionCost) {
let cost = tx_cost.sum();
for account_key in tx_cost.writable_accounts.iter() {
let account_cost = self
.cost_by_writable_accounts
.entry(*account_key)
@@ -243,10 +249,12 @@ impl CostTracker {
*account_cost = account_cost.saturating_add(cost);
}
self.block_cost = self.block_cost.saturating_add(cost);
if transaction.is_simple_vote_transaction() {
if tx_cost.is_simple_vote {
self.vote_cost = self.vote_cost.saturating_add(cost);
}
self.account_data_size = self.account_data_size.saturating_add(account_data_size);
self.account_data_size = self
.account_data_size
.saturating_add(tx_cost.account_data_size);
self.transaction_count = self.transaction_count.saturating_add(1);
}
}
@@ -303,19 +311,22 @@ mod tests {
fn build_simple_transaction(
mint_keypair: &Keypair,
start_hash: &Hash,
) -> (SanitizedTransaction, Vec<Pubkey>, u64) {
) -> (SanitizedTransaction, TransactionCost) {
let keypair = Keypair::new();
let simple_transaction = SanitizedTransaction::from_transaction_for_tests(
system_transaction::transfer(mint_keypair, &keypair.pubkey(), 2, *start_hash),
);
let mut tx_cost = TransactionCost::new_with_capacity(1);
tx_cost.execution_cost = 5;
tx_cost.writable_accounts.push(mint_keypair.pubkey());
(simple_transaction, vec![mint_keypair.pubkey()], 5)
(simple_transaction, tx_cost)
}
fn build_simple_vote_transaction(
mint_keypair: &Keypair,
start_hash: &Hash,
) -> (SanitizedTransaction, Vec<Pubkey>, u64) {
) -> (SanitizedTransaction, TransactionCost) {
let keypair = Keypair::new();
let transaction = vote_transaction::new_vote_transaction(
vec![42],
@@ -333,7 +344,12 @@ mod tests {
SimpleAddressLoader::Disabled,
)
.unwrap();
(vote_transaction, vec![mint_keypair.pubkey()], 10)
let mut tx_cost = TransactionCost::new_with_capacity(1);
tx_cost.execution_cost = 10;
tx_cost.writable_accounts.push(mint_keypair.pubkey());
tx_cost.is_simple_vote = true;
(vote_transaction, tx_cost)
}
#[test]
@@ -349,12 +365,13 @@ mod tests {
#[test]
fn test_cost_tracker_ok_add_one() {
let (mint_keypair, start_hash) = test_setup();
let (tx, keys, cost) = build_simple_transaction(&mint_keypair, &start_hash);
let (_tx, tx_cost) = build_simple_transaction(&mint_keypair, &start_hash);
let cost = tx_cost.sum();
// build testee to have capacity for one simple transaction
let mut testee = CostTracker::new(cost, cost, cost, None);
assert!(testee.would_fit(&keys, cost, 0, &tx).is_ok());
testee.add_transaction(&keys, cost, 0, &tx);
assert!(testee.would_fit(&tx_cost).is_ok());
testee.add_transaction(&tx_cost);
assert_eq!(cost, testee.block_cost);
assert_eq!(0, testee.vote_cost);
let (_costliest_account, costliest_account_cost) = testee.find_costliest_account();
@@ -364,12 +381,13 @@ mod tests {
#[test]
fn test_cost_tracker_ok_add_one_vote() {
let (mint_keypair, start_hash) = test_setup();
let (tx, keys, cost) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let (_tx, tx_cost) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let cost = tx_cost.sum();
// build testee to have capacity for one simple transaction
let mut testee = CostTracker::new(cost, cost, cost, None);
assert!(testee.would_fit(&keys, cost, 0, &tx).is_ok());
testee.add_transaction(&keys, cost, 0, &tx);
assert!(testee.would_fit(&tx_cost).is_ok());
testee.add_transaction(&tx_cost);
assert_eq!(cost, testee.block_cost);
assert_eq!(cost, testee.vote_cost);
let (_costliest_account, costliest_account_cost) = testee.find_costliest_account();
@@ -379,13 +397,15 @@ mod tests {
#[test]
fn test_cost_tracker_add_data() {
let (mint_keypair, start_hash) = test_setup();
let (tx, keys, cost) = build_simple_transaction(&mint_keypair, &start_hash);
let (_tx, mut tx_cost) = build_simple_transaction(&mint_keypair, &start_hash);
tx_cost.account_data_size = 1;
let cost = tx_cost.sum();
// build testee to have capacity for one simple transaction
let mut testee = CostTracker::new(cost, cost, cost, None);
assert!(testee.would_fit(&keys, cost, 0, &tx).is_ok());
assert!(testee.would_fit(&tx_cost).is_ok());
let old = testee.account_data_size;
testee.add_transaction(&keys, cost, 1, &tx);
testee.add_transaction(&tx_cost);
assert_eq!(old + 1, testee.account_data_size);
}
@@ -393,18 +413,20 @@ mod tests {
fn test_cost_tracker_ok_add_two_same_accounts() {
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);
let (_tx1, tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let cost1 = tx_cost1.sum();
let (_tx2, tx_cost2) = build_simple_transaction(&mint_keypair, &start_hash);
let cost2 = tx_cost2.sum();
// build testee to have capacity for two simple transactions, with same accounts
let mut testee = CostTracker::new(cost1 + cost2, cost1 + cost2, cost1 + cost2, None);
{
assert!(testee.would_fit(&keys1, cost1, 0, &tx1).is_ok());
testee.add_transaction(&keys1, cost1, 0, &tx1);
assert!(testee.would_fit(&tx_cost1).is_ok());
testee.add_transaction(&tx_cost1);
}
{
assert!(testee.would_fit(&keys2, cost2, 0, &tx2).is_ok());
testee.add_transaction(&keys2, cost2, 0, &tx2);
assert!(testee.would_fit(&tx_cost2).is_ok());
testee.add_transaction(&tx_cost2);
}
assert_eq!(cost1 + cost2, testee.block_cost);
assert_eq!(1, testee.cost_by_writable_accounts.len());
@@ -416,20 +438,22 @@ mod tests {
fn test_cost_tracker_ok_add_two_diff_accounts() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with diff accounts
let (tx1, keys1, cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let second_account = Keypair::new();
let (tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
let (_tx1, tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let cost1 = tx_cost1.sum();
let (_tx2, tx_cost2) = build_simple_transaction(&second_account, &start_hash);
let cost2 = tx_cost2.sum();
// build testee to have capacity for two simple transactions, with same accounts
let mut testee =
CostTracker::new(cmp::max(cost1, cost2), cost1 + cost2, cost1 + cost2, None);
{
assert!(testee.would_fit(&keys1, cost1, 0, &tx1).is_ok());
testee.add_transaction(&keys1, cost1, 0, &tx1);
assert!(testee.would_fit(&tx_cost1).is_ok());
testee.add_transaction(&tx_cost1);
}
{
assert!(testee.would_fit(&keys2, cost2, 0, &tx2).is_ok());
testee.add_transaction(&keys2, cost2, 0, &tx2);
assert!(testee.would_fit(&tx_cost2).is_ok());
testee.add_transaction(&tx_cost2);
}
assert_eq!(cost1 + cost2, testee.block_cost);
assert_eq!(2, testee.cost_by_writable_accounts.len());
@@ -441,20 +465,22 @@ mod tests {
fn test_cost_tracker_chain_reach_limit() {
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);
let (_tx1, tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let cost1 = tx_cost1.sum();
let (_tx2, tx_cost2) = build_simple_transaction(&mint_keypair, &start_hash);
let cost2 = tx_cost2.sum();
// build testee to have capacity for two simple transactions, but not for same accounts
let mut testee =
CostTracker::new(cmp::min(cost1, cost2), cost1 + cost2, cost1 + cost2, None);
// should have room for first transaction
{
assert!(testee.would_fit(&keys1, cost1, 0, &tx1).is_ok());
testee.add_transaction(&keys1, cost1, 0, &tx1);
assert!(testee.would_fit(&tx_cost1).is_ok());
testee.add_transaction(&tx_cost1);
}
// but no more sapce on the same chain (same signer account)
{
assert!(testee.would_fit(&keys2, cost2, 0, &tx2).is_err());
assert!(testee.would_fit(&tx_cost2).is_err());
}
}
@@ -462,9 +488,11 @@ mod tests {
fn test_cost_tracker_reach_limit() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with diff accounts
let (tx1, keys1, cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let second_account = Keypair::new();
let (tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
let (_tx1, tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let cost1 = tx_cost1.sum();
let (_tx2, tx_cost2) = build_simple_transaction(&second_account, &start_hash);
let cost2 = tx_cost2.sum();
// build testee to have capacity for each chain, but not enough room for both transactions
let mut testee = CostTracker::new(
@@ -475,12 +503,12 @@ mod tests {
);
// should have room for first transaction
{
assert!(testee.would_fit(&keys1, cost1, 0, &tx1).is_ok());
testee.add_transaction(&keys1, cost1, 0, &tx1);
assert!(testee.would_fit(&tx_cost1).is_ok());
testee.add_transaction(&tx_cost1);
}
// but no more room for package as whole
{
assert!(testee.would_fit(&keys2, cost2, 0, &tx2).is_err());
assert!(testee.would_fit(&tx_cost2).is_err());
}
}
@@ -488,9 +516,11 @@ mod tests {
fn test_cost_tracker_reach_vote_limit() {
let (mint_keypair, start_hash) = test_setup();
// build two mocking vote transactions with diff accounts
let (tx1, keys1, cost1) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let second_account = Keypair::new();
let (tx2, keys2, cost2) = build_simple_vote_transaction(&second_account, &start_hash);
let (_tx1, tx_cost1) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let (_tx2, tx_cost2) = build_simple_vote_transaction(&second_account, &start_hash);
let cost1 = tx_cost1.sum();
let cost2 = tx_cost2.sum();
// build testee to have capacity for each chain, but not enough room for both votes
let mut testee = CostTracker::new(
@@ -501,18 +531,18 @@ mod tests {
);
// should have room for first vote
{
assert!(testee.would_fit(&keys1, cost1, 0, &tx1).is_ok());
testee.add_transaction(&keys1, cost1, 0, &tx1);
assert!(testee.would_fit(&tx_cost1).is_ok());
testee.add_transaction(&tx_cost1);
}
// but no more room for package as whole
{
assert!(testee.would_fit(&keys2, cost2, 0, &tx2).is_err());
assert!(testee.would_fit(&tx_cost2).is_err());
}
// however there is room for none-vote tx3
{
let third_account = Keypair::new();
let (tx3, keys3, cost3) = build_simple_transaction(&third_account, &start_hash);
assert!(testee.would_fit(&keys3, cost3, 0, &tx3).is_ok());
let (_tx3, tx_cost3) = build_simple_transaction(&third_account, &start_hash);
assert!(testee.would_fit(&tx_cost3).is_ok());
}
}
@@ -520,9 +550,13 @@ mod tests {
fn test_cost_tracker_reach_data_block_limit() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with diff accounts
let (tx1, keys1, cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let second_account = Keypair::new();
let (tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
let (_tx1, mut tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let (_tx2, mut tx_cost2) = build_simple_transaction(&second_account, &start_hash);
tx_cost1.account_data_size = MAX_ACCOUNT_DATA_BLOCK_LEN;
tx_cost2.account_data_size = MAX_ACCOUNT_DATA_BLOCK_LEN + 1;
let cost1 = tx_cost1.sum();
let cost2 = tx_cost2.sum();
// build testee that passes
let testee = CostTracker::new(
@@ -531,12 +565,10 @@ mod tests {
cost1 + cost2 - 1,
None,
);
assert!(testee
.would_fit(&keys1, cost1, MAX_ACCOUNT_DATA_BLOCK_LEN, &tx1)
.is_ok());
assert!(testee.would_fit(&tx_cost1).is_ok());
// data is too big
assert_eq!(
testee.would_fit(&keys2, cost2, MAX_ACCOUNT_DATA_BLOCK_LEN + 1, &tx2),
testee.would_fit(&tx_cost2),
Err(CostTrackerError::WouldExceedAccountDataBlockLimit),
);
}
@@ -545,33 +577,70 @@ mod tests {
fn test_cost_tracker_reach_data_total_limit() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with diff accounts
let (tx1, keys1, cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let second_account = Keypair::new();
let (tx2, keys2, cost2) = build_simple_transaction(&second_account, &start_hash);
let (_tx1, mut tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let (_tx2, mut tx_cost2) = build_simple_transaction(&second_account, &start_hash);
let remaining_account_data_size = 1234;
tx_cost1.account_data_size = remaining_account_data_size;
tx_cost2.account_data_size = remaining_account_data_size + 1;
let cost1 = tx_cost1.sum();
let cost2 = tx_cost2.sum();
// build testee that passes
let remaining_account_data_size = 1234;
let testee = CostTracker::new(
cmp::max(cost1, cost2),
cost1 + cost2 - 1,
cost1 + cost2 - 1,
Some(remaining_account_data_size),
);
assert!(testee
.would_fit(&keys1, cost1, remaining_account_data_size, &tx1)
.is_ok());
assert!(testee.would_fit(&tx_cost1).is_ok());
// data is too big
assert_eq!(
testee.would_fit(&keys2, cost2, remaining_account_data_size + 1, &tx2),
testee.would_fit(&tx_cost2),
Err(CostTrackerError::WouldExceedAccountDataTotalLimit),
);
}
#[test]
fn test_cost_tracker_commit_and_cancel() {
let (mint_keypair, start_hash) = test_setup();
// build two transactions with diff accounts
let second_account = Keypair::new();
let (tx1, tx_cost1) = build_simple_transaction(&mint_keypair, &start_hash);
let (tx2, tx_cost2) = build_simple_transaction(&second_account, &start_hash);
let cost1 = tx_cost1.sum();
let cost2 = tx_cost2.sum();
// build testee
let mut testee = CostTracker::new(cost1 + cost2, cost1 + cost2, cost1 + cost2, None);
assert!(testee.try_add(&tx1, &tx_cost1).is_ok());
assert!(testee.try_add(&tx2, &tx_cost2).is_ok());
// assert the block cost is still zero
assert_eq!(0, testee.block_cost);
// assert tx1 cost applied to tracker if committed
testee.commit_transaction(&tx1, None);
assert_eq!(cost1, testee.block_cost);
// assert tx2 cost will not be applied to tracker if cancelled
testee.cancel_transaction(&tx2);
assert_eq!(cost1, testee.block_cost);
// still can add tx2
assert!(testee.try_add(&tx2, &tx_cost2).is_ok());
// cannot add tx1 while tx2 is pending
assert!(testee.try_add(&tx1, &tx_cost1).is_err());
// after commit tx2, the block will have both tx1 and tx2
testee.commit_transaction(&tx2, None);
assert_eq!(cost1 + cost2, testee.block_cost);
}
#[test]
fn test_cost_tracker_try_add_is_atomic() {
let (mint_keypair, start_hash) = test_setup();
// build two mocking vote transactions with diff accounts
let (tx1, _keys1, _cost1) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let (tx1, _tx_cost1) = build_simple_vote_transaction(&mint_keypair, &start_hash);
let acct1 = Pubkey::new_unique();
let acct2 = Pubkey::new_unique();
@@ -594,6 +663,7 @@ mod tests {
..TransactionCost::default()
};
assert!(testee.try_add(&tx1, &tx_cost).is_ok());
testee.commit_transaction(&tx1, None);
let (_costliest_account, costliest_account_cost) = testee.find_costliest_account();
assert_eq!(cost, testee.block_cost);
assert_eq!(3, testee.cost_by_writable_accounts.len());
@@ -612,6 +682,7 @@ mod tests {
..TransactionCost::default()
};
assert!(testee.try_add(&tx1, &tx_cost).is_ok());
testee.commit_transaction(&tx1, None);
let (costliest_account, costliest_account_cost) = testee.find_costliest_account();
assert_eq!(cost * 2, testee.block_cost);
assert_eq!(3, testee.cost_by_writable_accounts.len());
@@ -632,6 +703,7 @@ mod tests {
..TransactionCost::default()
};
assert!(testee.try_add(&tx1, &tx_cost).is_err());
testee.commit_transaction(&tx1, None);
let (costliest_account, costliest_account_cost) = testee.find_costliest_account();
assert_eq!(cost * 2, testee.block_cost);
assert_eq!(3, testee.cost_by_writable_accounts.len());