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<_> = (4..num_instructions)
+                    .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,104 @@
+// 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,
+};
+
+pub(crate) struct BuiltinAuxiliaryDataStore {
+    // Array of auxiliary data for all possible static and sanitized program_id_index,
+    // Each possible value of data indicates:
+    //   None - un-checked
+    //   Some<None> - checked, not builtin
+    //   Some<Some<(bool, u32)>> - checked, is builtin and (is-compute-budget, default-cost)
+    auxiliary_data: [Option<Option<(bool, u32)>>; FILTER_SIZE as usize],
+}
+
+impl BuiltinAuxiliaryDataStore {
+    pub(crate) fn new() -> Self {
+        BuiltinAuxiliaryDataStore {
+            auxiliary_data: [None; FILTER_SIZE as usize],
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_auxiliary_data(
+        &mut self,
+        index: usize,
+        program_id: &Pubkey,
+    ) -> Option<(bool, u32)> {
+        *self
+            .auxiliary_data
+            .get_mut(index)
+            .expect("program id index is sanitized")
+            .get_or_insert_with(|| {
+                if !MAYBE_BUILTIN_KEY[program_id.as_ref()[0] as usize] {
+                    return None;
+                }
+
+                BUILTIN_INSTRUCTION_COSTS.get(program_id).map(|cost| {
+                    (
+                        solana_sdk::compute_budget::check_id(program_id),
+                        *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 (eg, None)
+        assert!(test_store.auxiliary_data[index].is_none());
+
+        // 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_eq!(test_store.auxiliary_data[index], Some(None));
+        // 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());
+    }
+}