//! 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> = 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}"); } }