Files
prometeu-runtime/crates/console/prometeu-vm/tests/random_contract.rs
T
bquarkz 3e39a90083
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
feat(vm): add VM-owned PCG64 random and coverage headroom
Implement GC-managed random generators, next/nextf intrinsics, bounded ranges and deterministic conformance coverage. Publish the runtime contract and producer guidance.

Give coverage domains at least five percentage points of measured headroom while preserving sufficient floors. Record local qualification: make ci-domains passes with 939 tests and all domain gates green.
2026-10-09 12:51:05 +01:00

309 lines
12 KiB
Rust

mod support {
pub mod random;
}
use prometeu_bytecode::registry::{BuiltinId, Ownership, TypeId};
use prometeu_bytecode::{
TRAP_NULL_REFERENCE, TRAP_NUMERIC_DOMAIN, TRAP_RESOURCE_LIMIT, TRAP_TYPE, Value,
};
use prometeu_vm::resource_budget::{RuntimeLimits, RuntimeResource as Q};
use prometeu_vm::{
IntrinsicCostModel, IntrinsicImplementation, LogicalFrameEndingReason as End, VirtualMachine,
VmInitError, lookup_builtin_type, lookup_intrinsic_by_id,
};
use support::random::*;
fn trap(r: &prometeu_vm::BudgetReport) -> &prometeu_bytecode::TrapInfo {
let End::Trap(t) = &r.reason else { panic!("{r:?}") };
t
}
fn vectors(seed: i64) -> Vec<(u64, i64, u64)> {
include_str!("fixtures/random-conformance.tsv")
.lines()
.skip(1)
.filter_map(|l| {
let cols: Vec<_> = l.split('\t').collect();
(cols[0].parse::<i64>().unwrap() == seed).then(|| {
(
u64::from_str_radix(cols[2], 16).unwrap(),
cols[3].parse().unwrap(),
u64::from_str_radix(cols[4], 16).unwrap(),
)
})
})
.collect()
}
#[test]
fn independent_words_signed_and_float_bits_for_all_seed_patterns() {
for seed in [0, 1, 42, -1, i64::MIN, i64::MAX] {
for floating in [false, true] {
let mut code = format!("PUSH_I64 {seed}\nINTRINSIC 16384\nSET_LOCAL 0\n");
for _ in 0..8 {
code.push_str(if floating {
"GET_LOCAL 0\nINTRINSIC 16386\n"
} else {
"GET_LOCAL 0\nINTRINSIC 16385\n"
});
}
code.push_str("RET");
let mut v = vm(&[(&code, sig(&[], &vec![if floating { 2 } else { 0 }; 8]), vec![], 1)]);
let r = run(&mut v, 10000);
assert_eq!(r.reason, End::EndOfRom);
let expected: Vec<_> = vectors(seed)
.iter()
.rev()
.map(|(_, signed, bits)| {
if floating {
Value::Float(f64::from_bits(*bits))
} else {
Value::Int64(*signed)
}
})
.collect();
assert_eq!(v.operand_stack_top(8), expected, "seed={seed}, Float={floating}");
}
}
}
#[test]
fn interleaving_unit_range_aliases_and_equal_seed_independent_objects() {
let mut v = vm(&[(
"PUSH_I64 42\nINTRINSIC 16384\nDUP\nSET_LOCAL 0\nSET_GLOBAL 0\nPUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 1\nGET_LOCAL 0\nINTRINSIC 16385\nGET_GLOBAL 0\nINTRINSIC 16386\nGET_LOCAL 0\nPUSH_I64 -7\nPUSH_I64 -6\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nGET_LOCAL 1\nINTRINSIC 16385\nRET",
sig(&[], &[0, 2, 0, 0, 0]),
vec![],
2,
)]);
assert_eq!(run(&mut v, 1000).reason, End::EndOfRom);
let x = vectors(42);
assert_eq!(
v.operand_stack_top(5),
vec![
Value::Int64(x[0].1),
Value::Int64(x[3].1),
Value::Int64(-7),
Value::Float(f64::from_bits(x[1].2)),
Value::Int64(x[0].1)
]
);
assert_eq!(v.heap().len(), 2);
}
#[test]
fn range_all_int64_spans_and_power_of_two_consumption() {
for (min, max) in
[(0, 1), (-10, -3), (-10, 10), (0, 16), (i64::MIN, 0), (-1, i64::MAX), (i64::MIN, i64::MAX)]
{
let code = format!(
"PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nGET_LOCAL 0\nPUSH_I64 {min}\nPUSH_I64 {max}\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nRET"
);
let mut v = vm(&[(&code, sig(&[], &[0, 0]), vec![], 1)]);
assert_eq!(run(&mut v, 1000).reason, End::EndOfRom);
let span = (i128::from(max) - i128::from(min)) as u64;
let first = vectors(42)[0].0;
// This fixed first word is accepted for all these spans, including > i64 MAX.
let expected = (i128::from(min) + i128::from(first % span)) as i64;
assert_eq!(
v.operand_stack_top(2),
vec![Value::Int64(vectors(42)[1].1), Value::Int64(expected)]
);
}
}
#[test]
fn random_storage_dynamic_and_capture_preserve_shared_identity() {
let body = "PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nSTRUCT_NEW 4\nDUP\nGET_LOCAL 0\nSTRUCT_SET type=4,field=0\nSET_LOCAL 1\nPUSH_I64 1\nARRAY_NEW 5\nDUP\nPUSH_I64 0\nGET_LOCAL 0\nARRAY_SET 5\nSET_LOCAL 2\nGET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 1\nINTRINSIC 16385\nGET_LOCAL 1\nSTRUCT_GET type=4,field=0\nINTRINSIC 16385\nGET_LOCAL 2\nPUSH_I64 0\nARRAY_GET 5\nINTRINSIC 16385\nGET_LOCAL 0\nMAKE_CLOSURE fn=1,type=6\nCALL_CLOSURE 6\nRET";
let mut v = vm(&[
(body, sig(&[], &[0; 4]), vec![], 3),
("GET_CAPTURE 0\nINTRINSIC 16385\nRET", sig(&[], &[0]), vec![TypeId(1)], 0),
]);
assert_eq!(run(&mut v, 2000).reason, End::EndOfRom);
assert_eq!(
v.operand_stack_top(4),
vectors(42)[..4].iter().rev().map(|x| Value::Int64(x.1)).collect::<Vec<_>>()
);
// generator + Struct + Array + Closure; no Dynamic box for one-slot Random.
assert_eq!(v.heap().allocation_count(), 4);
}
#[test]
fn random_parameter_result_and_typed_null_have_exact_dynamic_type() {
let mut v = vm(&[
("PUSH_I64 42\nINTRINSIC 16384\nCALL 1\nINTRINSIC 16385\nRET", sig(&[], &[0]), vec![], 0),
("GET_LOCAL 0\nRET", sig(&[1], &[1]), vec![], 0),
]);
assert_eq!(run(&mut v, 1000).reason, End::EndOfRom);
assert_eq!(v.operand_stack_top(1), vec![Value::Int64(vectors(42)[0].1)]);
let mut v = vm(&[("GET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 1\nRET", sig(&[], &[1]), vec![], 1)]);
assert_eq!(run(&mut v, 1000).reason, End::EndOfRom);
assert_eq!(v.operand_stack_top(1), vec![Value::Null]);
let mut v = vm(&[("GET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 7\nRET", sig(&[], &[7]), vec![], 1)]);
let r = run(&mut v, 1000);
assert_eq!(trap(&r).code, TRAP_TYPE);
}
#[test]
fn all_random_attempts_charge_before_validation_and_budget_overshoot() {
for (id, cost) in [(16384, 32), (16385, 8), (16386, 12), (16387, 12)] {
let body = if id == 16384 {
"PUSH_I64 42\nINTRINSIC 16384\nPOP\nRET".into()
} else {
format!(
"PUSH_I64 42\nINTRINSIC 16384\n{}INTRINSIC {id}\nPOP\nRET",
if id == 16387 { "PUSH_I64 5\nPUSH_I64 6\n" } else { "" }
)
};
let mut v = vm(&[(&body, sig(&[], &[]), vec![], 0)]);
for _ in 0..if id == 16384 {
1
} else if id == 16387 {
4
} else {
2
} {
step(&mut v);
}
let before = (v.pc(), v.operand_stack_top(10).to_vec(), v.heap().allocation_count());
let zero = run(&mut v, 0);
assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0));
assert_eq!((v.pc(), v.operand_stack_top(10).to_vec(), v.heap().allocation_count()), before);
let one = run(&mut v, 1);
assert_eq!((one.cycles_used, one.steps_executed), (cost, 1));
assert_eq!(one.reason, End::BudgetExhausted);
}
}
#[test]
fn range_domain_fault_preserves_operands_and_shared_stream() {
for (min, max) in [(1, 1), (2, 1)] {
let code = format!(
"PUSH_I64 42\nINTRINSIC 16384\nDUP\nSET_GLOBAL 0\nPUSH_I64 {min}\nPUSH_I64 {max}\nINTRINSIC 16387\nRET"
);
let mut v = vm(&[(&code, sig(&[], &[0]), vec![], 0)]);
for _ in 0..6 {
step(&mut v);
}
let args = v.operand_stack_top(3).to_vec();
let r = run(&mut v, 1);
assert_eq!(trap(&r).code, TRAP_NUMERIC_DOMAIN);
assert_eq!((r.cycles_used, r.steps_executed), (4, 0));
assert_eq!(v.operand_stack_top(3), args);
}
}
#[test]
fn quota_refusal_new_preserves_seed_and_publishes_no_handle() {
let image =
image(&[("PUSH_I64 42\nINTRINSIC 16384\nPOP\nRET", sig(&[], &[]), vec![], 0)]).unwrap();
for resource in [Q::GuestBytes, Q::HandleSlots, Q::TemporaryBytes] {
let mut v = VirtualMachine::from_image(
image.clone(),
RuntimeLimits::default().lowered(resource, 0).unwrap(),
);
v.prepare_boot_call().unwrap();
step(&mut v);
let r = run(&mut v, 1);
assert_eq!(trap(&r).code, TRAP_RESOURCE_LIMIT);
assert_eq!(trap(&r).resource.as_ref().unwrap().resource, resource);
assert_eq!((r.cycles_used, r.steps_executed), (32, 0));
assert_eq!(v.operand_stack_top(1), vec![Value::Int64(42)]);
assert_eq!(v.heap().allocation_count(), 0);
}
}
#[test]
fn unknown_analysis_checks_null_receiver_at_runtime() {
let mut v = vm(&[(
"GET_LOCAL 0\nSET_GLOBAL 0\nGET_GLOBAL 0\nINTRINSIC 16385\nRET",
sig(&[], &[0]),
vec![],
1,
)]);
for _ in 0..3 {
step(&mut v);
}
let r = run(&mut v, 1);
assert_eq!(trap(&r).code, TRAP_NULL_REFERENCE);
assert_eq!((r.cycles_used, r.steps_executed), (8, 0));
assert_eq!(v.operand_stack_top(1), vec![Value::Null]);
}
#[test]
fn loader_rejects_unknown_unreachable_ids_and_new_random_construction() {
for code in ["RET\nINTRINSIC 16388", "STRUCT_NEW 1\nRET", "PUSH_I32 42\nINTRINSIC 16384\nRET"] {
let err = image(&[(code, sig(&[], &[]), vec![], 0)]).unwrap_err();
let VmInitError::RegistryLoadFailed(failure) = err else { panic!("{err:?}") };
if code.contains("16388") {
assert_eq!(failure.code, prometeu_bytecode::load_limits::LoadCode::InvalidCode);
assert_eq!(failure.reason, prometeu_bytecode::load_limits::LoadReason::NativeId);
}
}
}
#[test]
fn catalog_reference_layout_effects_and_cost_models_are_exact() {
let b = lookup_builtin_type("Random", 1).unwrap();
assert_eq!(b.id, 0x16);
assert!(b.fields.is_empty());
let l = BuiltinId::RANDOM.layout().unwrap();
assert_eq!((l.size, l.alignment, l.slots, l.ownership), (8, 8, 1, Ownership::GuestReference));
assert_eq!(l.default_values(), &[Value::Null]);
for (id, name, cost, slots) in [
(0x4000, "new", 32, 1),
(0x4001, "next", 8, 1),
(0x4002, "nextf", 12, 1),
(0x4003, "range", 4, 3),
] {
let m = lookup_intrinsic_by_id(id).unwrap();
assert_eq!(
(m.owner, m.name, m.version, m.cost_cycles, m.arg_slots(), m.ret_slots()),
("random", name, 1, cost, slots, 1)
);
assert!(m.deterministic && m.mutates_guest_state);
assert_eq!(m.may_allocate, id == 0x4000);
assert!(matches!(m.implementation, IntrinsicImplementation::VmOwned));
assert!(m.implementation.host_callback().is_none());
assert_eq!(
(m.cost_model, m.attempt_cost_cycles, m.max_attempts),
if id == 0x4003 {
(IntrinsicCostModel::RandomRejectionV1, 8, 64)
} else {
(IntrinsicCostModel::Fixed, 0, 0)
}
);
}
assert_eq!(lookup_intrinsic_by_id(0x4003).unwrap().parameter_names, &["rng", "min", "max"]);
for m in prometeu_vm::intrinsic_catalog().filter(|m| m.id < 0x4000) {
assert!(!m.mutates_guest_state);
assert_eq!(
(m.cost_model, m.attempt_cost_cycles, m.max_attempts),
(IntrinsicCostModel::Fixed, 0, 0)
);
}
}
#[test]
fn real_pcg_rejection_consumes_two_words_and_one_instruction() {
let mut v = vm(&[(
"PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nGET_LOCAL 0\nINTRINSIC 16385\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 -9223372036854775808\nPUSH_I64 1\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nRET",
sig(&[], &[0, 0]),
vec![],
2,
)]);
for _ in 0..9 {
step(&mut v);
}
let r = run(&mut v, 1);
assert_eq!((r.cycles_used, r.steps_executed, r.reason), (20, 1, End::BudgetExhausted));
assert_eq!(run(&mut v, 1000).reason, End::EndOfRom);
let x = vectors(42);
let expected = (i128::from(i64::MIN) + i128::from(x[2].0 % ((1u64 << 63) + 1))) as i64;
assert_eq!(v.operand_stack_top(2), vec![Value::Int64(x[3].1), Value::Int64(expected)]);
}
#[test]
fn published_emission_example_matches_bits_consumption_and_total_cycles() {
let doc = include_str!("../../../../docs/vm-arch/random-producer-handoff.md");
let code = doc.split("```text\n").nth(1).unwrap().split("```").next().unwrap();
let mut v = vm(&[(code, sig(&[], &[0, 2, 0]), vec![], 1)]);
let r = run(&mut v, 1000);
assert_eq!(r.reason, End::EndOfRom);
assert_eq!(r.cycles_used, 82);
assert_eq!(
v.operand_stack_top(3),
vec![
Value::Int64(-7),
Value::Float(f64::from_bits(0x3fb3_04aa_46c9_8538)),
Value::Int64(0x86b1_da1d_7206_2b68u64 as i64)
]
);
}