Updates rbpf to v0.2.0, (#12951)

which unifies the interfaces of the interpreter and the JIT.
However, the JIT is not enabled yet.

Cargo.lock

@@ -4986,9 +4986,9 @@ dependencies = [
 
 [[package]]
 name = "solana_rbpf"
-version = "0.1.32"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a95dbe2b00920ac4e1524b7442cf5319f01e8fa5742930ac60148882fd7738b"
+checksum = "09e18fa1e1b6cac20a5f2571882b7580a65ae685b1413fc498f975d07d4c968f"
 dependencies = [
  "byteorder",
  "combine",

cli/Cargo.toml

@@ -37,7 +37,7 @@ solana-config-program = { path = "../programs/config", version = "1.5.0" }
 solana-faucet = { path = "../faucet", version = "1.5.0" }
 solana-logger = { path = "../logger", version = "1.5.0" }
 solana-net-utils = { path = "../net-utils", version = "1.5.0" }
-solana_rbpf = "=0.1.32"
+solana_rbpf = "=0.2.0"
 solana-remote-wallet = { path = "../remote-wallet", version = "1.5.0" }
 solana-runtime = { path = "../runtime", version = "1.5.0" }
 solana-sdk = { path = "../sdk", version = "1.5.0" }

cli/src/cli.rs

@@ -9,7 +9,7 @@ use log::*;
 use num_traits::FromPrimitive;
 use serde_json::{self, json, Value};
 use solana_account_decoder::{UiAccount, UiAccountEncoding};
-use solana_bpf_loader_program::bpf_verifier;
+use solana_bpf_loader_program::{bpf_verifier, BPFError};
 use solana_clap_utils::{
     self,
     commitment::commitment_arg_with_default,
@@ -39,7 +39,7 @@ use solana_client::{
 use solana_faucet::faucet::request_airdrop_transaction;
 #[cfg(test)]
 use solana_faucet::faucet_mock::request_airdrop_transaction;
-use solana_rbpf::vm::EbpfVm;
+use solana_rbpf::vm::Executable;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     bpf_loader, bpf_loader_deprecated,
@@ -1217,7 +1217,7 @@ fn do_process_deploy(
         CliError::DynamicProgramError(format!("Unable to read program file: {}", err))
     })?;
 
-    EbpfVm::create_executable_from_elf(&program_data, Some(|x| bpf_verifier::check(x, true)))
+    Executable::<BPFError>::from_elf(&program_data, Some(|x| bpf_verifier::check(x, true)))
         .map_err(|err| CliError::DynamicProgramError(format!("ELF error: {}", err)))?;
 
     let loader_id = if use_deprecated_loader {

programs/bpf/Cargo.lock

@@ -2301,9 +2301,9 @@ dependencies = [
 
 [[package]]
 name = "solana_rbpf"
-version = "0.1.32"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a95dbe2b00920ac4e1524b7442cf5319f01e8fa5742930ac60148882fd7738b"
+checksum = "09e18fa1e1b6cac20a5f2571882b7580a65ae685b1413fc498f975d07d4c968f"
 dependencies = [
  "byteorder 1.3.4",
  "combine",

programs/bpf/Cargo.toml

@@ -27,7 +27,7 @@ solana-logger = { path = "../../logger", version = "1.5.0" }
 solana-measure = { path = "../../measure", version = "1.5.0" }
 solana-runtime = { path = "../../runtime", version = "1.5.0" }
 solana-sdk = { path = "../../sdk", version = "1.5.0" }
-solana_rbpf = "=0.1.32"
+solana_rbpf = "=0.2.0"
 
 [[bench]]
 name = "bpf_loader"

programs/bpf/benches/bpf_loader.rs

@@ -6,15 +6,16 @@ extern crate test;
 extern crate solana_bpf_loader_program;
 
 use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
+use solana_bpf_loader_program::ThisInstructionMeter;
 use solana_measure::measure::Measure;
-use solana_rbpf::vm::{EbpfVm, InstructionMeter};
+use solana_rbpf::vm::{Executable, InstructionMeter};
 use solana_runtime::{
     bank::Bank,
     bank_client::BankClient,
     bpf_test_utils::MockInvokeContext,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
     loader_utils::load_program,
-    process_instruction::{ComputeMeter, InvokeContext},
+    process_instruction::InvokeContext,
 };
 use solana_sdk::{
     account::Account,
@@ -26,7 +27,7 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{Keypair, Signer},
 };
-use std::{cell::RefCell, env, fs::File, io::Read, mem, path::PathBuf, rc::Rc, sync::Arc};
+use std::{cell::RefCell, env, fs::File, io::Read, mem, path::PathBuf, sync::Arc};
 use test::Bencher;
 
 /// BPF program file extension
@@ -72,9 +73,7 @@ fn bench_program_create_executable(bencher: &mut Bencher) {
     let elf = load_elf("bench_alu").unwrap();
 
     bencher.iter(|| {
-        let _ =
+        let _ = Executable::<solana_bpf_loader_program::BPFError>::from_elf(&elf, None).unwrap();
-            EbpfVm::<solana_bpf_loader_program::BPFError>::create_executable_from_elf(&elf, None)
-                .unwrap();
     });
 }
 
@@ -92,11 +91,13 @@ fn bench_program_alu(bencher: &mut Bencher) {
 
     let elf = load_elf("bench_alu").unwrap();
     let executable =
-        EbpfVm::<solana_bpf_loader_program::BPFError>::create_executable_from_elf(&elf, None)
+        Executable::<solana_bpf_loader_program::BPFError>::from_elf(&elf, None).unwrap();
-            .unwrap();
+    let compute_meter = invoke_context.get_compute_meter();
-    let (mut vm, _) = solana_bpf_loader_program::create_vm(
+    let mut instruction_meter = ThisInstructionMeter { compute_meter };
+    let mut vm = solana_bpf_loader_program::create_vm(
         &loader_id,
         executable.as_ref(),
+        &mut inner_iter,
         &[],
         &mut invoke_context,
     )
@@ -105,7 +106,8 @@ fn bench_program_alu(bencher: &mut Bencher) {
     println!("Interpreted:");
     assert_eq!(
         SUCCESS,
-        vm.execute_program(&mut inner_iter, &[], &[]).unwrap()
+        vm.execute_program_interpreted(&mut instruction_meter)
+            .unwrap()
     );
     assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
     assert_eq!(
@@ -114,7 +116,8 @@ fn bench_program_alu(bencher: &mut Bencher) {
     );
 
     bencher.iter(|| {
-        vm.execute_program(&mut inner_iter, &[], &[]).unwrap();
+        vm.execute_program_interpreted(&mut instruction_meter)
+            .unwrap();
     });
     let instructions = vm.get_total_instruction_count();
     let summary = bencher.bench(|_bencher| {}).unwrap();
@@ -125,31 +128,30 @@ fn bench_program_alu(bencher: &mut Bencher) {
     println!("  {:?} MIPS", mips);
     println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_interpreted_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
 
-    // JIT disabled until address translation support is added
+    println!("JIT to native:");
-    // println!("JIT to native:");
+    vm.jit_compile().unwrap();
-    // vm.jit_compile().unwrap();
+    unsafe {
-    // unsafe {
+        assert_eq!(
-    //     assert_eq!(
+            SUCCESS,
-    //         0, /*success*/
+            vm.execute_program_jit(&mut instruction_meter).unwrap()
-    //         vm.execute_program_jit(&mut inner_iter).unwrap()
+        );
-    //     );
+    }
-    // }
+    assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
-    // assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
+    assert_eq!(
-    // assert_eq!(
+        ARMSTRONG_EXPECTED,
-    //     ARMSTRONG_EXPECTED,
+        LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
-    //     LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
+    );
-    // );
 
-    // bencher.iter(|| unsafe {
+    bencher.iter(|| unsafe {
-    //     vm.execute_program_jit(&mut inner_iter).unwrap();
+        vm.execute_program_jit(&mut instruction_meter).unwrap();
-    // });
+    });
-    // let summary = bencher.bench(|_bencher| {}).unwrap();
+    let summary = bencher.bench(|_bencher| {}).unwrap();
-    // println!("  {:?} instructions", instructions);
+    println!("  {:?} instructions", instructions);
-    // println!("  {:?} ns/iter median", summary.median as u64);
+    println!("  {:?} ns/iter median", summary.median as u64);
-    // assert!(0f64 != summary.median);
+    assert!(0f64 != summary.median);
-    // let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
+    let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
-    // println!("  {:?} MIPS", mips);
+    println!("  {:?} MIPS", mips);
-    // println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_jit_to_native_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
+    println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_jit_to_native_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
 }
 
 #[bench]
@@ -192,22 +194,6 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
     let loader_id = bpf_loader::id();
     let mut invoke_context = MockInvokeContext::default();
     invoke_context.compute_meter.remaining = BUDGET;
-    let compute_meter = invoke_context.get_compute_meter();
-
-    let elf = load_elf("tuner").unwrap();
-    let executable =
-        EbpfVm::<solana_bpf_loader_program::BPFError>::create_executable_from_elf(&elf, None)
-            .unwrap();
-    let (mut vm, _) = solana_bpf_loader_program::create_vm(
-        &loader_id,
-        executable.as_ref(),
-        &[],
-        &mut invoke_context,
-    )
-    .unwrap();
-    let instruction_meter = MockInstructionMeter { compute_meter };
-
-    let mut measure = Measure::start("tune");
 
     let accounts = [RefCell::new(Account::new(
         1,
@@ -223,7 +209,7 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
     let instruction_data = vec![0u8];
 
     // Serialize account data
-    let mut serialized = solana_bpf_loader_program::serialization::serialize_parameters(
+    let serialized = solana_bpf_loader_program::serialization::serialize_parameters(
         &bpf_loader::id(),
         &solana_sdk::pubkey::new_rand(),
         &keyed_accounts,
@@ -231,8 +217,24 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
     )
     .unwrap();
 
-    let _ = vm.execute_program_metered(&mut serialized, &[], &[], instruction_meter.clone());
+    let elf = load_elf("tuner").unwrap();
+    let executable =
+        Executable::<solana_bpf_loader_program::BPFError>::from_elf(&elf, None).unwrap();
+    let compute_meter = invoke_context.get_compute_meter();
+    let mut instruction_meter = ThisInstructionMeter { compute_meter };
+    let mut vm = solana_bpf_loader_program::create_vm(
+        &loader_id,
+        executable.as_ref(),
+        &serialized,
+        &[],
+        &mut invoke_context,
+    )
+    .unwrap();
+
+    let mut measure = Measure::start("tune");
+    let _ = vm.execute_program_interpreted(&mut instruction_meter);
     measure.stop();
+
     assert_eq!(
         0,
         instruction_meter.get_remaining(),
@@ -245,19 +247,3 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
         vm.get_total_instruction_count(),
     );
 }
-
-/// Passed to the VM to enforce the compute budget
-#[derive(Clone)]
-struct MockInstructionMeter {
-    compute_meter: Rc<RefCell<dyn ComputeMeter>>,
-}
-impl InstructionMeter for MockInstructionMeter {
-    fn consume(&mut self, amount: u64) {
-        // 1 to 1 instruction to compute unit mapping
-        // ignore error, Ebpf will bail if exceeded
-        let _ = self.compute_meter.borrow_mut().consume(amount);
-    }
-    fn get_remaining(&self) -> u64 {
-        self.compute_meter.borrow().get_remaining()
-    }
-}

programs/bpf/tests/programs.rs

@@ -6,15 +6,16 @@ extern crate solana_bpf_loader_program;
 use solana_bpf_loader_program::{
     create_vm,
     serialization::{deserialize_parameters, serialize_parameters},
+    ThisInstructionMeter,
 };
-use solana_rbpf::vm::EbpfVm;
+use solana_rbpf::vm::Executable;
 use solana_runtime::{
     bank::Bank,
     bank_client::BankClient,
     bpf_test_utils::MockInvokeContext,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
     loader_utils::load_program,
-    process_instruction::ComputeBudget,
+    process_instruction::{ComputeBudget, InvokeContext},
 };
 use solana_sdk::{
     account::Account,
@@ -75,25 +76,29 @@ fn run_program(
     file.read_to_end(&mut data).unwrap();
     let loader_id = bpf_loader::id();
     let mut invoke_context = MockInvokeContext::default();
-
+    let parameter_bytes = serialize_parameters(
-    let executable = EbpfVm::create_executable_from_elf(&data, None).unwrap();
-    let (mut vm, heap_region) = create_vm(
-        &loader_id,
-        executable.as_ref(),
-        parameter_accounts,
-        &mut invoke_context,
-    )
-    .unwrap();
-    let mut parameter_bytes = serialize_parameters(
         &bpf_loader::id(),
         program_id,
         parameter_accounts,
         &instruction_data,
     )
     .unwrap();
+    let compute_meter = invoke_context.get_compute_meter();
+    let mut instruction_meter = ThisInstructionMeter { compute_meter };
+
+    let executable = Executable::from_elf(&data, None).unwrap();
+    let mut vm = create_vm(
+        &loader_id,
+        executable.as_ref(),
+        &parameter_bytes,
+        parameter_accounts,
+        &mut invoke_context,
+    )
+    .unwrap();
+
     assert_eq!(
         SUCCESS,
-        vm.execute_program(parameter_bytes.as_mut_slice(), &[], &[heap_region.clone()])
+        vm.execute_program_interpreted(&mut instruction_meter)
             .unwrap()
     );
     deserialize_parameters(&bpf_loader::id(), parameter_accounts, &parameter_bytes).unwrap();
@@ -812,7 +817,6 @@ fn test_program_bpf_instruction_introspection() {
         Some(&mint_keypair.pubkey()),
     );
     let result = bank_client.send_and_confirm_message(&[&mint_keypair], message);
-    println!("result: {:?}", result);
     assert!(result.is_ok());
 
     // writable special instructions11111 key, should not be allowed

programs/bpf_loader/Cargo.toml

@@ -16,7 +16,7 @@ num-derive = "0.3"
 num-traits = "0.2"
 solana-runtime = { path = "../../runtime", version = "1.5.0" }
 solana-sdk = { path = "../../sdk", version = "1.5.0" }
-solana_rbpf = "=0.1.32"
+solana_rbpf = "=0.2.0"
 thiserror = "1.0"
 
 [dev-dependencies]

programs/bpf_loader/src/lib.rs

@@ -12,12 +12,13 @@ use crate::{
 };
 use num_derive::{FromPrimitive, ToPrimitive};
 use solana_rbpf::{
+    ebpf::MM_HEAP_START,
     error::{EbpfError, UserDefinedError},
     memory_region::MemoryRegion,
     vm::{Config, EbpfVm, Executable, InstructionMeter},
 };
 use solana_runtime::{
-    feature_set::compute_budget_balancing,
+    feature_set::{bpf_just_in_time_compilation, compute_budget_balancing},
     process_instruction::{ComputeMeter, Executor, InvokeContext},
 };
 use solana_sdk::{
@@ -94,7 +95,7 @@ pub fn create_and_cache_executor(
     program: &KeyedAccount,
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<Arc<BPFExecutor>, InstructionError> {
-    let executable = EbpfVm::create_executable_from_elf(&program.try_account_ref()?.data, None)
+    let executable = Executable::from_elf(&program.try_account_ref()?.data, None)
         .map_err(|e| map_ebpf_error(invoke_context, e))?;
     let (_, elf_bytes) = executable
         .get_text_bytes()
@@ -109,13 +110,20 @@ pub fn create_and_cache_executor(
     Ok(executor)
 }
 
+/// Default program heap size, allocators
+/// are expected to enforce this
+const DEFAULT_HEAP_SIZE: usize = 32 * 1024;
+
 /// Create the BPF virtual machine
 pub fn create_vm<'a>(
     loader_id: &'a Pubkey,
     executable: &'a dyn Executable<BPFError>,
+    parameter_bytes: &[u8],
     parameter_accounts: &'a [KeyedAccount<'a>],
     invoke_context: &'a mut dyn InvokeContext,
-) -> Result<(EbpfVm<'a, BPFError>, MemoryRegion), EbpfError<BPFError>> {
+) -> Result<EbpfVm<'a, BPFError, ThisInstructionMeter>, EbpfError<BPFError>> {
+    let heap = vec![0_u8; DEFAULT_HEAP_SIZE];
+    let heap_region = MemoryRegion::new_from_slice(&heap, MM_HEAP_START, true);
     let compute_budget = invoke_context.get_compute_budget();
     let mut vm = EbpfVm::new(
         executable,
@@ -123,10 +131,11 @@ pub fn create_vm<'a>(
             max_call_depth: compute_budget.max_call_depth,
             stack_frame_size: compute_budget.stack_frame_size,
         },
+        parameter_bytes,
+        &[heap_region],
     )?;
-    let heap_region =
+    syscalls::register_syscalls(loader_id, &mut vm, parameter_accounts, invoke_context, heap)?;
-        syscalls::register_syscalls(loader_id, &mut vm, parameter_accounts, invoke_context)?;
+    Ok(vm)
-    Ok((vm, heap_region))
 }
 
 pub fn process_instruction(
@@ -191,8 +200,8 @@ pub fn process_instruction(
 }
 
 /// Passed to the VM to enforce the compute budget
-struct ThisInstructionMeter {
+pub struct ThisInstructionMeter {
-    compute_meter: Rc<RefCell<dyn ComputeMeter>>,
+    pub compute_meter: Rc<RefCell<dyn ComputeMeter>>,
 }
 impl ThisInstructionMeter {
     fn new(compute_meter: Rc<RefCell<dyn ComputeMeter>>) -> Self {
@@ -244,9 +253,12 @@ impl Executor for BPFExecutor {
         )?;
         {
             let compute_meter = invoke_context.get_compute_meter();
-            let (mut vm, heap_region) = match create_vm(
+            let is_jit_enabled =
+                invoke_context.is_feature_active(&bpf_just_in_time_compilation::id());
+            let mut vm = match create_vm(
                 program_id,
                 self.executable.as_ref(),
+                parameter_bytes.as_slice(),
                 &parameter_accounts,
                 invoke_context,
             ) {
@@ -258,14 +270,16 @@ impl Executor for BPFExecutor {
             };
 
             log!(logger, "Call BPF program {}", program.unsigned_key());
-            let instruction_meter = ThisInstructionMeter::new(compute_meter.clone());
+            let mut instruction_meter = ThisInstructionMeter::new(compute_meter.clone());
             let before = compute_meter.borrow().get_remaining();
-            let result = vm.execute_program_metered(
+            let result = if is_jit_enabled {
-                parameter_bytes.as_slice(),
+                if vm.jit_compile().is_err() {
-                &[],
+                    return Err(BPFLoaderError::VirtualMachineCreationFailed.into());
-                &[heap_region],
+                }
-                instruction_meter,
+                unsafe { vm.execute_program_jit(&mut instruction_meter) }
-            );
+            } else {
+                vm.execute_program_interpreted(&mut instruction_meter)
+            };
             let after = compute_meter.borrow().get_remaining();
             log!(
                 logger,
@@ -318,8 +332,8 @@ mod tests {
         message_processor::{Executors, ThisInvokeContext},
         process_instruction::ComputeBudget,
     };
-    use solana_sdk::{account::Account, rent::Rent};
+    use solana_sdk::{account::Account, instruction::InstructionError, pubkey::Pubkey, rent::Rent};
-    use std::{cell::RefCell, fs::File, io::Read, ops::Range, rc::Rc};
+    use std::{fs::File, io::Read, ops::Range};
 
     struct TestInstructionMeter {
         remaining: u64,
@@ -334,7 +348,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "ExceededMaxInstructions(10)")]
+    #[should_panic(expected = "ExceededMaxInstructions(31, 10)")]
     fn test_bpf_loader_non_terminating_program() {
         #[rustfmt::skip]
         let program = &[
@@ -344,10 +358,16 @@ mod tests {
         ];
         let input = &mut [0x00];
 
-        let executable = EbpfVm::create_executable_from_text_bytes(program, None).unwrap();
+        let executable = Executable::<BPFError>::from_text_bytes(program, None).unwrap();
-        let mut vm = EbpfVm::<BPFError>::new(executable.as_ref(), Config::default()).unwrap();
+        let mut vm = EbpfVm::<BPFError, TestInstructionMeter>::new(
-        let instruction_meter = TestInstructionMeter { remaining: 10 };
+            executable.as_ref(),
-        vm.execute_program_metered(input, &[], &[], instruction_meter)
+            Config::default(),
+            input,
+            &[],
+        )
+        .unwrap();
+        let mut instruction_meter = TestInstructionMeter { remaining: 10 };
+        vm.execute_program_interpreted(&mut instruction_meter)
             .unwrap();
     }
 

runtime/src/feature_set.rs

@@ -74,6 +74,10 @@ pub mod pull_request_ping_pong_check {
     solana_sdk::declare_id!("5RzEHTnf6D7JPZCvwEzjM19kzBsyjSU3HoMfXaQmVgnZ");
 }
 
+pub mod bpf_just_in_time_compilation {
+    solana_sdk::declare_id!("3bZhti6PMmsdkPxqPT8TPNzB3n9NYbKtnwqEpUDnFuPi");
+}
+
 lazy_static! {
     /// Map of feature identifiers to user-visible description
     pub static ref FEATURE_NAMES: HashMap<Pubkey, &'static str> = [
@@ -94,6 +98,7 @@ lazy_static! {
         (cumulative_rent_related_fixes::id(), "rent fixes (#10206, #10468, #11342)"),
         (pubkey_log_syscall_enabled::id(), "pubkey log syscall"),
         (pull_request_ping_pong_check::id(), "ping-pong packet check #12794"),
+        (bpf_just_in_time_compilation::id(), "bpf just-in-time compilation #12951"),
         /*************** ADD NEW FEATURES HERE ***************/
     ]
     .iter()