309 lines
12 KiB
Rust
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)
|
|
]
|
|
);
|
|
}
|