Add program heap bump instruction (#20607)

programs/bpf/benches/bpf_loader.rs

@@ -198,6 +198,58 @@ fn bench_program_execute_noop(bencher: &mut Bencher) {
     });
 }
 
+#[bench]
+fn bench_create_vm(bencher: &mut Bencher) {
+    const BUDGET: u64 = 200_000;
+    let loader_id = bpf_loader::id();
+
+    let accounts = [RefCell::new(AccountSharedData::new(
+        1,
+        10000001,
+        &solana_sdk::pubkey::new_rand(),
+    ))];
+    let keys = [solana_sdk::pubkey::new_rand()];
+    let keyed_accounts: Vec<_> = keys
+        .iter()
+        .zip(&accounts)
+        .map(|(key, account)| solana_sdk::keyed_account::KeyedAccount::new(&key, false, &account))
+        .collect();
+    let instruction_data = vec![0u8];
+
+    let mut invoke_context = MockInvokeContext::new(&loader_id, keyed_accounts);
+    invoke_context.compute_meter.remaining = BUDGET;
+
+    // Serialize account data
+    let keyed_accounts = invoke_context.get_keyed_accounts().unwrap();
+    let (mut serialized, account_lengths) = serialize_parameters(
+        &loader_id,
+        &solana_sdk::pubkey::new_rand(),
+        keyed_accounts,
+        &instruction_data,
+    )
+    .unwrap();
+
+    let elf = load_elf("noop").unwrap();
+    let executable = <dyn Executable<BpfError, ThisInstructionMeter>>::from_elf(
+        &elf,
+        None,
+        Config::default(),
+        register_syscalls(&mut invoke_context).unwrap(),
+    )
+    .unwrap();
+
+    bencher.iter(|| {
+        let _ = create_vm(
+            &loader_id,
+            executable.as_ref(),
+            serialized.as_slice_mut(),
+            &mut invoke_context,
+            &account_lengths,
+        )
+        .unwrap();
+    });
+}
+
 #[bench]
 fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
     const BUDGET: u64 = 200_000;

programs/bpf_loader/src/lib.rs

@@ -32,7 +32,8 @@ use solana_sdk::{
     entrypoint::{HEAP_LENGTH, SUCCESS},
     feature_set::{
         add_missing_program_error_mappings, close_upgradeable_program_accounts, do_support_realloc,
-        fix_write_privs, reduce_required_deploy_balance, stop_verify_mul64_imm_nonzero,
+        fix_write_privs, reduce_required_deploy_balance, requestable_heap_size,
+        stop_verify_mul64_imm_nonzero,
     },
     ic_logger_msg, ic_msg,
     instruction::{AccountMeta, InstructionError},
@@ -151,6 +152,13 @@ pub fn create_vm<'a>(
     orig_data_lens: &'a [usize],
 ) -> Result<EbpfVm<'a, BpfError, ThisInstructionMeter>, EbpfError<BpfError>> {
     let compute_budget = invoke_context.get_compute_budget();
+    let heap_size = compute_budget.heap_size.unwrap_or(HEAP_LENGTH);
+    if invoke_context.is_feature_active(&requestable_heap_size::id()) {
+        let _ = invoke_context
+            .get_compute_meter()
+            .borrow_mut()
+            .consume((heap_size as u64 / (32 * 1024)).saturating_sub(1) * compute_budget.heap_cost);
+    }
     let mut heap =
         AlignedMemory::new_with_size(compute_budget.heap_size.unwrap_or(HEAP_LENGTH), HOST_ALIGN);
     let mut vm = EbpfVm::new(program, heap.as_slice_mut(), parameter_bytes)?;