refactor(compiler)!: migrate SDK to minimal storage ISA
Replace retired guards and publication opcodes with SDK checks, neutral TRAP and sequential List/Linked mutations with explicit failure phases. Preserve snapshot cursors and import schema 2 metadata with the delivered provider pin. Include common/source/installed conformance, debug and release evidence, synchronized specs and the consolidated lesson. Runtime checkout remains unchanged.
This commit is contained in:
+150
-24
@@ -283,7 +283,7 @@ fn main() {
|
||||
fn verify_catalog_fixtures(root: &std::path::Path) {
|
||||
use prometeu_vm::LogicalFrameEndingReason as End;
|
||||
let mut random_cycles = None;
|
||||
for name in ["catalog-random-off", "catalog-random-on", "catalog-constants", "catalog-vec2-zero", "catalog-input", "catalog-string"] {
|
||||
for name in ["catalog-random-off", "catalog-random-on", "catalog-constants", "catalog-vec2-zero", "catalog-input", "catalog-string", "catalog-null-hash", "catalog-null-hash-optimized"] {
|
||||
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
|
||||
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
|
||||
.unwrap_or_else(|error| panic!("{name}: {error:?}"));
|
||||
@@ -309,6 +309,10 @@ fn verify_catalog_fixtures(root: &std::path::Path) {
|
||||
assert_eq!(vm.operand_stack_top(2), vec![Value::Float(0.0), Value::Float(0.0)]);
|
||||
} else if name == "catalog-string" {
|
||||
assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(0xAABBCCDD)]);
|
||||
} else if name.starts_with("catalog-null-hash") {
|
||||
assert_eq!(vm.operand_stack_top(1),vec![Value::Int64(0)],"provider null hash vector");
|
||||
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
||||
assert_eq!(report.cycles_used,Op::PushConst.cycles()+8+Op::Halt.cycles());
|
||||
} else {
|
||||
let mut constants: Vec<_> = prometeu_vm::builtin_constant_catalog().collect();
|
||||
constants.sort_by_key(|constant| constant.key.key());
|
||||
@@ -1040,12 +1044,12 @@ fn verify_pbs_random_fixtures(root: &std::path::Path) {
|
||||
|
||||
fn verify_pbs_list_cursor_fixtures(root: &std::path::Path) {
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource}};
|
||||
use prometeu_bytecode::{TRAP_OOB,TRAP_RESOURCE_LIMIT};
|
||||
use prometeu_bytecode::TRAP_EXPLICIT;
|
||||
let successful=["basic","construction","capacity","holes","structural-growth","cursor-empty","cursor-single",
|
||||
"cursor-many","snapshot","false-present","shared-optional","identity","tuple","nested-array","function","evaluation","vec2","pixel","contract"];
|
||||
let faults=[("fault-read",TRAP_OOB),("fault-write",TRAP_OOB),("fault-negative",TRAP_OOB),
|
||||
("fault-insert",TRAP_OOB),("fault-length",TRAP_OOB),("fault-overflow",TRAP_RESOURCE_LIMIT),
|
||||
("fault-long-index",TRAP_OOB),("fault-constructor",TRAP_OOB)];
|
||||
let faults=[("fault-read",TRAP_EXPLICIT),("fault-write",TRAP_EXPLICIT),("fault-negative",TRAP_EXPLICIT),
|
||||
("fault-insert",TRAP_EXPLICIT),("fault-length",TRAP_EXPLICIT),("fault-overflow",TRAP_EXPLICIT),
|
||||
("fault-long-index",TRAP_EXPLICIT),("fault-constructor",TRAP_EXPLICIT)];
|
||||
let cases=successful.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,c)|(n,Some(c))))
|
||||
.flat_map(|(name,fault)|[(name.to_string(),fault),(format!("{name}-optimized"),fault)]);
|
||||
for (name,fault) in cases {
|
||||
@@ -1087,14 +1091,50 @@ fn list_storage(vm:&VirtualMachine,image:&ValidatedProgramImage)->(prometeu_vm::
|
||||
(object,array)
|
||||
}
|
||||
|
||||
// Non-owning diagnostic snapshots observe only objects reachable before the operation.
|
||||
// Compare every instruction prefix against a successful execution, so a refused
|
||||
// instruction preserves its own entry state without inventing method rollback.
|
||||
type ObservedStorage = Vec<prometeu_vm::resource_diagnostics::StorageObject>;
|
||||
type MutationPrefix = (usize, ObservedStorage);
|
||||
fn observe_originals(vm:&VirtualMachine, original:&ObservedStorage)->ObservedStorage {
|
||||
let objects=vm.heap().diagnostic_typed_storage();
|
||||
original.iter().filter_map(|old|objects.iter().find(|now|now.reference==old.reference).cloned()).collect()
|
||||
}
|
||||
fn trace_collection_attempt(vm:&mut VirtualMachine, original:&ObservedStorage, stop_pc:usize)
|
||||
->(prometeu_vm::BudgetReport, Vec<MutationPrefix>, bool) {
|
||||
use prometeu_vm::LogicalFrameEndingReason as End;
|
||||
let mut prefixes=Vec::new(); let mut mutated=false;
|
||||
for _ in 0..200_000 {
|
||||
let before=observe_originals(vm,original);
|
||||
mutated|=before!=*original;
|
||||
prefixes.push((vm.pc(),before.clone()));
|
||||
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
let after=observe_originals(vm,original);
|
||||
if matches!(report.reason,End::Trap(_)) {
|
||||
assert_eq!(after,before,"refused instruction preserves its own observable entry state");
|
||||
}
|
||||
mutated|=after!=*original;
|
||||
if vm.pc()==stop_pc || !matches!(report.reason,End::BudgetExhausted) {return (report,prefixes,mutated);}
|
||||
}
|
||||
panic!("collection operation did not reach its completion marker");
|
||||
}
|
||||
fn assert_mutation_prefix(actual:&[MutationPrefix], successful:&[MutationPrefix]) {
|
||||
assert!(actual.len()<=successful.len(),"refusal must be a successful instruction prefix");
|
||||
for (index,(left,right)) in actual.iter().zip(successful).enumerate() {
|
||||
assert_eq!(left,right,"observable effects differ at source-operation instruction {index}");
|
||||
}
|
||||
}
|
||||
|
||||
fn verify_list_cursor_refusals(root:&std::path::Path) {
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
||||
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
||||
use prometeu_bytecode::{decode_next,TRAP_RESOURCE_LIMIT};
|
||||
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
||||
let mut publication_scratch=false;let mut return_carrier=false;let mut nodes=false;let mut candidate=false;let mut operand_preparation=false;
|
||||
let mut copy_scratch=false;let mut return_carrier=false;let mut nodes=false;let mut candidate=false;let mut operand_preparation=false;
|
||||
for name in ["insert","remove","growth","cursor"] {
|
||||
let bytes=std::fs::read(root.join(format!("pbs-list-refusal-{name}.pbx"))).expect("mandatory refusal fixture");
|
||||
for suffix in ["","-optimized"] {
|
||||
println!("PHASE CORPUS list {name}{suffix}");
|
||||
let bytes=std::fs::read(root.join(format!("pbs-list-refusal-{name}{suffix}.pbx"))).expect("mandatory refusal fixture");
|
||||
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
||||
let marker=|value:i32| {
|
||||
let mut pc=0;let mut found=Vec::new();
|
||||
@@ -1113,7 +1153,9 @@ fn verify_list_cursor_refusals(root:&std::path::Path) {
|
||||
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
||||
let before=baseline.resource_snapshot();let original=list_storage(&baseline,&image);
|
||||
baseline.remove_breakpoint(before_pc);
|
||||
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
||||
let watched=vec![original.0.clone(),original.1.clone()];
|
||||
let (completed_report,successful_prefix,_)=trace_collection_attempt(&mut baseline,&watched,after_pc);
|
||||
assert!(matches!(completed_report.reason,End::BudgetExhausted|End::Breakpoint) && baseline.pc()==after_pc,"operation completion: {completed_report:?}");
|
||||
let completed=baseline.resource_snapshot();let changed=list_storage(&baseline,&image);
|
||||
let expected_size=match name {"insert"|"growth"=>129,"remove"=>127,_=>128};
|
||||
assert_eq!(changed.0.groups[1],[V::Int64(expected_size)],"{name} logical size after success");
|
||||
@@ -1135,12 +1177,16 @@ fn verify_list_cursor_refusals(root:&std::path::Path) {
|
||||
assert!(matches!(setup.reason,End::Breakpoint),"{name} setup at {q:?}={limit}: {setup:?}");
|
||||
let state=list_storage(&vm,&image);
|
||||
vm.remove_breakpoint(before_pc);
|
||||
let report=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
let watched=vec![state.0.clone(),state.1.clone()];
|
||||
let (report,prefix,mutated)=trace_collection_attempt(&mut vm,&watched,after_pc);
|
||||
assert_mutation_prefix(&prefix,&successful_prefix);
|
||||
if let End::Trap(info)=report.reason {
|
||||
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"{name} at {q:?}={limit}: {info:?}");
|
||||
assert_eq!(list_storage(&vm,&image),state,"{name}: no partial slots/backing/size at {q:?}={limit}");
|
||||
if !mutated || name=="cursor" {
|
||||
assert_eq!(list_storage(&vm,&image),state,"{name}: failure before mutation preserves slots/backing/size");
|
||||
}
|
||||
let instruction=decode_next(info.pc as usize,image.code()).unwrap();
|
||||
publication_scratch|=q==Q::TemporaryBytes&&instruction.opcode==Op::StoragePublish;
|
||||
copy_scratch|=q==Q::TemporaryBytes&&instruction.opcode==Op::ArrayCopy;
|
||||
operand_preparation|=q==Q::AuxiliaryBytes;
|
||||
candidate|=name=="growth"&&instruction.opcode==Op::ArrayNew;
|
||||
if instruction.opcode==Op::StructNew {
|
||||
@@ -1155,15 +1201,16 @@ fn verify_list_cursor_refusals(root:&std::path::Path) {
|
||||
}
|
||||
}
|
||||
refusals+=1;
|
||||
println!("PBS LIST ATOMIC REFUSAL {name} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
||||
} else {assert!(matches!(report.reason,End::Breakpoint),"{name}: {report:?}");}
|
||||
println!("PBS LIST PHASE REFUSAL {name} mutated={mutated} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
||||
} else {assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint) && vm.pc()==after_pc,"{name}: {report:?}");}
|
||||
drop(vm);
|
||||
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {assert_eq!(observer.used(resource),0);}
|
||||
}
|
||||
}
|
||||
assert!(refusals>0,"{name}: mandatory source refusals executed");
|
||||
}
|
||||
assert!(publication_scratch,"no-growth publication scratch refusal");
|
||||
}
|
||||
assert!(copy_scratch,"no-growth copy scratch refusal");
|
||||
assert!(return_carrier,"removeAt optional return allocation refusal");
|
||||
assert!(candidate,"growth candidate allocation refusal");
|
||||
assert!(nodes,"snapshot node allocation refusal");
|
||||
@@ -1197,8 +1244,64 @@ fn verify_collection_cursor_gc(root:&std::path::Path,collection:&str) {
|
||||
assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
||||
}
|
||||
|
||||
fn verify_copy_attempts(root:&std::path::Path) {
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
|
||||
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_OOB,TRAP_NULL_REFERENCE,TRAP_RESOURCE_LIMIT};
|
||||
for base in ["scalar","vec2","string","zero","bad-range","bad-empty-range","null-source","null-zero","negative-count","huge-count","fault-order"] {
|
||||
for optimized in [false,true] {
|
||||
let name=format!("common-copy-{base}{}",if optimized{"-optimized"}else{""});
|
||||
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory copy oracle");
|
||||
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
||||
let mut pc=0;let mut copies=Vec::new();
|
||||
while pc<image.code().len() {
|
||||
let instruction=decode_next(pc,image.code()).unwrap();
|
||||
assert!(![0xa7,0xa8,0xaa,0xab].contains(&(instruction.opcode as u16)));
|
||||
if instruction.opcode==Op::ArrayCopy {copies.push(pc);} pc=instruction.next_pc;
|
||||
}
|
||||
assert_eq!(copies.len(),1);let copy_pc=copies[0];
|
||||
let prepare=|limits| {
|
||||
let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();vm.insert_breakpoint(copy_pc);
|
||||
assert!(matches!(vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));vm
|
||||
};
|
||||
let mut vm=prepare(RuntimeLimits::default());let observer=vm.resource_observer();
|
||||
let before=vm.heap().diagnostic_typed_storage();let operands=vm.operand_stack_top(5).to_vec();
|
||||
let scratch_floor=vm.resource_snapshot().budget.peaks[Q::TemporaryBytes as usize];
|
||||
let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
assert_eq!((zero.cycles_used,zero.steps_executed,vm.pc()),(0,0,copy_pc));
|
||||
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
let cycles=if base=="vec2"{44}else if ["zero","bad-empty-range","null-zero","negative-count","huge-count","fault-order"].contains(&base){4}else{24};
|
||||
assert_eq!(report.cycles_used,cycles,"{name}: precharged cost");
|
||||
let fault=if base.starts_with("null-")||base=="fault-order"{Some(TRAP_NULL_REFERENCE)}
|
||||
else if ["bad-range","bad-empty-range","negative-count","huge-count"].contains(&base){Some(TRAP_OOB)}else{None};
|
||||
if let Some(code)=fault {
|
||||
let End::Trap(info)=report.reason else {panic!("{name}: {report:?}")};
|
||||
assert_eq!(info.code,code);assert_eq!(report.steps_executed,0);
|
||||
assert_eq!(vm.operand_stack_top(5),operands);assert_eq!(vm.heap().diagnostic_typed_storage(),before);
|
||||
} else {
|
||||
assert!(matches!(report.reason,End::BudgetExhausted));assert_eq!(report.steps_executed,1);
|
||||
let mut expected=before.clone();
|
||||
if base!="zero" {for i in 0..10 {expected[0].groups[i+2]=before[0].groups[i].clone();}}
|
||||
assert_eq!(vm.heap().diagnostic_typed_storage(),expected,"{name}: snapshot overlap and complete native groups");
|
||||
}
|
||||
assert_eq!(observer.used(Q::TemporaryBytes),0,"copy releases provisional scratch");
|
||||
drop(vm);for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations] {assert_eq!(observer.used(resource),0);}
|
||||
if base=="scalar" {
|
||||
let mut refused=prepare(RuntimeLimits::default().lowered(Q::TemporaryBytes,scratch_floor).unwrap());
|
||||
let before=refused.heap().diagnostic_typed_storage();let operands=refused.operand_stack_top(5).to_vec();
|
||||
let report=refused.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(report.reason,End::Trap(ref info) if info.code==TRAP_RESOURCE_LIMIT),"scratch refusal: {report:?}");
|
||||
assert_eq!((report.cycles_used,report.steps_executed),(24,0));
|
||||
assert_eq!(refused.heap().diagnostic_typed_storage(),before);assert_eq!(refused.operand_stack_top(5),operands);
|
||||
assert_eq!(refused.resource_observer().used(Q::TemporaryBytes),0);
|
||||
}
|
||||
println!("COMMON COPY COST/FAULT/GROUP PASS {name} cycles={cycles}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn verify_common_storage_fixtures(root:&std::path::Path) {
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeLimits};
|
||||
verify_copy_attempts(root);
|
||||
for name in ["common-storage","common-storage-optimized","common-fields","common-fields-optimized"] {
|
||||
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory non-PBS storage fixture");
|
||||
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
||||
@@ -1207,7 +1310,23 @@ fn verify_common_storage_fixtures(root:&std::path::Path) {
|
||||
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
|
||||
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
|
||||
println!("COMMON STORAGE SOURCE/LOAD/EXEC PASS {name}");
|
||||
} for opcode in [0xa7,0xa8,0xaa,0xab] {
|
||||
let bytes=std::fs::read(root.join(format!("retired-storage-{opcode:x}.pbx"))).expect("mandatory dead-opcode refusal");
|
||||
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err());
|
||||
let data=std::fs::read(root.join(format!("storage-immediate-{opcode:x}.pbx"))).unwrap();
|
||||
assert!(ValidatedProgramImage::load(&data,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_ok());
|
||||
}
|
||||
for suffix in ["","-optimized"] {
|
||||
let bytes=std::fs::read(root.join(format!("common-partial-fault{suffix}.pbx"))).unwrap();
|
||||
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
||||
let mut vm=VirtualMachine::from_image(image,RuntimeLimits::default());vm.prepare_boot_call().unwrap();
|
||||
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(report.reason,End::Trap(ref info) if info.code==prometeu_bytecode::TRAP_EXPLICIT));
|
||||
use prometeu_vm::resource_diagnostics::StorageValue as V;
|
||||
assert_eq!(vm.heap().diagnostic_typed_storage()[0].groups[1],[V::Int32(20)],"terminal fault does not undo prior store");
|
||||
println!("COMMON PARTIAL FAULT PASS {suffix}");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fn verify_list_cursor_distribution(root:&std::path::Path) { verify_collection_distribution(root,"list",22); }
|
||||
@@ -1243,11 +1362,11 @@ fn verify_collection_distribution(root:&std::path::Path,collection:&str,last:i32
|
||||
|
||||
fn verify_pbs_linked_fixtures(root: &std::path::Path) {
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End, resource_budget::{RuntimeLimits,RuntimeResource}};
|
||||
use prometeu_bytecode::TRAP_OOB;
|
||||
use prometeu_bytecode::TRAP_EXPLICIT;
|
||||
let successful=["basic","links","construction","long-size","empty-cursor","empty-reverseCursor",
|
||||
"single-cursor","single-reverseCursor","snapshot","false-present","optional-field","identity","tuple","nested-array","function","evaluation","vec2","pixel","contract"];
|
||||
let faults=[("fault-read",TRAP_OOB),("fault-write",TRAP_OOB),("fault-negative",TRAP_OOB),
|
||||
("fault-insert",TRAP_OOB),("fault-remove",TRAP_OOB),("fault-overflow",TRAP_OOB),("fault-long-index",TRAP_OOB)];
|
||||
let faults=[("fault-read",TRAP_EXPLICIT),("fault-write",TRAP_EXPLICIT),("fault-negative",TRAP_EXPLICIT),
|
||||
("fault-insert",TRAP_EXPLICIT),("fault-remove",TRAP_EXPLICIT),("fault-overflow",TRAP_EXPLICIT),("fault-long-index",TRAP_EXPLICIT)];
|
||||
let cases=successful.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,c)|(n,Some(c))))
|
||||
.flat_map(|(name,fault)|[(name.to_string(),fault),(format!("{name}-optimized"),fault)]);
|
||||
for (name,fault) in cases {
|
||||
@@ -1301,7 +1420,9 @@ fn verify_linked_refusals(root:&std::path::Path) {
|
||||
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
||||
let mut node_allocation=false;let mut optional_return=false;let mut snapshot_allocation=false;let mut preparation=false;
|
||||
for name in ["insert","add","addFirst","remove","removeFirst","removeLast","replace","clear","cursor","reverseCursor"] {
|
||||
let bytes=std::fs::read(root.join(format!("pbs-linked-refusal-{name}.pbx"))).expect("mandatory Linked refusal fixture");
|
||||
for suffix in ["","-optimized"] {
|
||||
println!("PHASE CORPUS linked {name}{suffix}");
|
||||
let bytes=std::fs::read(root.join(format!("pbs-linked-refusal-{name}{suffix}.pbx"))).expect("mandatory Linked refusal fixture");
|
||||
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
|
||||
let marker=|value:i32| {
|
||||
let mut pc=0;let mut found=Vec::new();
|
||||
@@ -1318,7 +1439,8 @@ fn verify_linked_refusals(root:&std::path::Path) {
|
||||
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
||||
let before=baseline.resource_snapshot();let original=linked_state(&baseline,&image);
|
||||
baseline.remove_breakpoint(before_pc);
|
||||
assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
|
||||
let (completed_report,successful_prefix,_)=trace_collection_attempt(&mut baseline,&original,after_pc);
|
||||
assert!(matches!(completed_report.reason,End::BudgetExhausted|End::Breakpoint) && baseline.pc()==after_pc,"operation completion: {completed_report:?}");
|
||||
let after=baseline.resource_snapshot();let changed=linked_state(&baseline,&image);
|
||||
let owner=changed.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("linked<int>")).unwrap();
|
||||
let expected=match name {"insert"|"add"|"addFirst"=>33,"remove"|"removeFirst"|"removeLast"=>31,"clear"=>0,_=>32};
|
||||
@@ -1334,10 +1456,13 @@ fn verify_linked_refusals(root:&std::path::Path) {
|
||||
let setup=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(setup.reason,End::Breakpoint),"{name} setup {q:?}={limit}: {setup:?}");
|
||||
let old=linked_state(&vm,&image);vm.remove_breakpoint(before_pc);
|
||||
let report=vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
|
||||
let (report,prefix,mutated)=trace_collection_attempt(&mut vm,&old,after_pc);
|
||||
assert_mutation_prefix(&prefix,&successful_prefix);
|
||||
if let End::Trap(info)=report.reason {
|
||||
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"{name} {q:?}={limit}: {info:?}");
|
||||
assert_eq!(linked_state(&vm,&image),old,"{name}: all original fields, groups and reciprocal links at {q:?}={limit}");
|
||||
if !mutated || name=="cursor" || name=="reverseCursor" {
|
||||
assert_eq!(linked_state(&vm,&image),old,"{name}: failure before mutation preserves original topology");
|
||||
}
|
||||
let instruction=decode_next(info.pc as usize,image.code()).unwrap();
|
||||
preparation|=q==Q::AuxiliaryBytes;
|
||||
if instruction.opcode==Op::StructNew {
|
||||
@@ -1351,12 +1476,13 @@ fn verify_linked_refusals(root:&std::path::Path) {
|
||||
}
|
||||
}
|
||||
}
|
||||
refused+=1;println!("PBS LINKED ATOMIC REFUSAL {name} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
||||
} else {assert!(matches!(report.reason,End::Breakpoint),"{name}: {report:?}");}
|
||||
refused+=1;println!("PBS LINKED PHASE REFUSAL {name} mutated={mutated} resource={q:?} limit={limit} opcode={:?}",instruction.opcode);
|
||||
} else {assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint) && vm.pc()==after_pc,"{name}: {report:?}");}
|
||||
drop(vm);for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes] {assert_eq!(observer.used(resource),0);}
|
||||
}
|
||||
}
|
||||
assert!(refused>0,"{name}: whole-source-operation refusals required");
|
||||
assert!(refused>0,"{name}: source-operation phase refusals required");
|
||||
}
|
||||
}
|
||||
assert!(node_allocation,"new Linked node refusal");assert!(optional_return,"optional removed-value refusal");
|
||||
assert!(snapshot_allocation,"snapshot node refusal");assert!(preparation,"frame/operand preparation refusal");
|
||||
|
||||
Reference in New Issue
Block a user