feat(vm): integrate metered strings and native retention for PLN-0176 step 19
This commit is contained in:
@@ -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]
|
||||
|
||||
Reference in New Issue
Block a user