From 43b466c8135dc2cd5db63ff3b7809746754e58bd Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Wed, 7 Oct 2026 19:24:54 +0100 Subject: [PATCH] feat(vm): add metered shared-string infrastructure for PLN-0176 step 19 --- crates/console/prometeu-bytecode/src/value.rs | 31 ++- crates/console/prometeu-vm/src/lib.rs | 3 + .../prometeu-vm/src/resource_budget.rs | 11 + .../console/prometeu-vm/src/string_ledger.rs | 206 ++++++++++++++++ .../prometeu-vm/src/string_ledger/tests.rs | 219 ++++++++++++++++++ 5 files changed, 452 insertions(+), 18 deletions(-) create mode 100644 crates/console/prometeu-vm/src/string_ledger.rs create mode 100644 crates/console/prometeu-vm/src/string_ledger/tests.rs diff --git a/crates/console/prometeu-bytecode/src/value.rs b/crates/console/prometeu-bytecode/src/value.rs index 486fb63..90b7061 100644 --- a/crates/console/prometeu-bytecode/src/value.rs +++ b/crates/console/prometeu-bytecode/src/value.rs @@ -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"), } } diff --git a/crates/console/prometeu-vm/src/lib.rs b/crates/console/prometeu-vm/src/lib.rs index 8b28381..0e91966 100644 --- a/crates/console/prometeu-vm/src/lib.rs +++ b/crates/console/prometeu-vm/src/lib.rs @@ -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; diff --git a/crates/console/prometeu-vm/src/resource_budget.rs b/crates/console/prometeu-vm/src/resource_budget.rs index 91d120f..a4efdb7 100644 --- a/crates/console/prometeu-vm/src/resource_budget.rs +++ b/crates/console/prometeu-vm/src/resource_budget.rs @@ -441,6 +441,17 @@ impl BudgetVec { 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); } diff --git a/crates/console/prometeu-vm/src/string_ledger.rs b/crates/console/prometeu-vm/src/string_ledger.rs new file mode 100644 index 0000000..1a74132 --- /dev/null +++ b/crates/console/prometeu-vm/src/string_ledger.rs @@ -0,0 +1,206 @@ +//! Allocation-identity accounting over ordinary Arc values. +//! The ledger never owns string content strongly. Native owners retain an +//! explicit provenance lease; guest slots remain Arc, 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, + _bytes: Reservation, + _allocation: Reservation, +} + +#[derive(Debug)] +struct Domain { + budget: RuntimeBudget, + entries: BudgetVec, + _state: Reservation, +} + +#[derive(Debug, Clone)] +pub(crate) struct StringLedger(Arc>); + +/// 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, + domain: StringLedger, +} +impl StringLease { + pub(crate) fn content(&self) -> &Arc { + &self.content + } + pub(crate) fn domain(&self) -> &StringLedger { + &self.domain + } +} + +impl StringLedger { + pub(crate) fn new(budget: RuntimeBudget) -> Result { + let state = budget.reserve( + Q::AuxiliaryBytes, + budget.bytes::>(1, Q::AuxiliaryBytes)? + 2 * size_of::() 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) -> 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) -> Option { + 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, 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 = Arc::from(text); + domain.publish(&content, charges); + Ok(content) + } + + pub(crate) fn concat(&self, left: &str, right: &str) -> Result, 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::::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 = Arc::from(text); + domain.publish(&content, charges); + Ok(content) + } + pub(crate) fn format(&self, value: &Value) -> Result, ResourceFailure> { + self.format_values(&[value]) + } + pub(crate) fn concat_values( + &self, + left: &Value, + right: &Value, + ) -> Result, ResourceFailure> { + self.format_values(&[left, right]) + } + fn format_values(&self, values: &[&Value]) -> Result, 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 = 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, + failure: Option, +} +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 { + 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 { + 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, 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; diff --git a/crates/console/prometeu-vm/src/string_ledger/tests.rs b/crates/console/prometeu-vm/src/string_ledger/tests.rs new file mode 100644 index 0000000..376dd52 --- /dev/null +++ b/crates/console/prometeu-vm/src/string_ledger/tests.rs @@ -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::>() + 2 * size_of::()) 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); +}