Files
bquarkz 3899b7f12c
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
feat(vm): add resource diagnostics and macOS stability qualification
2026-10-14 08:26:07 +01:00

205 lines
7.6 KiB
Rust

use prometeu_bytecode::{
Value, assemble, load_limits::LoadBudget, registry::*, registry_codec::PbxModule,
};
use prometeu_hal::{HostContext, HostReturn, NativeInterface};
use prometeu_vm::{LogicalFrameEndingReason, ValidatedProgramImage, VirtualMachine};
use std::sync::Arc;
pub const NAMES: [&str; 3] = ["collections", "closures", "strings_dynamic"];
pub struct Native;
impl NativeInterface for Native {
fn syscall(
&mut self,
_: u32,
_: &[Value],
_: &mut HostReturn,
_: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
panic!("workload has no syscalls")
}
}
fn field(id: u32) -> NamedType {
NamedType { type_id: TypeId(id), name: None }
}
fn sig(results: &[u32]) -> Signature {
Signature { parameters: vec![], results: results.iter().copied().map(TypeId).collect() }
}
pub fn image(name: &str) -> Arc<ValidatedProgramImage> {
let mut kinds = vec![
TypeKind::Builtin(BuiltinId::INT64),
TypeKind::Builtin(BuiltinId::INT32),
TypeKind::Builtin(BuiltinId::FLOAT),
TypeKind::Builtin(BuiltinId::BOOL),
TypeKind::Builtin(BuiltinId::STRING),
TypeKind::Builtin(BuiltinId::DYNAMIC),
TypeKind::Builtin(BuiltinId::VEC2),
];
kinds.extend([
TypeKind::Struct(vec![field(0), field(7), field(4), field(5)]),
TypeKind::Array(TypeId(7)),
TypeKind::Fn(sig(&[0])),
TypeKind::Array(TypeId(4)),
]);
let (root, body, captures) = match name {
"collections" => {
// Each iteration publishes one self-cycle plus a rooted containing array.
let chunk = "STRUCT_NEW 7\nSET_LOCAL 0\nGET_LOCAL 0\nGET_LOCAL 0\nSTRUCT_SET type=7,field=1\nGET_LOCAL 0\nPUSH_I64 73\nSTRUCT_SET type=7,field=0\nPUSH_I64 2\nARRAY_NEW 8\nSET_LOCAL 1\nGET_LOCAL 1\nPUSH_I64 0\nGET_LOCAL 0\nARRAY_SET 8\nGET_LOCAL 1\nPUSH_I64 0\nARRAY_GET 8\nSTRUCT_GET type=7,field=0\nPOP\n";
(
format!("{}GET_LOCAL 0\nSTRUCT_GET type=7,field=0\nRET", chunk.repeat(64)),
"RET".to_owned(),
vec![],
)
}
"closures" => (
format!(
"{}PUSH_I64 73\nMAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET",
"PUSH_I64 73\nMAKE_CLOSURE fn=1,type=9\nPOP\n".repeat(127)
),
"FRAME_SYNC\nGET_CAPTURE 0\nRET".to_owned(),
vec![TypeId(0)],
),
"strings_dynamic" => {
let chunk = "PUSH_CONST 0\nPUSH_CONST 1\nADD\nSET_LOCAL 0\nPUSH_I64 1\nARRAY_NEW 10\nSET_LOCAL 1\nGET_LOCAL 1\nPUSH_I64 0\nGET_LOCAL 0\nARRAY_SET 10\nGET_LOCAL 1\nPUSH_I64 0\nARRAY_GET 10\nDYN_PACK 4\nDYN_UNPACK 4\nPOP\n";
(
format!("{}GET_LOCAL 0\nPUSH_CONST 2\nEQ\nRET", chunk.repeat(64)),
"RET".to_owned(),
vec![],
)
}
_ => panic!("unknown workload"),
};
let mut code = assemble(&root).unwrap();
let body = assemble(&body).unwrap();
let functions = vec![
FunctionDecl {
signature: sig(&[if name == "strings_dynamic" { 3 } else { 0 }]),
local_slots: 2,
max_stack_slots: 32,
code_len: code.len() as u32,
..Default::default()
},
FunctionDecl {
signature: if name == "closures" { sig(&[0]) } else { sig(&[]) },
captures,
code_offset: code.len() as u32,
code_len: body.len() as u32,
max_stack_slots: 4,
..Default::default()
},
];
code.extend(body);
let mut budget = LoadBudget::new(Default::default());
let registry = Registry::resolve(
RegistryDeclarations {
types: kinds.into_iter().map(|kind| TypeDecl { name: None, kind }).collect(),
functions,
implementations: vec![],
},
code.len(),
&mut budget,
)
.unwrap();
let constants = vec![
prometeu_bytecode::model::ConstantPoolEntry::String("resource".into()),
prometeu_bytecode::model::ConstantPoolEntry::String("-73".into()),
prometeu_bytecode::model::ConstantPoolEntry::String("resource-73".into()),
];
let bytes = PbxModule {
registry: &registry,
code: &code,
constants: &constants,
debug: None,
exports: &[],
syscalls: &[],
}
.serialize(&mut budget)
.unwrap();
ValidatedProgramImage::load(
&bytes,
&mut LoadBudget::new(Default::default()),
prometeu_hal::syscalls::caps::NONE,
)
.unwrap()
}
pub struct Workload {
pub name: &'static str,
pub vm: VirtualMachine,
pub frames: u64,
pub digest: u64,
prepare: bool,
envelope: Option<([u64; 8], usize, usize, usize)>,
}
impl Workload {
pub fn new(name: &'static str) -> Self {
Self {
name,
vm: VirtualMachine::from_image(image(name), Default::default()),
frames: 0,
digest: 0xcbf29ce484222325,
prepare: true,
envelope: None,
}
}
pub fn frame(&mut self) {
if self.prepare {
self.vm.prepare_boot_call().unwrap();
}
let mut finished = false;
for _ in 0..1_000 {
let r = self.vm.run_budget(10_000, &mut Native, &mut HostContext::new(None)).unwrap();
self.digest = (self.digest ^ r.cycles_used).wrapping_mul(0x100000001b3);
match r.reason {
LogicalFrameEndingReason::BudgetExhausted => {}
LogicalFrameEndingReason::FrameSync => {
self.prepare = false;
finished = true;
break;
}
LogicalFrameEndingReason::EndOfRom => {
let expected = if self.name == "strings_dynamic" {
Value::Boolean(true)
} else {
Value::Int64(73)
};
assert_eq!(&*self.vm.operand_stack_top(1), &[expected]);
self.prepare = true;
finished = true;
break;
}
reason => panic!("{} unexpected {reason:?}", self.name),
}
}
assert!(finished, "bounded workload did not complete");
self.frames += 1;
self.digest = (self.digest ^ self.vm.pc() as u64 ^ self.frames).wrapping_mul(0x100000001b3);
}
pub fn check_stationary(&mut self) {
let s = self.vm.resource_snapshot();
assert_eq!(s.budget.used[3], 0, "temporary reservations must be refunded");
assert_eq!(s.retired_handles, 0);
assert_eq!(s.call_depth, 0, "checkpoint at root completion");
// Default threshold 1024; fixtures allocate a divisor of 1024 per entry.
// The closure is rooted at FRAME_SYNC collection, then dies at RET.
// RET has insufficient new allocations to trigger another collection;
// one unrooted object legitimately waits for the next threshold sweep.
assert_eq!(s.live_objects, usize::from(self.name == "closures"));
assert_eq!(s.tracked_strings, 0);
let now = (s.budget.used, s.live_objects, s.free_handles, s.tracked_strings);
if let Some(expected) = &self.envelope {
assert_eq!(&now, expected, "{} stationary envelope", self.name);
} else {
self.envelope = Some(now);
}
}
pub fn finish(self) {
let observer = self.vm.resource_observer();
drop(self);
assert_eq!(
observer.diagnostic_snapshot().used,
[0; 8],
"last session owner must release every reservation"
);
}
}