Files

230 lines
8.1 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}");
}
}
#[cfg(feature = "resource-diagnostics")]
#[allow(dead_code)]
#[path = "support/callables.rs"]
mod provenance_callables;
#[cfg(feature = "resource-diagnostics")]
#[test]
fn provenance_queries_allocate_nothing_at_all_qualification_sizes() {
use prometeu_bytecode::model::ConstantPoolEntry;
use prometeu_vm::string_provenance_qualification::Fixture;
for count in [1024_usize, 16384, 65536] {
let constants = vec![ConstantPoolEntry::String("same".into()); count];
let image = provenance_callables::image_constants(
&[("RET", provenance_callables::sig(&[], &[]), vec![])],
vec![],
&constants,
)
.unwrap();
let mut fixture = Fixture::new(image, count);
let work = fixture.work();
let bound = count.ilog2() as usize + 1;
assert!(work[0] <= bound && work[1] <= bound);
for workload in ["image_hit", "image_miss", "session_hit", "session_miss", "import_hit"] {
COUNTS.with(|c| c.set(Some((0, 0))));
for _ in 0..100 {
fixture.run(workload);
}
let counts = COUNTS.with(|c| c.replace(None)).unwrap();
assert_eq!(counts, (0, 0), "{workload}, owners={count}");
}
COUNTS.with(|c| c.set(Some((0, 0))));
fixture.run("snapshot_mixed");
let counts = COUNTS.with(|c| c.replace(None)).unwrap();
assert_eq!(counts, (1, 1), "only snapshot Value storage allocates");
}
}
#[path = "support/identity.rs"]
mod identity_support;
#[test]
fn identity_and_borrowed_hash_instruction_regions_do_not_allocate() {
use prometeu_bytecode::model::ConstantPoolEntry as K;
for (name, initialize, operand, operation, steps, closure) in [
("hash_i64", "PUSH_I64 -73\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4100", 4, false),
("hash_float", "PUSH_CONST 0\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4101", 4, false),
("hash_string", "PUSH_CONST 1\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4102", 4, false),
(
"struct_hash",
"STRUCT_NEW 5\nSET_LOCAL 0",
"GET_LOCAL 0",
"REF_IDENTITY_HASH 5",
4,
false,
),
(
"array_hash",
"PUSH_I64 0\nARRAY_NEW 6\nSET_LOCAL 0",
"GET_LOCAL 0",
"REF_IDENTITY_HASH 6",
4,
false,
),
(
"fn_hash",
"MAKE_CLOSURE fn=1,type=9\nSET_LOCAL 0",
"GET_LOCAL 0",
"REF_IDENTITY_HASH 9",
4,
true,
),
(
"random_hash",
"PUSH_I64 1\nINTRINSIC 0x4000\nSET_LOCAL 0",
"GET_LOCAL 0",
"REF_IDENTITY_HASH 10",
4,
false,
),
(
"trait_hash",
"STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nSET_LOCAL 1\nSET_LOCAL 0",
"GET_LOCAL 0\nGET_LOCAL 1",
"REF_IDENTITY_HASH 7",
5,
false,
),
(
"struct_eq",
"STRUCT_NEW 5\nSET_LOCAL 0",
"GET_LOCAL 0\nGET_LOCAL 0",
"REF_IDENTITY_EQ left=5,right=5",
5,
false,
),
(
"trait_eq",
"STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nSET_LOCAL 1\nSET_LOCAL 0",
"GET_LOCAL 0\nGET_LOCAL 1\nGET_LOCAL 0\nGET_LOCAL 1",
"REF_IDENTITY_EQ left=7,right=7",
7,
false,
),
] {
let start = assemble(initialize).unwrap().len();
let text = format!("{initialize}\n{operand}\n{operation}\nPOP\nJMP {start}");
let mut bodies = vec![(text.as_str(), identity_support::sig(&[], &[]))];
if closure {
bodies.push(("RET", identity_support::sig(&[], &[])));
}
let mut vm =
identity_support::vm(&bodies, &[K::Float64(-0.0), K::String("π\0".repeat(512))]);
let mut host = HostContext::new(None);
while vm.pc() != start {
vm.step(&mut identity_support::Native, &mut host).unwrap();
}
for _ in 0..steps * 10 {
vm.step(&mut identity_support::Native, &mut host).unwrap();
}
let heap_allocations = vm.heap().allocation_count();
COUNTS.with(|c| c.set(Some((0, 0))));
for _ in 0..steps * 1000 {
vm.step(&mut identity_support::Native, &mut host).unwrap();
}
let counts = COUNTS.with(|c| c.replace(None).unwrap());
assert_eq!(counts, (0, 0), "{name}: allocations and deallocations");
assert_eq!(vm.heap().allocation_count(), heap_allocations, "{name}: guest allocations");
}
}