feat(registry): checkpoint PLN-0176 foundations and validated partial integrations
This commit is contained in:
@@ -264,7 +264,9 @@ fn stack_value(value: &VmValue) -> Value {
|
||||
VmValue::Float(v) => json!({"kind":"float64","value":v.to_string()}),
|
||||
VmValue::Boolean(v) => json!({"kind":"boolean","value":v}),
|
||||
VmValue::String(v) => json!({"kind":"string","value":v.as_ref()}),
|
||||
VmValue::HeapRef(v) => json!({"kind":"heap_ref","value":v.0}),
|
||||
VmValue::HeapRef(v) => {
|
||||
json!({"kind":"heap_ref","value":{"index":v.index,"generation":v.generation}})
|
||||
}
|
||||
VmValue::Null => json!({"kind":"null","value":null}),
|
||||
}
|
||||
}
|
||||
@@ -287,6 +289,7 @@ pub(super) fn fault(report: &CrashReport) -> Value {
|
||||
}
|
||||
CrashReport::VmInit { error } => {
|
||||
let code = match error {
|
||||
VmInitError::RuntimeResourceLimit(_) => "runtime_resource_limit",
|
||||
VmInitError::InvalidFormat => "invalid_format",
|
||||
VmInitError::UnsupportedFormat => "unsupported_format",
|
||||
VmInitError::ImageLoadFailed(_) => "image_load_failed",
|
||||
|
||||
@@ -481,9 +481,7 @@ fn color_program() -> Vec<u8> {
|
||||
PUSH_I32 0\n\
|
||||
HOSTCALL 1\n\
|
||||
POP_N 1\n\
|
||||
INTRINSIC 0x2000\n\
|
||||
INTRINSIC 0x2013\n\
|
||||
INTRINSIC 0x2032\n"));
|
||||
INTRINSIC 0x210E\n"));
|
||||
let jump_to_blue = rom.len() + 2;
|
||||
rom.extend(asm("JMP_IF_FALSE 0"));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
@@ -495,17 +493,17 @@ fn color_program() -> Vec<u8> {
|
||||
|
||||
fn input_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_right_predicate(&mut rom, 0x2030);
|
||||
let pressed_jump = emit_right_predicate(&mut rom, 0x210C);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_right_predicate(&mut rom, 0x2031);
|
||||
let released_jump = emit_right_predicate(&mut rom, 0x210D);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_right_predicate(&mut rom, 0x2032);
|
||||
let down_jump = emit_right_predicate(&mut rom, 0x210E);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
@@ -515,7 +513,7 @@ fn input_edge_program() -> Vec<u8> {
|
||||
}
|
||||
|
||||
fn emit_right_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
rom.extend(asm(&format!("INTRINSIC 0x2000\nINTRINSIC 0x2013\nINTRINSIC {predicate:#x}\n")));
|
||||
rom.extend(asm(&format!("INTRINSIC {predicate:#x}\n")));
|
||||
let target = rom.len() + 2;
|
||||
rom.extend(asm("JMP_IF_FALSE 0\n"));
|
||||
target
|
||||
@@ -523,17 +521,17 @@ fn emit_right_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
|
||||
fn touch_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_touch_predicate(&mut rom, 0x2030);
|
||||
let pressed_jump = emit_touch_predicate(&mut rom, 0x2130);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_touch_predicate(&mut rom, 0x2031);
|
||||
let released_jump = emit_touch_predicate(&mut rom, 0x2131);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_touch_predicate(&mut rom, 0x2032);
|
||||
let down_jump = emit_touch_predicate(&mut rom, 0x2132);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
@@ -544,9 +542,9 @@ fn touch_edge_program() -> Vec<u8> {
|
||||
|
||||
fn emit_touch_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
rom.extend(asm(&format!(
|
||||
"INTRINSIC 0x2001\nINTRINSIC 0x2020\nINTRINSIC {predicate:#x}\n\
|
||||
INTRINSIC 0x2001\nINTRINSIC 0x2021\nPUSH_I64 123\nEQ\nAND\n\
|
||||
INTRINSIC 0x2001\nINTRINSIC 0x2022\nPUSH_I64 45\nEQ\nAND\n"
|
||||
"INTRINSIC {predicate:#x}\n\
|
||||
INTRINSIC 0x2134\nPUSH_I64 123\nEQ\nAND\n\
|
||||
INTRINSIC 0x2135\nPUSH_I64 45\nEQ\nAND\n"
|
||||
)));
|
||||
let target = rom.len() + 2;
|
||||
rom.extend(asm("JMP_IF_FALSE 0\n"));
|
||||
|
||||
@@ -0,0 +1,231 @@
|
||||
//! Independent catalogue and execution oracles for the fixed input ABI.
|
||||
use prometeu_bytecode::{TRAP_INVALID_INTRINSIC, TRAP_UNAVAILABLE, Value, assembler::assemble};
|
||||
use prometeu_drivers::TestPlatform;
|
||||
use prometeu_hal::{InputSignals, RuntimePlatform, vm_fault::VmFault};
|
||||
use prometeu_vm::{
|
||||
AbiType, BuiltinScalarType, HostContext, HostReturn, IntrinsicExecutionError,
|
||||
LogicalFrameEndingReason, NativeInterface, VirtualMachine, lookup_builtin_type,
|
||||
lookup_intrinsic, lookup_intrinsic_by_id,
|
||||
};
|
||||
|
||||
const BUTTONS: [(&str, u32); 13] = [
|
||||
("input.pad.up", 0x2100),
|
||||
("input.pad.down", 0x2104),
|
||||
("input.pad.left", 0x2108),
|
||||
("input.pad.right", 0x210C),
|
||||
("input.pad.a", 0x2110),
|
||||
("input.pad.b", 0x2114),
|
||||
("input.pad.x", 0x2118),
|
||||
("input.pad.y", 0x211C),
|
||||
("input.pad.l", 0x2120),
|
||||
("input.pad.r", 0x2124),
|
||||
("input.pad.start", 0x2128),
|
||||
("input.pad.select", 0x212C),
|
||||
("input.touch.button", 0x2130),
|
||||
];
|
||||
|
||||
struct NoSyscalls;
|
||||
impl NativeInterface for NoSyscalls {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
_: u32,
|
||||
_: &[Value],
|
||||
_: &mut HostReturn,
|
||||
_: &mut HostContext,
|
||||
) -> Result<(), VmFault> {
|
||||
panic!("input must not invoke a syscall")
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn catalogue_has_exact_names_ids_signatures_and_no_endpoint_aliases() {
|
||||
let mut ids = std::collections::BTreeSet::new();
|
||||
for (owner, base) in BUTTONS {
|
||||
for (offset, property) in ["pressed", "released", "down", "hold"].into_iter().enumerate() {
|
||||
let meta = lookup_intrinsic(owner, property, 1).unwrap();
|
||||
assert_eq!(meta.id, base + offset as u32);
|
||||
assert!(ids.insert(meta.id));
|
||||
assert_eq!(lookup_intrinsic_by_id(meta.id).unwrap().key(), meta.key());
|
||||
assert!(meta.arg_layout.is_empty());
|
||||
assert_eq!(
|
||||
meta.ret_layout,
|
||||
&[AbiType::Scalar(if offset == 3 {
|
||||
BuiltinScalarType::Int64
|
||||
} else {
|
||||
BuiltinScalarType::Bool
|
||||
})]
|
||||
);
|
||||
assert!(meta.deterministic);
|
||||
assert!(!meta.may_allocate);
|
||||
assert!(lookup_intrinsic(owner, property, 2).is_none());
|
||||
}
|
||||
}
|
||||
for (name, id) in [("x", 0x2134), ("y", 0x2135)] {
|
||||
let meta = lookup_intrinsic("input.touch", name, 1).unwrap();
|
||||
assert_eq!(meta.id, id);
|
||||
assert!(ids.insert(id));
|
||||
assert!(meta.arg_layout.is_empty());
|
||||
assert_eq!(meta.ret_layout, &[AbiType::Scalar(BuiltinScalarType::Int64)]);
|
||||
}
|
||||
assert_eq!(ids.len(), 54);
|
||||
assert!(lookup_intrinsic_by_id(0x2136).is_none());
|
||||
for id in [0x2000, 0x2001]
|
||||
.into_iter()
|
||||
.chain(0x2010..=0x201B)
|
||||
.chain(0x2020..=0x2022)
|
||||
.chain(0x2030..=0x2033)
|
||||
{
|
||||
assert!(lookup_intrinsic_by_id(id).is_none(), "removed ID {id:#x}");
|
||||
}
|
||||
for name in ["input.pad", "input.touch", "input.button", "input.touch.button"] {
|
||||
assert!(lookup_builtin_type(name, 1).is_none());
|
||||
}
|
||||
for (owner, name) in [
|
||||
("input", "pad"),
|
||||
("input", "touch"),
|
||||
("input.pad", "up"),
|
||||
("input.touch", "button"),
|
||||
("input.button", "down"),
|
||||
] {
|
||||
assert!(lookup_intrinsic(owner, name, 1).is_none());
|
||||
}
|
||||
let csv = include_str!("../../../../docs/vm-arch/INTRINSICS.csv");
|
||||
let mut documented = std::collections::BTreeSet::new();
|
||||
for row in csv.lines().skip(1) {
|
||||
let columns: Vec<_> = row.split(',').collect();
|
||||
if !columns[2].starts_with("input.") {
|
||||
continue;
|
||||
}
|
||||
let id = columns[1].parse::<u32>().unwrap();
|
||||
let meta = lookup_intrinsic(columns[4], columns[5], 1).unwrap();
|
||||
assert_eq!(id, meta.id);
|
||||
assert_eq!(columns[2], format!("{}.{}", meta.owner, meta.name));
|
||||
assert_eq!(&columns[6..9], &["0", "1", ""]);
|
||||
assert_eq!(
|
||||
columns[9],
|
||||
if meta.name == "hold" || meta.owner == "input.touch" { "Int64" } else { "Bool" }
|
||||
);
|
||||
assert!(documented.insert(id));
|
||||
}
|
||||
assert_eq!(ids, documented);
|
||||
}
|
||||
|
||||
fn set_frame(platform: &mut TestPlatform, active: Option<usize>) {
|
||||
let mut signals = InputSignals { x_pos: -123, y_pos: i32::MAX, ..Default::default() };
|
||||
if let Some(index) = active {
|
||||
let fields = [
|
||||
&mut signals.up_signal,
|
||||
&mut signals.down_signal,
|
||||
&mut signals.left_signal,
|
||||
&mut signals.right_signal,
|
||||
&mut signals.a_signal,
|
||||
&mut signals.b_signal,
|
||||
&mut signals.x_signal,
|
||||
&mut signals.y_signal,
|
||||
&mut signals.l_signal,
|
||||
&mut signals.r_signal,
|
||||
&mut signals.start_signal,
|
||||
&mut signals.select_signal,
|
||||
&mut signals.f_signal,
|
||||
];
|
||||
*fields[index] = true;
|
||||
}
|
||||
platform.input_mut().pad_mut().begin_frame(&signals);
|
||||
platform.input_mut().touch_mut().begin_frame(&signals);
|
||||
}
|
||||
|
||||
fn query_all(platform: &mut TestPlatform) -> Vec<Value> {
|
||||
let mut ctx = HostContext::new(Some(platform));
|
||||
(0x2100..=0x2135)
|
||||
.map(|id| {
|
||||
let meta = lookup_intrinsic_by_id(id).unwrap();
|
||||
let result = (meta.implementation)(&[], &mut ctx).unwrap();
|
||||
meta.validate_result_values(&result).unwrap();
|
||||
result.into_iter().next().unwrap()
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_button_uses_its_own_snapshot_and_queries_do_not_advance_frames() {
|
||||
let mut platform = TestPlatform::new();
|
||||
for active in 0..13 {
|
||||
set_frame(&mut platform, None);
|
||||
for (pressed, released, down, hold) in [
|
||||
(true, false, true, 1),
|
||||
(false, false, true, 2),
|
||||
(false, true, false, 0),
|
||||
(false, false, false, 0),
|
||||
] {
|
||||
set_frame(&mut platform, down.then_some(active));
|
||||
let result = query_all(&mut platform);
|
||||
assert_eq!(query_all(&mut platform), result, "same-frame queries changed state");
|
||||
for index in 0..13 {
|
||||
let values = if index == active {
|
||||
(pressed, released, down, hold)
|
||||
} else {
|
||||
(false, false, false, 0)
|
||||
};
|
||||
assert_eq!(
|
||||
&result[index * 4..index * 4 + 4],
|
||||
&[
|
||||
Value::Boolean(values.0),
|
||||
Value::Boolean(values.1),
|
||||
Value::Boolean(values.2),
|
||||
Value::Int64(values.3),
|
||||
],
|
||||
"button {index}, active {active}"
|
||||
);
|
||||
}
|
||||
assert_eq!(&result[52..], &[Value::Int64(-123), Value::Int64(i32::MAX as i64)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects() {
|
||||
let mut source = String::new();
|
||||
for id in 0x2100..=0x2135 {
|
||||
source.push_str(&format!("INTRINSIC {id}\n"));
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble(&source).unwrap(), vec![]);
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let objects = vm.heap().len();
|
||||
let mut platform = TestPlatform::new();
|
||||
set_frame(&mut platform, Some(3));
|
||||
let expected = query_all(&mut platform);
|
||||
let report =
|
||||
vm.run_budget(54, &mut NoSyscalls, &mut HostContext::new(Some(&mut platform))).unwrap();
|
||||
assert_eq!(report.cycles_used, 54);
|
||||
assert_eq!(report.steps_executed, 54);
|
||||
assert_eq!(vm.heap().len(), objects);
|
||||
// Inspection returns the topmost slot first.
|
||||
assert_eq!(vm.operand_stack_top(54), expected.into_iter().rev().collect::<Vec<_>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_known_query_faults_when_unavailable_and_rejects_arguments() {
|
||||
for id in 0x2100..=0x2135 {
|
||||
let meta = lookup_intrinsic_by_id(id).unwrap();
|
||||
let mut ctx = HostContext::new(None);
|
||||
assert_eq!(
|
||||
(meta.implementation)(&[], &mut ctx),
|
||||
Err(IntrinsicExecutionError::HardwareUnavailable)
|
||||
);
|
||||
assert_eq!(
|
||||
(meta.implementation)(&[Value::Int64(0)], &mut ctx),
|
||||
Err(IntrinsicExecutionError::ArityMismatch { expected: 0, got: 1 })
|
||||
);
|
||||
let mut vm = VirtualMachine::new(assemble(&format!("INTRINSIC {id}\n")).unwrap(), vec![]);
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut ctx).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_UNAVAILABLE && trap.pc == 0));
|
||||
assert!(vm.operand_stack_top(1).is_empty());
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble("INTRINSIC 0x2136\n").unwrap(), vec![]);
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_INVALID_INTRINSIC));
|
||||
}
|
||||
Reference in New Issue
Block a user