Persist cartridge identity and slot configuration, add MemcardBoot and the MemcardBuffer SDK, and consume the runtime's negotiated memcard host controls with protected teardown. Qualify save/reopen and version upgrades through distinct configured runtime processes. Include specs, examples, regression evidence and the consolidated discussion lesson.
2080 lines
138 KiB
Rust
2080 lines
138 KiB
Rust
use prometeu_bytecode::Value;
|
|
mod stack_queue;
|
|
mod lifecycle;
|
|
mod memcard;
|
|
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 == "--memcard-only") { memcard::verify(&root); return; }
|
|
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}");
|
|
}
|
|
}
|