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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user