use {
solana_measure::measure,
solana_sdk::{clock::Slot, pubkey::Pubkey, saturating_add_assign},
std::collections::HashMap,
};
#[derive(Debug, Default)]
struct PrioritizationFeeMetrics {
total_writable_accounts_count: u64,
relevant_writable_accounts_count: u64,
prioritized_transactions_count: u64,
non_prioritized_transactions_count: u64,
total_prioritization_fee: u64,
min_prioritization_fee: Option<u64>,
max_prioritization_fee: u64,
total_update_elapsed_us: u64,
}
impl PrioritizationFeeMetrics {
fn accumulate_total_prioritization_fee(&mut self, val: u64) {
saturating_add_assign!(self.total_prioritization_fee, val);
}
fn accumulate_total_update_elapsed_us(&mut self, val: u64) {
saturating_add_assign!(self.total_update_elapsed_us, val);
}
fn update_prioritization_fee(&mut self, fee: u64) {
if fee == 0 {
saturating_add_assign!(self.non_prioritized_transactions_count, 1);
return;
}
saturating_add_assign!(self.prioritized_transactions_count, 1);
self.max_prioritization_fee = self.max_prioritization_fee.max(fee);
self.min_prioritization_fee = Some(
self.min_prioritization_fee
.map_or(fee, |min_fee| min_fee.min(fee)),
);
}
fn report(&self, slot: Slot) {
datapoint_info!(
"block_prioritization_fee",
("slot", slot as i64, i64),
(
"total_writable_accounts_count",
self.total_writable_accounts_count as i64,
i64
),
(
"relevant_writable_accounts_count",
self.relevant_writable_accounts_count as i64,
i64
),
(
"prioritized_transactions_count",
self.prioritized_transactions_count as i64,
i64
),
(
"non_prioritized_transactions_count",
self.non_prioritized_transactions_count as i64,
i64
),
(
"total_prioritization_fee",
self.total_prioritization_fee as i64,
i64
),
(
"min_prioritization_fee",
self.min_prioritization_fee.unwrap_or(0) as i64,
i64
),
(
"max_prioritization_fee",
self.max_prioritization_fee as i64,
i64
),
(
"total_update_elapsed_us",
self.total_update_elapsed_us as i64,
i64
),
);
}
}
pub enum PrioritizationFeeError {
FailGetTransactionAccountLocks,
FailGetTransactionPriorityDetails,
BlockIsAlreadyFinalized,
}
#[derive(Debug)]
pub struct PrioritizationFee {
min_transaction_fee: u64,
min_writable_account_fees: HashMap<Pubkey, u64>,
is_finalized: bool,
metrics: PrioritizationFeeMetrics,
}
impl Default for PrioritizationFee {
fn default() -> Self {
PrioritizationFee {
min_transaction_fee: u64::MAX,
min_writable_account_fees: HashMap::new(),
is_finalized: false,
metrics: PrioritizationFeeMetrics::default(),
}
}
}
impl PrioritizationFee {
pub fn update(
&mut self,
transaction_fee: u64,
writable_accounts: &[Pubkey],
) -> Result<(), PrioritizationFeeError> {
let (_, update_time) = measure!(
{
if transaction_fee < self.min_transaction_fee {
self.min_transaction_fee = transaction_fee;
}
for write_account in writable_accounts.iter() {
self.min_writable_account_fees
.entry(*write_account)
.and_modify(|write_lock_fee| {
*write_lock_fee = std::cmp::min(*write_lock_fee, transaction_fee)
})
.or_insert(transaction_fee);
}
self.metrics
.accumulate_total_prioritization_fee(transaction_fee);
self.metrics.update_prioritization_fee(transaction_fee);
},
"update_time",
);
self.metrics
.accumulate_total_update_elapsed_us(update_time.as_us());
Ok(())
}
fn prune_irrelevant_writable_accounts(&mut self) {
self.metrics.total_writable_accounts_count = self.get_writable_accounts_count() as u64;
self.min_writable_account_fees
.retain(|_, account_fee| account_fee > &mut self.min_transaction_fee);
self.metrics.relevant_writable_accounts_count = self.get_writable_accounts_count() as u64;
}
pub fn mark_block_completed(&mut self) -> Result<(), PrioritizationFeeError> {
if self.is_finalized {
return Err(PrioritizationFeeError::BlockIsAlreadyFinalized);
}
self.prune_irrelevant_writable_accounts();
self.is_finalized = true;
Ok(())
}
pub fn get_min_transaction_fee(&self) -> Option<u64> {
(self.min_transaction_fee != u64::MAX).then_some(self.min_transaction_fee)
}
pub fn get_writable_account_fee(&self, key: &Pubkey) -> Option<u64> {
self.min_writable_account_fees.get(key).copied()
}
pub fn get_writable_account_fees(&self) -> impl Iterator<Item = (&Pubkey, &u64)> {
self.min_writable_account_fees.iter()
}
pub fn get_writable_accounts_count(&self) -> usize {
self.min_writable_account_fees.len()
}
pub fn is_finalized(&self) -> bool {
self.is_finalized
}
pub fn report_metrics(&self, slot: Slot) {
self.metrics.report(slot);
let min_transaction_fee = self.get_min_transaction_fee().unwrap_or(0);
let mut accounts_fees: Vec<_> = self.get_writable_account_fees().collect();
accounts_fees.sort_by(|lh, rh| rh.1.cmp(lh.1));
datapoint_info!(
"block_min_prioritization_fee",
("slot", slot as i64, i64),
("entity", "block", String),
("min_prioritization_fee", min_transaction_fee as i64, i64),
);
for (account_key, fee) in accounts_fees.iter().take(10) {
datapoint_info!(
"block_min_prioritization_fee",
("slot", slot as i64, i64),
("entity", account_key.to_string(), String),
("min_prioritization_fee", **fee as i64, i64),
);
}
}
}
#[cfg(test)]
mod tests {
use {super::*, solana_sdk::pubkey::Pubkey};
#[test]
fn test_update_prioritization_fee() {
solana_logger::setup();
let write_account_a = Pubkey::new_unique();
let write_account_b = Pubkey::new_unique();
let write_account_c = Pubkey::new_unique();
let mut prioritization_fee = PrioritizationFee::default();
assert!(prioritization_fee.get_min_transaction_fee().is_none());
{
assert!(prioritization_fee
.update(5, &[write_account_a, write_account_b])
.is_ok());
assert_eq!(5, prioritization_fee.get_min_transaction_fee().unwrap());
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_a)
.unwrap()
);
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_b)
.unwrap()
);
assert!(prioritization_fee
.get_writable_account_fee(&write_account_c)
.is_none());
}
{
assert!(prioritization_fee
.update(9, &[write_account_b, write_account_c])
.is_ok());
assert_eq!(5, prioritization_fee.get_min_transaction_fee().unwrap());
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_a)
.unwrap()
);
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_b)
.unwrap()
);
assert_eq!(
9,
prioritization_fee
.get_writable_account_fee(&write_account_c)
.unwrap()
);
}
{
assert!(prioritization_fee
.update(2, &[write_account_a, write_account_c])
.is_ok());
assert_eq!(2, prioritization_fee.get_min_transaction_fee().unwrap());
assert_eq!(
2,
prioritization_fee
.get_writable_account_fee(&write_account_a)
.unwrap()
);
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_b)
.unwrap()
);
assert_eq!(
2,
prioritization_fee
.get_writable_account_fee(&write_account_c)
.unwrap()
);
}
{
prioritization_fee.prune_irrelevant_writable_accounts();
assert_eq!(1, prioritization_fee.min_writable_account_fees.len());
assert_eq!(2, prioritization_fee.get_min_transaction_fee().unwrap());
assert!(prioritization_fee
.get_writable_account_fee(&write_account_a)
.is_none());
assert_eq!(
5,
prioritization_fee
.get_writable_account_fee(&write_account_b)
.unwrap()
);
assert!(prioritization_fee
.get_writable_account_fee(&write_account_c)
.is_none());
}
}
#[test]
fn test_mark_block_completed() {
let mut prioritization_fee = PrioritizationFee::default();
assert!(prioritization_fee.mark_block_completed().is_ok());
assert!(prioritization_fee.mark_block_completed().is_err());
}
}