feat(pbs): integrate explicit runtime Random handles
This commit is contained in:
@@ -36,8 +36,10 @@ impl NativeInterface for NoNative {
|
||||
|
||||
fn main() {
|
||||
let root = std::path::PathBuf::from(std::env::args().nth(1).expect("fixture directory"));
|
||||
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_catalog_fixtures(&root);
|
||||
verify_pbs_fixtures(&root);
|
||||
verify_pbs_structured_fixtures(&root);
|
||||
@@ -477,7 +479,7 @@ fn verify_pbs_fixtures(root: &std::path::Path) {
|
||||
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-math-") || name.starts_with("pbs-structured-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
|
||||
if name.starts_with("pbs-random-") || name.starts_with("pbs-math-") || name.starts_with("pbs-structured-") || !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)
|
||||
@@ -726,3 +728,114 @@ fn verify_pbs_math_fixtures(root: &std::path::Path) {
|
||||
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,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,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![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");
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user