Files

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(&[], &[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)
]
);
}