//! 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;