feat(vm): add metered shared-string infrastructure for PLN-0176 step 19
This commit is contained in:
@@ -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);
|
||||
}
|
||||
Reference in New Issue
Block a user