Refactoring: Move KeyedAccounts to InvokeContext

program-test/src/lib.rs

@@ -25,7 +25,6 @@ use {
         hash::Hash,
         instruction::Instruction,
         instruction::InstructionError,
-        keyed_account::KeyedAccount,
         message::Message,
         native_token::sol_to_lamports,
         process_instruction::{
@@ -99,12 +98,13 @@ fn get_invoke_context<'a>() -> &'a mut dyn InvokeContext {
 pub fn builtin_process_instruction(
     process_instruction: solana_sdk::entrypoint::ProcessInstruction,
     program_id: &Pubkey,
-    keyed_accounts: &[KeyedAccount],
     input: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
     set_invoke_context(invoke_context);
 
+    let keyed_accounts = invoke_context.get_keyed_accounts()?;
+
     // Copy all the accounts into a HashMap to ensure there are no duplicates
     let mut accounts: HashMap<Pubkey, Account> = keyed_accounts
         .iter()
@@ -172,13 +172,11 @@ macro_rules! processor {
     ($process_instruction:expr) => {
         Some(
             |program_id: &Pubkey,
-             keyed_accounts: &[solana_sdk::keyed_account::KeyedAccount],
              input: &[u8],
              invoke_context: &mut dyn solana_sdk::process_instruction::InvokeContext| {
                 $crate::builtin_process_instruction(
                     $process_instruction,
                     program_id,
-                    keyed_accounts,
                     input,
                     invoke_context,
                 )

programs/bpf/benches/bpf_loader.rs

@@ -76,7 +76,7 @@ fn bench_program_create_executable(bencher: &mut Bencher) {
 
     bencher.iter(|| {
         let _ =
-            Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
+            <dyn Executable::<BpfError, ThisInstructionMeter>>::from_elf(&elf, None, Config::default())
                 .unwrap();
     });
 }
@@ -91,11 +91,11 @@ fn bench_program_alu(bencher: &mut Bencher) {
         .unwrap();
     inner_iter.write_u64::<LittleEndian>(0).unwrap();
     let loader_id = bpf_loader::id();
-    let mut invoke_context = MockInvokeContext::default();
+    let mut invoke_context = MockInvokeContext::new(vec![]);
 
     let elf = load_elf("bench_alu").unwrap();
     let mut executable =
-        Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
+        <dyn Executable::<BpfError, ThisInstructionMeter>>::from_elf(&elf, None, Config::default())
             .unwrap();
     executable.set_syscall_registry(register_syscalls(&mut invoke_context).unwrap());
     executable.jit_compile().unwrap();
@@ -105,7 +105,6 @@ fn bench_program_alu(bencher: &mut Bencher) {
         &loader_id,
         executable.as_ref(),
         &mut inner_iter,
-        &[],
         &mut invoke_context,
     )
     .unwrap();
@@ -195,8 +194,6 @@ fn bench_program_execute_noop(bencher: &mut Bencher) {
 fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
     const BUDGET: u64 = 200_000;
     let loader_id = bpf_loader::id();
-    let mut invoke_context = MockInvokeContext::default();
-    invoke_context.compute_meter.remaining = BUDGET;
 
     let accounts = [RefCell::new(AccountSharedData::new(
         1,
@@ -211,18 +208,22 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
         .collect();
     let instruction_data = vec![0u8];
 
+    let mut invoke_context = MockInvokeContext::new(keyed_accounts);
+    invoke_context.compute_meter.remaining = BUDGET;
+
     // Serialize account data
+    let keyed_accounts = invoke_context.get_keyed_accounts().unwrap();
     let mut serialized = serialize_parameters(
         &bpf_loader::id(),
         &solana_sdk::pubkey::new_rand(),
-        &keyed_accounts,
+        keyed_accounts,
         &instruction_data,
     )
     .unwrap();
 
     let elf = load_elf("tuner").unwrap();
     let mut executable =
-        Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
+        <dyn Executable::<BpfError, ThisInstructionMeter>>::from_elf(&elf, None, Config::default())
             .unwrap();
     executable.set_syscall_registry(register_syscalls(&mut invoke_context).unwrap());
     let compute_meter = invoke_context.get_compute_meter();
@@ -231,7 +232,6 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
         &loader_id,
         executable.as_ref(),
         &mut serialized,
-        &[],
         &mut invoke_context,
     )
     .unwrap();

programs/bpf/tests/programs.rs

@@ -179,7 +179,7 @@ fn upgrade_bpf_program(
 fn run_program(
     name: &str,
     program_id: &Pubkey,
-    parameter_accounts: &[KeyedAccount],
+    parameter_accounts: Vec<KeyedAccount>,
     instruction_data: &[u8],
 ) -> Result<u64, InstructionError> {
     let path = create_bpf_path(name);
@@ -188,14 +188,14 @@ fn run_program(
     let mut data = vec![];
     file.read_to_end(&mut data).unwrap();
     let loader_id = bpf_loader::id();
-    let mut invoke_context = MockInvokeContext::default();
     let parameter_bytes = serialize_parameters(
         &bpf_loader::id(),
         program_id,
-        parameter_accounts,
+        &parameter_accounts,
         &instruction_data,
     )
     .unwrap();
+    let mut invoke_context = MockInvokeContext::new(parameter_accounts);
     let compute_meter = invoke_context.get_compute_meter();
     let mut instruction_meter = ThisInstructionMeter { compute_meter };
 
@@ -213,51 +213,53 @@ fn run_program(
     let mut tracer = None;
     for i in 0..2 {
         let mut parameter_bytes = parameter_bytes.clone();
-        let mut vm = create_vm(
-            &loader_id,
-            executable.as_ref(),
-            &mut parameter_bytes,
-            parameter_accounts,
-            &mut invoke_context,
-        )
-        .unwrap();
-        let result = if i == 0 {
-            vm.execute_program_interpreted(&mut instruction_meter)
-        } else {
-            vm.execute_program_jit(&mut instruction_meter)
-        };
-        assert_eq!(SUCCESS, result.unwrap());
+        {
+            let mut vm = create_vm(
+                &loader_id,
+                executable.as_ref(),
+                &mut parameter_bytes,
+                &mut invoke_context,
+            )
+            .unwrap();
+            let result = if i == 0 {
+                vm.execute_program_interpreted(&mut instruction_meter)
+            } else {
+                vm.execute_program_jit(&mut instruction_meter)
+            };
+            assert_eq!(SUCCESS, result.unwrap());
+            if i == 1 {
+                assert_eq!(instruction_count, vm.get_total_instruction_count());
+            }
+            instruction_count = vm.get_total_instruction_count();
+            if config.enable_instruction_tracing {
+                if i == 1 {
+                    if !Tracer::compare(tracer.as_ref().unwrap(), vm.get_tracer()) {
+                        let mut tracer_display = String::new();
+                        tracer
+                            .as_ref()
+                            .unwrap()
+                            .write(&mut tracer_display, vm.get_program())
+                            .unwrap();
+                        println!("TRACE (interpreted): {}", tracer_display);
+                        let mut tracer_display = String::new();
+                        vm.get_tracer()
+                            .write(&mut tracer_display, vm.get_program())
+                            .unwrap();
+                        println!("TRACE (jit): {}", tracer_display);
+                        assert!(false);
+                    }
+                }
+                tracer = Some(vm.get_tracer().clone());
+            }
+        }
+        let parameter_accounts = invoke_context.get_keyed_accounts().unwrap();
         deserialize_parameters(
             &bpf_loader::id(),
             parameter_accounts,
             &parameter_bytes,
             true,
         )
         .unwrap();
-        if i == 1 {
-            assert_eq!(instruction_count, vm.get_total_instruction_count());
-        }
-        instruction_count = vm.get_total_instruction_count();
-        if config.enable_instruction_tracing {
-            if i == 1 {
-                if !Tracer::compare(tracer.as_ref().unwrap(), vm.get_tracer()) {
-                    let mut tracer_display = String::new();
-                    tracer
-                        .as_ref()
-                        .unwrap()
-                        .write(&mut tracer_display, vm.get_program())
-                        .unwrap();
-                    println!("TRACE (interpreted): {}", tracer_display);
-                    let mut tracer_display = String::new();
-                    vm.get_tracer()
-                        .write(&mut tracer_display, vm.get_program())
-                        .unwrap();
-                    println!("TRACE (jit): {}", tracer_display);
-                    assert!(false);
-                }
-            }
-            tracer = Some(vm.get_tracer().clone());
-        }
     }
 
     Ok(instruction_count)
@@ -1263,7 +1265,7 @@ fn assert_instruction_count() {
         let key = solana_sdk::pubkey::new_rand();
         let mut account = RefCell::new(AccountSharedData::default());
         let parameter_accounts = vec![KeyedAccount::new(&key, false, &mut account)];
-        let count = run_program(program.0, &program_id, &parameter_accounts[..], &[]).unwrap();
+        let count = run_program(program.0, &program_id, parameter_accounts, &[]).unwrap();
         let diff: i64 = count as i64 - program.1 as i64;
         println!("  {:30} {:8} {:6} {:+4}", program.0, program.1, count, diff);
         if count > program.1 {