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