blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rbpf v0.2.0 (#13365) 

* Updates rbpf to v0.2.0,
which unifies the interfaces of the interpreter and the JIT.
However, the JIT is not enabled yet.
This commit is contained in:
Alexander Meißner 2020-11-04 18:46:26 +01:00 committed by GitHub
parent 5db6e4748d
commit 4999fe298b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 636 additions and 466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@ -5123,9 +5123,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",

2
cli/Cargo.toml
View File

@ -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-sdk = { path = "../sdk", version = "1.5.0" }
solana-stake-program = { path = "../programs/stake", version = "1.5.0" }

6
cli/src/cli.rs
View File

@ -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 {

4
programs/bpf/Cargo.lock generated
View File

@ -2340,9 +2340,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",

2
programs/bpf/Cargo.toml
View File

@ -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"

124
programs/bpf/benches/bpf_loader.rs
View File

@ -6,8 +6,9 @@ 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,
@ -21,11 +22,11 @@ use solana_sdk::{
entrypoint::SUCCESS,
instruction::{AccountMeta, Instruction},
message::Message,
process_instruction::{ComputeMeter, InvokeContext, MockInvokeContext},
process_instruction::{InvokeContext, MockInvokeContext},
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
@ -71,9 +72,7 @@ fn bench_program_create_executable(bencher: &mut Bencher) {
let elf = load_elf("bench_alu").unwrap();
bencher.iter(|| {
let _ =
EbpfVm::<solana_bpf_loader_program::BPFError>::create_executable_from_elf(&elf, None)
.unwrap();
let _ = Executable::<solana_bpf_loader_program::BPFError>::from_elf(&elf, None).unwrap();
});
}
@ -91,11 +90,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)
.unwrap();
let (mut vm, _) = solana_bpf_loader_program::create_vm(
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(),
&mut inner_iter,
&[],
&mut invoke_context,
)
@ -104,7 +105,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!(
@ -113,7 +115,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();
@ -124,31 +127,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:");
// vm.jit_compile().unwrap();
// unsafe {
// assert_eq!(
// 0, /*success*/
// vm.execute_program_jit(&mut inner_iter).unwrap()
// );
// }
// assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
// assert_eq!(
// ARMSTRONG_EXPECTED,
// LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
// );
println!("JIT to native:");
vm.jit_compile().unwrap();
unsafe {
assert_eq!(
SUCCESS,
vm.execute_program_jit(&mut instruction_meter).unwrap()
);
}
assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
assert_eq!(
ARMSTRONG_EXPECTED,
LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
);
// bencher.iter(|| unsafe {
// vm.execute_program_jit(&mut inner_iter).unwrap();
// });
// let summary = bencher.bench(|_bencher| {}).unwrap();
// println!(" {:?} instructions", instructions);
// println!(" {:?} ns/iter median", summary.median as u64);
// assert!(0f64 != summary.median);
// let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
// println!(" {:?} MIPS", mips);
// println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_jit_to_native_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
bencher.iter(|| unsafe {
vm.execute_program_jit(&mut instruction_meter).unwrap();
});
let summary = bencher.bench(|_bencher| {}).unwrap();
println!(" {:?} instructions", instructions);
println!(" {:?} ns/iter median", summary.median as u64);
assert!(0f64 != summary.median);
let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
println!(" {:?} MIPS", mips);
println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_jit_to_native_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
}
#[bench]
@ -191,22 +193,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,
@ -222,7 +208,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,
@ -230,8 +216,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(),
@ -244,19 +246,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()
}
}

39
programs/bpf/tests/programs.rs
View File

