feat: collect and cache builtin instructions cost and count per transaction

runtime-transaction/Cargo.toml

@@ -26,6 +26,8 @@ name = "solana_runtime_transaction"
 bincode = { workspace = true }
 criterion = { workspace = true }
 rand = { workspace = true }
+solana-compute-budget-program = { workspace = true }
+solana-loader-v4-program = { workspace = true }
 solana-program = { workspace = true }
 
 [package.metadata.docs.rs]

runtime-transaction/benches/process_compute_budget_instructions.rs

@@ -158,12 +158,45 @@ fn bench_process_compute_budget_instructions_mixed(c: &mut Criterion) {
         );
 }
 
+fn bench_process_compute_budget_and_transfer_only(c: &mut Criterion) {
+    let num_instructions = 355;
+    let pubkey = Pubkey::new_unique();
+    c.benchmark_group("bench_process_compute_budget_and_transfer_only")
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function(
+            format!("{num_instructions} transfer instructions and compute budget ixs"),
+            |bencher| {
+                let payer_keypair = Keypair::new();
+                let mut ixs: Vec<_> = (0..num_instructions - 4)
+                    .map(|i| system_instruction::transfer(&payer_keypair.pubkey(), &pubkey, i))
+                    .collect();
+                ixs.extend(vec![
+                    ComputeBudgetInstruction::request_heap_frame(40 * 1024),
+                    ComputeBudgetInstruction::set_compute_unit_limit(u32::MAX),
+                    ComputeBudgetInstruction::set_compute_unit_price(u64::MAX),
+                    ComputeBudgetInstruction::set_loaded_accounts_data_size_limit(u32::MAX),
+                ]);
+                let tx = build_sanitized_transaction(&payer_keypair, &ixs);
+
+                bencher.iter(|| {
+                    (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                        assert!(process_compute_budget_instructions(black_box(
+                            SVMMessage::program_instructions_iter(&tx)
+                        ))
+                        .is_ok())
+                    })
+                });
+            },
+        );
+}
+
 criterion_group!(
     benches,
     bench_process_compute_budget_instructions_empty,
     bench_process_compute_budget_instructions_no_builtins,
     bench_process_compute_budget_instructions_compute_budgets,
     bench_process_compute_budget_instructions_builtins,
     bench_process_compute_budget_instructions_mixed,
+    bench_process_compute_budget_and_transfer_only,
 );
 criterion_main!(benches);

runtime-transaction/src/builtin_auxiliary_data_store.rs

@@ -0,0 +1,126 @@
+// static account keys has max
+use {
+    agave_transaction_view::static_account_keys_meta::MAX_STATIC_ACCOUNTS_PER_PACKET as FILTER_SIZE,
+    solana_builtins_default_costs::{BUILTIN_INSTRUCTION_COSTS, MAYBE_BUILTIN_KEY},
+    solana_sdk::pubkey::Pubkey,
+};
+
+#[derive(Default, PartialEq)]
+enum BuiltinCheckStatus {
+    #[default]
+    Unchecked,
+    NotBuiltin,
+    Builtin {
+        is_compute_budget: bool,
+        default_cost: u32,
+    },
+}
+
+pub(crate) struct BuiltinAuxiliaryDataStore {
+    auxiliary_data: [BuiltinCheckStatus; FILTER_SIZE as usize],
+}
+
+impl BuiltinAuxiliaryDataStore {
+    pub(crate) fn new() -> Self {
+        BuiltinAuxiliaryDataStore {
+            auxiliary_data: core::array::from_fn(|_| BuiltinCheckStatus::default()),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_auxiliary_data(
+        &mut self,
+        index: usize,
+        program_id: &Pubkey,
+    ) -> Option<(bool, u32)> {
+        let stat = self
+            .auxiliary_data
+            .get_mut(index)
+            .expect("program id index is sanitized");
+        if stat == &BuiltinCheckStatus::Unchecked {
+            *stat = Self::check_status(program_id)
+        }
+
+        match stat {
+            BuiltinCheckStatus::NotBuiltin => None,
+            BuiltinCheckStatus::Builtin {
+                is_compute_budget,
+                default_cost,
+            } => Some((*is_compute_budget, *default_cost)),
+            _ => unreachable!("already checked"),
+        }
+    }
+
+    #[inline]
+    fn check_status(program_id: &Pubkey) -> BuiltinCheckStatus {
+        if !MAYBE_BUILTIN_KEY[program_id.as_ref()[0] as usize] {
+            return BuiltinCheckStatus::NotBuiltin;
+        }
+
+        BUILTIN_INSTRUCTION_COSTS
+            .get(program_id)
+            .map_or(BuiltinCheckStatus::NotBuiltin, |cost| {
+                BuiltinCheckStatus::Builtin {
+                    is_compute_budget: solana_sdk::compute_budget::check_id(program_id),
+                    default_cost: *cost as u32,
+                }
+            })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    const DUMMY_PROGRAM_ID: &str = "dummmy1111111111111111111111111111111111111";
+
+    #[test]
+    fn test_get_auxiliary_data() {
+        let mut test_store = BuiltinAuxiliaryDataStore::new();
+        let mut index = 9;
+
+        // initial state is Unchecked
+        assert!(test_store.auxiliary_data[index] == BuiltinCheckStatus::Unchecked);
+
+        // non builtin returns None
+        assert!(test_store
+            .get_auxiliary_data(index, &DUMMY_PROGRAM_ID.parse().unwrap())
+            .is_none());
+        // but its state is now checked (eg, Some(...))
+        assert!(test_store.auxiliary_data[index] == BuiltinCheckStatus::NotBuiltin);
+        // lookup same `index` will return cached auxiliary data, will *not* lookup `program_id`
+        // again
+        assert!(test_store
+            .get_auxiliary_data(index, &solana_sdk::loader_v4::id())
+            .is_none());
+
+        // builtin return default cost
+        index += 1;
+        assert_eq!(
+            test_store.get_auxiliary_data(index, &solana_sdk::loader_v4::id()),
+            Some((
+                false,
+                solana_loader_v4_program::DEFAULT_COMPUTE_UNITS as u32
+            ))
+        );
+
+        // compute-budget return default cost, and true flag
+        index += 1;
+        assert_eq!(
+            test_store.get_auxiliary_data(index, &solana_sdk::compute_budget::id()),
+            Some((
+                true,
+                solana_compute_budget_program::DEFAULT_COMPUTE_UNITS as u32
+            ))
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "program id index is sanitized")]
+    fn test_get_auxiliary_data_out_of_bound_index() {
+        let mut test_store = BuiltinAuxiliaryDataStore::new();
+        assert!(test_store
+            .get_auxiliary_data(FILTER_SIZE as usize + 1, &DUMMY_PROGRAM_ID.parse().unwrap())
+            .is_none());
+    }
+}