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

Remove feature set from compute budget processor (#34472) 

remove feature_set from compute_budget_processor
This commit is contained in:
Tao Zhu 2023-12-15 15:01:02 -06:00 committed by GitHub
parent 7360f48eb5
commit 86c88d7ff6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 29 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cost-model/src/cost_model.rs
View File

@ -115,10 +115,8 @@ impl CostModel {
// if failed to process compute_budget instructions, the transaction will not be executed
// by `bank`, therefore it should be considered as no execution cost by cost model.
match process_compute_budget_instructions(
transaction.message().program_instructions_iter(),
feature_set,
) {
match process_compute_budget_instructions(transaction.message().program_instructions_iter())
{
Ok(compute_budget_limits) => {
// if tx contained user-space instructions and a more accurate estimate available correct it,
// where "user-space instructions" must be specifically checked by

8
program-runtime/src/compute_budget.rs
View File

@ -1,9 +1,6 @@
use {
crate::compute_budget_processor::{self, process_compute_budget_instructions},
solana_sdk::{
feature_set::FeatureSet, instruction::CompiledInstruction, pubkey::Pubkey,
transaction::Result,
},
solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey, transaction::Result},
};
#[cfg(RUSTC_WITH_SPECIALIZATION)]
@ -183,9 +180,8 @@ impl ComputeBudget {
pub fn try_from_instructions<'a>(
instructions: impl Iterator<Item = (&'a Pubkey, &'a CompiledInstruction)>,
feature_set: &FeatureSet,
) -> Result<Self> {
let compute_budget_limits = process_compute_budget_instructions(instructions, feature_set)?;
let compute_budget_limits = process_compute_budget_instructions(instructions)?;
Ok(ComputeBudget {
compute_unit_limit: u64::from(compute_budget_limits.compute_unit_limit),
heap_size: compute_budget_limits.updated_heap_bytes,

18
program-runtime/src/compute_budget_processor.rs
View File

@ -1,4 +1,3 @@
//! Process compute_budget instructions to extract and sanitize limits.
use {
crate::{
compute_budget::DEFAULT_HEAP_COST,
@ -8,7 +7,6 @@ use {
borsh1::try_from_slice_unchecked,
compute_budget::{self, ComputeBudgetInstruction},
entrypoint::HEAP_LENGTH as MIN_HEAP_FRAME_BYTES,
feature_set::FeatureSet,
fee::FeeBudgetLimits,
instruction::{CompiledInstruction, InstructionError},
pubkey::Pubkey,
@ -69,7 +67,6 @@ impl From<ComputeBudgetLimits> for FeeBudgetLimits {
/// are retrieved and returned,
pub fn process_compute_budget_instructions<'a>(
instructions: impl Iterator<Item = (&'a Pubkey, &'a CompiledInstruction)>,
_feature_set: &FeatureSet,
) -> Result<ComputeBudgetLimits, TransactionError> {
let mut num_non_compute_budget_instructions: u32 = 0;
let mut updated_compute_unit_limit = None;
@ -178,11 +175,8 @@ mod tests {
Message::new($instructions, Some(&payer_keypair.pubkey())),
Hash::default(),
));
let feature_set = FeatureSet::default();
let result = process_compute_budget_instructions(
tx.message().program_instructions_iter(),
&feature_set,
);
let result =
process_compute_budget_instructions(tx.message().program_instructions_iter());
assert_eq!($expected_result, result);
};
}
@ -489,12 +483,8 @@ mod tests {
Hash::default(),
));
let feature_set = FeatureSet::default();
let result = process_compute_budget_instructions(
transaction.message().program_instructions_iter(),
&feature_set,
);
let result =
process_compute_budget_instructions(transaction.message().program_instructions_iter());
// assert process_instructions will be successful with default,
// and the default compute_unit_limit is 2 times default: one for bpf ix, one for

21
programs/sbf/tests/programs.rs
View File

@ -3868,18 +3868,13 @@ fn test_program_fees() {
Some(&mint_keypair.pubkey()),
);
let feature_set = FeatureSet::all_enabled();
let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
let expected_normal_fee = fee_structure.calculate_fee(
&sanitized_message,
congestion_multiplier,
&process_compute_budget_instructions(
sanitized_message.program_instructions_iter(),
&feature_set,
)
.unwrap_or_default()
.into(),
&process_compute_budget_instructions(sanitized_message.program_instructions_iter())
.unwrap_or_default()
.into(),
true,
false,
);
@ -3898,16 +3893,12 @@ fn test_program_fees() {
Some(&mint_keypair.pubkey()),
);
let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
let feature_set = FeatureSet::all_enabled();
let expected_prioritized_fee = fee_structure.calculate_fee(
&sanitized_message,
congestion_multiplier,
&process_compute_budget_instructions(
sanitized_message.program_instructions_iter(),
&feature_set,
)
.unwrap_or_default()
.into(),
&process_compute_budget_instructions(sanitized_message.program_instructions_iter())
.unwrap_or_default()
.into(),
true,
false,
);

25
runtime/src/accounts/mod.rs
View File

@ -80,7 +80,6 @@ pub(super) fn load_accounts(
lamports_per_signature,
&process_compute_budget_instructions(
tx.message().program_instructions_iter(),
feature_set,
)
.unwrap_or_default()
.into(),
@ -170,7 +169,7 @@ fn load_transaction_accounts(
feature_set.is_active(&solana_sdk::feature_set::set_exempt_rent_epoch_max::id());
let requested_loaded_accounts_data_size_limit =
get_requested_loaded_accounts_data_size_limit(tx, feature_set)?;
get_requested_loaded_accounts_data_size_limit(tx)?;
let mut accumulated_accounts_data_size: usize = 0;
let instruction_accounts = message
@ -423,10 +422,9 @@ fn load_transaction_accounts(
/// Note, requesting zero bytes will result transaction error
fn get_requested_loaded_accounts_data_size_limit(
tx: &SanitizedTransaction,
feature_set: &FeatureSet,
) -> Result<Option<NonZeroUsize>> {
let compute_budget_limits =
process_compute_budget_instructions(tx.message().program_instructions_iter(), feature_set)
process_compute_budget_instructions(tx.message().program_instructions_iter())
.unwrap_or_default();
// sanitize against setting size limit to zero
NonZeroUsize::new(
@ -732,13 +730,11 @@ mod tests {
instructions,
);
let feature_set = FeatureSet::all_enabled();
let message = SanitizedMessage::try_from(tx.message().clone()).unwrap();
let fee = FeeStructure::default().calculate_fee(
&message,
lamports_per_signature,
&process_compute_budget_instructions(message.program_instructions_iter(), &feature_set)
&process_compute_budget_instructions(message.program_instructions_iter())
.unwrap_or_default()
.into(),
true,
@ -1502,7 +1498,6 @@ mod tests {
// an prrivate helper function
fn test(
instructions: &[solana_sdk::instruction::Instruction],
feature_set: &FeatureSet,
expected_result: &Result<Option<NonZeroUsize>>,
) {
let payer_keypair = Keypair::new();
@ -1513,7 +1508,7 @@ mod tests {
));
assert_eq!(
*expected_result,
get_requested_loaded_accounts_data_size_limit(&tx, feature_set)
get_requested_loaded_accounts_data_size_limit(&tx)
);
}
@ -1544,15 +1539,13 @@ mod tests {
Ok(Some(NonZeroUsize::new(99).unwrap()));
let result_invalid_limit = Err(TransactionError::InvalidLoadedAccountsDataSizeLimit);
let feature_set = FeatureSet::default();
// the results should be:
// if tx doesn't set limit, then default limit (64MiB)
// if tx sets limit, then requested limit
// if tx sets limit to zero, then TransactionError::InvalidLoadedAccountsDataSizeLimit
test(tx_not_set_limit, &feature_set, &result_default_limit);
test(tx_set_limit_99, &feature_set, &result_requested_limit);
test(tx_set_limit_0, &feature_set, &result_invalid_limit);
test(tx_not_set_limit, &result_default_limit);
test(tx_set_limit_99, &result_requested_limit);
test(tx_set_limit_0, &result_invalid_limit);
}
#[test]
@ -1583,13 +1576,11 @@ mod tests {
Hash::default(),
);
let feature_set = FeatureSet::all_enabled();
let message = SanitizedMessage::try_from(tx.message().clone()).unwrap();
let fee = FeeStructure::default().calculate_fee(
&message,
lamports_per_signature,
&process_compute_budget_instructions(message.program_instructions_iter(), &feature_set)
&process_compute_budget_instructions(message.program_instructions_iter())
.unwrap_or_default()
.into(),
true,

10
runtime/src/bank.rs
View File

@ -4067,12 +4067,9 @@ impl Bank {
self.fee_structure.calculate_fee(
message,
lamports_per_signature,
&process_compute_budget_instructions(
message.program_instructions_iter(),
&self.feature_set,
)
.unwrap_or_default()
.into(),
&process_compute_budget_instructions(message.program_instructions_iter())
.unwrap_or_default()
.into(),
self.feature_set
.is_active(&remove_congestion_multiplier_from_fee_calculation::id()),
self.feature_set
@ -5214,7 +5211,6 @@ impl Bank {
Measure::start("compute_budget_process_transaction_time");
let maybe_compute_budget = ComputeBudget::try_from_instructions(
tx.message().program_instructions_iter(),
&self.feature_set,
);
compute_budget_process_transaction_time.stop();
saturating_add_assign!(

7
runtime/src/bank/tests.rs
View File

@ -10012,10 +10012,9 @@ fn calculate_test_fee(
);
}
let budget_limits =
process_compute_budget_instructions(message.program_instructions_iter(), &feature_set)
.unwrap_or_default()
.into();
let budget_limits = process_compute_budget_instructions(message.program_instructions_iter())
.unwrap_or_default()
.into();
fee_structure.calculate_fee(
message,

6
runtime/src/transaction_priority_details.rs
View File

@ -1,7 +1,6 @@
use {
solana_program_runtime::compute_budget_processor::process_compute_budget_instructions,
solana_sdk::{
feature_set::FeatureSet,
instruction::CompiledInstruction,
pubkey::Pubkey,
transaction::{SanitizedTransaction, SanitizedVersionedTransaction},
@ -24,10 +23,7 @@ pub trait GetTransactionPriorityDetails {
instructions: impl Iterator<Item = (&'a Pubkey, &'a CompiledInstruction)>,
_round_compute_unit_price_enabled: bool,
) -> Option<TransactionPriorityDetails> {
let feature_set = FeatureSet::default();
let compute_budget_limits =
process_compute_budget_instructions(instructions, &feature_set).ok()?;
let compute_budget_limits = process_compute_budget_instructions(instructions).ok()?;
Some(TransactionPriorityDetails {
priority: compute_budget_limits.compute_unit_price,
compute_unit_limit: u64::from(compute_budget_limits.compute_unit_limit),