2078 lines
138 KiB
Rust
2078 lines
138 KiB
Rust
use prometeu_bytecode::Value;
|
|
mod stack_queue;
|
|
mod lifecycle;
|
|
use prometeu_bytecode::load_limits::{LoadBudget, LoadLimits};
|
|
use prometeu_hal::syscalls::caps;
|
|
use prometeu_vm::{
|
|
HostContext, HostReturn, NativeInterface, ValidatedProgramImage, VirtualMachine,
|
|
};
|
|
|
|
struct HasCart(usize);
|
|
impl NativeInterface for HasCart {
|
|
fn syscall(
|
|
&mut self,
|
|
id: u32,
|
|
args: &[Value],
|
|
ret: &mut HostReturn,
|
|
_: &mut HostContext,
|
|
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
|
assert_eq!(id, 1);
|
|
assert!(args.is_empty());
|
|
self.0 += 1;
|
|
ret.push_bool(false);
|
|
Ok(())
|
|
}
|
|
}
|
|
struct NoNative;
|
|
impl NativeInterface for NoNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_: u32,
|
|
_: &[Value],
|
|
_: &mut HostReturn,
|
|
_: &mut HostContext,
|
|
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
|
panic!("fixture unexpectedly invoked native code")
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let root = std::path::PathBuf::from(std::env::args().nth(1).expect("fixture directory"));
|
|
use prometeu_vm::resource_budget::{RuntimeLimits,RuntimeResource as Q};
|
|
let limits=RuntimeLimits::default();
|
|
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations,Q::IndividualStringBytes,Q::CallDepth] {
|
|
println!("DEFAULT VM LIMIT {resource:?}={}",limits.get(resource));
|
|
}
|
|
if std::env::args().any(|arg| arg == "--lifecycle-only") { lifecycle::verify(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--stack-queue-only") { stack_queue::verify(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--map-only") { verify_pbs_map_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--set-only") { verify_pbs_set_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--identity-hashing-only") { verify_identity_hashing_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--linked-only") { verify_common_storage_fixtures(&root); verify_pbs_linked_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--list-cursor-only") { verify_common_storage_fixtures(&root); verify_pbs_list_cursor_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--generic-contracts-only") { verify_pbs_generic_contract_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--generic-structs-only") { verify_pbs_generic_struct_fixtures(&root); return; }
|
|
if std::env::args().any(|arg| arg == "--random-only") { verify_pbs_random_fixtures(&root); return; }
|
|
verify_pbs_math_fixtures(&root);
|
|
if std::env::args().any(|arg| arg == "--math-only") { return; }
|
|
verify_pbs_random_fixtures(&root);
|
|
verify_identity_hashing_fixtures(&root);
|
|
verify_catalog_fixtures(&root);
|
|
verify_pbs_fixtures(&root);
|
|
verify_pbs_structured_fixtures(&root);
|
|
verify_pbs_generic_contract_fixtures(&root);
|
|
verify_pbs_generic_struct_fixtures(&root);
|
|
verify_common_storage_fixtures(&root);
|
|
verify_pbs_list_cursor_fixtures(&root);
|
|
verify_pbs_linked_fixtures(&root);
|
|
verify_pbs_set_fixtures(&root);
|
|
verify_pbs_map_fixtures(&root);
|
|
stack_queue::verify(&root);
|
|
lifecycle::verify(&root);
|
|
verify_pbs_resource_refusals(&root);
|
|
verify_pbs_closure_frames(&root);
|
|
for name in [
|
|
"minimal",
|
|
"jump-end",
|
|
"vec2-signature",
|
|
"closure-capture",
|
|
"trait-call",
|
|
"array-dynamic",
|
|
"common-pipeline",
|
|
"roles",
|
|
"join",
|
|
"memcard-role",
|
|
"intrinsic-dot",
|
|
] {
|
|
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
let image = ValidatedProgramImage::load(
|
|
&bytes,
|
|
&mut LoadBudget::new(LoadLimits::default()),
|
|
caps::NONE,
|
|
)
|
|
.unwrap_or_else(|e| panic!("{name}: {e:?}"));
|
|
println!("LOAD PASS {name}");
|
|
if name != "vec2-signature" {
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm
|
|
.run_budget(1000, &mut NoNative, &mut HostContext::new(None))
|
|
.unwrap();
|
|
let reason = format!("{:?}", report.reason);
|
|
assert!(
|
|
reason == "Halted" || reason == "EndOfRom",
|
|
"{name}: {report:?}"
|
|
);
|
|
if name == "closure-capture" || name == "trait-call" {
|
|
assert!(matches!(vm.operand_stack_top(1)[0], Value::Int32(42)));
|
|
}
|
|
if name == "intrinsic-dot" {
|
|
assert!(
|
|
matches!(vm.operand_stack_top(1)[0], Value::Float(value) if value.to_bits() == 11f64.to_bits())
|
|
);
|
|
}
|
|
if name == "array-dynamic" {
|
|
assert!(matches!(vm.operand_stack_top(1)[0], Value::Int32(0)));
|
|
}
|
|
println!(
|
|
"EXEC PASS {name}: {reason}, {} steps",
|
|
report.steps_executed
|
|
);
|
|
}
|
|
}
|
|
for name in ["native", "unknown-native", "native-abi", "unused-native"] {
|
|
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
if name == "native" {
|
|
let image = ValidatedProgramImage::load(
|
|
&bytes,
|
|
&mut LoadBudget::new(LoadLimits::default()),
|
|
caps::SYSTEM,
|
|
)
|
|
.unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut native = HasCart(0);
|
|
let report = vm
|
|
.run_budget(1000, &mut native, &mut HostContext::new(None))
|
|
.unwrap();
|
|
assert_eq!(native.0, 1);
|
|
assert_eq!(format!("{:?}", report.reason), "Halted");
|
|
println!("BIND + EXEC PASS native with SYSTEM");
|
|
}
|
|
let capabilities = if name == "native" {
|
|
caps::NONE
|
|
} else {
|
|
caps::SYSTEM
|
|
};
|
|
let error = ValidatedProgramImage::load(
|
|
&bytes,
|
|
&mut LoadBudget::new(LoadLimits::default()),
|
|
capabilities,
|
|
)
|
|
.unwrap_err();
|
|
record_fault(&root, name, error);
|
|
}
|
|
let baseline = std::fs::read(root.join("minimal.pbx")).unwrap();
|
|
for (name, offset, value) in [
|
|
("version", 4, 1),
|
|
("unsupported-section", 116, 9),
|
|
("unknown-builtin", 178, 0),
|
|
("invalid-role", 136, 4),
|
|
("retired-opcode", 162, 0x54),
|
|
] {
|
|
let mut bytes = baseline.clone();
|
|
bytes[offset] = value;
|
|
reject(&root, name, &bytes, LoadLimits::default());
|
|
}
|
|
for (name, code, max) in [
|
|
("raw-syscall", vec![0x70, 0, 1, 0, 0, 0, 1, 0], 0),
|
|
("hostcall-index", vec![0x71, 0, 0, 0, 0, 0, 1, 0], 0),
|
|
(
|
|
"retired-spawn",
|
|
vec![0x54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
|
|
0,
|
|
),
|
|
("retired-yield", vec![0x55, 0, 1, 0], 0),
|
|
("retired-sleep", vec![0x56, 0, 0, 0, 0, 0, 1, 0], 0),
|
|
(
|
|
"unreachable-reference",
|
|
vec![1, 0, 0x50, 0, 255, 255, 255, 255],
|
|
0,
|
|
),
|
|
(
|
|
"nonfinite",
|
|
vec![1, 0, 0x15, 0, 0, 0, 0, 0, 0, 0, 0xf0, 0x7f],
|
|
0,
|
|
),
|
|
("jump-immediate", vec![2, 0, 3, 0, 0, 0, 1, 0], 0),
|
|
("zero-max", vec![0x17, 0, 0, 0, 0, 0, 1, 0], 0),
|
|
("return-height", vec![0x17, 0, 0, 0, 0, 0, 0x51, 0], 1),
|
|
("fallthrough", vec![0, 0], 0),
|
|
] {
|
|
let mut functions = section(&baseline, 1).to_vec();
|
|
functions[18..22].copy_from_slice(&(code.len() as u32).to_le_bytes());
|
|
functions[26..30].copy_from_slice(&(max as u32).to_le_bytes());
|
|
let bytes = replace(&replace(&baseline, 1, &functions), 2, &code);
|
|
reject(&root, name, &bytes, LoadLimits::default());
|
|
}
|
|
// Two mutually recursive Array declarations: a structural cycle, with valid IDs.
|
|
reject(
|
|
&root,
|
|
"array-cycle",
|
|
&replace(
|
|
&baseline,
|
|
6,
|
|
&[2, 0, 0, 0, 2, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0],
|
|
),
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"structural-cycle",
|
|
&replace(
|
|
&baseline,
|
|
6,
|
|
&[
|
|
2, 0, 0, 0, 4, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
|
|
],
|
|
),
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"invalid-type-reference",
|
|
&replace(&baseline, 6, &[1, 0, 0, 0, 2, 0, 99, 0, 0, 0]),
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"invalid-utf8",
|
|
&replace(
|
|
&baseline,
|
|
6,
|
|
&[1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 255, 0x13, 0, 0, 0],
|
|
),
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"removed-input",
|
|
&replace(&baseline, 6, &[1, 0, 0, 0, 0, 0, 0, 1, 0, 0]),
|
|
LoadLimits::default(),
|
|
);
|
|
let mut overlap = baseline.clone();
|
|
overlap[36..40].copy_from_slice(&0u32.to_le_bytes());
|
|
reject(&root, "overlap", &overlap, LoadLimits::default());
|
|
reject(
|
|
&root,
|
|
"truncated",
|
|
&baseline[..baseline.len() - 1],
|
|
LoadLimits::default(),
|
|
);
|
|
let mut duplicate = baseline.clone();
|
|
duplicate[44..48].copy_from_slice(&0u32.to_le_bytes());
|
|
reject(
|
|
&root,
|
|
"duplicate-section",
|
|
&duplicate,
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"empty-entry",
|
|
&replace(&replace(&baseline, 1, &[0, 0, 0, 0]), 8, &[0, 0, 0, 0]),
|
|
LoadLimits::default(),
|
|
);
|
|
reject(
|
|
&root,
|
|
"resource-types",
|
|
&baseline,
|
|
LoadLimits {
|
|
types: 0,
|
|
..Default::default()
|
|
},
|
|
);
|
|
reject(
|
|
&root,
|
|
"resource-scratch",
|
|
&baseline,
|
|
LoadLimits {
|
|
temporary_bytes: 0,
|
|
..Default::default()
|
|
},
|
|
);
|
|
reject(
|
|
&root,
|
|
"resource",
|
|
&baseline,
|
|
LoadLimits {
|
|
work: 0,
|
|
..Default::default()
|
|
},
|
|
);
|
|
}
|
|
|
|
fn verify_catalog_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let mut random_cycles = None;
|
|
for name in ["catalog-random-off", "catalog-random-on", "catalog-constants", "catalog-vec2-zero", "catalog-input", "catalog-string", "catalog-null-hash", "catalog-null-hash-optimized"] {
|
|
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
|
.unwrap_or_else(|error| panic!("{name}: {error:?}"));
|
|
println!("LOAD PASS {name}");
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
if name == "catalog-input" {
|
|
assert!(matches!(report.reason, End::Trap(ref trap) if trap.code == prometeu_bytecode::TRAP_UNAVAILABLE));
|
|
println!("EXEC PASS {name}: TRAP_UNAVAILABLE (known query, no hardware)");
|
|
continue;
|
|
}
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
if name.starts_with("catalog-random-") {
|
|
// Independent seed-42 vector and unit-range consumption from the provider handoff/tests.
|
|
assert_eq!(vm.operand_stack_top(3), vec![
|
|
Value::Int64(0xF9090E529A7DAE00u64 as i64), Value::Int64(-7),
|
|
Value::Float(f64::from_bits(0x3FB304AA46C98538)),
|
|
], "{name}: aliasing, discarded first next, mixed operations and exact order");
|
|
if let Some(cycles) = random_cycles { assert_eq!(report.cycles_used, cycles, "optimization changed charged work"); }
|
|
random_cycles = Some(report.cycles_used);
|
|
} else if name == "catalog-vec2-zero" {
|
|
assert_eq!(vm.operand_stack_top(2), vec![Value::Float(0.0), Value::Float(0.0)]);
|
|
} else if name == "catalog-string" {
|
|
assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(0xAABBCCDD)]);
|
|
} else if name.starts_with("catalog-null-hash") {
|
|
assert_eq!(vm.operand_stack_top(1),vec![Value::Int64(0)],"provider null hash vector");
|
|
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
|
assert_eq!(report.cycles_used,Op::PushConst.cycles()+8+Op::Halt.cycles());
|
|
} else {
|
|
let mut constants: Vec<_> = prometeu_vm::builtin_constant_catalog().collect();
|
|
constants.sort_by_key(|constant| constant.key.key());
|
|
let mut expected = Vec::new();
|
|
for constant in constants { expected.extend(constant.materialize().unwrap()); }
|
|
expected.reverse();
|
|
let actual = vm.operand_stack_top(expected.len());
|
|
assert_eq!(actual.len(), 16);
|
|
for (actual, expected) in actual.iter().zip(expected.iter()) {
|
|
match (actual, expected) {
|
|
(Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits()),
|
|
_ => assert_eq!(actual, expected),
|
|
}
|
|
}
|
|
}
|
|
println!("EXEC PASS {name}: {} cycles, {} steps", report.cycles_used, report.steps_executed);
|
|
}
|
|
let removed = std::fs::read(root.join("catalog-removed.pbx")).unwrap();
|
|
reject(root, "catalog-removed", &removed, LoadLimits::default());
|
|
let null_string = std::fs::read(root.join("catalog-null-string.pbx")).unwrap();
|
|
reject(root, "catalog-null-string", &null_string, LoadLimits::default());
|
|
}
|
|
|
|
fn reject(root: &std::path::Path, name: &str, bytes: &[u8], limits: LoadLimits) {
|
|
let error =
|
|
ValidatedProgramImage::load(bytes, &mut LoadBudget::new(limits), caps::NONE).unwrap_err();
|
|
record_fault(root, name, error);
|
|
}
|
|
fn record_fault(root: &std::path::Path, name: &str, error: prometeu_vm::VmInitError) {
|
|
if let prometeu_vm::VmInitError::RegistryLoadFailed(ref failure) = error {
|
|
let expected = match name {
|
|
"array-cycle" => Some("ArrayCycle"),
|
|
"structural-cycle" => Some("StructuralTypeCycle"),
|
|
"invalid-type-reference" => Some("TypeId"),
|
|
"invalid-utf8" => Some("Utf8"),
|
|
"removed-input" => Some("Builtin"),
|
|
"retired-spawn" | "retired-yield" | "retired-sleep" => Some("RemovedOpcode"),
|
|
"nonfinite" => Some("NonFiniteValue"),
|
|
"unreachable-reference" => Some("FunctionId"),
|
|
"return-height" => Some("ReturnHeight"),
|
|
"fallthrough" => Some("UnterminatedPath"),
|
|
"zero-max" => Some("StackOverflow"),
|
|
"duplicate-section" => Some("DuplicateSection"),
|
|
_ => None,
|
|
};
|
|
if let Some(reason) = expected {
|
|
assert_eq!(format!("{:?}", failure.reason), reason, "{name}");
|
|
}
|
|
}
|
|
let report = prometeu_system::CrashReport::VmInit { error };
|
|
assert_eq!(report.pc(), None);
|
|
let fault = serde_json::json!({"kind":"vm_init", "pc":null, "summary":"Conformance fixture", "initError":report.init_diagnostic().unwrap()});
|
|
let full: serde_json::Value = serde_json::from_slice(
|
|
&std::fs::read(std::env::args().nth(2).expect("schema path")).unwrap(),
|
|
)
|
|
.unwrap();
|
|
let schema = jsonschema::validator_for(
|
|
&serde_json::json!({"$defs":full["$defs"],"$ref":"#/$defs/fault"}),
|
|
)
|
|
.unwrap();
|
|
if !schema.is_valid(&fault) {
|
|
let reason = fault["initError"]["load"]["reason"].as_str().unwrap();
|
|
assert!(
|
|
["LifecycleRole", "NonFiniteValue"].contains(&reason),
|
|
"unexpected schema failure: {fault}"
|
|
);
|
|
// Validate the ORIGINAL payload with only the observed missing enum value added.
|
|
// This is an explicit upstream defect report, not a claim of published-schema conformance.
|
|
let mut corrected = full.clone();
|
|
corrected["$defs"]["loadFailure"]["properties"]["reason"]["enum"]
|
|
.as_array_mut()
|
|
.unwrap()
|
|
.push(serde_json::json!(reason));
|
|
jsonschema::validator_for(
|
|
&serde_json::json!({"$defs":corrected["$defs"],"$ref":"#/$defs/fault"}),
|
|
)
|
|
.unwrap()
|
|
.validate(&fault)
|
|
.unwrap();
|
|
println!(
|
|
"UPSTREAM SCHEMA GAP: {reason} missing from published enum; original payload preserved"
|
|
);
|
|
}
|
|
std::fs::write(
|
|
root.join(format!("fault-{name}.json")),
|
|
serde_json::to_vec_pretty(&fault).unwrap(),
|
|
)
|
|
.unwrap();
|
|
println!("REJECT PASS {name}: {}", fault["initError"]);
|
|
}
|
|
|
|
fn word(bytes: &[u8], at: usize) -> usize {
|
|
u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap()) as usize
|
|
}
|
|
fn section(bytes: &[u8], kind: usize) -> &[u8] {
|
|
for i in 0..word(bytes, 8) {
|
|
let at = 32 + 12 * i;
|
|
if word(bytes, at) == kind {
|
|
let offset = word(bytes, at + 4);
|
|
return &bytes[offset..offset + word(bytes, at + 8)];
|
|
}
|
|
}
|
|
panic!("missing section {kind}")
|
|
}
|
|
fn replace(bytes: &[u8], kind: usize, payload: &[u8]) -> Vec<u8> {
|
|
let count = word(bytes, 8);
|
|
let mut output = bytes[..32 + 12 * count].to_vec();
|
|
for i in 0..count {
|
|
let at = 32 + 12 * i;
|
|
let body = if word(bytes, at) == kind {
|
|
payload
|
|
} else {
|
|
section(bytes, word(bytes, at))
|
|
};
|
|
let offset = output.len() as u32;
|
|
output[at + 4..at + 8].copy_from_slice(&offset.to_le_bytes());
|
|
output[at + 8..at + 12].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
|
output.extend_from_slice(body);
|
|
}
|
|
output
|
|
}
|
|
|
|
// Controlled provider boundary: every input read checks its identity and is counted.
|
|
struct PbsInput {
|
|
expected: usize,
|
|
reads: std::cell::Cell<usize>,
|
|
button: prometeu_hal::button::Button,
|
|
}
|
|
impl PbsInput {
|
|
fn read(&self, index: usize) -> &prometeu_hal::button::Button {
|
|
assert_eq!(index, self.expected, "PBS queried an unselected endpoint");
|
|
self.reads.set(self.reads.get() + 1);
|
|
&self.button
|
|
}
|
|
}
|
|
impl prometeu_hal::PadBridge for PbsInput {
|
|
fn begin_frame(&mut self, _: &prometeu_hal::InputSignals) { unreachable!() }
|
|
fn any(&self) -> bool { unreachable!() }
|
|
fn up(&self) -> &prometeu_hal::button::Button { self.read(0) }
|
|
fn down(&self) -> &prometeu_hal::button::Button { self.read(1) }
|
|
fn left(&self) -> &prometeu_hal::button::Button { self.read(2) }
|
|
fn right(&self) -> &prometeu_hal::button::Button { self.read(3) }
|
|
fn a(&self) -> &prometeu_hal::button::Button { self.read(4) }
|
|
fn b(&self) -> &prometeu_hal::button::Button { self.read(5) }
|
|
fn x(&self) -> &prometeu_hal::button::Button { self.read(6) }
|
|
fn y(&self) -> &prometeu_hal::button::Button { self.read(7) }
|
|
fn l(&self) -> &prometeu_hal::button::Button { self.read(8) }
|
|
fn r(&self) -> &prometeu_hal::button::Button { self.read(9) }
|
|
fn start(&self) -> &prometeu_hal::button::Button { self.read(10) }
|
|
fn select(&self) -> &prometeu_hal::button::Button { self.read(11) }
|
|
}
|
|
impl prometeu_hal::TouchBridge for PbsInput {
|
|
fn begin_frame(&mut self, _: &prometeu_hal::InputSignals) { unreachable!() }
|
|
fn f(&self) -> &prometeu_hal::button::Button { self.read(12) }
|
|
fn x(&self) -> i32 { self.read(13); -123 }
|
|
fn y(&self) -> i32 { self.read(14); 456 }
|
|
}
|
|
impl prometeu_hal::InputPlatform for PbsInput {
|
|
fn pad(&self) -> &dyn prometeu_hal::PadBridge { self }
|
|
fn pad_mut(&mut self) -> &mut dyn prometeu_hal::PadBridge { self }
|
|
fn touch(&self) -> &dyn prometeu_hal::TouchBridge { self }
|
|
fn touch_mut(&mut self) -> &mut dyn prometeu_hal::TouchBridge { self }
|
|
}
|
|
impl prometeu_hal::RuntimePlatform for PbsInput {
|
|
fn input(&self) -> &dyn prometeu_hal::InputPlatform { self }
|
|
fn input_mut(&mut self) -> &mut dyn prometeu_hal::InputPlatform { self }
|
|
fn wall_clock(&self) -> &dyn prometeu_hal::WallClock { unreachable!("non-input platform access") }
|
|
fn render_submission_sink(&mut self) -> &mut dyn prometeu_hal::RenderSubmissionSink { unreachable!("non-input platform access") }
|
|
fn render_backend(&mut self) -> &mut dyn prometeu_hal::RenderBackend { unreachable!("non-input platform access") }
|
|
fn game2d_frame_composer(&mut self) -> &mut dyn prometeu_hal::Game2DFrameComposer { unreachable!("non-input platform access") }
|
|
fn audio(&self) -> &dyn prometeu_hal::AudioBridge { unreachable!("non-input platform access") }
|
|
fn audio_mut(&mut self) -> &mut dyn prometeu_hal::AudioBridge { unreachable!("non-input platform access") }
|
|
fn assets(&self) -> &dyn prometeu_hal::AssetBridge { unreachable!("non-input platform access") }
|
|
fn assets_mut(&mut self) -> &mut dyn prometeu_hal::AssetBridge { unreachable!("non-input platform access") }
|
|
fn telemetry(&self) -> &dyn prometeu_hal::TelemetryPlatform { unreachable!("non-input platform access") }
|
|
}
|
|
fn verify_pbs_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let buttons = ["up","down","left","right","a","b","x","y","l","r","start","select"];
|
|
let mut count = 0;
|
|
let mut defaults_checked = std::collections::BTreeSet::new();
|
|
for entry in std::fs::read_dir(root).unwrap() {
|
|
let path = entry.unwrap().path();
|
|
let name = path.file_stem().unwrap().to_str().unwrap();
|
|
if name.starts_with("pbs-random-") || name.starts_with("pbs-math-") || name.starts_with("pbs-structured-") || name.starts_with("pbs-generic-contract-") || name.starts_with("pbs-generic-struct-") || name.starts_with("pbs-list-") || name.starts_with("pbs-linked-") || name.starts_with("pbs-hash-") || name.starts_with("pbs-set-") || name.starts_with("pbs-map-") || name.starts_with("pbs-stack-") || name.starts_with("pbs-queue-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
|
|
count += 1;
|
|
let bytes = std::fs::read(&path).unwrap();
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
|
.unwrap_or_else(|e| panic!("{name}: {e:?}"));
|
|
for (index, ty) in image.registry().declarations().types.iter().enumerate() {
|
|
if let prometeu_bytecode::registry::TypeKind::Builtin(id) = ty.kind {
|
|
let expected = match id.0 {
|
|
1 | 0x11 => vec![Value::Int64(0)],
|
|
2 => vec![Value::Float(0.0), Value::Float(0.0)],
|
|
3 => vec![Value::Int64(0), Value::Int64(0), Value::Int64(0)],
|
|
0x10 => vec![Value::Int32(0)], 0x12 => vec![Value::Float(0.0)],
|
|
0x13 => vec![Value::Boolean(false)], 0x14 => vec![Value::Null],
|
|
_ => panic!("unexpected PBS builtin {}", id.0),
|
|
};
|
|
assert_eq!(image.registry().type_layout(prometeu_bytecode::registry::TypeId(index as u32)).unwrap().storage.default_values(), expected);
|
|
defaults_checked.insert(id.0);
|
|
}
|
|
}
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let parts: Vec<_> = name.split('-').collect();
|
|
if parts[1] == "pad" || parts[1] == "touch" {
|
|
let query = if parts[1] == "pad" { &parts[3] } else { parts.last().unwrap() };
|
|
let expected = if parts[1] == "pad" { buttons.iter().position(|b| *b == parts[2]).unwrap() }
|
|
else { match *query { "x" => 13, "y" => 14, _ => 12 } };
|
|
let button = prometeu_hal::button::Button { pressed: expected % 2 == 0, released: expected % 3 == 0, down: expected % 5 == 0, hold_frames: 100 + expected as u16 };
|
|
let value = match *query {
|
|
"pressed" => Value::Boolean(button.pressed), "released" => Value::Boolean(button.released), "down" => Value::Boolean(button.down),
|
|
"hold" => Value::Int64(button.hold_frames.into()), "x" => Value::Int64(-123), "y" => Value::Int64(456), _ => unreachable!()
|
|
};
|
|
let mut input = PbsInput { expected, reads: std::cell::Cell::new(0), button };
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(Some(&mut input))).unwrap();
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1), vec![value], "{name}");
|
|
assert_eq!(input.reads.get(), 1, "{name}: exactly one input query");
|
|
let unavailable_image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut unavailable_vm = VirtualMachine::from_image(unavailable_image, Default::default());
|
|
unavailable_vm.prepare_boot_call().unwrap();
|
|
let unavailable = unavailable_vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(unavailable.reason, End::Trap(ref trap) if trap.code == prometeu_bytecode::TRAP_UNAVAILABLE));
|
|
} else {
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
match parts[1] {
|
|
"numeric" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{report:?}"); assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(2147483655)]); }
|
|
"vec2" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(2), vec![Value::Float(0.0),Value::Float(0.0)]); }
|
|
"tuple" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(2), vec![Value::Int64(8),Value::Int32(7)]); }
|
|
"named" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(1), vec![Value::Int32(211020)]); }
|
|
"color" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(0xFF0000FF)]); }
|
|
"pixel" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{report:?}"); assert_eq!(vm.operand_stack_top(3), vec![Value::Int64(0xFF0000FF),Value::Int64(-34),Value::Int64(12)]); }
|
|
"string" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert!(matches!(&vm.operand_stack_top(1)[0], Value::String(value) if value.as_ref() == "hello")); }
|
|
"division" => assert!(matches!(report.reason, End::Trap(ref trap) if trap.code == prometeu_bytecode::TRAP_DIV_ZERO)),
|
|
"minimum" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(i64::MIN)]); }
|
|
"float" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{report:?}"); assert_eq!(vm.operand_stack_top(1), vec![Value::Float(3.75)]); }
|
|
"overflow" => { assert!(matches!(report.reason, End::Halted | End::EndOfRom)); assert_eq!(vm.operand_stack_top(1), vec![Value::Int32(i32::MIN)]); }
|
|
"narrow" => assert!(matches!(report.reason, End::Trap(ref trap) if trap.code == prometeu_bytecode::TRAP_NUMERIC_RANGE), "{name}: {report:?}"),
|
|
_ => panic!("unasserted PBS fixture: {name}"),
|
|
}
|
|
}
|
|
println!("PBS SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
assert_eq!(defaults_checked, [1,2,3,0x10,0x11,0x12,0x13,0x14].into_iter().collect());
|
|
println!("PBS Registry defaults PASS: all eight existing value types");
|
|
assert_eq!(count, 114, "The complete PBS qualification corpus must be present");
|
|
}
|
|
|
|
fn verify_pbs_structured_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let success = ["closure-import", "closure-installed", "closure-groups", "closure-isolation", "closure-fields", "closure-functions", "closure-snapshot", "closure-objects", "closure-nested", "array-cycle", "array-nested", "array-parametric", "optional-flow", "struct-contract", "service-contract",
|
|
"optional-tuple", "tuple-storage", "optional-intrinsics", "optional-lazy", "array-context",
|
|
"binding-scope", "overloads", "single-evaluation", "long-boundaries", "gc-roots", "native-groups", "contract-elements", "imports", "global-array", "installed-example", "return-overloads", "inferred-optional-tuple", "inline-integers"];
|
|
for name in success.into_iter().chain(["negative-index", "past-end", "negative-length", "large-length"]) {
|
|
let bytes = std::fs::read(root.join(format!("pbs-structured-{name}.pbx")))
|
|
.unwrap_or_else(|e| panic!("missing mandatory PBS structured fixture {name}: {e}"));
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
|
.unwrap_or_else(|e| panic!("{name}: {e:?}"));
|
|
let limits = if name == "inline-integers" {
|
|
prometeu_vm::resource_budget::RuntimeLimits::default()
|
|
.lowered(prometeu_vm::resource_budget::RuntimeResource::HandleSlots, 1).unwrap()
|
|
} else { Default::default() };
|
|
let mut vm = VirtualMachine::from_image(image, limits);
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
if name == "gc-roots" {
|
|
assert!(matches!(report.reason, End::FrameSync), "{report:?}");
|
|
let snapshot = vm.resource_snapshot();
|
|
assert_eq!(snapshot.gc.collections, 1);
|
|
assert!(snapshot.gc.reclaimed >= 1100, "{:?}", snapshot.gc);
|
|
report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
}
|
|
match name {
|
|
"negative-index" | "past-end" | "negative-length" => assert!(matches!(report.reason,
|
|
End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_OOB), "{name}: {report:?}"),
|
|
"large-length" => assert!(matches!(report.reason,
|
|
End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_RESOURCE_LIMIT), "{name}: {report:?}"),
|
|
_ => {
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1), vec![Value::Int32(42)], "{name}");
|
|
}
|
|
}
|
|
if name == "inline-integers" { assert_eq!(vm.heap().len(), 1, "single-slot integers must not allocate boxes"); }
|
|
let ownership = vm.resource_observer();
|
|
drop(vm);
|
|
for resource in [prometeu_vm::resource_budget::RuntimeResource::StringBytes,
|
|
prometeu_vm::resource_budget::RuntimeResource::StringAllocations] {
|
|
assert_eq!(ownership.used(resource), 0, "{name}: string ownership released");
|
|
}
|
|
println!("PBS STRUCTURED SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_generic_struct_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits, RuntimeResource}};
|
|
use prometeu_bytecode::registry::TypeKind;
|
|
let mut object_heap = None;
|
|
let mut function_heap = None;
|
|
for name in ["basic", "manual", "constructor", "phantom", "tuple", "optional", "array", "recursive",
|
|
"combined", "function", "function-manual", "gc", "imports", "installed", "multiple", "origins"] {
|
|
let bytes = std::fs::read(root.join(format!("pbs-generic-struct-{name}.pbx")))
|
|
.unwrap_or_else(|error| panic!("missing mandatory generic struct/function fixture {name}: {error}"));
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
|
.unwrap_or_else(|error| panic!("generic struct/function {name}: {error:?}"));
|
|
let declarations = image.registry().declarations();
|
|
if name == "phantom" {
|
|
let structs = declarations.types.iter().filter(|t| matches!(t.kind, TypeKind::Struct(_))
|
|
&& t.name.as_deref().is_some_and(|name| name.starts_with("Marker<"))).count();
|
|
assert_eq!(structs, 2, "phantom arguments preserve distinct nominal applications");
|
|
}
|
|
if name == "origins" {
|
|
assert_eq!(declarations.types.iter().filter(|t| t.name.as_deref() == Some("Enemy")).count(), 2);
|
|
assert_eq!(declarations.types.iter().filter(|t| t.name.as_deref() == Some("Box<Enemy>")).count(), 2);
|
|
}
|
|
if name == "combined" || name == "imports" {
|
|
assert_eq!(declarations.implementations.len(), 1, "one concrete owner/contract pair, shared across aliases");
|
|
let first = &declarations.implementations[0];
|
|
assert_eq!(image.registry().implementation(first.owner, first.trait_id).unwrap().0, 0);
|
|
}
|
|
println!("PBS GENERIC STRUCT METADATA {name}: types={} implementations={} bytes={}", declarations.types.len(), declarations.implementations.len(), bytes.len());
|
|
let limits = if ["basic", "manual", "function", "function-manual"].contains(&name) {
|
|
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 1).unwrap()
|
|
} else { RuntimeLimits::default() };
|
|
let mut vm = VirtualMachine::from_image(image, limits);
|
|
let observer = vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
if name == "gc" {
|
|
assert!(matches!(report.reason, End::FrameSync), "{name}: {report:?}");
|
|
let gc = vm.resource_snapshot().gc;
|
|
assert!(gc.collections >= 1 && gc.reclaimed >= 1100, "{gc:?}");
|
|
report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
}
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
if name != "imports" && name != "origins" { assert_eq!(vm.operand_stack_top(1), vec![Value::Int32(42)], "{name}"); }
|
|
if name == "basic" || name == "manual" {
|
|
assert_eq!(vm.heap().len(), 1, "one object, without a generic wrapper");
|
|
let heap = observer.used(RuntimeResource::GuestBytes);
|
|
if let Some(reference) = object_heap { assert_eq!(heap, reference); }
|
|
object_heap = Some(heap);
|
|
}
|
|
if name == "function" || name == "function-manual" {
|
|
let heap = observer.used(RuntimeResource::GuestBytes);
|
|
if let Some(reference) = function_heap { assert_eq!(heap, reference); }
|
|
function_heap = Some(heap);
|
|
}
|
|
drop(vm);
|
|
for resource in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots, RuntimeResource::AuxiliaryBytes,
|
|
RuntimeResource::TemporaryBytes, RuntimeResource::StringBytes, RuntimeResource::StringAllocations] {
|
|
assert_eq!(observer.used(resource), 0, "{name}: release {resource:?}");
|
|
}
|
|
if name == "basic" || name == "combined" {
|
|
for (resource, limit) in [(RuntimeResource::GuestBytes, 0), (RuntimeResource::HandleSlots, 0)] {
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut refused = VirtualMachine::from_image(image, RuntimeLimits::default().lowered(resource, limit).unwrap());
|
|
let observed = refused.resource_observer();
|
|
refused.prepare_boot_call().unwrap();
|
|
let report = refused.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_RESOURCE_LIMIT), "{name}/{resource:?}: {report:?}");
|
|
assert_eq!(refused.heap().len(), 0);
|
|
assert!(observed.used(resource) <= limit);
|
|
drop(refused);
|
|
for domain in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots, RuntimeResource::AuxiliaryBytes, RuntimeResource::TemporaryBytes] {
|
|
assert_eq!(observed.used(domain), 0);
|
|
}
|
|
}
|
|
}
|
|
println!("PBS GENERIC STRUCT SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_generic_contract_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits, RuntimeResource}};
|
|
use prometeu_bytecode::{registry::{TypeId, TypeKind}, isa::core::CoreOpCode};
|
|
let mut reference_heap = None;
|
|
for name in ["identity", "manual", "multiple", "tuple", "optional", "function", "contract", "native", "recursive", "phantom", "receiver", "gc", "installed", "imports"] {
|
|
let bytes = std::fs::read(root.join(format!("pbs-generic-contract-{name}.pbx")))
|
|
.unwrap_or_else(|error| panic!("missing mandatory generic-contract fixture {name}: {error}"));
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
|
.unwrap_or_else(|error| panic!("generic contract {name}: {error:?}"));
|
|
let declarations = image.registry().declarations();
|
|
let traits: Vec<_> = declarations.types.iter().enumerate().filter(|(_, t)| matches!(t.kind, TypeKind::Trait(_))).collect();
|
|
assert!(!traits.is_empty(), "{name}: source must emit concrete traits");
|
|
for (index, _) in &traits {
|
|
assert_eq!(image.registry().type_layout(TypeId(*index as u32)).unwrap().storage.default_values(), &[Value::Null, Value::Null], "{name}: absent concrete trait");
|
|
}
|
|
assert!(!declarations.implementations.is_empty());
|
|
// The first dense implementation is valid; zero must never act as an absence sentinel.
|
|
assert_eq!(image.registry().implementation(declarations.implementations[0].owner, declarations.implementations[0].trait_id).unwrap().0, 0);
|
|
if name == "multiple" || name == "phantom" {
|
|
assert_eq!(traits.len(), 2);
|
|
assert_eq!(declarations.implementations.len(), 2);
|
|
assert_eq!(declarations.implementations[0].owner, declarations.implementations[1].owner);
|
|
assert_ne!(declarations.implementations[0].trait_id, declarations.implementations[1].trait_id);
|
|
}
|
|
if name == "imports" { assert_eq!(traits.len(), 3); assert_eq!(declarations.implementations.len(), 3); }
|
|
if name == "phantom" {
|
|
let mut code = image.code().to_vec();
|
|
let mut pc = 0;
|
|
let mut changed = false;
|
|
while pc < code.len() {
|
|
let instruction = prometeu_bytecode::decode_next(pc, &code).unwrap();
|
|
if instruction.opcode == CoreOpCode::CallTrait {
|
|
let (original, _) = instruction.imm_u32x2().unwrap();
|
|
let other = traits.iter().map(|(index, _)| *index as u32).find(|id| *id != original).unwrap();
|
|
code[pc+2..pc+6].copy_from_slice(&other.to_le_bytes());
|
|
changed = true; break;
|
|
}
|
|
pc = instruction.next_pc;
|
|
}
|
|
assert!(changed);
|
|
let corrupt = replace(&bytes, 2, &code);
|
|
match ValidatedProgramImage::load(&corrupt, &mut LoadBudget::new(LoadLimits::default()), caps::NONE) {
|
|
Err(error) => record_fault(root, "generic-contract-wrong-view", error),
|
|
Ok(image) => {
|
|
// Unknown receiver facts may defer rejection to the mandatory runtime check.
|
|
let mut invalid = VirtualMachine::from_image(image, RuntimeLimits::default());
|
|
invalid.prepare_boot_call().unwrap();
|
|
let report = invalid.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_TYPE), "mismatched concrete view: {report:?}");
|
|
}
|
|
}
|
|
println!("PBS GENERIC WRONG-VIEW REJECTION PASS");
|
|
}
|
|
println!("PBS GENERIC METADATA {name}: types={} implementations={} bytes={}", declarations.types.len(), declarations.implementations.len(), bytes.len());
|
|
let limits = if name == "identity" || name == "manual" {
|
|
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 1).unwrap()
|
|
} else { RuntimeLimits::default() };
|
|
let mut vm = VirtualMachine::from_image(image, limits);
|
|
let observer = vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
if name == "gc" {
|
|
assert!(matches!(report.reason, End::FrameSync), "{name}: {report:?}");
|
|
let gc = vm.resource_snapshot().gc;
|
|
assert!(gc.collections >= 1 && gc.reclaimed >= 1100, "{gc:?}");
|
|
report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
}
|
|
if name == "imports" {
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
} else {
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1), vec![Value::Int32(42)], "{name}");
|
|
}
|
|
if name == "identity" || name == "manual" {
|
|
assert_eq!(vm.heap().len(), 1, "no generic argument box or view wrapper");
|
|
let heap = observer.used(RuntimeResource::GuestBytes);
|
|
if let Some(reference) = reference_heap { assert_eq!(heap, reference, "generic and manual contract heap footprints"); }
|
|
reference_heap = Some(heap);
|
|
}
|
|
drop(vm);
|
|
for resource in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots, RuntimeResource::AuxiliaryBytes,
|
|
RuntimeResource::TemporaryBytes, RuntimeResource::StringBytes, RuntimeResource::StringAllocations] {
|
|
assert_eq!(observer.used(resource), 0, "{name}: release {resource:?}");
|
|
}
|
|
if name == "identity" || name == "receiver" {
|
|
for (resource, limit) in [(RuntimeResource::GuestBytes, 0), (RuntimeResource::GuestBytes, 1), (RuntimeResource::GuestBytes, 2), (RuntimeResource::HandleSlots, 0)] {
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut refused = VirtualMachine::from_image(image, RuntimeLimits::default().lowered(resource, limit).unwrap());
|
|
let observed = refused.resource_observer();
|
|
refused.prepare_boot_call().unwrap();
|
|
let report = refused.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_RESOURCE_LIMIT), "{name}/{resource:?}: {report:?}");
|
|
assert_eq!(refused.heap().len(), 0, "refusal cannot publish partial objects");
|
|
assert!(observed.used(resource) <= limit);
|
|
drop(refused);
|
|
for domain in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots, RuntimeResource::AuxiliaryBytes, RuntimeResource::TemporaryBytes] {
|
|
assert_eq!(observed.used(domain), 0);
|
|
}
|
|
}
|
|
reject(root, &format!("generic-contract-{name}-load-quota"), &bytes, LoadLimits { implementations: 0, ..LoadLimits::default() });
|
|
}
|
|
println!("PBS GENERIC SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_resource_refusals(root: &std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits, RuntimeResource}};
|
|
for name in ["closure-objects", "array-cycle", "tuple-storage", "struct-contract"] {
|
|
for resource in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots] {
|
|
for limit in [0, 1, 2] {
|
|
let bytes = std::fs::read(root.join(format!("pbs-structured-{name}.pbx"))).unwrap();
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let limits = RuntimeLimits::default().lowered(resource, limit).unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, limits);
|
|
let observer = vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(100_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Trap(ref fault) if fault.code == prometeu_bytecode::TRAP_RESOURCE_LIMIT), "{name}/{resource:?}/{limit}: {report:?}");
|
|
assert!(observer.used(resource) <= limit);
|
|
if limit == 0 { assert_eq!(vm.heap().len(), 0, "no partially published object"); }
|
|
drop(vm);
|
|
for domain in [RuntimeResource::GuestBytes, RuntimeResource::HandleSlots,
|
|
RuntimeResource::AuxiliaryBytes, RuntimeResource::TemporaryBytes] {
|
|
assert_eq!(observer.used(domain), 0, "{name}: session ownership released after refusal: {domain:?}");
|
|
}
|
|
println!("PBS QUOTA/OWNERSHIP PASS {name}/{resource:?}/{limit}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_closure_frames(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes = std::fs::read(root.join("closure-frame-lifecycle.pbx")).expect("mandatory closure frame fixture");
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
for frame in 0..3 {
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(2_000_000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "frame {frame}: {report:?}");
|
|
assert!(vm.operand_stack_top(1).is_empty(), "frame root returns void");
|
|
let snapshot = vm.resource_snapshot();
|
|
assert!(snapshot.gc.collections >= frame + 1, "frame {frame}: {:?}", snapshot.gc);
|
|
assert!(snapshot.gc.reclaimed >= (frame + 1) * 1200, "frame {frame}: {:?}", snapshot.gc);
|
|
if frame == 0 { assert!(vm.heap().len() >= 3, "array, closure and capture survive root return"); }
|
|
else { assert_eq!(vm.heap().len(), 1, "only the empty global array remains after closure release"); }
|
|
}
|
|
println!("PBS CLOSURE FRAME LIFECYCLE/RETENTION/GC PASS");
|
|
}
|
|
|
|
// The expected results/call costs are independent provider fixtures. Step costs
|
|
// use the published opcode contract, not observed timings or compiler estimates.
|
|
fn verify_pbs_math_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
|
|
let corpus = std::fs::read_to_string(root.join("math-vectors.tsv")).expect("mandatory math corpus");
|
|
let mut covered = std::collections::BTreeSet::new();
|
|
let mut count = 0;
|
|
let mut original_cycles = std::collections::BTreeMap::new();
|
|
let mut names = std::collections::BTreeSet::new();
|
|
for line in corpus.lines() {
|
|
let parts: Vec<_> = line.split_whitespace().collect();
|
|
let name = parts[0];
|
|
assert!(names.insert(parts[0]), "duplicate math fixture");
|
|
let id = u32::from_str_radix(parts[1], 16).unwrap();
|
|
let expected = parts[parts.len()-2];
|
|
let cost: u64 = parts.last().unwrap().parse().unwrap();
|
|
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let code = image.code().to_vec();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut total = 0;
|
|
let mut calls = 0;
|
|
let ending = loop {
|
|
let pc = vm.pc();
|
|
let opcode = OpCode::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
|
|
let cycles = if opcode == OpCode::Intrinsic {
|
|
let actual = u32::from_le_bytes(code[pc+2..pc+6].try_into().unwrap());
|
|
assert_eq!(actual, id, "{name}: wrong overload or unexpected conversion");
|
|
calls += 1;
|
|
cost
|
|
} else { opcode.cycles() };
|
|
let report = vm.run_budget(1, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert_eq!(report.cycles_used, cycles, "{name}: cycle charge at {pc}, {opcode:?}");
|
|
total += cycles;
|
|
if matches!(report.reason, End::Halted | End::EndOfRom | End::Trap(_)) { break report.reason; }
|
|
assert!(total < 10000, "{name}: nonterminating source fixture");
|
|
};
|
|
assert_eq!(calls, 1, "{name}: preserve literal calls and no hidden conversions");
|
|
if let Some(code) = expected.strip_prefix("trap:") {
|
|
let code = u32::from_str_radix(code,16).unwrap();
|
|
assert!(matches!(ending, End::Trap(ref trap) if trap.code == code), "{name}: {ending:?}");
|
|
} else {
|
|
assert!(matches!(ending, End::Halted | End::EndOfRom), "{name}: {ending:?}");
|
|
let value = vm.operand_stack_top(1);
|
|
let actual = match &value[0] {
|
|
Value::Float(value) => format!("f:{:016x}",value.to_bits()),
|
|
Value::Int32(value) => format!("i:{value}"),
|
|
Value::Int64(value) => format!("l:{value}"),
|
|
value => panic!("{name}: unexpected value {value:?}"),
|
|
};
|
|
assert_eq!(actual, expected, "{name}: exact result bits");
|
|
}
|
|
// A full-budget execution must charge exactly the independently checked steps.
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert_eq!(report.cycles_used, total, "{name}: aggregate cost");
|
|
if let Some(original) = name.strip_suffix("-optimized") {
|
|
assert_eq!(original_cycles.get(original), Some(&total), "{name}: optimization changed cycles");
|
|
} else { original_cycles.insert(name.to_string(), total); }
|
|
covered.insert(id);
|
|
count += 1;
|
|
}
|
|
assert_eq!(covered, (0x3000..=0x3019).collect());
|
|
assert_eq!(count, 522, "mandatory boundary corpus missing");
|
|
for (name, expected) in [("pi", Value::Float(f64::from_bits(0x400921fb54442d18))),
|
|
("tau", Value::Float(f64::from_bits(0x401921fb54442d18))),
|
|
("literal", Value::Float(-0.0)), ("dependency", Value::Int32(42)), ("long", Value::Int64(2147483648)),
|
|
("service", Value::Int32(42)), ("min", Value::Int64(42))] {
|
|
let bytes = std::fs::read(root.join(format!("pbs-math-{name}.pbx"))).unwrap();
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
|
|
let actual = vm.operand_stack_top(1);
|
|
match (&actual[0], &expected) {
|
|
(Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits(), "{name}"),
|
|
_ => assert_eq!(actual, vec![expected]),
|
|
}
|
|
if name == "pi" || name == "tau" || name == "service" { assert_eq!(report.cycles_used, 6, "constant load + root RET only"); }
|
|
}
|
|
let bytes = std::fs::read(root.join("pbs-math-import.pbx")).expect("real SDK imports fixture");
|
|
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "import: {report:?}");
|
|
println!("PBS MATH PASS: {count} exact bits/faults/cycle vectors; all 26 signatures; service constants");
|
|
}
|
|
|
|
|
|
fn verify_pbs_random_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
|
|
let corpus = std::fs::read_to_string(root.join("random-vectors.tsv")).expect("mandatory random seed corpus");
|
|
let mut cases: Vec<(String, Vec<String>, Vec<u64>, Option<u32>)> = Vec::new();
|
|
let mut names = std::collections::BTreeSet::new();
|
|
for row in corpus.lines() {
|
|
let p: Vec<_> = row.split_whitespace().collect();
|
|
assert!(names.insert(p[0]), "duplicate random fixture");
|
|
let draw: usize = p[2].parse().unwrap();
|
|
assert!((1..=8).contains(&draw));
|
|
let mut costs = vec![32];
|
|
costs.extend(std::iter::repeat_n(8, draw-1));
|
|
costs.push(if p[1].starts_with("f:") { 12 } else { 8 });
|
|
cases.push((p[0].to_string(), vec![p[1].to_string()], costs, None));
|
|
}
|
|
assert_eq!(cases.len(), 192, "six seeds, eight draws, two outputs, two optimizer variants required");
|
|
let words = [0x86B1DA1D72062B68u64, 0x1304AA46C9853D39, 0xA3670E9E0DD50358, 0xF9090E529A7DAE00];
|
|
let long = |word: u64| format!("l:{}",word as i64);
|
|
let mut add = |name: &str, expected: Vec<String>, costs: Vec<u64>, fault: Option<u32>| {
|
|
for suffix in ["", "-optimized"] {
|
|
cases.push((format!("pbs-random-{name}{suffix}"), expected.clone(), costs.clone(), fault));
|
|
}
|
|
};
|
|
add("mixed", vec![long(words[3]), "l:-7".into(), "f:3fb304aa46c98538".into()], vec![32,8,12,12,8], None);
|
|
add("storage", vec![long(words[0]),long(words[3]),long(words[2]),long(words[1]),long(words[0])], vec![32,32,8,8,8,8,32,8], None);
|
|
for (name, trace) in [("named",312),("positional",123)] {
|
|
add(name,vec![long(words[3]),"l:-7".into(),format!("i:{trace}")],vec![32,32,8,8,12,8],None);
|
|
}
|
|
let bounds = [(0,1),(-10,-3),(-10,10),(0,16),(i64::MIN,0),(-1,i64::MAX),(i64::MIN,i64::MAX)];
|
|
for (index,(min,max)) in bounds.into_iter().enumerate() {
|
|
let span = (i128::from(max)-i128::from(min)) as u64;
|
|
// Independent provider fixture word, accepted for each of these spans.
|
|
let expected = i128::from(min)+i128::from(words[0]%span);
|
|
assert!(expected>=i128::from(min) && expected<i128::from(max));
|
|
add(&format!("range-{index}"),vec![format!("l:{expected}")],vec![32,12],None);
|
|
}
|
|
for index in [7,8] { add(&format!("range-{index}"),vec![],vec![32,4],Some(prometeu_bytecode::TRAP_NUMERIC_DOMAIN)); }
|
|
let rejected_then_accepted = i128::from(i64::MIN)+i128::from(words[2]%((1u64<<63)+1));
|
|
add("rejection",vec![long(words[3]),format!("l:{rejected_then_accepted}")],vec![32,8,20,8],None);
|
|
for name in ["null","typed-null"] { add(name,vec![],vec![32,8],Some(prometeu_bytecode::TRAP_NULL_REFERENCE)); }
|
|
let mut gc_costs=vec![32;1101]; gc_costs.extend([8,8,8]);
|
|
add("gc",vec![long(words[2]),long(words[1]),long(words[0])],gc_costs,None);
|
|
let mut cycles_by_name = std::collections::BTreeMap::new();
|
|
for (name,expected,costs,fault) in cases {
|
|
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap_or_else(|e|panic!("{name}: {e}"));
|
|
let mut reference = None;
|
|
for budget in [1,100000,100000] {
|
|
let image = ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE)
|
|
.unwrap_or_else(|e|panic!("{name}: {e:?}"));
|
|
let code = image.code().to_vec();
|
|
let mut vm = VirtualMachine::from_image(image,Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let mut total=0;
|
|
let mut calls=0;
|
|
let ending = loop {
|
|
let pc=vm.pc();
|
|
let opcode=OpCode::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
|
|
let report=vm.run_budget(budget,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if budget==1 && opcode==OpCode::Intrinsic {
|
|
let id=u32::from_le_bytes(code[pc+2..pc+6].try_into().unwrap());
|
|
if id == 0x3014 {
|
|
// Explicit source `as long` conversion; not a Random call.
|
|
assert_eq!(report.cycles_used,2,"{name}: explicit Int32 to Int64");
|
|
} else {
|
|
assert!((0x4000..=0x4003).contains(&id),"{name}: wrong intrinsic {id:x}");
|
|
assert_eq!(report.cycles_used,costs[calls],"{name}: call {calls} id={id:x}");
|
|
calls+=1;
|
|
}
|
|
}
|
|
total+=report.cycles_used;
|
|
if matches!(report.reason,End::Halted|End::EndOfRom|End::Trap(_)) { break report.reason; }
|
|
if matches!(report.reason,End::FrameSync) {
|
|
assert!(name.starts_with("pbs-random-gc"));
|
|
let snapshot=vm.resource_snapshot();
|
|
assert_eq!(snapshot.gc.collections,1);
|
|
assert!(snapshot.gc.reclaimed>=1100,"{name}: {:?}",snapshot.gc);
|
|
}
|
|
assert!(total<1000000,"{name}: nontermination");
|
|
};
|
|
if budget==1 { assert_eq!(calls,costs.len(),"{name}: missing or extra calls"); }
|
|
if let Some(fault)=fault {
|
|
assert!(matches!(ending,End::Trap(ref t) if t.code==fault),"{name}: {ending:?}");
|
|
} else {
|
|
assert!(matches!(ending,End::Halted|End::EndOfRom),"{name}: {ending:?}");
|
|
let actual:Vec<_>=vm.operand_stack_top(expected.len()).iter().map(|v|match v {
|
|
Value::Int64(v)=>format!("l:{v}"),Value::Int32(v)=>format!("i:{v}"),
|
|
Value::Float(v)=>format!("f:{:016x}",v.to_bits()),v=>panic!("{name}: {v:?}")
|
|
}).collect();
|
|
assert_eq!(actual,expected,"{name}: output bits/replay");
|
|
}
|
|
if let Some(reference)=reference { assert_eq!(total,reference,"{name}: replay/budget cycles"); }
|
|
reference=Some(total);
|
|
}
|
|
let total=reference.unwrap();
|
|
if let Some(original)=name.strip_suffix("-optimized") {
|
|
assert_eq!(cycles_by_name.get(original),Some(&total),"{name}: optimizer cycles");
|
|
} else { cycles_by_name.insert(name.clone(),total); }
|
|
println!("RANDOM PASS {name}: {total} cycles, exact bits/fault and replay");
|
|
}
|
|
let bytes=std::fs::read(root.join("pbs-random-import.pbx")).expect("mandatory real Random SDK import");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image,Default::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(10000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"Random import: {report:?}");
|
|
println!("RANDOM PASS real SDK imports and aliases");
|
|
|
|
}
|
|
|
|
|
|
fn verify_pbs_list_cursor_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource}};
|
|
use prometeu_bytecode::TRAP_EXPLICIT;
|
|
let successful=["basic","construction","capacity","holes","structural-growth","cursor-empty","cursor-single",
|
|
"cursor-many","snapshot","false-present","shared-optional","identity","tuple","nested-array","function","evaluation","vec2","pixel","contract"];
|
|
let faults=[("fault-read",TRAP_EXPLICIT),("fault-write",TRAP_EXPLICIT),("fault-negative",TRAP_EXPLICIT),
|
|
("fault-insert",TRAP_EXPLICIT),("fault-length",TRAP_EXPLICIT),("fault-overflow",TRAP_EXPLICIT),
|
|
("fault-long-index",TRAP_EXPLICIT),("fault-constructor",TRAP_EXPLICIT)];
|
|
let cases=successful.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,c)|(n,Some(c))))
|
|
.flat_map(|(name,fault)|[(name.to_string(),fault),(format!("{name}-optimized"),fault)]);
|
|
for (name,fault) in cases {
|
|
let bytes=std::fs::read(root.join(format!("pbs-list-{name}.pbx")))
|
|
.unwrap_or_else(|e|panic!("missing mandatory SDK List/Cursor fixture {name}: {e}"));
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE)
|
|
.unwrap_or_else(|e|panic!("List/Cursor {name}: {e:?}"));
|
|
let mut vm=VirtualMachine::from_image(image,RuntimeLimits::default());
|
|
let observer=vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if let Some(code)=fault {
|
|
let End::Trap(info)=report.reason else {panic!("{name}: {report:?}")};
|
|
assert_eq!(info.code,code,"{name}: {info:?}");
|
|
} else {
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)],"{name}");
|
|
}
|
|
drop(vm);
|
|
for resource in [RuntimeResource::GuestBytes,RuntimeResource::HandleSlots,RuntimeResource::AuxiliaryBytes,
|
|
RuntimeResource::TemporaryBytes,RuntimeResource::StringBytes,RuntimeResource::StringAllocations] {
|
|
assert_eq!(observer.used(resource),0,"{name}: final owner release {resource:?}");
|
|
}
|
|
println!("PBS LIST/CURSOR SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
verify_list_cursor_refusals(root);
|
|
verify_list_cursor_gc(root);
|
|
verify_list_cursor_distribution(root);
|
|
}
|
|
|
|
|
|
fn list_storage(vm:&VirtualMachine,image:&ValidatedProgramImage)->(prometeu_vm::resource_diagnostics::StorageObject,prometeu_vm::resource_diagnostics::StorageObject) {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let object=objects.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("list<int>"))
|
|
.expect("one source List remains observable").clone();
|
|
let V::Reference(backing)=object.groups[0][0] else {panic!("List storage reference")};
|
|
let array=objects.iter().find(|o|o.reference==backing).unwrap().clone();
|
|
(object,array)
|
|
}
|
|
|
|
// Non-owning diagnostic snapshots observe only objects reachable before the operation.
|
|
// Compare every instruction prefix against a successful execution, so a refused
|
|
// instruction preserves its own entry state without inventing method rollback.
|
|
type ObservedStorage = Vec<prometeu_vm::resource_diagnostics::StorageObject>;
|
|
type MutationPrefix = (usize, ObservedStorage);
|
|
fn observe_originals(vm:&VirtualMachine, original:&ObservedStorage)->ObservedStorage {
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
original.iter().filter_map(|old|objects.iter().find(|now|now.reference==old.reference).cloned()).collect()
|
|
}
|
|
fn trace_collection_attempt(vm:&mut VirtualMachine, original:&ObservedStorage, stop_pc:usize)
|
|
->(prometeu_vm::BudgetReport, Vec<MutationPrefix>, bool) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let mut prefixes=Vec::new(); let mut mutated=false;
|
|
for _ in 0..200_000 {
|
|
let before=observe_originals(vm,original);
|
|
mutated|=before!=*original;
|
|
prefixes.push((vm.pc(),before.clone()));
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
let after=observe_originals(vm,original);
|
|
if matches!(report.reason,End::Trap(_)) {
|
|
assert_eq!(after,before,"refused instruction preserves its own observable entry state");
|
|
}
|
|
mutated|=after!=*original;
|
|
if vm.pc()==stop_pc || !matches!(report.reason,End::BudgetExhausted) {return (report,prefixes,mutated);}
|
|
}
|
|
panic!("collection operation did not reach its completion marker");
|
|
}
|
|
fn assert_mutation_prefix(actual:&[MutationPrefix], successful:&[MutationPrefix]) {
|
|
assert!(actual.len()<=successful.len(),"refusal must be a successful instruction prefix");
|
|
for (index,(left,right)) in actual.iter().zip(successful).enumerate() {
|
|
assert_eq!(left,right,"observable effects differ at source-operation instruction {index}");
|
|
}
|
|
}
|
|
|
|
fn verify_list_cursor_refusals(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
use prometeu_bytecode::{decode_next,TRAP_RESOURCE_LIMIT};
|
|
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
|
let mut copy_scratch=false;let mut return_carrier=false;let mut nodes=false;let mut candidate=false;let mut operand_preparation=false;
|
|
for name in ["insert","remove","growth","cursor"] {
|
|
for suffix in ["","-optimized"] {
|
|
println!("PHASE CORPUS list {name}{suffix}");
|
|
let bytes=std::fs::read(root.join(format!("pbs-list-refusal-{name}{suffix}.pbx"))).expect("mandatory refusal fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let marker=|value:i32| {
|
|
let mut pc=0;let mut found=Vec::new();
|
|
while pc<image.code().len() {let instruction=decode_next(pc,image.code()).unwrap();
|
|
if instruction.opcode==Op::PushI32&&instruction.imm_i32().unwrap()==value {found.push(pc);}
|
|
pc=instruction.next_pc;
|
|
}
|
|
assert_eq!(found.len(),1,"one explicit test marker");found[0]
|
|
};
|
|
let before_pc=marker(314160);let after_pc=marker(314161);
|
|
let prepare=|limits| {
|
|
let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();
|
|
vm.insert_breakpoint(before_pc);vm.insert_breakpoint(after_pc);vm
|
|
};
|
|
let mut baseline=prepare(RuntimeLimits::default());
|
|
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
|
let before=baseline.resource_snapshot();let original=list_storage(&baseline,&image);
|
|
baseline.remove_breakpoint(before_pc);
|
|
let watched=vec![original.0.clone(),original.1.clone()];
|
|
let (completed_report,successful_prefix,_)=trace_collection_attempt(&mut baseline,&watched,after_pc);
|
|
assert!(matches!(completed_report.reason,End::BudgetExhausted|End::Breakpoint) && baseline.pc()==after_pc,"operation completion: {completed_report:?}");
|
|
let completed=baseline.resource_snapshot();let changed=list_storage(&baseline,&image);
|
|
let expected_size=match name {"insert"|"growth"=>129,"remove"=>127,_=>128};
|
|
assert_eq!(changed.0.groups[1],[V::Int64(expected_size)],"{name} logical size after success");
|
|
if name=="remove" {assert_eq!(changed.1.groups[12][1],V::Int32(13));assert_eq!(changed.1.groups[127],[V::Null,V::Null]);}
|
|
if name=="insert" {assert_eq!(changed.1.groups[12][1],V::Int32(42));assert_eq!(changed.1.groups[13][1],V::Int32(12));}
|
|
if name=="growth" {assert_eq!(changed.1.groups.len(),192);assert_eq!(changed.1.groups[128][1],V::Int32(42));}
|
|
if name=="cursor" {assert_eq!(changed,original);}
|
|
let mut refusals=0;
|
|
for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {
|
|
let lower=before.budget.peaks[q as usize];let upper=completed.budget.peaks[q as usize];
|
|
if lower>=upper {continue;}
|
|
let mut limits=vec![lower,lower+(upper-lower)/4,lower+(upper-lower)/2,upper-1];
|
|
if q==Q::HandleSlots {limits.extend(lower..upper.min(lower+16));}
|
|
limits.sort_unstable();limits.dedup();
|
|
for limit in limits {
|
|
let mut vm=prepare(RuntimeLimits::default().lowered(q,limit).unwrap());
|
|
let observer=vm.resource_observer();
|
|
let setup=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(setup.reason,End::Breakpoint),"{name} setup at {q:?}={limit}: {setup:?}");
|
|
let state=list_storage(&vm,&image);
|
|
vm.remove_breakpoint(before_pc);
|
|
let watched=vec![state.0.clone(),state.1.clone()];
|
|
let (report,prefix,mutated)=trace_collection_attempt(&mut vm,&watched,after_pc);
|
|
assert_mutation_prefix(&prefix,&successful_prefix);
|
|
if let End::Trap(info)=report.reason {
|
|
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"{name} at {q:?}={limit}: {info:?}");
|
|
if !mutated || name=="cursor" {
|
|
assert_eq!(list_storage(&vm,&image),state,"{name}: failure before mutation preserves slots/backing/size");
|
|
}
|
|
let instruction=decode_next(info.pc as usize,image.code()).unwrap();
|
|
copy_scratch|=q==Q::TemporaryBytes&&instruction.opcode==Op::ArrayCopy;
|
|
operand_preparation|=q==Q::AuxiliaryBytes;
|
|
candidate|=name=="growth"&&instruction.opcode==Op::ArrayNew;
|
|
if instruction.opcode==Op::StructNew {
|
|
let ty=instruction.imm_u32().unwrap();
|
|
let declaration=&image.registry().declarations().types[ty as usize];
|
|
nodes|=name=="cursor"&&declaration.name.as_deref().is_some_and(|n|n.starts_with("_SnapshotNode<"));
|
|
if name=="remove" {
|
|
if let prometeu_bytecode::registry::TypeKind::Struct(fields)=&declaration.kind {
|
|
return_carrier|=fields.len()==1&&matches!(image.registry().declarations().types[fields[0].type_id.0 as usize].kind,
|
|
prometeu_bytecode::registry::TypeKind::Builtin(prometeu_bytecode::registry::BuiltinId::INT32));
|
|
}
|
|
}
|
|
}
|
|
refusals+=1;
|
|
println!("PBS LIST PHASE REFUSAL {name} mutated={mutated} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
|
} else {assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint) && vm.pc()==after_pc,"{name}: {report:?}");}
|
|
drop(vm);
|
|
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {assert_eq!(observer.used(resource),0);}
|
|
}
|
|
}
|
|
assert!(refusals>0,"{name}: mandatory source refusals executed");
|
|
}
|
|
}
|
|
assert!(copy_scratch,"no-growth copy scratch refusal");
|
|
assert!(return_carrier,"removeAt optional return allocation refusal");
|
|
assert!(candidate,"growth candidate allocation refusal");
|
|
assert!(nodes,"snapshot node allocation refusal");
|
|
assert!(operand_preparation,"source operation operand/frame preparation refusal");
|
|
}
|
|
|
|
fn verify_list_cursor_gc(root:&std::path::Path) { verify_collection_cursor_gc(root,"list"); }
|
|
|
|
fn verify_collection_cursor_gc(root:&std::path::Path,collection:&str) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeLimits};
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let bytes=std::fs::read(root.join(format!("pbs-{collection}-gc.pbx"))).expect("mandatory snapshot GC fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
|
let mut previous=0;
|
|
for (round,(nodes,items)) in [(1200,1200),(1,1),(1,1),(0,0)].into_iter().enumerate() {
|
|
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::FrameSync),"snapshot GC {round}: {report:?}");
|
|
let snapshot=vm.resource_snapshot();assert!(snapshot.gc.collections>previous);previous=snapshot.gc.collections;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
assert!(!objects.iter().any(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,
|
|
prometeu_bytecode::registry::TypeKind::Array(_))),"Cursor retains no source or snapshot array");
|
|
let named=|name:&str|objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).collect::<Vec<_>>();
|
|
assert_eq!(named("_SnapshotNode<Item>").len(),nodes,"prefix nodes round {round}");
|
|
if collection=="linked" {assert!(named("_LinkedNode<Item>").is_empty(),"snapshot does not retain original Linked nodes");}
|
|
if collection=="set" {assert!(named("_SetNode<Item>").is_empty(),"snapshot does not retain original Set nodes");}
|
|
let values=named("Item");assert_eq!(values.len(),items,"captured object roots round {round}");
|
|
if items==1 && collection!="set" {assert_eq!(values[0].groups[0],[V::Int32(1199)],"sticky last payload remains live");}
|
|
println!("PBS {} CURSOR GC PASS round={round} nodes={nodes} items={items} collected={}",collection.to_uppercase(),snapshot.gc.reclaimed);
|
|
}
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
}
|
|
|
|
fn verify_copy_attempts(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_OOB,TRAP_NULL_REFERENCE,TRAP_RESOURCE_LIMIT};
|
|
for base in ["scalar","vec2","string","zero","bad-range","bad-empty-range","null-source","null-zero","negative-count","huge-count","fault-order"] {
|
|
for optimized in [false,true] {
|
|
let name=format!("common-copy-{base}{}",if optimized{"-optimized"}else{""});
|
|
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory copy oracle");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut pc=0;let mut copies=Vec::new();
|
|
while pc<image.code().len() {
|
|
let instruction=decode_next(pc,image.code()).unwrap();
|
|
assert!(![0xa7,0xa8,0xaa,0xab].contains(&(instruction.opcode as u16)));
|
|
if instruction.opcode==Op::ArrayCopy {copies.push(pc);} pc=instruction.next_pc;
|
|
}
|
|
assert_eq!(copies.len(),1);let copy_pc=copies[0];
|
|
let prepare=|limits| {
|
|
let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();vm.insert_breakpoint(copy_pc);
|
|
assert!(matches!(vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));vm
|
|
};
|
|
let mut vm=prepare(RuntimeLimits::default());let observer=vm.resource_observer();
|
|
let before=vm.heap().diagnostic_typed_storage();let operands=vm.operand_stack_top(5).to_vec();
|
|
let scratch_floor=vm.resource_snapshot().budget.peaks[Q::TemporaryBytes as usize];
|
|
let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert_eq!((zero.cycles_used,zero.steps_executed,vm.pc()),(0,0,copy_pc));
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
let cycles=if base=="vec2"{44}else if ["zero","bad-empty-range","null-zero","negative-count","huge-count","fault-order"].contains(&base){4}else{24};
|
|
assert_eq!(report.cycles_used,cycles,"{name}: precharged cost");
|
|
let fault=if base.starts_with("null-")||base=="fault-order"{Some(TRAP_NULL_REFERENCE)}
|
|
else if ["bad-range","bad-empty-range","negative-count","huge-count"].contains(&base){Some(TRAP_OOB)}else{None};
|
|
if let Some(code)=fault {
|
|
let End::Trap(info)=report.reason else {panic!("{name}: {report:?}")};
|
|
assert_eq!(info.code,code);assert_eq!(report.steps_executed,0);
|
|
assert_eq!(vm.operand_stack_top(5),operands);assert_eq!(vm.heap().diagnostic_typed_storage(),before);
|
|
} else {
|
|
assert!(matches!(report.reason,End::BudgetExhausted));assert_eq!(report.steps_executed,1);
|
|
let mut expected=before.clone();
|
|
if base!="zero" {for i in 0..10 {expected[0].groups[i+2]=before[0].groups[i].clone();}}
|
|
assert_eq!(vm.heap().diagnostic_typed_storage(),expected,"{name}: snapshot overlap and complete native groups");
|
|
}
|
|
assert_eq!(observer.used(Q::TemporaryBytes),0,"copy releases provisional scratch");
|
|
drop(vm);for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations] {assert_eq!(observer.used(resource),0);}
|
|
if base=="scalar" {
|
|
let mut refused=prepare(RuntimeLimits::default().lowered(Q::TemporaryBytes,scratch_floor).unwrap());
|
|
let before=refused.heap().diagnostic_typed_storage();let operands=refused.operand_stack_top(5).to_vec();
|
|
let report=refused.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Trap(ref info) if info.code==TRAP_RESOURCE_LIMIT),"scratch refusal: {report:?}");
|
|
assert_eq!((report.cycles_used,report.steps_executed),(24,0));
|
|
assert_eq!(refused.heap().diagnostic_typed_storage(),before);assert_eq!(refused.operand_stack_top(5),operands);
|
|
assert_eq!(refused.resource_observer().used(Q::TemporaryBytes),0);
|
|
}
|
|
println!("COMMON COPY COST/FAULT/GROUP PASS {name} cycles={cycles}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn verify_common_storage_fixtures(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeLimits};
|
|
verify_copy_attempts(root);
|
|
for name in ["common-storage","common-storage-optimized","common-fields","common-fields-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory non-PBS storage fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image,RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
println!("COMMON STORAGE SOURCE/LOAD/EXEC PASS {name}");
|
|
} for opcode in [0xa7,0xa8,0xaa,0xab] {
|
|
let bytes=std::fs::read(root.join(format!("retired-storage-{opcode:x}.pbx"))).expect("mandatory dead-opcode refusal");
|
|
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err());
|
|
let data=std::fs::read(root.join(format!("storage-immediate-{opcode:x}.pbx"))).unwrap();
|
|
assert!(ValidatedProgramImage::load(&data,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_ok());
|
|
}
|
|
for suffix in ["","-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("common-partial-fault{suffix}.pbx"))).unwrap();
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image,RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Trap(ref info) if info.code==prometeu_bytecode::TRAP_EXPLICIT));
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
assert_eq!(vm.heap().diagnostic_typed_storage()[0].groups[1],[V::Int32(20)],"terminal fault does not undo prior store");
|
|
println!("COMMON PARTIAL FAULT PASS {suffix}");
|
|
}
|
|
|
|
}
|
|
|
|
fn verify_list_cursor_distribution(root:&std::path::Path) { verify_collection_distribution(root,"list",22); }
|
|
|
|
fn verify_collection_distribution(root:&std::path::Path,collection:&str,last:i32) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeLimits};
|
|
for name in ["imports","installed"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-{collection}-{name}.pbx"))).expect("mandatory workspace/installed List fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::FrameSync|End::Halted|End::EndOfRom),"{name}: {report:?}");
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let cursors=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SnapshotCursor<int>")).collect::<Vec<_>>();
|
|
assert!(!cursors.is_empty(),"distributed frame actually created its shared snapshot Cursor");
|
|
let mut retained=Vec::new();
|
|
for cursor in cursors {
|
|
let V::Reference(current)=cursor.groups[0][0] else {panic!("nonempty Cursor retains its current node carrier")};
|
|
let carrier=objects.iter().find(|o|o.reference==current).unwrap();
|
|
let V::Reference(node)=carrier.groups[0][0] else {panic!("current points at a snapshot node")};
|
|
let node=objects.iter().find(|o|o.reference==node).unwrap();
|
|
let V::Int32(value)=node.groups[0][0] else {panic!("typed captured value")};
|
|
retained.push(value);
|
|
assert_eq!(node.groups[1],[V::Null],"{name}: final node has no successor");
|
|
}
|
|
retained.sort_unstable();
|
|
let expected=if collection=="linked"&&name=="installed" {vec![20,22]} else {vec![last]};
|
|
if collection=="set" {
|
|
assert_eq!(retained.len(),1);assert!([20,22].contains(&retained[0]),"Set has no order guarantee");
|
|
}else{assert_eq!(retained,expected,"{collection} {name}: complete traversal retains each final value");}
|
|
println!("PBS {} DISTRIBUTION LOAD/EXEC PASS {name}",collection.to_uppercase());
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_linked_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource}};
|
|
use prometeu_bytecode::TRAP_EXPLICIT;
|
|
let successful=["basic","links","construction","long-size","empty-cursor","empty-reverseCursor",
|
|
"single-cursor","single-reverseCursor","snapshot","false-present","optional-field","identity","tuple","nested-array","function","evaluation","vec2","pixel","contract"];
|
|
let faults=[("fault-read",TRAP_EXPLICIT),("fault-write",TRAP_EXPLICIT),("fault-negative",TRAP_EXPLICIT),
|
|
("fault-insert",TRAP_EXPLICIT),("fault-remove",TRAP_EXPLICIT),("fault-overflow",TRAP_EXPLICIT),("fault-long-index",TRAP_EXPLICIT)];
|
|
let cases=successful.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,c)|(n,Some(c))))
|
|
.flat_map(|(name,fault)|[(name.to_string(),fault),(format!("{name}-optimized"),fault)]);
|
|
for (name,fault) in cases {
|
|
let bytes=std::fs::read(root.join(format!("pbs-linked-{name}.pbx")))
|
|
.unwrap_or_else(|e|panic!("missing mandatory SDK Linked fixture {name}: {e}"));
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE)
|
|
.unwrap_or_else(|e|panic!("Linked {name}: {e:?}"));
|
|
let mut vm=VirtualMachine::from_image(image,RuntimeLimits::default());
|
|
let observer=vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if let Some(code)=fault {
|
|
let End::Trap(info)=report.reason else {panic!("{name}: {report:?}")};
|
|
assert_eq!(info.code,code,"{name}: {info:?}");
|
|
} else {
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)],"{name}");
|
|
}
|
|
drop(vm);
|
|
for resource in [RuntimeResource::GuestBytes,RuntimeResource::HandleSlots,RuntimeResource::AuxiliaryBytes,
|
|
RuntimeResource::TemporaryBytes,RuntimeResource::StringBytes,RuntimeResource::StringAllocations] {
|
|
assert_eq!(observer.used(resource),0,"{name}: final owner release {resource:?}");
|
|
}
|
|
println!("PBS LINKED SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
verify_linked_collection_gc(root);
|
|
verify_linked_refusals(root);
|
|
verify_collection_cursor_gc(root,"linked");
|
|
verify_collection_distribution(root,"linked",20);
|
|
}
|
|
|
|
fn linked_state(vm:&VirtualMachine,image:&ValidatedProgramImage)->Vec<prometeu_vm::resource_diagnostics::StorageObject> {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let root=objects.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("linked<int>"))
|
|
.expect("source Linked remains observable");
|
|
let mut pending=vec![root.reference];let mut state=Vec::new();
|
|
while let Some(reference)=pending.pop() {
|
|
if state.iter().any(|o:&prometeu_vm::resource_diagnostics::StorageObject|o.reference==reference) {continue;}
|
|
let object=objects.iter().find(|o|o.reference==reference).expect("live complete Linked group");
|
|
for group in &object.groups {for value in group {if let V::Reference(r)=value {pending.push(*r);}}}
|
|
state.push(object.clone());
|
|
}
|
|
state.sort_by_key(|o|(o.reference.index,o.reference.generation));state
|
|
}
|
|
|
|
fn verify_linked_refusals(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
use prometeu_bytecode::{decode_next,TRAP_RESOURCE_LIMIT};
|
|
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
|
let mut node_allocation=false;let mut optional_return=false;let mut snapshot_allocation=false;let mut preparation=false;
|
|
for name in ["insert","add","addFirst","remove","removeFirst","removeLast","replace","clear","cursor","reverseCursor"] {
|
|
for suffix in ["","-optimized"] {
|
|
println!("PHASE CORPUS linked {name}{suffix}");
|
|
let bytes=std::fs::read(root.join(format!("pbs-linked-refusal-{name}{suffix}.pbx"))).expect("mandatory Linked refusal fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let marker=|value:i32| {
|
|
let mut pc=0;let mut found=Vec::new();
|
|
while pc<image.code().len() {let instruction=decode_next(pc,image.code()).unwrap();
|
|
if instruction.opcode==Op::PushI32&&instruction.imm_i32().unwrap()==value {found.push(pc);}
|
|
pc=instruction.next_pc;
|
|
}
|
|
assert_eq!(found.len(),1);found[0]
|
|
};
|
|
let before_pc=marker(314160);let after_pc=marker(314161);
|
|
let prepare=|limits| {let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();
|
|
vm.insert_breakpoint(before_pc);vm.insert_breakpoint(after_pc);vm};
|
|
let mut baseline=prepare(RuntimeLimits::default());
|
|
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
|
let before=baseline.resource_snapshot();let original=linked_state(&baseline,&image);
|
|
baseline.remove_breakpoint(before_pc);
|
|
let (completed_report,successful_prefix,_)=trace_collection_attempt(&mut baseline,&original,after_pc);
|
|
assert!(matches!(completed_report.reason,End::BudgetExhausted|End::Breakpoint) && baseline.pc()==after_pc,"operation completion: {completed_report:?}");
|
|
let after=baseline.resource_snapshot();let changed=linked_state(&baseline,&image);
|
|
let owner=changed.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("linked<int>")).unwrap();
|
|
let expected=match name {"insert"|"add"|"addFirst"=>33,"remove"|"removeFirst"|"removeLast"=>31,"clear"=>0,_=>32};
|
|
assert_eq!(owner.groups[2],[V::Int64(expected)]);
|
|
if name=="cursor"||name=="reverseCursor" {assert_eq!(changed,original);}
|
|
let mut refused=0;
|
|
for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {
|
|
let lower=before.budget.peaks[q as usize];let upper=after.budget.peaks[q as usize];if lower>=upper {continue;}
|
|
let mut limits=vec![lower,lower+(upper-lower)/4,lower+(upper-lower)/2,upper-1];
|
|
if q==Q::HandleSlots {limits.extend(lower..upper.min(lower+24));}limits.sort_unstable();limits.dedup();
|
|
for limit in limits {
|
|
let mut vm=prepare(RuntimeLimits::default().lowered(q,limit).unwrap());let observer=vm.resource_observer();
|
|
let setup=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(setup.reason,End::Breakpoint),"{name} setup {q:?}={limit}: {setup:?}");
|
|
let old=linked_state(&vm,&image);vm.remove_breakpoint(before_pc);
|
|
let (report,prefix,mutated)=trace_collection_attempt(&mut vm,&old,after_pc);
|
|
assert_mutation_prefix(&prefix,&successful_prefix);
|
|
if let End::Trap(info)=report.reason {
|
|
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"{name} {q:?}={limit}: {info:?}");
|
|
if !mutated || name=="cursor" || name=="reverseCursor" {
|
|
assert_eq!(linked_state(&vm,&image),old,"{name}: failure before mutation preserves original topology");
|
|
}
|
|
let instruction=decode_next(info.pc as usize,image.code()).unwrap();
|
|
preparation|=q==Q::AuxiliaryBytes;
|
|
if instruction.opcode==Op::StructNew {
|
|
let declaration=&image.registry().declarations().types[instruction.imm_u32().unwrap() as usize];
|
|
node_allocation|=declaration.name.as_deref()==Some("_LinkedNode<int>");
|
|
snapshot_allocation|=declaration.name.as_deref()==Some("_SnapshotNode<int>");
|
|
if name.starts_with("remove") {
|
|
if let prometeu_bytecode::registry::TypeKind::Struct(fields)=&declaration.kind {
|
|
optional_return|=fields.len()==1&&matches!(image.registry().declarations().types[fields[0].type_id.0 as usize].kind,
|
|
prometeu_bytecode::registry::TypeKind::Builtin(prometeu_bytecode::registry::BuiltinId::INT32));
|
|
}
|
|
}
|
|
}
|
|
refused+=1;println!("PBS LINKED PHASE REFUSAL {name} mutated={mutated} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
|
} else {assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint) && vm.pc()==after_pc,"{name}: {report:?}");}
|
|
drop(vm);for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {assert_eq!(observer.used(resource),0);}
|
|
}
|
|
}
|
|
assert!(refused>0,"{name}: source-operation phase refusals required");
|
|
}
|
|
}
|
|
assert!(node_allocation,"new Linked node refusal");assert!(optional_return,"optional removed-value refusal");
|
|
assert!(snapshot_allocation,"snapshot node refusal");assert!(preparation,"frame/operand preparation refusal");
|
|
}
|
|
|
|
|
|
fn verify_linked_collection_gc(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeLimits};
|
|
let bytes=std::fs::read(root.join("pbs-linked-gc-collection.pbx")).expect("mandatory Linked removal/clear GC fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
|
let mut previous=0;
|
|
for (round,count) in [1200,1197,0,0].into_iter().enumerate() {
|
|
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::FrameSync),"collection GC {round}: {report:?}");
|
|
let collections=vm.resource_snapshot().gc.collections;assert!(collections>previous,"real collection at round {round}");previous=collections;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
for name in ["_LinkedNode<Item>","Item"] {
|
|
let actual=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count();
|
|
assert_eq!(actual,count,"{name} after removal/clear at round {round}");
|
|
}
|
|
println!("PBS LINKED COLLECTION GC PASS round={round} nodes={count} items={count}");
|
|
}
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
}
|
|
|
|
|
|
fn verify_identity_hashing_fixtures(root: &std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
use prometeu_bytecode::{isa::core::CoreOpCode as Op,registry::TypeId};
|
|
let corpus=std::fs::read_to_string(root.join("hash-vectors.tsv")).expect("mandatory hashing oracle manifest");
|
|
let mut originals=std::collections::BTreeMap::new();let mut count=0;
|
|
for row in corpus.lines() {
|
|
let parts:Vec<_>=row.split_whitespace().collect();let name=parts[0];
|
|
let expected=u64::from_str_radix(parts[1],16).unwrap() as i64;
|
|
let id:u32=parts[2].parse().unwrap();let cost:u64=parts[3].parse().unwrap();
|
|
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let code=image.code().to_vec();let mut vm=VirtualMachine::from_image(image,Default::default());
|
|
vm.prepare_boot_call().unwrap();let mut total=0;let mut calls=0;
|
|
loop {
|
|
let pc=vm.pc();let op=Op::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
|
|
let charge=if op==Op::Intrinsic {
|
|
assert_eq!(u32::from_le_bytes(code[pc+2..pc+6].try_into().unwrap()),id,"{name}");
|
|
let before=vm.operand_stack_top(1).to_vec();let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert_eq!((vm.pc(),zero.cycles_used,zero.steps_executed),(pc,0,0));
|
|
assert_eq!(vm.operand_stack_top(1),before);calls+=1;cost
|
|
}else{op.cycles()};
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert_eq!(report.cycles_used,charge,"{name} at {pc}");total+=charge;
|
|
if matches!(report.reason,End::EndOfRom|End::Halted){break;}
|
|
assert!(matches!(report.reason,End::BudgetExhausted),"{name}: {report:?}");
|
|
assert!(total<100_000);
|
|
}
|
|
assert_eq!(calls,1,"{name}");assert_eq!(vm.operand_stack_top(1),vec![Value::Int64(expected)],"{name}");
|
|
if let Some(base)=name.strip_suffix("-optimized") {assert_eq!(originals.get(base),Some(&total),"{name}: optimizer charging");}
|
|
else{originals.insert(name.to_string(),total);}
|
|
println!("HASH ORACLE/COST/FUEL PASS {name} result={expected} cycles={total}");count+=1;
|
|
}
|
|
assert_eq!(count,60,"all 30 source scalar/String vectors in both optimizer paths");
|
|
for prefix in ["common-identity","pbs-hash-object","pbs-hash-contract","pbs-hash-array","pbs-hash-function","pbs-hash-random","pbs-hash-discard","pbs-hash-discard-reference"] {
|
|
for suffix in ["","-optimized"] {
|
|
let name=format!("{prefix}{suffix}");let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory identity fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("{name}: {e:?}"));
|
|
let code=image.code().to_vec();let registry=image.registry().clone();
|
|
let mut vm=VirtualMachine::from_image(image,Default::default());let observer=vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();let mut steps=0;let mut queries=0;
|
|
loop {
|
|
let pc=vm.pc();let op=Op::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
|
|
let width=|at:usize|registry.type_layout(TypeId(u32::from_le_bytes(code[at..at+4].try_into().unwrap()))).unwrap().storage.slots as u64;
|
|
let charge=match op {Op::RefIdentityHash=>Some(8+width(pc+2)),Op::RefIdentityEq=>Some(4+width(pc+2)+width(pc+6)),_=>None};
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if let Some(charge)=charge {queries+=1;assert_eq!(report.cycles_used,charge,"{name}: typed query charge");}
|
|
if matches!(report.reason,End::EndOfRom|End::Halted){break;}
|
|
assert!(matches!(report.reason,End::BudgetExhausted),"{name}: {report:?}");steps+=1;assert!(steps<100_000);
|
|
}
|
|
if prefix=="pbs-hash-discard-reference"{assert_eq!(queries,2,"unused reference queries retain charged work");}
|
|
let expected=if prefix=="common-identity"{Value::Boolean(true)}else{Value::Int32(42)};
|
|
assert_eq!(vm.operand_stack_top(1),vec![expected],"{name}");drop(vm);
|
|
for resource in [prometeu_vm::resource_budget::RuntimeResource::GuestBytes,prometeu_vm::resource_budget::RuntimeResource::HandleSlots,prometeu_vm::resource_budget::RuntimeResource::StringBytes] {
|
|
assert_eq!(observer.used(resource),0,"{name}: owner release");
|
|
}
|
|
println!("IDENTITY COMPLETE GROUP/ALIAS/COST PASS {name}");
|
|
}
|
|
}
|
|
verify_identity_negative_fixtures(root);
|
|
|
|
}
|
|
|
|
|
|
fn verify_pbs_set_fixtures(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeResource as Q};
|
|
let successes=["basic","construction","arithmetic","scalars","objects","collisions","content","tuple",
|
|
"cursor-empty","cursor-single","snapshot","callback-reads","references","random","vec2","pixel","evaluation","contract-snapshot","string-snapshot","false-snapshot"];
|
|
let faults=[("fault-callback-1",prometeu_bytecode::TRAP_EXPLICIT),("fault-callback-2",prometeu_bytecode::TRAP_EXPLICIT),
|
|
("fault-callback-3",prometeu_bytecode::TRAP_EXPLICIT),("fault-callback-4",prometeu_bytecode::TRAP_EXPLICIT),
|
|
("fault-callback-5",prometeu_bytecode::TRAP_DIV_ZERO),("fault-overflow",prometeu_bytecode::TRAP_EXPLICIT)];
|
|
for (base,fault) in successes.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,f)|(n,Some(f)))) {
|
|
for suffix in ["","-optimized"] {
|
|
let name=format!("{base}{suffix}");let bytes=std::fs::read(root.join(format!("pbs-set-{name}.pbx"))).unwrap_or_else(|e|panic!("mandatory Set {name}: {e}"));
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("Set {name}: {e:?}"));
|
|
let registry=image.registry().clone();let mut vm=VirtualMachine::from_image(image,Default::default());let observer=vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();let report=vm.run_budget(10_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if let Some(code)=fault {
|
|
let End::Trap(info)=report.reason else{panic!("{name}: {report:?}")};assert_eq!(info.code,code,"{name}: {info:?}");
|
|
if base.starts_with("fault-callback") {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let set=objects.iter().find(|o|registry.declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).expect("faulted Set retained");
|
|
assert_eq!(set.groups[0],vec![V::Null],"{name}: unpublished buckets");
|
|
assert_eq!(set.groups[1],vec![V::Int64(0)],"{name}: old size");
|
|
assert_eq!(set.groups[3],vec![V::Boolean(true)],"{name}: guard is not cleaned after fault");
|
|
}
|
|
}else {
|
|
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
|
|
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)],"{name}");
|
|
}
|
|
drop(vm);
|
|
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations] {
|
|
assert_eq!(observer.used(resource),0,"{name}: final resource release {resource:?}");
|
|
}
|
|
println!("SET SOURCE/LOAD/EXEC/GUARD PASS {name}");
|
|
}
|
|
}
|
|
verify_set_refusals(root);
|
|
verify_set_postpublication_injection(root);
|
|
verify_collection_cursor_gc(root,"set");
|
|
verify_set_collection_gc(root);
|
|
verify_collection_distribution(root,"set",0);
|
|
verify_installed_hash(root);
|
|
|
|
}
|
|
|
|
|
|
fn set_state(vm:&VirtualMachine,image:&ValidatedProgramImage)->ObservedStorage {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let owner=objects.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).expect("source Set");
|
|
let mut pending=vec![owner.reference];let mut state:ObservedStorage=Vec::new();
|
|
while let Some(reference)=pending.pop() {
|
|
if state.iter().any(|o|o.reference==reference){continue;}
|
|
let object=objects.iter().find(|o|o.reference==reference).expect("live complete Set group");
|
|
for value in object.groups.iter().flatten(){if let V::Reference(reference)=value{pending.push(*reference);}}
|
|
state.push(object.clone());
|
|
}
|
|
state.sort_by_key(|o|(o.reference.index,o.reference.generation));state
|
|
}
|
|
fn set_without_guard(mut state:ObservedStorage,image:&ValidatedProgramImage)->ObservedStorage {
|
|
for object in &mut state {
|
|
if image.registry().declarations().types[object.type_id.0 as usize].name.as_deref()==Some("set<int>") {
|
|
object.groups[3]=vec![prometeu_vm::resource_diagnostics::StorageValue::Boolean(false)];
|
|
}
|
|
}
|
|
state
|
|
}
|
|
fn validate_set(vm:&VirtualMachine,image:&ValidatedProgramImage,expected:i64)->usize {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let state=set_state(vm,image);
|
|
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).unwrap();
|
|
assert_eq!(owner.groups[1],vec![V::Int64(expected)]);assert_eq!(owner.groups[3],vec![V::Boolean(false)]);
|
|
let get=|reference|state.iter().find(|o|o.reference==reference).expect("reachable object");
|
|
let V::Reference(carrier)=owner.groups[0][0] else{assert_eq!(expected,0);return 0;};
|
|
let V::Reference(table)=get(carrier).groups[0][0] else{panic!("bucket carrier")};
|
|
let buckets=get(table);let capacity=buckets.groups.len();let mut nodes=std::collections::HashSet::new();
|
|
for (bucket,group) in buckets.groups.iter().enumerate() {
|
|
if *group==vec![V::Null,V::Null]{continue;}
|
|
let [V::Int64(tag),V::Reference(first)]=group.as_slice() else{panic!("complete bucket group")};
|
|
assert_eq!(image.registry().declarations().types[*tag as usize].name.as_deref(),Some("_SetNode<int>"));
|
|
let mut next=Some(*first);
|
|
while let Some(reference)=next {
|
|
assert!(nodes.insert(reference),"each node appears once, no cycles");let node=get(reference);
|
|
let V::Int64(hash)=node.groups[0][0] else{panic!("cached complete hash")};
|
|
assert_eq!(hash.rem_euclid(capacity as i64) as usize,bucket);
|
|
next=match node.groups[2][0]{V::Null=>None,V::Reference(carrier)=>{let V::Reference(value)=get(carrier).groups[0][0] else{panic!("next node carrier")};Some(value)},_=>panic!("next group")};
|
|
}
|
|
}
|
|
assert_eq!(nodes.len(),expected as usize);capacity
|
|
}
|
|
fn verify_set_refusals(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
|
|
let mut node_refusal=false;let mut snapshot_refusal=false;let mut table_refusal=false;let mut guard_effect=false;
|
|
for name in ["growth","add","duplicate","remove","clear","cursor"] {
|
|
for suffix in ["","-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-set-refusal-{name}{suffix}.pbx"))).expect("mandatory Set resource fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let marker=|value:i32|{let mut pc=0;let mut found=Vec::new();while pc<image.code().len(){let i=decode_next(pc,image.code()).unwrap();if i.opcode==Op::PushI32&&i.imm_i32().unwrap()==value{found.push(pc);}pc=i.next_pc;}assert_eq!(found.len(),1);found[0]};
|
|
let before_pc=marker(314160);let after_pc=marker(314161);
|
|
let prepare=|limits|{let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();vm.insert_breakpoint(before_pc);vm.insert_breakpoint(after_pc);vm};
|
|
let mut baseline=prepare(RuntimeLimits::default());assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
|
let before=baseline.resource_snapshot();let old=set_state(&baseline,&image);let size=if name=="growth"{6}else{5};
|
|
assert_eq!(validate_set(&baseline,&image,size),8);baseline.remove_breakpoint(before_pc);
|
|
let mut successful=Vec::new();let mut max_nodes=0;let mut max_tables=0;
|
|
loop {
|
|
let objects=baseline.heap().diagnostic_typed_storage();
|
|
max_nodes=max_nodes.max(objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SetNode<int>")).count());
|
|
max_tables=max_tables.max(objects.iter().filter(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))).count());
|
|
successful.push((baseline.pc(),observe_originals(&baseline,&old)));
|
|
let report=baseline.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if baseline.pc()==after_pc{break;}
|
|
assert!(matches!(report.reason,End::BudgetExhausted),"Set {name}: {report:?}");assert!(successful.len()<200_000);
|
|
}
|
|
let after=baseline.resource_snapshot();let expected=match name{"growth"|"add"=>size+1,"remove"=>size-1,"clear"=>0,_=>size};
|
|
let capacity=validate_set(&baseline,&image,expected);
|
|
assert_eq!(capacity,if name=="growth"{16}else if name=="clear"{0}else{8});
|
|
if name=="growth"{assert!(max_nodes>=13,"six old + six copied + inserted");assert!(max_tables>=2);}
|
|
if name=="duplicate"||name=="cursor"{assert_eq!(set_state(&baseline,&image),old);}
|
|
println!("SET PEAK {name}{suffix} nodes={max_nodes} tables={max_tables} before={:?} after={:?}",before.budget.peaks,after.budget.peaks);
|
|
let mut refusals=0;let mut structural_refusals=0;
|
|
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::CallDepth] {
|
|
let lower=before.budget.peaks[resource as usize];let upper=after.budget.peaks[resource as usize];if lower>=upper{continue;}
|
|
let mut limits=vec![lower,lower+(upper-lower)/4,lower+(upper-lower)/2,upper-1];
|
|
if resource==Q::HandleSlots{limits.extend(lower..upper.min(lower+24));}limits.sort_unstable();limits.dedup();
|
|
for limit in limits {
|
|
let mut vm=prepare(RuntimeLimits::default().lowered(resource,limit).unwrap());let observer=vm.resource_observer();
|
|
assert!(matches!(vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint),"Set setup {name} {resource:?}={limit}");
|
|
let original=set_state(&vm,&image);vm.remove_breakpoint(before_pc);
|
|
let (report,prefix,_)=trace_collection_attempt(&mut vm,&original,after_pc);assert_mutation_prefix(&prefix,&successful);
|
|
if let End::Trap(info)=report.reason {
|
|
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"Set {name} {resource:?}={limit}: {info:?}");
|
|
let touched=prefix.iter().any(|(_,state)|set_without_guard(state.clone(),&image)!=set_without_guard(original.clone(),&image));
|
|
if !touched {assert_eq!(set_without_guard(observe_originals(&vm,&original),&image),set_without_guard(original.clone(),&image));}
|
|
if name=="cursor"{assert_eq!(set_state(&vm,&image),original);}
|
|
let now=observe_originals(&vm,&original);guard_effect|=!touched&&now!=original;
|
|
structural_refusals+=usize::from(touched);
|
|
let instruction=decode_next(info.pc as usize,image.code()).unwrap();table_refusal|=name=="growth"&&instruction.opcode==Op::ArrayNew;
|
|
if instruction.opcode==Op::StructNew {
|
|
let named=image.registry().declarations().types[instruction.imm_u32().unwrap() as usize].name.as_deref();
|
|
node_refusal|=named==Some("_SetNode<int>");snapshot_refusal|=named==Some("_SnapshotNode<int>");
|
|
}
|
|
refusals+=1;println!("SET PHASE REFUSAL {name}{suffix} structural={touched} resource={resource:?} limit={limit} opcode={:?}",instruction.opcode);
|
|
}else{assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint)&&vm.pc()==after_pc);}
|
|
drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
|
|
}
|
|
}
|
|
assert!(refusals>0,"Set {name}: resource refusal evidence");
|
|
println!("SET PHASE SUMMARY {name}{suffix} refusals={refusals} after_structural_write={structural_refusals}");
|
|
}
|
|
}
|
|
assert!(node_refusal&&snapshot_refusal&&table_refusal&&guard_effect,"nodes/snapshot/table/guard refusal evidence required");
|
|
}
|
|
fn verify_set_collection_gc(root:&std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes=std::fs::read(root.join("pbs-set-gc-collection.pbx")).expect("mandatory Set collection GC fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();let mut previous=0;
|
|
for (round,count) in [64,61,0,0].into_iter().enumerate() {
|
|
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::FrameSync),"Set GC {round}: {report:?}");
|
|
let collections=vm.resource_snapshot().gc.collections;assert!(collections>previous);previous=collections;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
for name in ["_SetNode<Item>","Item"] {
|
|
let actual=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count();assert_eq!(actual,count,"Set GC {round}: {name}");
|
|
}
|
|
println!("SET COLLECTION/OLD-CANDIDATE GC PASS round={round} live_nodes={count}");
|
|
}
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
}
|
|
|
|
|
|
// Controlled test-only source instrumentation, never a production SDK algorithm.
|
|
// A quota probe is inserted after the real candidate-table store and before size.
|
|
// Natural production-quota coverage and its refusal frequencies remain separate.
|
|
fn verify_set_postpublication_injection(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q},resource_diagnostics::StorageValue as V};
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
|
|
for suffix in ["","-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-set-injected-refusal-growth{suffix}.pbx"))).expect("explicit test-only post-publication injection");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let limits=RuntimeLimits::default().lowered(Q::GuestBytes,500_000).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),limits);let observer=vm.resource_observer();vm.prepare_boot_call().unwrap();
|
|
let mut found=false;
|
|
for _ in 0..200_000 {
|
|
let instruction=decode_next(vm.pc(),image.code()).unwrap();
|
|
if instruction.opcode==Op::ArrayNew&&vm.operand_stack_top(1)==vec![Value::Int64(1_000_000)] {
|
|
let original=vm.heap().diagnostic_typed_storage();let state=set_state(&vm,&image);
|
|
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).unwrap();
|
|
assert_eq!(owner.groups[1],vec![V::Int64(6)]);assert_eq!(owner.groups[3],vec![V::Boolean(true)]);
|
|
assert_eq!(state.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SetNode<int>")).count(),7);
|
|
assert!(state.iter().any(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))&&o.groups.len()==16));
|
|
let input=vm.operand_stack_top(1).to_vec();let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
let End::Trap(info)=report.reason else{panic!("post-publication injection: {report:?}")};assert_eq!(info.code,TRAP_RESOURCE_LIMIT);
|
|
assert_eq!(vm.heap().diagnostic_typed_storage(),original,"refused probe preserves its entry state, retaining earlier table publication");
|
|
assert_eq!(vm.operand_stack_top(1),input);
|
|
println!("SET TEST-ONLY POST-PUBLICATION QUOTA INJECTION PASS {suffix}: new table=16 nodes=7 old size=6 guard=true");found=true;break;
|
|
}
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::BudgetExhausted),"before injection: {report:?}");
|
|
}
|
|
assert!(found);drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
|
|
}
|
|
}
|
|
|
|
|
|
fn verify_identity_negative_fixtures(root:&std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op};
|
|
for base in ["bad-category","bad-right","dead-bad-category","bad-typeid"] {
|
|
for suffix in ["","-optimized"] {
|
|
let name=format!("common-identity-{base}{suffix}");let bytes=std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
|
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err(),"{name}");
|
|
println!("IDENTITY NEUTRAL ADMISSION REJECT PASS {name}");
|
|
}
|
|
}
|
|
for base in ["partial","truncated"] {
|
|
let bytes=std::fs::read(root.join(format!("common-identity-{base}.pbx"))).unwrap();
|
|
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err());
|
|
println!("IDENTITY PARTIAL/TRUNCATED ADMISSION REJECT PASS {base}");
|
|
}
|
|
for base in ["null-views","right-after-null","right-after-distinct"] {
|
|
let bytes=std::fs::read(root.join(format!("common-identity-{base}.pbx"))).unwrap();
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("{base}: {e:?}"));
|
|
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();
|
|
loop {
|
|
let instruction=decode_next(vm.pc(),image.code()).unwrap();
|
|
if instruction.opcode==Op::RefIdentityEq {
|
|
let operands=vm.operand_stack_top(3).to_vec();
|
|
let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();assert_eq!((zero.cycles_used,zero.steps_executed),(0,0));
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert_eq!(report.cycles_used,7);
|
|
if base=="null-views" {
|
|
assert!(matches!(report.reason,End::BudgetExhausted));assert_eq!(vm.operand_stack_top(1),vec![Value::Boolean(true)]);
|
|
}else {
|
|
let End::Trap(info)=report.reason else{panic!("{base}: right validation was skipped: {report:?}")};
|
|
assert_eq!(info.code,prometeu_bytecode::TRAP_TYPE);assert_eq!(report.steps_executed,0);assert_eq!(vm.operand_stack_top(3),operands);
|
|
}
|
|
println!("IDENTITY COMPLETE RIGHT/NULL/FUEL/COST PASS {base}");break;
|
|
}
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::BudgetExhausted));
|
|
}
|
|
}
|
|
}
|
|
fn verify_installed_hash(root:&std::path::Path) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes=std::fs::read(root.join("pbs-hash-installed.pbx")).expect("mandatory installed hashing example");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image,Default::default());vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason,End::FrameSync|End::Halted|End::EndOfRom),"installed hashing: {report:?}");
|
|
println!("HASH INSTALLED JAR/SDK/EXAMPLE LOAD/EXEC PASS");
|
|
}
|
|
|
|
|
|
fn map_state(vm:&VirtualMachine,image:&ValidatedProgramImage)->ObservedStorage {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let owner=objects.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("map<int, int>")).expect("source Map");
|
|
let mut pending=vec![owner.reference];let mut state:ObservedStorage=Vec::new();
|
|
while let Some(reference)=pending.pop() {
|
|
if state.iter().any(|o|o.reference==reference){continue;}
|
|
let object=objects.iter().find(|o|o.reference==reference).expect("live complete Map group");
|
|
for value in object.groups.iter().flatten(){if let V::Reference(reference)=value{pending.push(*reference);}}
|
|
state.push(object.clone());
|
|
}
|
|
state.sort_by_key(|o|(o.reference.index,o.reference.generation));state
|
|
}
|
|
fn map_without_guard(mut state:ObservedStorage,image:&ValidatedProgramImage)->ObservedStorage {
|
|
for object in &mut state {
|
|
if image.registry().declarations().types[object.type_id.0 as usize].name.as_deref()==Some("map<int, int>") {
|
|
object.groups[3]=vec![prometeu_vm::resource_diagnostics::StorageValue::Boolean(false)];
|
|
}
|
|
}
|
|
state
|
|
}
|
|
fn validate_map(vm:&VirtualMachine,image:&ValidatedProgramImage,expected:i64)->usize {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let state=map_state(vm,image);
|
|
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("map<int, int>")).unwrap();
|
|
assert_eq!(owner.groups[1],vec![V::Int64(expected)]);assert_eq!(owner.groups[3],vec![V::Boolean(false)]);
|
|
let get=|reference|state.iter().find(|o|o.reference==reference).expect("reachable object");
|
|
let V::Reference(carrier)=owner.groups[0][0] else{assert_eq!(expected,0);return 0;};
|
|
let V::Reference(table)=get(carrier).groups[0][0] else{panic!("bucket carrier")};
|
|
let buckets=get(table);let capacity=buckets.groups.len();let mut nodes=std::collections::HashSet::new();
|
|
for (bucket,group) in buckets.groups.iter().enumerate() {
|
|
if *group==vec![V::Null,V::Null]{continue;}
|
|
let [V::Int64(tag),V::Reference(first)]=group.as_slice() else{panic!("complete bucket group")};
|
|
assert_eq!(image.registry().declarations().types[*tag as usize].name.as_deref(),Some("_MapNode<int, int>"));
|
|
let mut next=Some(*first);
|
|
while let Some(reference)=next {
|
|
assert!(nodes.insert(reference),"each node appears once, no cycles");let node=get(reference);
|
|
let V::Int64(hash)=node.groups[0][0] else{panic!("cached complete hash")};
|
|
assert_eq!(hash.rem_euclid(capacity as i64) as usize,bucket);
|
|
next=match node.groups[3][0]{V::Null=>None,V::Reference(carrier)=>{let V::Reference(value)=get(carrier).groups[0][0] else{panic!("next node carrier")};Some(value)},_=>panic!("next group")};
|
|
}
|
|
}
|
|
assert_eq!(nodes.len(),expected as usize);capacity
|
|
}
|
|
fn verify_map_refusals(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
|
|
let mut node_refusal=false;let mut snapshot_refusal=false;let mut table_refusal=false;let mut guard_effect=false;
|
|
for name in ["growth","add","replace","put","remove","clear","cursor","read"] {
|
|
for suffix in ["","-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-map-refusal-{name}{suffix}.pbx"))).expect("mandatory Map resource fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let marker=|value:i32|{let mut pc=0;let mut found=Vec::new();while pc<image.code().len(){let i=decode_next(pc,image.code()).unwrap();if i.opcode==Op::PushI32&&i.imm_i32().unwrap()==value{found.push(pc);}pc=i.next_pc;}assert_eq!(found.len(),1);found[0]};
|
|
let before_pc=marker(314160);let after_pc=marker(314161);
|
|
let prepare=|limits|{let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();vm.insert_breakpoint(before_pc);vm.insert_breakpoint(after_pc);vm};
|
|
let mut baseline=prepare(RuntimeLimits::default());assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
|
let before=baseline.resource_snapshot();let old=map_state(&baseline,&image);let size=if name=="growth"{6}else{5};
|
|
assert_eq!(validate_map(&baseline,&image,size),8);baseline.remove_breakpoint(before_pc);
|
|
let mut successful=Vec::new();let mut max_nodes=0;let mut max_tables=0;
|
|
loop {
|
|
let objects=baseline.heap().diagnostic_typed_storage();
|
|
max_nodes=max_nodes.max(objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_MapNode<int, int>")).count());
|
|
max_tables=max_tables.max(objects.iter().filter(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))).count());
|
|
successful.push((baseline.pc(),observe_originals(&baseline,&old)));
|
|
let report=baseline.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if baseline.pc()==after_pc{break;}
|
|
assert!(matches!(report.reason,End::BudgetExhausted),"Map {name}: {report:?}");assert!(successful.len()<200_000);
|
|
}
|
|
let after=baseline.resource_snapshot();let expected=match name{"growth"|"add"=>size+1,"remove"=>size-1,"clear"=>0,_=>size};
|
|
let capacity=validate_map(&baseline,&image,expected);
|
|
assert_eq!(capacity,if name=="growth"{16}else if name=="clear"{0}else{8});
|
|
if name=="replace"||name=="put"{let state=map_state(&baseline,&image);assert!(state.iter().any(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_MapNode<int, int>")&&o.groups[1]==vec![prometeu_vm::resource_diagnostics::StorageValue::Int32(1)]&&o.groups[2]==vec![prometeu_vm::resource_diagnostics::StorageValue::Int32(42)]));}
|
|
if name=="growth"{assert!(max_nodes>=13,"six old + six copied + inserted");assert!(max_tables>=2);}
|
|
if name=="read"||name=="cursor"{assert_eq!(map_state(&baseline,&image),old);}
|
|
println!("MAP PEAK {name}{suffix} nodes={max_nodes} tables={max_tables} before={:?} after={:?}",before.budget.peaks,after.budget.peaks);
|
|
let mut refusals=0;let mut structural_refusals=0;
|
|
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::CallDepth] {
|
|
let lower=before.budget.peaks[resource as usize];let upper=after.budget.peaks[resource as usize];if lower>=upper{continue;}
|
|
let mut limits=vec![lower,lower+(upper-lower)/4,lower+(upper-lower)/2,upper-1];
|
|
if resource==Q::HandleSlots{limits.extend(lower..upper.min(lower+24));}limits.sort_unstable();limits.dedup();
|
|
for limit in limits {
|
|
let mut vm=prepare(RuntimeLimits::default().lowered(resource,limit).unwrap());let observer=vm.resource_observer();
|
|
assert!(matches!(vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint),"Map setup {name} {resource:?}={limit}");
|
|
let original=map_state(&vm,&image);vm.remove_breakpoint(before_pc);
|
|
let (report,prefix,_)=trace_collection_attempt(&mut vm,&original,after_pc);assert_mutation_prefix(&prefix,&successful);
|
|
if let End::Trap(info)=report.reason {
|
|
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"Map {name} {resource:?}={limit}: {info:?}");
|
|
let touched=prefix.iter().any(|(_,state)|map_without_guard(state.clone(),&image)!=map_without_guard(original.clone(),&image));
|
|
if !touched {assert_eq!(map_without_guard(observe_originals(&vm,&original),&image),map_without_guard(original.clone(),&image));}
|
|
if name=="cursor"{assert_eq!(map_state(&vm,&image),original);}
|
|
let now=observe_originals(&vm,&original);guard_effect|=!touched&&now!=original;
|
|
structural_refusals+=usize::from(touched);
|
|
let instruction=decode_next(info.pc as usize,image.code()).unwrap();table_refusal|=name=="growth"&&instruction.opcode==Op::ArrayNew;
|
|
if instruction.opcode==Op::StructNew {
|
|
let named=image.registry().declarations().types[instruction.imm_u32().unwrap() as usize].name.as_deref();
|
|
node_refusal|=named==Some("_MapNode<int, int>");snapshot_refusal|=named==Some("_SnapshotNode<keyval<int, int>>");
|
|
}
|
|
refusals+=1;println!("MAP PHASE REFUSAL {name}{suffix} structural={touched} resource={resource:?} limit={limit} opcode={:?}",instruction.opcode);
|
|
}else{assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint)&&vm.pc()==after_pc);}
|
|
drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
|
|
}
|
|
}
|
|
assert!(refusals>0,"Map {name}: resource refusal evidence");
|
|
println!("MAP PHASE SUMMARY {name}{suffix} refusals={refusals} after_structural_write={structural_refusals}");
|
|
}
|
|
}
|
|
assert!(node_refusal&&snapshot_refusal&&table_refusal&&guard_effect,"nodes/snapshot/table/guard refusal evidence required");
|
|
}
|
|
fn verify_map_collection_gc(root:&std::path::Path) {
|
|
for suffix in ["","-optimized"] {verify_map_collection_gc_variant(root,suffix);}
|
|
}
|
|
fn verify_map_collection_gc_variant(root:&std::path::Path,suffix:&str) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes=std::fs::read(root.join(format!("pbs-map-gc-collection{suffix}.pbx"))).expect("mandatory Map collection GC fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();let mut previous=0;
|
|
for (round,count) in [64,64,61,0,0].into_iter().enumerate() {
|
|
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::FrameSync),"Map GC {round}: {report:?}");
|
|
let collections=vm.resource_snapshot().gc.collections;assert!(collections>previous);previous=collections;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
for name in ["_MapNode<Item, Item>","Item"] {
|
|
let actual=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count();assert_eq!(actual,if name=="Item"{count*2}else{count},"Map GC {round}: {name}");
|
|
}
|
|
println!("MAP COLLECTION/OLD-CANDIDATE GC PASS {suffix} round={round} live_nodes={count}");
|
|
}
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
}
|
|
|
|
|
|
// Controlled test-only source instrumentation, never a production SDK algorithm.
|
|
// A quota probe is inserted after the real candidate-table store and before size.
|
|
// Natural production-quota coverage and its refusal frequencies remain separate.
|
|
fn verify_map_postpublication_injection(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q},resource_diagnostics::StorageValue as V};
|
|
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
|
|
for suffix in ["","-optimized"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-map-injected-refusal-growth{suffix}.pbx"))).expect("explicit test-only post-publication injection");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let limits=RuntimeLimits::default().lowered(Q::GuestBytes,500_000).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),limits);let observer=vm.resource_observer();vm.prepare_boot_call().unwrap();
|
|
let mut found=false;
|
|
for _ in 0..200_000 {
|
|
let instruction=decode_next(vm.pc(),image.code()).unwrap();
|
|
if instruction.opcode==Op::ArrayNew&&vm.operand_stack_top(1)==vec![Value::Int64(1_000_000)] {
|
|
let original=vm.heap().diagnostic_typed_storage();let state=map_state(&vm,&image);
|
|
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("map<int, int>")).unwrap();
|
|
assert_eq!(owner.groups[1],vec![V::Int64(6)]);assert_eq!(owner.groups[3],vec![V::Boolean(true)]);
|
|
assert_eq!(state.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_MapNode<int, int>")).count(),7);
|
|
assert!(state.iter().any(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))&&o.groups.len()==16));
|
|
let input=vm.operand_stack_top(1).to_vec();let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
let End::Trap(info)=report.reason else{panic!("post-publication injection: {report:?}")};assert_eq!(info.code,TRAP_RESOURCE_LIMIT);
|
|
assert_eq!(vm.heap().diagnostic_typed_storage(),original,"refused probe preserves its entry state, retaining earlier table publication");
|
|
assert_eq!(vm.operand_stack_top(1),input);
|
|
println!("MAP TEST-ONLY POST-PUBLICATION QUOTA INJECTION PASS {suffix}: new table=16 nodes=7 old size=6 guard=true");found=true;break;
|
|
}
|
|
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::BudgetExhausted),"before injection: {report:?}");
|
|
}
|
|
assert!(found);drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
|
|
}
|
|
}
|
|
|
|
fn verify_pbs_map_fixtures(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeResource as Q};
|
|
let successes=["basic","optional","scalars","objects","references","content","collisions","arithmetic",
|
|
"tuple","native","pixel","random","cursor-empty","cursor-single","snapshot","evaluation","callback-reads"];
|
|
let faults=(1..=7).map(|n|(format!("fault-callback-{n}"),if n==7{prometeu_bytecode::TRAP_DIV_ZERO}else{prometeu_bytecode::TRAP_EXPLICIT}))
|
|
.chain((1..=7).map(|n|(format!("fault-equals-{n}"),if n==7{prometeu_bytecode::TRAP_DIV_ZERO}else{prometeu_bytecode::TRAP_EXPLICIT})))
|
|
.chain(std::iter::once(("fault-overflow".to_string(),prometeu_bytecode::TRAP_EXPLICIT)));
|
|
let mut count=0;
|
|
for (base,fault) in successes.into_iter().map(|n|(n.to_string(),None)).chain(faults.map(|(n,f)|(n,Some(f)))) {
|
|
for suffix in ["","-optimized"] {
|
|
let name=format!("{base}{suffix}");let bytes=std::fs::read(root.join(format!("pbs-map-{name}.pbx"))).unwrap_or_else(|e|panic!("mandatory Map {name}: {e}"));
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("Map {name}: {e:?}"));
|
|
let registry=image.registry().clone();let mut vm=VirtualMachine::from_image(image,Default::default());let observer=vm.resource_observer();
|
|
vm.prepare_boot_call().unwrap();let report=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
|
if let Some(code)=fault {
|
|
let End::Trap(info)=report.reason else{panic!("{name}: {report:?}")};assert_eq!(info.code,code,"{name}: {info:?}");
|
|
if base.starts_with("fault-callback")||base.starts_with("fault-equals") {
|
|
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let owner=objects.iter().find(|o|registry.declarations().types[o.type_id.0 as usize].name.as_deref()==Some("map<int, int>")).expect("faulted Map retained");
|
|
let populated=base.starts_with("fault-equals");
|
|
assert_eq!(owner.groups[1],vec![V::Int64(if populated{1}else{0})]);assert_eq!(owner.groups[3],vec![V::Boolean(true)]);
|
|
if populated{assert!(objects.iter().any(|o|registry.declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_MapNode<int, int>")&&o.groups[1]==vec![V::Int32(0)]&&o.groups[2]==vec![V::Int32(20)]));}
|
|
else{assert_eq!(owner.groups[0],vec![V::Null]);}
|
|
}
|
|
} else {assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)],"{name}");}
|
|
drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations]{assert_eq!(observer.used(q),0,"{name}: owner release {q:?}");}
|
|
count+=1;println!("MAP SOURCE/LOAD/EXEC/GUARD PASS {name}");
|
|
}
|
|
}
|
|
println!("MAP MANDATORY SOURCE CASES {count}");
|
|
verify_map_refusals(root);verify_map_postpublication_injection(root);verify_map_cursor_gc(root);verify_map_collection_gc(root);verify_map_distribution(root);
|
|
}
|
|
|
|
fn verify_map_cursor_gc(root:&std::path::Path) {
|
|
for suffix in ["","-optimized"] {verify_map_cursor_gc_variant(root,suffix);}
|
|
}
|
|
fn verify_map_cursor_gc_variant(root:&std::path::Path,suffix:&str) {
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes=std::fs::read(root.join(format!("pbs-map-gc{suffix}.pbx"))).expect("mandatory Map snapshot GC fixture");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();let mut previous=0;
|
|
for (round,count) in [1200,1,1,0].into_iter().enumerate() {
|
|
let report=vm.run_budget(100_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::FrameSync),"Map cursor GC {round}: {report:?}");
|
|
let snapshot=vm.resource_snapshot();assert!(snapshot.gc.collections>previous);previous=snapshot.gc.collections;
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
assert!(!objects.iter().any(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))),"snapshot retains no Map table");
|
|
for (name,expected) in [("_SnapshotNode<keyval<Item, Item>>",count),("keyval<Item, Item>",count),("Item",count*2),("_MapNode<Item, Item>",0)] {
|
|
assert_eq!(objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count(),expected,"Map cursor GC {round}: {name}");
|
|
}
|
|
println!("MAP CURSOR/KEYVAL/KEY/VALUE GC PASS {suffix} round={round} nodes={count} items={}",count*2);
|
|
}
|
|
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
|
}
|
|
|
|
fn verify_map_distribution(root:&std::path::Path) {
|
|
use prometeu_vm::{LogicalFrameEndingReason as End,resource_diagnostics::StorageValue as V};
|
|
for name in ["imports","installed"] {
|
|
let bytes=std::fs::read(root.join(format!("pbs-map-{name}.pbx"))).expect("mandatory Map workspace/installed example");
|
|
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
|
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();
|
|
let report=vm.run_budget(2_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::FrameSync|End::Halted|End::EndOfRom),"Map distribution {name}: {report:?}");
|
|
let objects=vm.heap().diagnostic_typed_storage();
|
|
let cursors=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SnapshotCursor<keyval<str, optional int>>")).collect::<Vec<_>>();
|
|
assert!(!cursors.is_empty(),"installed/imported Map actually constructs the common entry Cursor");
|
|
let get=|r|objects.iter().find(|o|o.reference==r).unwrap();
|
|
for cursor in cursors {
|
|
let V::Reference(carrier)=cursor.groups[0][0] else{panic!("current carrier")};let V::Reference(node)=get(carrier).groups[0][0] else{panic!("node")};
|
|
assert_eq!(get(node).groups[1],vec![V::Null],"complete traversal retains sticky final node");
|
|
let V::Reference(entry)=get(node).groups[0][0] else{panic!("captured keyval")};
|
|
assert_eq!(image.registry().declarations().types[get(entry).type_id.0 as usize].name.as_deref(),Some("keyval<str, optional int>"));
|
|
}
|
|
println!("MAP DISTRIBUTION SOURCE/LOAD/EXEC PASS {name}");
|
|
}
|
|
}
|