feat: retain read-only execution frames across instruction slices

This commit is contained in:
2026-10-23 00:59:23 +08:00
parent e511e393d9
commit 1c729b4128
9 changed files with 298 additions and 10 deletions
+117
View File
@@ -1386,3 +1386,120 @@ fn later_execution_failure_releases_a_new_function_and_its_temporary_default() {
vm.release(globals).unwrap();
assert_eq!(vm.object_count(), 0);
}
#[test]
fn suspended_read_only_call_keeps_roots_and_releases_them_on_completion() {
use endor_core::ExecutionProgress;
let mut vm = Vm::new().unwrap();
let shared = vm.new_object().unwrap();
vm.set_attr(shared, "value", Value::Number(7_i64.into()))
.unwrap();
let globals = vm.new_dict().unwrap();
let mut instructions = vec![simple(Opcode::Nop); 16];
instructions.extend([op(Opcode::LoadConst, 0), simple(Opcode::ReturnValue)]);
let code = make_code(
&mut vm,
&instructions,
vec![Value::Object(shared)],
CodeLayout::default(),
);
let function = vm
.new_function("sliced", code, globals, vec![], vec![])
.unwrap();
let mut progress = vm
.start_read_only_call(
function,
&[],
ExecutionLimits {
max_frames: 8,
max_instructions: 100,
},
1,
)
.unwrap();
assert!(matches!(
progress,
ExecutionProgress::Pending { instructions: 1 }
));
assert!(
vm.set_attr(shared, "value", Value::Number(8_i64.into()))
.is_err()
);
assert!(vm.call(function, &[]).is_err());
vm.release(function).unwrap();
vm.release(code).unwrap();
vm.release(globals).unwrap();
vm.release(shared).unwrap();
vm.collect_cycles();
loop {
match progress {
ExecutionProgress::Pending { .. } => progress = vm.resume_read_only_call(2).unwrap(),
ExecutionProgress::Complete {
value,
instructions,
..
} => {
assert_eq!(instructions, 18);
assert_eq!(value, Value::Object(shared));
assert_eq!(
vm.get_attr(shared, "value").unwrap(),
Value::Number(7_i64.into())
);
vm.release_value(value).unwrap();
break;
}
}
}
assert!(!vm.has_suspended_call());
assert_eq!(vm.object_count(), 0);
}
#[test]
fn suspended_call_cancellation_and_total_budget_restore_read_only_state() {
let mut vm = Vm::new().unwrap();
let shared = vm.new_object().unwrap();
let globals = vm.new_dict().unwrap();
let mut instructions = vec![simple(Opcode::Nop); 8];
instructions.extend([op(Opcode::LoadConst, 0), simple(Opcode::ReturnValue)]);
let code = make_code(
&mut vm,
&instructions,
vec![Value::Object(shared)],
CodeLayout::default(),
);
let function = vm
.new_function("budget", code, globals, vec![], vec![])
.unwrap();
let roots = vm.ref_count(function).unwrap();
vm.start_read_only_call(
function,
&[],
ExecutionLimits {
max_frames: 8,
max_instructions: 3,
},
1,
)
.unwrap();
assert!(vm.resume_read_only_call(0).is_err());
assert!(vm.has_suspended_call());
vm.resume_read_only_call(1).unwrap();
assert_eq!(
vm.resume_read_only_call(1).unwrap_err(),
VmError::ExecutionLimit("instructions")
);
assert!(!vm.has_suspended_call());
assert_eq!(vm.ref_count(function).unwrap(), roots);
vm.set_attr(shared, "after", Value::Bool(true)).unwrap();
vm.start_read_only_call(function, &[], ExecutionLimits::default(), 1)
.unwrap();
assert!(vm.cancel_read_only_call().unwrap());
assert!(!vm.cancel_read_only_call().unwrap());
assert_eq!(vm.ref_count(function).unwrap(), roots);
vm.set_attr(shared, "after", Value::Bool(false)).unwrap();
vm.release(function).unwrap();
vm.release(code).unwrap();
vm.release(globals).unwrap();
vm.release(shared).unwrap();
assert_eq!(vm.object_count(), 0);
}