@ -6,8 +6,9 @@ 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,
@ -23,7 +24,7 @@ use solana_sdk::{
instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError},
keyed_account::KeyedAccount,
message::Message,
process_instruction::{BpfComputeBudget, MockInvokeContext},
process_instruction::{BpfComputeBudget, InvokeContext, MockInvokeContext},
pubkey::Pubkey,
signature::{Keypair, Signer},
sysvar::{clock, fees, rent, slot_hashes, stake_history},
@ -74,25 +75,29 @@ fn run_program(
file.read_to_end(&mut data).unwrap();
let loader_id = bpf_loader::id();
let mut invoke_context = MockInvokeContext::default();
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(
let 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();
@ -722,8 +727,11 @@ fn test_program_bpf_call_depth() {
let result = bank_client.send_and_confirm_instruction(&mint_keypair, instruction);
assert!(result.is_ok());
let instruction =
Instruction::new(program_id, &BpfComputeBudget::default().max_call_depth, vec![]);
let instruction = Instruction::new(
program_id,
&BpfComputeBudget::default().max_call_depth,
vec![],
);
let result = bank_client.send_and_confirm_instruction(&mint_keypair, instruction);
assert!(result.is_err());
}
@ -811,7 +819,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

2
programs/bpf_loader/Cargo.toml
View File

@ -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]

60
programs/bpf_loader/src/lib.rs
View File

@ -12,6 +12,7 @@ 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},
@ -92,7 +93,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()
@ -107,13 +108,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 bpf_compute_budget = invoke_context.get_bpf_compute_budget();
let mut vm = EbpfVm::new(
executable,
@ -121,10 +129,11 @@ pub fn create_vm<'a>(
max_call_depth: bpf_compute_budget.max_call_depth,
stack_frame_size: bpf_compute_budget.stack_frame_size,
},
parameter_bytes,
&[heap_region],
)?;
let heap_region =
syscalls::register_syscalls(loader_id, &mut vm, parameter_accounts, invoke_context)?;
Ok((vm, heap_region))
syscalls::register_syscalls(loader_id, &mut vm, parameter_accounts, invoke_context, heap)?;
Ok(vm)
}
pub fn process_instruction(
@ -189,8 +198,8 @@ pub fn process_instruction(
}
/// Passed to the VM to enforce the compute budget
struct ThisInstructionMeter {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
pub struct ThisInstructionMeter {
pub compute_meter: Rc<RefCell<dyn ComputeMeter>>,
}
impl ThisInstructionMeter {
fn new(compute_meter: Rc<RefCell<dyn ComputeMeter>>) -> Self {
@ -242,9 +251,10 @@ impl Executor for BPFExecutor {
)?;
{
let compute_meter = invoke_context.get_compute_meter();
let (mut vm, heap_region) = match create_vm(
let mut vm = match create_vm(
program_id,
self.executable.as_ref(),
parameter_bytes.as_slice(),
&parameter_accounts,
invoke_context,
) {
@ -256,14 +266,17 @@ 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(
parameter_bytes.as_slice(),
&[],
&[heap_region],
instruction_meter,
);
const IS_JIT_ENABLED: bool = false;
let result = if IS_JIT_ENABLED {
if vm.jit_compile().is_err() {
return Err(BPFLoaderError::VirtualMachineCreationFailed.into());
}
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,
@ -316,6 +329,7 @@ mod tests {
feature_set::FeatureSet,
instruction::InstructionError,
process_instruction::{BpfComputeBudget, MockInvokeContext},
pubkey::Pubkey,
rent::Rent,
};
use std::{cell::RefCell, fs::File, io::Read, ops::Range, rc::Rc};
@ -333,7 +347,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 = &[
@ -343,10 +357,16 @@ mod tests {
];
let input = &mut [0x00];
let executable = EbpfVm::create_executable_from_text_bytes(program, None).unwrap();
let mut vm = EbpfVm::<BPFError>::new(executable.as_ref(), Config::default()).unwrap();
let instruction_meter = TestInstructionMeter { remaining: 10 };
vm.execute_program_metered(input, &[], &[], instruction_meter)
let executable = Executable::<BPFError>::from_text_bytes(program, None).unwrap();
let mut vm = EbpfVm::<BPFError, TestInstructionMeter>::new(
executable.as_ref(),
Config::default(),
input,
&[],
)
.unwrap();
let mut instruction_meter = TestInstructionMeter { remaining: 10 };
vm.execute_program_interpreted(&mut instruction_meter)
.unwrap();
}

859
programs/bpf_loader/src/syscalls.rs
View File

File diff suppressed because it is too large Load Diff