feat(vm): integrate metered strings and native retention for PLN-0176 step 19

This commit is contained in:
2026-10-07 20:50:44 +01:00
parent 1124ac10e7
commit 74c7522dd1
17 changed files with 661 additions and 54 deletions
@@ -74,6 +74,9 @@ pub struct ValidatedProgramImage {
capabilities: CapFlags,
}
impl ValidatedProgramImage {
pub(crate) fn string_retention(&self) -> Arc<dyn Send + Sync> {
self.strings.clone()
}
pub fn registry(&self) -> &Arc<Registry> {
&self.registry
}
@@ -213,3 +213,48 @@ fn late_work_refusal_releases_all_new_owners() {
assert_eq!(b.used(Q::ConstantStringBytes), 0);
assert_eq!(b.used(Q::PbxBytes), 0);
}
#[test]
fn constant_strings_share_image_domain_across_sessions_and_native_snapshots() {
use crate::resource_budget::{RuntimeLimits, RuntimeResource};
use crate::{HostContext, HostReturn, NativeInterface, VirtualMachine};
struct Native;
impl NativeInterface for Native {
fn syscall(
&mut self,
_id: u32,
_args: &[Value],
_ret: &mut HostReturn,
_ctx: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
Ok(())
}
}
let mut code = (Op::PushConst as u16).to_le_bytes().to_vec();
code.extend_from_slice(&0u32.to_le_bytes());
code.extend_from_slice(&(Op::Halt as u16).to_le_bytes());
let bytes = fixture(&code, 1, &[K::String("shared".into())], None, &[]);
let image = ValidatedProgramImage::load(&bytes, &mut budget(), caps::NONE).unwrap();
let lease = image.lease_constant(0).unwrap();
let limits = RuntimeLimits::default().lowered(RuntimeResource::StringBytes, 0).unwrap();
let mut first = VirtualMachine::from_image(image.clone(), limits.clone());
let mut second = VirtualMachine::from_image(image.clone(), limits);
first.prepare_boot_call().unwrap();
second.prepare_boot_call().unwrap();
for vm in [&mut first, &mut second] {
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
let snapshot = first.operand_stack_top(1);
let other = second.operand_stack_top(1);
let (Value::String(left), Value::String(right)) = (&snapshot[0], &other[0]) else { panic!() };
assert!(Arc::ptr_eq(left, right));
assert_eq!(snapshot.retained_domains(), 1);
drop(image);
drop(first);
drop(second);
drop(other);
assert_eq!(lease.retained_content(), (6, 1));
drop(lease);
let Value::String(text) = &snapshot[0] else { panic!() };
assert_eq!(text.as_ref(), "shared");
}
@@ -41,6 +41,9 @@ impl StringLease {
}
impl StringLedger {
pub(crate) fn retention(&self) -> Arc<dyn Send + Sync> {
self.0.clone()
}
pub(crate) fn new(budget: RuntimeBudget) -> Result<Self, ResourceFailure> {
let state = budget.reserve(
Q::AuxiliaryBytes,
@@ -144,6 +147,60 @@ struct TextBuffer {
bytes: BudgetVec<u8>,
failure: Option<ResourceFailure>,
}
pub(crate) enum MaterializeError {
Resource(ResourceFailure),
InvalidLength,
}
impl From<ResourceFailure> for MaterializeError {
fn from(error: ResourceFailure) -> Self {
Self::Resource(error)
}
}
impl StringLedger {
pub(crate) fn build(
&self,
length: usize,
write: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<Arc<str>, MaterializeError> {
let mut domain = self.domain();
let charges = domain.prepare(length)?;
let mut writer = LimitedTextBuffer {
buffer: TextBuffer {
bytes: BudgetVec::new(&domain.budget, Q::TemporaryBytes),
failure: None,
},
length,
};
writer.buffer.bytes.reserve(length)?;
if write(&mut writer).is_err() {
return Err(writer
.buffer
.failure
.map(MaterializeError::Resource)
.unwrap_or(MaterializeError::InvalidLength));
}
if writer.buffer.bytes.len() != length {
return Err(MaterializeError::InvalidLength);
}
let text = std::str::from_utf8(&writer.buffer.bytes).expect("fmt::Write receives UTF-8");
let content: Arc<str> = Arc::from(text);
domain.publish(&content, charges);
Ok(content)
}
}
struct LimitedTextBuffer {
buffer: TextBuffer,
length: usize,
}
impl std::fmt::Write for LimitedTextBuffer {
fn write_str(&mut self, text: &str) -> std::fmt::Result {
if text.len() > self.length.saturating_sub(self.buffer.bytes.len()) {
return Err(std::fmt::Error);
}
std::fmt::Write::write_str(&mut self.buffer, text)
}
}
impl std::fmt::Write for TextBuffer {
fn write_str(&mut self, text: &str) -> std::fmt::Result {
self.bytes.extend_from_slice(text.as_bytes()).map_err(|failure| {
@@ -34,6 +34,48 @@ fn clones_share_charge_but_equal_independent_allocations_do_not() {
assert_eq!(budget.used(Q::StringAllocations), 0);
}
#[test]
fn native_writer_quota_refusal_happens_before_callback_or_content_materialization() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 2)]);
let mut called = false;
let result = ledger.build(3, &mut |writer| {
called = true;
writer.write_str("abc")
});
assert!(
matches!(result,Err(MaterializeError::Resource(error)) if error.resource==Q::StringBytes)
);
assert!(!called);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
}
#[test]
fn native_writer_length_mismatch_cannot_grow_buffer_and_refunds_content_reservations() {
let (budget, ledger) = fixture(&[]);
for (length, text) in [(2, "abc"), (4, "abc")] {
assert!(matches!(
ledger.build(length, &mut |writer| writer.write_str(text)),
Err(MaterializeError::InvalidLength)
));
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
let content = ledger
.build(5, &mut |writer| {
writer.write_str("é")?;
writer.write_str("猫")
})
.ok()
.unwrap();
assert_eq!(&*content, "é猫");
assert_eq!(budget.used(Q::StringBytes), 5);
assert_eq!(budget.used(Q::StringAllocations), 1);
}
#[test]
fn empty_strings_still_consume_distinct_allocation_records() {
let (budget, ledger) = fixture(&[(Q::StringAllocations, 2), (Q::StringBytes, 0)]);
@@ -5,6 +5,7 @@ mod loader;
mod reference;
mod runtime;
mod stack;
mod strings;
mod typed;
#[cfg(test)]
mod typed_tests;
@@ -87,6 +88,7 @@ pub struct VirtualMachine {
/// The loaded executable (Bytecode + Constant Pool), that is the ROM translated.
program: ProgramImage,
validated_image: Option<std::sync::Arc<crate::ValidatedProgramImage>>,
strings: Option<crate::string_ledger::StringLedger>,
/// Heap Memory: Dynamic allocation pool.
heap: Heap,
/// Total virtual cycles consumed since the VM started.
@@ -144,10 +146,26 @@ impl VirtualMachine {
}
/// Returns up to `n` values from the top of the operand stack (top-first order).
pub fn operand_stack_top(&self, n: usize) -> Vec<Value> {
pub fn operand_stack_top(&self, n: usize) -> prometeu_hal::ValueSnapshot {
let len = self.operand_stack.len();
let start = len.saturating_sub(n);
self.operand_stack[start..].iter().rev().cloned().collect()
let values: Vec<_> = self.operand_stack[start..].iter().rev().cloned().collect();
let mut owners = [None, None];
for value in &values {
if let Value::String(content) = value {
if let Some(image) = &self.validated_image {
if owners[0].is_none() && image.retains_string(content) {
owners[0] = Some(image.string_retention());
}
}
if let Some(strings) = &self.strings {
if owners[1].is_none() && strings.retains(content) {
owners[1] = Some(strings.retention());
}
}
}
}
prometeu_hal::ValueSnapshot::with_owners(values, owners)
}
/// Returns a reference to the VM's heap.
@@ -204,6 +222,7 @@ impl VirtualMachine {
std::collections::HashMap::new(),
),
validated_image: None,
strings: None,
heap: Heap::with_budget(&budget),
cycles: 0,
halted: false,
@@ -723,26 +742,32 @@ impl VirtualMachine {
self.push_trap(a, opcode, start_pc as u32)?;
self.push_trap(b, opcode, start_pc as u32)?;
}
OpCode::Add => self.binary_op(opcode, start_pc as u32, |a, b| match (&a, &b) {
(Value::String(_), _) | (_, Value::String(_)) => {
let mut out = String::with_capacity(a.string_len_hint() + b.string_len_hint());
a.append_to_string(&mut out);
b.append_to_string(&mut out);
Ok(Value::string(out))
OpCode::Add => {
let len = self.operand_stack.len();
if self.temporary_slots() >= 2
&& (matches!(self.operand_stack[len - 2], Value::String(_))
|| matches!(self.operand_stack[len - 1], Value::String(_)))
{
self.execute_string_add(opcode, start_pc as u32)?;
} else {
self.binary_op(opcode, start_pc as u32, |a, b| match (&a, &b) {
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_add(*b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_add(*b))),
(Value::Int32(a), Value::Int64(b)) => {
Ok(Value::Int64((*a as i64).wrapping_add(*b)))
}
(Value::Int64(a), Value::Int32(b)) => {
Ok(Value::Int64(a.wrapping_add(*b as i64)))
}
(Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)),
(Value::Int32(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a + *b as f64)),
(Value::Int64(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a + *b as f64)),
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for ADD".into())),
})?;
}
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_add(*b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_add(*b))),
(Value::Int32(a), Value::Int64(b)) => {
Ok(Value::Int64((*a as i64).wrapping_add(*b)))
}
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_add(*b as i64))),
(Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)),
(Value::Int32(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a + *b as f64)),
(Value::Int64(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a + *b as f64)),
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for ADD".into())),
})?,
}
OpCode::Sub => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_sub(b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_sub(b))),
@@ -1222,12 +1247,22 @@ impl VirtualMachine {
self.operand_stack
.reserve(syscall.results_count())
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
let mut strings = strings::SessionStringAllocator {
ledger: &mut self.strings,
budget: self.budget.clone(),
};
let mut ret = crate::HostReturn::new(
self.operand_stack.native_result_buffer(),
syscall.results_count(),
&mut strings,
);
let native_result = native.syscall(id, &args, &mut ret, ctx);
let return_overflow = ret.overflowed();
let return_failure = ret.failure().cloned();
let native_result = return_failure.map(Err).unwrap_or(native_result);
if native_result.is_err() {
self.operand_stack.truncate(stack_height_before);
}
native_result.map_err(|fault| match fault {
VmFault::Trap(code, msg) => {
self.trap(code, OpCode::Syscall as u16, msg, pc_at_syscall)
@@ -20,6 +20,9 @@ impl VirtualMachine {
}
}
if let Some(strings) = &self.strings {
strings.reconcile();
}
self.current_tick = self.current_tick.wrapping_add(1);
self.scheduler.wake_ready(self.current_tick)?;
@@ -71,6 +71,7 @@ impl VirtualMachine {
pub fn initialize(&mut self, program_bytes: Vec<u8>) -> Result<(), VmInitError> {
self.program = ProgramImage::default();
self.validated_image = None;
self.strings = None;
self.pc = 0;
self.operand_stack.clear();
self.call_stack.clear();
@@ -177,6 +178,13 @@ impl VirtualMachine {
})?;
}
self.budget.check(RuntimeResource::CallDepth, 1)?;
let mut imported = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
if self.validated_image.is_some() {
imported.reserve(arguments.len())?;
for value in arguments {
imported.push(self.import_string_value(value)?)?;
}
}
let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default();
let total_slots = callee.param_slots as usize + callee.local_slots as usize;
let stack_growth = self
@@ -202,7 +210,7 @@ impl VirtualMachine {
if let Some(func) = self.program.functions.get(func_idx) {
let typed = self.validated_image.is_some();
if typed {
self.operand_stack.extend_from_slice(arguments)?;
self.operand_stack.extend_from_slice(&imported)?;
}
let null_slots =
func.local_slots as usize + if typed { 0 } else { func.param_slots as usize };
@@ -32,6 +32,9 @@ impl VirtualMachine {
}
pub fn push(&mut self, val: Value) -> Result<(), ResourceFailure> {
let growth = self.operand_stack.prepare_growth(1)?;
let val = self.import_string_value(&val)?;
self.operand_stack.commit_growth(growth);
self.operand_stack.push(val)
}
@@ -41,10 +44,12 @@ impl VirtualMachine {
opcode: OpCode,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
self.push(val).map_err(|e| self.resource_trap(e, opcode, pc))
// Interpreter copies already belong to the current image/session;
// native imports use the public push boundary instead.
self.operand_stack.push(val).map_err(|e| self.resource_trap(e, opcode, pc))
}
pub fn pop(&mut self) -> Result<Value, String> {
pub(crate) fn pop(&mut self) -> Result<Value, String> {
if self.temporary_slots() == 0 {
return Err("Stack underflow".into());
}
@@ -64,7 +69,7 @@ impl VirtualMachine {
val.as_integer().ok_or_else(|| "Expected integer".into())
}
pub fn peek(&self) -> Result<&Value, String> {
pub(crate) fn peek(&self) -> Result<&Value, String> {
if self.temporary_slots() == 0 {
return Err("Stack underflow".into());
}
@@ -0,0 +1,69 @@
use super::*;
use crate::string_ledger::{MaterializeError, StringLedger};
use std::sync::Arc;
pub(super) struct SessionStringAllocator<'a> {
pub ledger: &'a mut Option<StringLedger>,
pub budget: RuntimeBudget,
}
impl prometeu_hal::host_return::GuestStringAllocator for SessionStringAllocator<'_> {
fn build(
&mut self,
length: usize,
writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<Arc<str>, VmFault> {
if self.ledger.is_none() {
*self.ledger = Some(StringLedger::new(self.budget.clone()).map_err(resource_fault)?);
}
self.ledger.as_ref().unwrap().build(length, writer).map_err(|error| match error {
MaterializeError::Resource(resource) => resource_fault(resource),
MaterializeError::InvalidLength => VmFault::Panic(
"Native string writer did not produce its declared UTF-8 length".into(),
),
})
}
}
fn resource_fault(resource: ResourceFailure) -> VmFault {
VmFault::Trap(TRAP_RESOURCE_LIMIT, resource.to_string())
}
impl VirtualMachine {
pub(super) fn import_string_value(&mut self, value: &Value) -> Result<Value, ResourceFailure> {
let Value::String(content) = value else {
return Ok(value.clone());
};
if self.validated_image.as_ref().is_some_and(|image| image.retains_string(content))
|| self.strings.as_ref().is_some_and(|domain| domain.retains(content))
{
return Ok(value.clone());
}
if self.strings.is_none() {
self.strings = Some(StringLedger::new(self.budget.clone())?);
}
self.strings.as_ref().unwrap().import(content).map(Value::String)
}
pub(super) fn execute_string_add(
&mut self,
opcode: OpCode,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
if self.strings.is_none() {
self.strings = Some(
StringLedger::new(self.budget.clone())
.map_err(|error| self.resource_trap(error, opcode, pc))?,
);
}
let base = self.operand_stack.len() - 2;
let content = self
.strings
.as_ref()
.unwrap()
.concat_values(&self.operand_stack[base], &self.operand_stack[base + 1])
.map_err(|error| self.resource_trap(error, opcode, pc))?;
self.operand_stack.truncate(base);
self.operand_stack
.push(Value::String(content))
.expect("ADD replaces two existing slots with one");
Ok(())
}
}
@@ -426,6 +426,114 @@ fn decoded_stale_handle_is_an_invalid_handle_even_when_target_type_differs() {
}
}
#[test]
fn decoded_string_add_accounts_content_and_preserves_inputs_on_quota_refusal() {
let mut code = vec![];
arg(&mut code, OpCode::GetLocal, 0);
arg(&mut code, OpCode::GetLocal, 1);
op(&mut code, OpCode::Add);
op(&mut code, OpCode::Halt);
let image = image(&code, vec![function(0, code.len(), &[4, 0], &[], 0, 2)]);
for (ceiling, success) in [(4, false), (5, true)] {
let mut vm = VirtualMachine::from_image(
image.clone(),
RuntimeLimits::default().lowered(RuntimeResource::StringBytes, ceiling).unwrap(),
);
vm.prepare_call_with_args("0", &[Value::String(Arc::from("é")), Value::Int32(7)]).unwrap();
assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 2);
let result = run(&mut vm);
if success {
assert_eq!(result, LogicalFrameEndingReason::Halted);
assert_eq!(vm.operand_stack.last(), Some(&Value::String(Arc::from("é7"))));
assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 5);
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 2);
} else {
assert!(
matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==12)
);
assert_eq!(vm.operand_stack.len(), 4);
assert_eq!(vm.operand_stack[2..], vm.operand_stack[..2]);
assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 2);
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 1);
}
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
}
}
#[test]
fn native_import_and_snapshot_retention_preserve_domain_across_session_close() {
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 1)]);
let mut vm = VirtualMachine::from_image(image.clone(), RuntimeLimits::default());
let external: Arc<str> = Arc::from("same");
vm.push(Value::String(external.clone())).unwrap();
let Value::String(first) = &vm.operand_stack[0] else { panic!() };
let first = first.clone();
assert!(!Arc::ptr_eq(&first, &external));
vm.push(Value::String(first.clone())).unwrap();
assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 4);
let snapshot = vm.operand_stack_top(2);
assert_eq!(snapshot.retained_domains(), 1);
let budget = vm.budget.clone();
drop(first);
drop(vm);
assert_eq!(budget.used(RuntimeResource::StringBytes), 4);
let retained = snapshot.clone();
drop(snapshot);
assert_eq!(budget.used(RuntimeResource::StringAllocations), 1);
let mut destination = VirtualMachine::from_image(image, RuntimeLimits::default());
destination.push(retained[0].clone()).unwrap();
let (Value::String(source), Value::String(imported)) =
(&retained[0], &destination.operand_stack[0])
else {
panic!()
};
assert!(!Arc::ptr_eq(source, imported));
assert_eq!(destination.budget.used(RuntimeResource::StringBytes), 4);
drop(retained);
assert_eq!(budget.used(RuntimeResource::StringBytes), 0);
assert_eq!(budget.used(RuntimeResource::StringAllocations), 0);
}
#[test]
fn native_string_failures_cannot_publish_partial_results_even_if_handler_ignores_error() {
struct ReturnsString;
impl NativeInterface for ReturnsString {
fn syscall(
&mut self,
_id: u32,
_args: &[Value],
ret: &mut HostReturn,
_ctx: &mut HostContext,
) -> Result<(), VmFault> {
let _ = ret.push_string("abc");
Ok(())
}
}
let mut code = vec![];
arg(&mut code, OpCode::Syscall, prometeu_hal::syscalls::Syscall::SystemHasCart as u32);
let mut vm = VirtualMachine::with_runtime_limits(
code,
vec![],
RuntimeLimits::default().lowered(RuntimeResource::StringBytes, 2).unwrap(),
);
vm.program.functions = Arc::from(vec![prometeu_bytecode::FunctionMeta {
code_len: 6,
max_stack_slots: 1,
..Default::default()
}]);
vm.set_capabilities(prometeu_hal::syscalls::caps::SYSTEM);
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(100, &mut ReturnsString, &mut HostContext::new(None)).unwrap();
// This synthetic native implementation tests the bounded writer, not the
// has-cart handler's ordinary Boolean semantic contract.
assert!(
matches!(report.reason,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==0)
);
assert!(vm.operand_stack.is_empty());
assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 0);
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 0);
}
#[test]
fn typed_sessions_share_image_but_have_independent_execution_and_heap() {
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]);
@@ -527,11 +635,14 @@ fn ordered_multi_group_return_preserves_native_owners_and_receiver_identity() {
Value::String(text.clone()),
];
vm.prepare_call_with_args("0", &args).unwrap();
let Value::String(imported) = &vm.operand_stack[6] else { panic!() };
let imported = imported.clone();
assert!(!Arc::ptr_eq(&imported, &text));
assert_eq!(run(&mut vm), LogicalFrameEndingReason::EndOfRom);
assert_eq!(vm.operand_stack.as_slice(), &args);
assert!(vm.call_stack.is_empty());
let Value::String(returned) = &vm.operand_stack[6] else { panic!() };
assert!(Arc::ptr_eq(returned, &text));
assert!(Arc::ptr_eq(returned, &imported));
}
#[test]