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
@@ -1,4 +1,5 @@
use crate::app_mode::AppMode;
#[cfg(test)]
use prometeu_bytecode::Value;
use serde::{Deserialize, Serialize};
@@ -35,7 +36,7 @@ pub enum DebugResponse {
#[serde(rename = "handshake")]
Handshake { protocol_version: u32, runtime_version: String, cartridge: HandshakeCartridge },
#[serde(rename = "getState")]
GetState { pc: usize, stack_top: Vec<Value>, frame_index: u64, app_id: u32 },
GetState { pc: usize, stack_top: crate::ValueSnapshot, frame_index: u64, app_id: u32 },
#[serde(rename = "breakpoints")]
Breakpoints { pcs: Vec<usize> },
}
@@ -115,7 +116,8 @@ mod tests {
fn test_get_state_serialization() {
let resp = DebugResponse::GetState {
pc: 42,
stack_top: vec![Value::Int64(10), Value::String("test".into()), Value::Boolean(true)],
stack_top: vec![Value::Int64(10), Value::String("test".into()), Value::Boolean(true)]
.into(),
frame_index: 5,
app_id: 1,
};
+183 -7
View File
@@ -1,4 +1,16 @@
use crate::vm_fault::VmFault;
use prometeu_bytecode::{HeapRef, Value};
use std::sync::Arc;
/// Native producers describe their output before materializing guest content.
/// The VM provides the session allocator; HAL does not own guest quotas.
pub trait GuestStringAllocator {
fn build(
&mut self,
length: usize,
writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<Arc<str>, VmFault>;
}
/// Writes only into result slots reserved by the VM. A native handler cannot
/// grow the operand buffer or exceed its declared result count.
@@ -6,16 +18,28 @@ pub struct HostReturn<'a> {
stack: &'a mut Vec<Value>,
remaining: usize,
overflowed: bool,
strings: &'a mut dyn GuestStringAllocator,
failure: Option<VmFault>,
}
impl<'a> HostReturn<'a> {
pub fn new(stack: &'a mut Vec<Value>, result_slots: usize) -> Self {
Self { stack, remaining: result_slots, overflowed: false }
pub fn new(
stack: &'a mut Vec<Value>,
result_slots: usize,
strings: &'a mut dyn GuestStringAllocator,
) -> Self {
Self { stack, remaining: result_slots, overflowed: false, strings, failure: None }
}
pub fn failure(&self) -> Option<&VmFault> {
self.failure.as_ref()
}
pub fn overflowed(&self) -> bool {
self.overflowed
}
fn admit(&mut self) -> bool {
if self.failure.is_some() {
return false;
}
if self.remaining == 0 || self.stack.len() == self.stack.capacity() {
self.overflowed = true;
false
@@ -45,31 +69,183 @@ impl<'a> HostReturn<'a> {
self.stack.push(if handle.is_null() { Value::Null } else { Value::HeapRef(handle) });
}
}
pub fn push_string(&mut self, s: String) {
if self.admit() {
self.stack.push(Value::string(s));
pub fn push_string(&mut self, text: &str) -> Result<(), VmFault> {
self.push_string_with_len(text.len(), &mut |writer| writer.write_str(text))
}
pub fn push_string_with_len(
&mut self,
length: usize,
writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<(), VmFault> {
if !self.admit() {
return self.failure.clone().map_or(Ok(()), Err);
}
match self.strings.build(length, writer) {
Ok(content) => {
self.stack.push(Value::String(content));
Ok(())
}
Err(error) => {
self.failure = Some(error.clone());
Err(error)
}
}
}
pub fn push_utf8_lossy(&mut self, bytes: &[u8]) -> Result<(), VmFault> {
let mut length = 0usize;
lossy_chunks(bytes, &mut |part| {
length = length.checked_add(part.len()).ok_or(std::fmt::Error)?;
Ok(())
})
.map_err(|_| size_overflow())?;
self.push_string_with_len(length, &mut |writer| {
lossy_chunks(bytes, &mut |part| writer.write_str(part))
})
}
pub fn push_hex(&mut self, bytes: &[u8]) -> Result<(), VmFault> {
const HEX: &[u8; 16] = b"0123456789abcdef";
let length = bytes.len().checked_mul(2).ok_or_else(size_overflow)?;
self.push_string_with_len(length, &mut |writer| {
for &byte in bytes {
let pair = [HEX[(byte >> 4) as usize], HEX[(byte & 15) as usize]];
writer.write_str(std::str::from_utf8(&pair).expect("ASCII hex"))?;
}
Ok(())
})
}
pub fn push_joined<'s, I: Iterator<Item = &'s str> + Clone>(
&mut self,
parts: I,
separator: &str,
) -> Result<(), VmFault> {
let mut length = 0usize;
for (index, part) in parts.clone().enumerate() {
if index > 0 {
length = length.checked_add(separator.len()).ok_or_else(size_overflow)?;
}
length = length.checked_add(part.len()).ok_or_else(size_overflow)?;
}
self.push_string_with_len(length, &mut |writer| {
for (index, part) in parts.clone().enumerate() {
if index > 0 {
writer.write_str(separator)?;
}
writer.write_str(part)?;
}
Ok(())
})
}
}
fn size_overflow() -> VmFault {
VmFault::Trap(prometeu_bytecode::TRAP_RESOURCE_LIMIT, "Native string length overflow".into())
}
fn lossy_chunks(
mut bytes: &[u8],
emit: &mut dyn FnMut(&str) -> std::fmt::Result,
) -> std::fmt::Result {
while !bytes.is_empty() {
match std::str::from_utf8(bytes) {
Ok(valid) => {
emit(valid)?;
break;
}
Err(error) => {
let valid = error.valid_up_to();
emit(std::str::from_utf8(&bytes[..valid]).expect("validated prefix"))?;
emit("\u{fffd}")?;
match error.error_len() {
Some(invalid) => bytes = &bytes[valid + invalid..],
None => break,
}
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
struct RejectStrings;
impl GuestStringAllocator for RejectStrings {
fn build(
&mut self,
_length: usize,
_writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<Arc<str>, VmFault> {
panic!("unexpected string allocation")
}
}
#[test]
fn native_results_cannot_grow_the_reserved_buffer_or_exceed_the_signature() {
let mut stack = Vec::with_capacity(8);
let capacity = stack.capacity();
let mut ret = HostReturn::new(&mut stack, 1);
let mut strings = RejectStrings;
let mut ret = HostReturn::new(&mut stack, 1, &mut strings);
ret.push_int(7);
ret.push_int(8);
assert!(ret.overflowed());
assert_eq!(stack, vec![Value::Int64(7)]);
assert_eq!(stack.capacity(), capacity);
let mut empty = Vec::new();
let mut ret = HostReturn::new(&mut empty, 1);
let mut ret = HostReturn::new(&mut empty, 1, &mut strings);
ret.push_null();
assert!(ret.overflowed());
assert!(empty.is_empty());
assert_eq!(empty.capacity(), 0);
}
struct Collect;
impl GuestStringAllocator for Collect {
fn build(
&mut self,
length: usize,
writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
) -> Result<Arc<str>, VmFault> {
let mut text = String::new();
writer(&mut text).unwrap();
assert_eq!(text.len(), length);
Ok(Arc::from(text))
}
}
#[test]
fn measured_native_encoding_matches_utf8_lossy_hex_and_join_semantics() {
for bytes in [
b"plain".as_slice(),
"é猫".as_bytes(),
&[0xff, 0xe2, 0x82],
&[0xf0, 0x80, 0x80, 0x80, 0x61, 0xc2, 0xa9],
&[],
] {
let mut stack = Vec::with_capacity(1);
let mut allocator = Collect;
let mut ret = HostReturn::new(&mut stack, 1, &mut allocator);
ret.push_utf8_lossy(bytes).unwrap();
assert_eq!(stack, vec![Value::string(String::from_utf8_lossy(bytes).as_ref())]);
}
for byte in 0..=255u8 {
let bytes = [b'a', byte, b'b', byte];
let mut stack = Vec::with_capacity(1);
let mut allocator = Collect;
HostReturn::new(&mut stack, 1, &mut allocator).push_utf8_lossy(&bytes).unwrap();
assert_eq!(stack, vec![Value::string(String::from_utf8_lossy(&bytes).as_ref())]);
}
let mut stack = Vec::with_capacity(2);
let mut allocator = Collect;
let mut ret = HostReturn::new(&mut stack, 2, &mut allocator);
ret.push_hex(&[0, 0x12, 0xab, 0xff]).unwrap();
ret.push_joined(["", "é", "猫"].into_iter(), ";").unwrap();
assert_eq!(stack, vec![Value::string("0012abff"), Value::string(";é;猫")]);
}
#[test]
fn full_native_result_buffer_does_not_invoke_string_allocator() {
let mut stack = Vec::with_capacity(1);
let mut allocator = RejectStrings;
let mut ret = HostReturn::new(&mut stack, 0, &mut allocator);
ret.push_string("ignored").unwrap();
assert!(ret.overflowed());
assert!(stack.is_empty());
}
}
+2
View File
@@ -36,6 +36,7 @@ pub mod telemetry;
pub mod tile;
pub mod tilemap;
pub mod touch_bridge;
pub mod value_snapshot;
pub mod vm_fault;
pub use asset_bridge::AssetBridge;
@@ -64,3 +65,4 @@ pub use render_worker::{
RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink, RenderWorkerTelemetry,
};
pub use touch_bridge::TouchBridge;
pub use value_snapshot::ValueSnapshot;
@@ -0,0 +1,62 @@
use prometeu_bytecode::Value;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
/// Native/debug ownership only. Wire data is the ordinary list of values;
/// opaque accounting domains stay alive for every retained string allocation.
#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ValueSnapshot {
values: Vec<Value>,
#[serde(skip)]
owners: [Option<Arc<dyn Send + Sync>>; 2],
}
impl ValueSnapshot {
pub fn with_owners(values: Vec<Value>, owners: [Option<Arc<dyn Send + Sync>>; 2]) -> Self {
Self { values, owners }
}
pub fn retained_domains(&self) -> usize {
self.owners.iter().filter(|owner| owner.is_some()).count()
}
}
impl std::ops::Deref for ValueSnapshot {
type Target = [Value];
fn deref(&self) -> &[Value] {
&self.values
}
}
impl std::fmt::Debug for ValueSnapshot {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.values.fmt(f)
}
}
impl PartialEq<Vec<Value>> for ValueSnapshot {
fn eq(&self, other: &Vec<Value>) -> bool {
self.values == *other
}
}
impl From<Vec<Value>> for ValueSnapshot {
/// External/native values have no provenance and are copied on guest import.
fn from(values: Vec<Value>) -> Self {
Self::with_owners(values, [None, None])
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serialization_contains_values_and_never_exports_native_domain_metadata() {
let owner: Arc<dyn Send + Sync> = Arc::new(17u32);
let snapshot = ValueSnapshot::with_owners(
vec![Value::string("shared"), Value::Null],
[Some(owner), None],
);
assert_eq!(snapshot.retained_domains(), 1);
let bytes = serde_json::to_string(&snapshot).unwrap();
assert_eq!(bytes, "[\"shared\",null]");
let imported: ValueSnapshot = serde_json::from_str(&bytes).unwrap();
assert_eq!(imported.retained_domains(), 0);
assert_eq!(&*imported, &*snapshot);
}
}
@@ -3,7 +3,6 @@ use crate::os::{GameLifecycleEvent, SystemOS};
use crate::task::TaskId;
use crate::vm_session::VmSession;
use crate::{RenderWorkerConfig, RenderWorkerController};
use prometeu_bytecode::Value;
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame};
use prometeu_hal::{
@@ -100,7 +99,7 @@ impl<'a> VmFacade<'a> {
self.active_session().map(|session| session.vm.pc())
}
pub fn active_operand_stack_top(&self, n: usize) -> Vec<Value> {
pub fn active_operand_stack_top(&self, n: usize) -> prometeu_hal::ValueSnapshot {
self.active_session().map(|session| session.vm.operand_stack_top(n)).unwrap_or_default()
}
@@ -561,7 +561,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
.ok_or_else(|| VmFault::Panic("Invalid handle".into()))?
.clone();
match self.fs.read_file(&path) {
Ok(data) => ret.push_string(String::from_utf8_lossy(&data).into_owned()),
Ok(data) => ret.push_utf8_lossy(&data)?,
Err(_) => ret.push_null(),
}
Ok(())
@@ -588,8 +588,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
let path = expect_string(args, 0, "path")?;
match self.fs.list_dir(&path) {
Ok(entries) => {
let names: Vec<String> = entries.into_iter().map(|e| e.name).collect();
ret.push_string(names.join(";"));
ret.push_joined(entries.iter().map(|entry| entry.name.as_str()), ";")?;
}
Err(_) => ret.push_null(),
}
@@ -645,14 +644,14 @@ impl NativeInterface for VmRuntimeHost<'_> {
let max_bytes = expect_non_negative_usize(args, 2, "max_bytes")?;
if self.current_cartridge_app_mode != AppMode::Game {
ret.push_int(MemcardStatus::AccessDenied as i64);
ret.push_string(String::new());
ret.push_string("")?;
ret.push_int(0);
return Ok(());
}
let read =
self.memcard.slot_read(self.fs, self.current_app_id, slot, offset, max_bytes);
ret.push_int(read.status as i64);
ret.push_string(hex_encode(&read.bytes));
ret.push_hex(&read.bytes)?;
ret.push_int(read.bytes_read as i64);
Ok(())
}
@@ -866,16 +865,6 @@ fn expect_non_negative_usize(args: &[Value], index: usize, field: &str) -> Resul
Ok(val as usize)
}
fn hex_encode(bytes: &[u8]) -> String {
const HEX: &[u8; 16] = b"0123456789abcdef";
let mut out = String::with_capacity(bytes.len() * 2);
for &b in bytes {
out.push(HEX[(b >> 4) as usize] as char);
out.push(HEX[(b & 0x0f) as usize] as char);
}
out
}
fn hex_decode(s: &str) -> Result<Vec<u8>, VmFault> {
fn nibble(c: u8) -> Option<u8> {
match c {
@@ -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]
@@ -1,7 +1,6 @@
use std::fmt;
use std::sync::Arc;
use prometeu_bytecode::Value;
use prometeu_drivers::MemoryBanks;
use prometeu_drivers::hardware::Hardware;
use prometeu_firmware::firmware_state::{AppCrashesStep, ResetStep};
@@ -27,7 +26,7 @@ pub struct CapturedFrame {
#[derive(Debug, Clone)]
pub struct HostState {
pub pc: usize,
pub stack_top: Vec<Value>,
pub stack_top: prometeu_hal::ValueSnapshot,
pub frame_index: u64,
pub tick_index: u64,
pub app_id: u32,