100 lines
3.4 KiB
Rust
100 lines
3.4 KiB
Rust
//! Count only this thread's warmed instruction region, including reallocations.
|
|
use prometeu_bytecode::{assemble, load_limits::LoadBudget, registry::*};
|
|
use prometeu_hal::{HostContext, syscalls::caps};
|
|
use prometeu_test_support::program::{TestProgram, int64_signature};
|
|
use prometeu_vm::{ValidatedProgramImage, VirtualMachine};
|
|
use std::alloc::{GlobalAlloc, Layout, System};
|
|
use std::cell::Cell;
|
|
struct Native;
|
|
impl prometeu_hal::NativeInterface for Native {
|
|
fn syscall(
|
|
&mut self,
|
|
_: u32,
|
|
_: &[prometeu_bytecode::Value],
|
|
_: &mut prometeu_hal::HostReturn,
|
|
_: &mut HostContext,
|
|
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
|
panic!("no syscalls in allocation fixtures")
|
|
}
|
|
}
|
|
|
|
thread_local! {
|
|
static COUNTS: Cell<Option<(usize, usize)>> = const { Cell::new(None) };
|
|
}
|
|
struct Counter;
|
|
fn count(alloc: usize, free: usize) {
|
|
let _ = COUNTS.try_with(|c| {
|
|
if let Some((a, d)) = c.get() {
|
|
c.set(Some((a + alloc, d + free)));
|
|
}
|
|
});
|
|
}
|
|
unsafe impl GlobalAlloc for Counter {
|
|
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
|
|
count(1, 0);
|
|
unsafe { System.alloc(l) }
|
|
}
|
|
unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {
|
|
count(1, 0);
|
|
unsafe { System.alloc_zeroed(l) }
|
|
}
|
|
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
|
|
count(0, 1);
|
|
unsafe { System.dealloc(p, l) }
|
|
}
|
|
unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 {
|
|
count(1, 1);
|
|
unsafe { System.realloc(p, l, n) }
|
|
}
|
|
}
|
|
#[global_allocator]
|
|
static ALLOCATOR: Counter = Counter;
|
|
|
|
#[test]
|
|
fn warmed_instruction_regions_do_not_allocate() {
|
|
let mut observations = vec![];
|
|
for (name, caller, callee, results, steps) in [
|
|
("scalar", "CALL 1\nPOP\nJMP 0", "PUSH_I64 42\nRET", 1, 5),
|
|
("void", "CALL 1\nJMP 0", "RET", 0, 3),
|
|
("multi", "CALL 1\nPOP\nPOP\nJMP 0", "PUSH_I64 11\nPUSH_I64 22\nRET", 2, 7),
|
|
("arithmetic_peek", "PUSH_I64 3\nDUP\nADD\nPOP\nJMP 0", "RET", 0, 5),
|
|
] {
|
|
let mut code = assemble(caller).unwrap();
|
|
let offset = code.len();
|
|
let body = assemble(callee).unwrap();
|
|
let mut program = TestProgram::single(code.clone(), int64_signature(0, 0), 4, 8);
|
|
program.functions.push(FunctionDecl {
|
|
signature: int64_signature(0, results),
|
|
code_offset: offset as u32,
|
|
code_len: body.len() as u32,
|
|
local_slots: 4,
|
|
max_stack_slots: 8,
|
|
..Default::default()
|
|
});
|
|
code.extend(body);
|
|
program.code = code;
|
|
let image = ValidatedProgramImage::load(
|
|
&program.serialize(),
|
|
&mut LoadBudget::new(Default::default()),
|
|
caps::NONE,
|
|
)
|
|
.unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut host = HostContext::new(None);
|
|
for _ in 0..steps * 10 {
|
|
vm.step(&mut Native, &mut host).unwrap();
|
|
}
|
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
|
for _ in 0..steps * 1000 {
|
|
vm.step(&mut Native, &mut host).unwrap();
|
|
}
|
|
let counts = COUNTS.with(|c| c.replace(None).unwrap());
|
|
println!("{name}: 1000 iterations, {counts:?} allocations/deallocations");
|
|
observations.push((name, counts));
|
|
}
|
|
for (name, counts) in observations {
|
|
assert_eq!(counts, (0, 0), "{name}");
|
|
}
|
|
}
|