feat(vm): add metered shared-string infrastructure for PLN-0176 step 19

This commit is contained in:
2026-10-07 19:24:54 +01:00
parent 01112da951
commit 43b466c813
5 changed files with 452 additions and 18 deletions
+13 -18
View File
@@ -1,7 +1,6 @@
use serde::{Deserialize, Serialize};
use std::cell::Cell;
use std::cmp::Ordering;
use std::fmt::Write;
use std::sync::Arc;
thread_local! {
@@ -119,24 +118,20 @@ impl Value {
}
pub fn append_to_string(&self, out: &mut String) {
self.write_text(out).expect("writing into String is infallible");
}
/// Writes existing Value text without allocating a String, so bounded
/// callers can measure and reserve with their own fmt::Write sink.
pub fn write_text(&self, out: &mut impl std::fmt::Write) -> std::fmt::Result {
match self {
Value::Int32(i) => {
let _ = write!(out, "{}", i);
}
Value::Int64(i) => {
let _ = write!(out, "{}", i);
}
Value::Float(f) => {
let _ = write!(out, "{}", f);
}
Value::Boolean(b) => {
let _ = write!(out, "{}", b);
}
Value::String(s) => out.push_str(s),
Value::HeapRef(r) => {
let _ = write!(out, "[HeapRef {}:{}]", r.index, r.generation);
}
Value::Null => out.push_str("null"),
Value::Int32(i) => write!(out, "{}", i),
Value::Int64(i) => write!(out, "{}", i),
Value::Float(f) => write!(out, "{}", f),
Value::Boolean(b) => write!(out, "{}", b),
Value::String(s) => out.write_str(s),
Value::HeapRef(r) => write!(out, "[HeapRef {}:{}]", r.index, r.generation),
Value::Null => out.write_str("null"),
}
}
+3
View File
@@ -12,6 +12,9 @@ mod roots;
#[allow(dead_code)]
mod registry_verifier;
mod scheduler;
// Image/session creation and native provenance consume this in step 19.
#[allow(dead_code)]
mod string_ledger;
// Registry-backed consumers are integrated with executable images in PLN-0176.
#[allow(dead_code)]
mod typed_storage;
@@ -441,6 +441,17 @@ impl<T> BudgetVec<T> {
pub fn clear(&mut self) {
self.data.clear();
}
pub(crate) fn retain(&mut self, keep: impl FnMut(&T) -> bool) {
self.data.retain(keep);
}
pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> Result<(), ResourceFailure>
where
T: Clone,
{
self.reserve(values.len())?;
self.data.extend_from_slice(values);
Ok(())
}
pub fn truncate(&mut self, len: usize) {
self.data.truncate(len);
}
@@ -0,0 +1,206 @@
//! Allocation-identity accounting over ordinary Arc<str> values.
//! The ledger never owns string content strongly. Native owners retain an
//! explicit provenance lease; guest slots remain Arc<str>, with no drop wrapper.
use crate::resource_budget::{
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
};
use prometeu_bytecode::Value;
use std::sync::{Arc, Mutex, MutexGuard, Weak};
#[derive(Debug)]
struct Entry {
content: Weak<str>,
_bytes: Reservation,
_allocation: Reservation,
}
#[derive(Debug)]
struct Domain {
budget: RuntimeBudget,
entries: BudgetVec<Entry>,
_state: Reservation,
}
#[derive(Debug, Clone)]
pub(crate) struct StringLedger(Arc<Mutex<Domain>>);
/// Host/tool retention must retain provenance along with the Arc. This is
/// boundary metadata, never a replacement for Value::String/StringSlot.
#[derive(Debug, Clone)]
pub(crate) struct StringLease {
content: Arc<str>,
domain: StringLedger,
}
impl StringLease {
pub(crate) fn content(&self) -> &Arc<str> {
&self.content
}
pub(crate) fn domain(&self) -> &StringLedger {
&self.domain
}
}
impl StringLedger {
pub(crate) fn new(budget: RuntimeBudget) -> Result<Self, ResourceFailure> {
let state = budget.reserve(
Q::AuxiliaryBytes,
budget.bytes::<Mutex<Domain>>(1, Q::AuxiliaryBytes)? + 2 * size_of::<usize>() as u64,
)?;
let entries = BudgetVec::new(&budget, Q::AuxiliaryBytes);
Ok(Self(Arc::new(Mutex::new(Domain { budget, entries, _state: state }))))
}
fn domain(&self) -> MutexGuard<'_, Domain> {
self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
/// Safepoint reconciliation is bounded by the accepted allocation count.
/// Retain compacts in place; unused capacity remains charged until drop.
pub(crate) fn reconcile(&self) -> usize {
self.domain().reconcile()
}
pub(crate) fn tracked_allocations(&self) -> usize {
self.domain().entries.len()
}
pub(crate) fn retains(&self, content: &Arc<str>) -> bool {
let address = Arc::as_ptr(content);
self.domain().entries.iter().any(|entry| std::ptr::eq(entry.content.as_ptr(), address))
}
pub(crate) fn lease(&self, content: &Arc<str>) -> Option<StringLease> {
self.retains(content)
.then(|| StringLease { content: content.clone(), domain: self.clone() })
}
/// Imports always materialize a distinct allocation in the destination
/// domain. Assignment/call/storage of existing guest Arcs uses Arc::clone.
pub(crate) fn import(&self, text: &str) -> Result<Arc<str>, ResourceFailure> {
let mut domain = self.domain();
let charges = domain.prepare(text.len())?;
// Rust's stable Arc allocation can abort on physical allocator failure;
// quotas and fallible ledger/buffer growth are checked before this call.
let content: Arc<str> = Arc::from(text);
domain.publish(&content, charges);
Ok(content)
}
pub(crate) fn concat(&self, left: &str, right: &str) -> Result<Arc<str>, ResourceFailure> {
let mut domain = self.domain();
let len = left.len().checked_add(right.len()).ok_or_else(|| {
domain.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
})?;
let charges = domain.prepare(len)?;
// The temporary buffer and eventual content coexist. Its actual
// capacity is accounted independently, not hidden by the final length.
let mut buffer = BudgetVec::<u8>::new(&domain.budget, Q::TemporaryBytes);
buffer.reserve(len)?;
buffer.extend_from_slice(left.as_bytes())?;
buffer.extend_from_slice(right.as_bytes())?;
let text = std::str::from_utf8(&buffer).expect("concatenating UTF-8 preserves validity");
let content: Arc<str> = Arc::from(text);
domain.publish(&content, charges);
Ok(content)
}
pub(crate) fn format(&self, value: &Value) -> Result<Arc<str>, ResourceFailure> {
self.format_values(&[value])
}
pub(crate) fn concat_values(
&self,
left: &Value,
right: &Value,
) -> Result<Arc<str>, ResourceFailure> {
self.format_values(&[left, right])
}
fn format_values(&self, values: &[&Value]) -> Result<Arc<str>, ResourceFailure> {
let mut domain = self.domain();
let mut counter = SizeCounter(0);
for value in values {
value.write_text(&mut counter).map_err(|_| {
domain.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
})?;
}
let charges = domain.prepare(counter.0)?;
let mut writer =
TextBuffer { bytes: BudgetVec::new(&domain.budget, Q::TemporaryBytes), failure: None };
writer.bytes.reserve(counter.0)?;
for value in values {
if value.write_text(&mut writer).is_err() {
return Err(writer.failure.expect("bounded writer records its resource failure"));
}
}
let text = std::str::from_utf8(&writer.bytes).expect("Value text is UTF-8");
let content: Arc<str> = Arc::from(text);
domain.publish(&content, charges);
Ok(content)
}
}
struct SizeCounter(usize);
impl std::fmt::Write for SizeCounter {
fn write_str(&mut self, text: &str) -> std::fmt::Result {
self.0 = self.0.checked_add(text.len()).ok_or(std::fmt::Error)?;
Ok(())
}
}
struct TextBuffer {
bytes: BudgetVec<u8>,
failure: Option<ResourceFailure>,
}
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| {
self.failure = Some(failure);
std::fmt::Error
})
}
}
struct Charges {
bytes: Reservation,
allocation: Reservation,
}
impl Domain {
fn reconcile(&mut self) -> usize {
let before = self.entries.len();
self.entries.retain(|entry| entry.content.strong_count() != 0);
before - self.entries.len()
}
fn reserve_content(&self, len: u64) -> Result<Charges, ResourceFailure> {
let bytes = self.budget.reserve(Q::StringBytes, len)?;
let allocation = self.budget.reserve(Q::StringAllocations, 1)?;
Ok(Charges { bytes, allocation })
}
fn prepare(&mut self, len: usize) -> Result<Charges, ResourceFailure> {
let len = u64::try_from(len).map_err(|_| {
self.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
})?;
self.budget.check(Q::IndividualStringBytes, len)?;
let charges = match self.reserve_content(len) {
Ok(charges) => charges,
Err(failure) if failure.reason == ResourceReason::Limit => {
// One bounded pressure pass; never remove a live allocation.
self.reconcile();
self.reserve_content(len)?
}
Err(failure) => return Err(failure),
};
if let Err(failure) = self.entries.reserve(1) {
if failure.reason != ResourceReason::Limit {
return Err(failure);
}
self.reconcile();
self.entries.reserve(1)?;
}
Ok(charges)
}
fn publish(&mut self, content: &Arc<str>, charges: Charges) {
self.entries
.push(Entry {
content: Arc::downgrade(content),
_bytes: charges.bytes,
_allocation: charges.allocation,
})
.expect("prepare reserved one ledger record before materialization");
}
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,219 @@
use super::*;
use crate::resource_budget::RuntimeLimits;
fn fixture(overrides: &[(Q, u64)]) -> (RuntimeBudget, StringLedger) {
let mut limits = RuntimeLimits::default();
for &(resource, ceiling) in overrides {
limits = limits.lowered(resource, ceiling).unwrap();
}
let budget = RuntimeBudget::new(limits);
let ledger = StringLedger::new(budget.clone()).unwrap();
(budget, ledger)
}
#[test]
fn clones_share_charge_but_equal_independent_allocations_do_not() {
let (budget, ledger) = fixture(&[]);
let first = ledger.import("same").unwrap();
let cloned = first.clone();
assert_eq!(budget.used(Q::StringBytes), 4);
assert_eq!(budget.used(Q::StringAllocations), 1);
let second = ledger.import("same").unwrap();
assert!(!Arc::ptr_eq(&first, &second));
assert_eq!(budget.used(Q::StringBytes), 8);
assert_eq!(budget.used(Q::StringAllocations), 2);
drop(first);
drop(second);
assert_eq!(ledger.reconcile(), 1);
assert_eq!(budget.used(Q::StringBytes), 4);
drop(cloned);
// The Weak and counters survive the last owner until reconciliation.
assert_eq!(budget.used(Q::StringBytes), 4);
assert_eq!(ledger.reconcile(), 1);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
}
#[test]
fn empty_strings_still_consume_distinct_allocation_records() {
let (budget, ledger) = fixture(&[(Q::StringAllocations, 2), (Q::StringBytes, 0)]);
let first = ledger.import("").unwrap();
let second = ledger.import("").unwrap();
assert!(!Arc::ptr_eq(&first, &second));
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 2);
let e = ledger.import("").unwrap_err();
assert_eq!((e.resource, e.requested, e.limit), (Q::StringAllocations, 3, 2));
assert_eq!(ledger.tracked_allocations(), 2);
}
#[test]
fn content_and_individual_limits_are_checked_before_materialization() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 4), (Q::IndividualStringBytes, 3)]);
assert_eq!(ledger.import("1234").unwrap_err().resource, Q::IndividualStringBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
let retained = ledger.import("123").unwrap();
let err = ledger.import("45").unwrap_err();
assert_eq!((err.resource, err.requested, err.limit), (Q::StringBytes, 5, 4));
assert_eq!(budget.used(Q::StringBytes), 3);
assert_eq!(budget.used(Q::StringAllocations), 1);
assert_eq!(&*retained, "123");
}
#[test]
fn pressure_reconciliation_reclaims_only_dead_owners_and_reuses_capacity() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 3), (Q::StringAllocations, 1)]);
let content = ledger.import("abc").unwrap();
let auxiliary = budget.used(Q::AuxiliaryBytes);
assert!(ledger.import("abc").is_err());
drop(content);
let replacement = ledger.import("xyz").unwrap();
assert_eq!(&*replacement, "xyz");
assert_eq!(budget.used(Q::StringBytes), 3);
assert_eq!(budget.used(Q::StringAllocations), 1);
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
}
#[test]
fn allocation_count_failure_refunds_provisional_content_charge() {
let (budget, ledger) = fixture(&[(Q::StringAllocations, 0)]);
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::StringAllocations);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
#[test]
fn ledger_growth_is_fallible_and_keeps_live_records_on_refusal() {
let state = (size_of::<Mutex<Domain>>() + 2 * size_of::<usize>()) as u64;
let (budget, ledger) = fixture(&[(Q::AuxiliaryBytes, state)]);
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::AuxiliaryBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::AuxiliaryBytes), state);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
#[test]
fn concatenation_accounts_utf8_length_and_temporary_result_coexistence() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 5), (Q::TemporaryBytes, 5)]);
let result = ledger.concat("é", "猫").unwrap();
assert_eq!(&*result, "é猫");
assert_eq!(budget.used(Q::StringBytes), 5);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 1);
}
#[test]
fn temporary_refusal_leaves_no_published_content_or_content_reservation() {
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
let error = ledger.concat("ab", "c").unwrap_err();
assert_eq!((error.resource, error.requested, error.limit), (Q::TemporaryBytes, 3, 2));
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);
// Direct import does not need a temporary concatenation buffer.
let imported = ledger.import("abc").unwrap();
assert_eq!(&*imported, "abc");
}
#[test]
fn foreign_arc_import_copies_into_destination_without_implicit_session_sharing() {
let (first_budget, first) = fixture(&[]);
let (second_budget, second) = fixture(&[]);
let source = first.import("text").unwrap();
assert!(first.retains(&source));
assert!(!second.retains(&source));
assert!(second.lease(&source).is_none());
let imported = second.import(&source).unwrap();
assert!(!Arc::ptr_eq(&source, &imported));
assert!(second.retains(&imported));
assert_eq!(first_budget.used(Q::StringBytes), 4);
assert_eq!(second_budget.used(Q::StringBytes), 4);
}
#[test]
fn native_provenance_lease_keeps_accounting_domain_alive_after_session_owner() {
let (budget, ledger) = fixture(&[]);
let content = ledger.import("kept").unwrap();
let host = ledger.lease(&content).unwrap();
let tool = host.clone();
drop(content);
drop(ledger);
assert_eq!(&**host.content(), "kept");
assert_eq!(host.domain().reconcile(), 0);
assert_eq!(budget.used(Q::StringBytes), 4);
drop(host);
assert_eq!(budget.used(Q::StringAllocations), 1);
drop(tool);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn shared_domain_survives_one_consumer_and_final_drop_releases_weak_storage() {
let (budget, ledger) = fixture(&[]);
let shared = ledger.clone();
let value = ledger.import("image").unwrap();
drop(ledger);
assert!(shared.retains(&value));
assert_eq!(budget.used(Q::StringBytes), 5);
drop(value);
shared.reconcile();
assert_eq!(budget.used(Q::StringBytes), 0);
assert!(budget.used(Q::AuxiliaryBytes) > 0);
drop(shared);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn domain_construction_refusal_does_not_publish_a_partial_owner() {
let budget =
RuntimeBudget::new(RuntimeLimits::default().lowered(Q::AuxiliaryBytes, 0).unwrap());
assert_eq!(StringLedger::new(budget.clone()).unwrap_err().resource, Q::AuxiliaryBytes);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn bounded_formatting_preserves_existing_value_text_without_unmetered_string_buffers() {
let (budget, ledger) = fixture(&[]);
for value in [
Value::Int32(i32::MIN),
Value::Int64(i64::MAX),
Value::Float(-0.0),
Value::Float(f64::MAX),
Value::Float(f64::NAN),
Value::Boolean(false),
Value::Null,
Value::HeapRef(prometeu_bytecode::HeapRef { index: u32::MAX, generation: 7 }),
Value::String(Arc::from("é猫")),
] {
let text = ledger.format(&value).unwrap();
assert_eq!(&*text, value.to_string());
assert_eq!(budget.used(Q::TemporaryBytes), 0);
drop(text);
ledger.reconcile();
assert_eq!(budget.used(Q::StringBytes), 0);
}
let text = ledger.concat_values(&Value::String(Arc::from("x=")), &Value::Int64(42)).unwrap();
assert_eq!(&*text, "x=42");
assert_eq!(budget.used(Q::StringBytes), 4);
}
#[test]
fn formatting_refuses_result_and_temporary_limits_with_no_content_publication() {
let (budget, ledger) = fixture(&[(Q::IndividualStringBytes, 2)]);
assert_eq!(ledger.format(&Value::Int32(123)).unwrap_err().resource, Q::IndividualStringBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(ledger.tracked_allocations(), 0);
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
assert_eq!(ledger.format(&Value::Boolean(false)).unwrap_err().resource, Q::TemporaryBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}