diff --git a/runtime-transaction/benches/process_compute_budget_instructions.rs b/runtime-transaction/benches/process_compute_budget_instructions.rs
index 479b0b1108a888..a1a8661fc7f21c 100644
--- a/runtime-transaction/benches/process_compute_budget_instructions.rs
+++ b/runtime-transaction/benches/process_compute_budget_instructions.rs
@@ -1,5 +1,5 @@
 use {
-    criterion::{black_box, criterion_group, criterion_main, Criterion},
+    criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput},
     solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sdk::{
         compute_budget::ComputeBudgetInstruction,
@@ -27,104 +27,118 @@ fn build_sanitized_transaction(
 }
 
 fn bench_process_compute_budget_instructions_empty(c: &mut Criterion) {
-    c.bench_function("No instructions", |bencher| {
-        let tx = build_sanitized_transaction(&Keypair::new(), &[]);
-        bencher.iter(|| {
-            (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
-                assert!(process_compute_budget_instructions(black_box(
-                    tx.message().program_instructions_iter()
-                ))
-                .is_ok())
-            })
+    c.benchmark_group(format!("bench_size_{NUM_TRANSACTIONS_PER_ITER}"))
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function("No instructions", |bencher| {
+            let tx = build_sanitized_transaction(&Keypair::new(), &[]);
+            bencher.iter(|| {
+                (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                    assert!(process_compute_budget_instructions(black_box(
+                        tx.message().program_instructions_iter()
+                    ))
+                    .is_ok())
+                })
+            });
         });
-    });
 }
 
 fn bench_process_compute_budget_instructions_no_builtins(c: &mut Criterion) {
-    c.bench_function("No builtins", |bencher| {
-        let ixs: Vec<_> = (0..4)
-            .map(|_| Instruction::new_with_bincode(DUMMY_PROGRAM_ID.parse().unwrap(), &(), vec![]))
-            .collect();
-        let tx = build_sanitized_transaction(&Keypair::new(), &ixs);
-        bencher.iter(|| {
-            (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
-                assert!(process_compute_budget_instructions(black_box(
-                    tx.message().program_instructions_iter()
-                ))
-                .is_ok())
-            })
+    c.benchmark_group(format!("bench_size_{NUM_TRANSACTIONS_PER_ITER}"))
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function("No builtins", |bencher| {
+            let ixs: Vec<_> = (0..4)
+                .map(|_| {
+                    Instruction::new_with_bincode(DUMMY_PROGRAM_ID.parse().unwrap(), &(), vec![])
+                })
+                .collect();
+            let tx = build_sanitized_transaction(&Keypair::new(), &ixs);
+            bencher.iter(|| {
+                (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                    assert!(process_compute_budget_instructions(black_box(
+                        tx.message().program_instructions_iter()
+                    ))
+                    .is_ok())
+                })
+            });
         });
-    });
 }
 
 fn bench_process_compute_budget_instructions_compute_budgets(c: &mut Criterion) {
-    c.bench_function("Only compute-budget instructions", |bencher| {
-        let ixs = 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(&Keypair::new(), &ixs);
-        bencher.iter(|| {
-            (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
-                assert!(process_compute_budget_instructions(black_box(
-                    tx.message().program_instructions_iter()
-                ))
-                .is_ok())
-            })
+    c.benchmark_group(format!("bench_size_{NUM_TRANSACTIONS_PER_ITER}"))
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function("Only compute-budget instructions", |bencher| {
+            let ixs = 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(&Keypair::new(), &ixs);
+            bencher.iter(|| {
+                (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                    assert!(process_compute_budget_instructions(black_box(
+                        tx.message().program_instructions_iter()
+                    ))
+                    .is_ok())
+                })
+            });
         });
-    });
 }
 
 fn bench_process_compute_budget_instructions_builtins(c: &mut Criterion) {
-    c.bench_function("Only builtins", |bencher| {
-        let ixs = vec![
-            Instruction::new_with_bincode(solana_sdk::bpf_loader::id(), &(), vec![]),
-            Instruction::new_with_bincode(solana_sdk::secp256k1_program::id(), &(), vec![]),
-            Instruction::new_with_bincode(
-                solana_sdk::address_lookup_table::program::id(),
-                &(),
-                vec![],
-            ),
-            Instruction::new_with_bincode(solana_sdk::loader_v4::id(), &(), vec![]),
-        ];
-        let tx = build_sanitized_transaction(&Keypair::new(), &ixs);
-        bencher.iter(|| {
-            (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
-                assert!(process_compute_budget_instructions(black_box(
-                    tx.message().program_instructions_iter()
-                ))
-                .is_ok())
-            })
+    c.benchmark_group(format!("bench_size_{NUM_TRANSACTIONS_PER_ITER}"))
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function("Only builtins", |bencher| {
+            let ixs = vec![
+                Instruction::new_with_bincode(solana_sdk::bpf_loader::id(), &(), vec![]),
+                Instruction::new_with_bincode(solana_sdk::secp256k1_program::id(), &(), vec![]),
+                Instruction::new_with_bincode(
+                    solana_sdk::address_lookup_table::program::id(),
+                    &(),
+                    vec![],
+                ),
+                Instruction::new_with_bincode(solana_sdk::loader_v4::id(), &(), vec![]),
+            ];
+            let tx = build_sanitized_transaction(&Keypair::new(), &ixs);
+            bencher.iter(|| {
+                (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                    assert!(process_compute_budget_instructions(black_box(
+                        tx.message().program_instructions_iter()
+                    ))
+                    .is_ok())
+                })
+            });
         });
-    });
 }
 
 fn bench_process_compute_budget_instructions_mixed(c: &mut Criterion) {
-    c.bench_function("Mixed instructions", |bencher| {
-        let payer_keypair = Keypair::new();
-        let mut ixs: Vec<_> = (0..128)
-            .map(|_| Instruction::new_with_bincode(DUMMY_PROGRAM_ID.parse().unwrap(), &(), vec![]))
-            .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),
-            system_instruction::transfer(&payer_keypair.pubkey(), &Pubkey::new_unique(), 1),
-        ]);
-        let tx = build_sanitized_transaction(&payer_keypair, &ixs);
+    c.benchmark_group(format!("bench_size_{NUM_TRANSACTIONS_PER_ITER}"))
+        .throughput(Throughput::Elements(NUM_TRANSACTIONS_PER_ITER as u64))
+        .bench_function("Mixed instructions", |bencher| {
+            let payer_keypair = Keypair::new();
+            let mut ixs: Vec<_> = (0..128)
+                .map(|_| {
+                    Instruction::new_with_bincode(DUMMY_PROGRAM_ID.parse().unwrap(), &(), vec![])
+                })
+                .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),
+                system_instruction::transfer(&payer_keypair.pubkey(), &Pubkey::new_unique(), 1),
+            ]);
+            let tx = build_sanitized_transaction(&payer_keypair, &ixs);
 
-        bencher.iter(|| {
-            (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
-                assert!(process_compute_budget_instructions(black_box(
-                    tx.message().program_instructions_iter()
-                ))
-                .is_ok())
-            })
+            bencher.iter(|| {
+                (0..NUM_TRANSACTIONS_PER_ITER).for_each(|_| {
+                    assert!(process_compute_budget_instructions(black_box(
+                        tx.message().program_instructions_iter()
+                    ))
+                    .is_ok())
+                })
+            });
         });
-    });
 }
 
 criterion_group!(