refactor: extract core objects into a standalone package
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 7m34s

This commit is contained in:
2026-10-19 13:33:24 +08:00
parent 78fc859825
commit f77b8370ea
40 changed files with 631 additions and 202 deletions
+381
View File
@@ -0,0 +1,381 @@
use std::collections::BTreeMap;
use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
use crate::{EndorObject, ObjectHeader, ObjectPayload, Value, VmError};
static NEXT_HEAP_ID: AtomicU64 = AtomicU64::new(1);
/// Checked, process-local reference. Copying it never retains an object.
/// The generation prevents a released handle from aliasing a reused slot.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ObjectRef {
heap_id: u64,
index: usize,
generation: u64,
}
impl fmt::Display for ObjectRef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}:{}:{}", self.heap_id, self.index, self.generation)
}
}
#[derive(Debug)]
struct Slot {
generation: u64,
object: Option<Box<EndorObject>>,
}
#[derive(Debug)]
pub(crate) struct Heap {
id: u64,
slots: Vec<Slot>,
free: Vec<usize>,
live: usize,
}
impl Heap {
pub(crate) fn new() -> Result<Self, VmError> {
let id = NEXT_HEAP_ID
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |id| id.checked_add(1))
.map_err(|_| VmError::IdentityExhausted)?;
Ok(Self {
id,
slots: Vec::new(),
free: Vec::new(),
live: 0,
})
}
pub(crate) fn allocate(
&mut self,
payload: Box<dyn ObjectPayload>,
) -> Result<ObjectRef, VmError> {
let mut edges = Vec::new();
payload.trace(&mut |reference| edges.push(reference));
let increments = self.prepare_increments(&edges)?;
let index = self.free.pop().unwrap_or(self.slots.len());
if index == self.slots.len() {
self.slots.push(Slot {
generation: 0,
object: None,
});
}
let reference = ObjectRef {
heap_id: self.id,
index,
generation: self.slots[index].generation,
};
let object = Box::new(EndorObject {
header: ObjectHeader {
identity: reference,
strong_refs: 1,
external_refs: 1,
},
payload,
attributes: BTreeMap::new(),
payload_edges: edges,
});
self.apply_increments(increments);
self.slots[index].object = Some(object);
self.live += 1;
Ok(reference)
}
pub(crate) fn get(&self, reference: ObjectRef) -> Result<&EndorObject, VmError> {
self.validate_owner(reference)?;
self.slots
.get(reference.index)
.filter(|slot| slot.generation == reference.generation)
.and_then(|slot| slot.object.as_deref())
.ok_or(VmError::InvalidHandle)
}
/// Transactional copy-on-update for built-in containers. The EndorObject
/// box and identity stay stable; only its payload and edge snapshot change.
/// All new edges are validated/retained before any old edge is released.
pub(crate) fn replace_payload(
&mut self,
reference: ObjectRef,
payload: impl ObjectPayload,
) -> Result<(), VmError> {
self.get(reference)?;
let mut edges = Vec::new();
payload.trace(&mut |target| edges.push(target));
let increments = self.prepare_increments(&edges)?;
self.apply_increments(increments);
let object = self.get_mut(reference)?;
let old_edges = std::mem::replace(&mut object.payload_edges, edges);
let old_payload = std::mem::replace(&mut object.payload, Box::new(payload));
self.release_edges(old_edges);
drop(old_payload);
Ok(())
}
fn get_mut(&mut self, reference: ObjectRef) -> Result<&mut EndorObject, VmError> {
self.get(reference)?;
Ok(self.slots[reference.index].object.as_deref_mut().unwrap())
}
fn validate_owner(&self, reference: ObjectRef) -> Result<(), VmError> {
if reference.heap_id != self.id {
return Err(VmError::ForeignHandle);
}
Ok(())
}
fn prepare_increments(
&self,
references: &[ObjectRef],
) -> Result<BTreeMap<ObjectRef, usize>, VmError> {
let mut counts = BTreeMap::<ObjectRef, usize>::new();
for reference in references {
self.get(*reference)?;
let count = counts.entry(*reference).or_default();
*count = count.checked_add(1).ok_or(VmError::RefCountOverflow)?;
}
for (reference, count) in &counts {
self.get(*reference)?
.header
.strong_refs
.checked_add(*count)
.ok_or(VmError::RefCountOverflow)?;
}
Ok(counts)
}
fn apply_increments(&mut self, increments: BTreeMap<ObjectRef, usize>) {
for (reference, count) in increments {
self.get_mut(reference).unwrap().header.strong_refs += count;
}
}
pub(crate) fn retain(&mut self, reference: ObjectRef) -> Result<(), VmError> {
let header = &mut self.get_mut(reference)?.header;
let strong = header
.strong_refs
.checked_add(1)
.ok_or(VmError::RefCountOverflow)?;
let external = header
.external_refs
.checked_add(1)
.ok_or(VmError::RefCountOverflow)?;
header.strong_refs = strong;
header.external_refs = external;
Ok(())
}
pub(crate) fn release(&mut self, reference: ObjectRef) -> Result<(), VmError> {
let header = &mut self.get_mut(reference)?.header;
if header.external_refs == 0 {
return Err(VmError::NoOwnedReference);
}
header.external_refs -= 1;
header.strong_refs -= 1;
let pending = if header.strong_refs == 0 {
vec![reference]
} else {
Vec::new()
};
self.drain_zero_counts(pending);
Ok(())
}
pub(crate) fn set_attr(
&mut self,
reference: ObjectRef,
name: String,
value: Value,
) -> Result<(), VmError> {
self.check_attributes(reference)?;
let edges: Vec<_> = match &value {
Value::Object(target) => vec![*target],
_ => Vec::new(),
};
let increments = self.prepare_increments(&edges)?;
self.apply_increments(increments);
let old = self.get_mut(reference)?.attributes.insert(name, value);
if let Some(Value::Object(target)) = old {
self.release_edges(vec![target]);
}
Ok(())
}
pub(crate) fn get_attr(&self, reference: ObjectRef, name: &str) -> Result<Value, VmError> {
self.check_attributes(reference)?;
self.get(reference)?
.attributes
.get(name)
.cloned()
.ok_or_else(|| VmError::AttributeNotFound(name.into()))
}
pub(crate) fn del_attr(&mut self, reference: ObjectRef, name: &str) -> Result<(), VmError> {
self.check_attributes(reference)?;
let old = self
.get_mut(reference)?
.attributes
.remove(name)
.ok_or_else(|| VmError::AttributeNotFound(name.into()))?;
if let Value::Object(target) = old {
self.release_edges(vec![target]);
}
Ok(())
}
fn check_attributes(&self, reference: ObjectRef) -> Result<(), VmError> {
if !self.get(reference)?.payload.allows_attributes() {
return Err(VmError::UnsupportedOperation("attributes"));
}
Ok(())
}
fn release_edges(&mut self, edges: Vec<ObjectRef>) {
let mut pending = Vec::new();
for target in edges {
let header = &mut self.get_mut(target).unwrap().header;
header.strong_refs -= 1;
if header.strong_refs == 0 {
pending.push(target);
}
}
self.drain_zero_counts(pending);
}
/// Removes the object before running Drop. Reuse increments its generation;
/// an exhausted generation permanently retires that slot.
fn take(&mut self, reference: ObjectRef) -> Box<EndorObject> {
let slot = &mut self.slots[reference.index];
let object = slot.object.take().unwrap();
if let Some(next) = slot.generation.checked_add(1) {
slot.generation = next;
self.free.push(reference.index);
}
self.live -= 1;
object
}
fn drain_zero_counts(&mut self, mut pending: Vec<ObjectRef>) {
while let Some(reference) = pending.pop() {
let object = self.take(reference);
for target in object.edges() {
let header = &mut self.get_mut(target).unwrap().header;
header.strong_refs -= 1;
if header.strong_refs == 0 {
pending.push(target);
}
}
drop(object);
}
}
/// Full, explicit cycle collection. External references are roots; every
/// managed attribute and declared payload edge participates in tracing.
pub(crate) fn collect_cycles(&mut self) -> usize {
let mut marked = vec![false; self.slots.len()];
let mut pending = Vec::new();
for slot in &self.slots {
if let Some(object) = &slot.object
&& object.header.external_refs > 0
{
pending.push(object.header.identity);
}
}
while let Some(reference) = pending.pop() {
if marked[reference.index] {
continue;
}
marked[reference.index] = true;
pending.extend(self.get(reference).unwrap().edges());
}
let garbage: Vec<_> = self
.slots
.iter()
.enumerate()
.filter(|(index, _)| !marked[*index])
.filter_map(|(_, slot)| slot.object.as_ref().map(|object| object.header.identity))
.collect();
let objects: Vec<_> = garbage
.iter()
.map(|reference| self.take(*reference))
.collect();
// All garbage slots are detached before touching edges or running Drop.
for object in &objects {
for target in object.edges() {
if let Ok(survivor) = self.get_mut(target) {
survivor.header.strong_refs -= 1;
}
}
}
let collected = objects.len();
drop(objects);
collected
}
pub(crate) fn len(&self) -> usize {
self.live
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Record;
#[test]
fn invalid_slots_and_generations_are_rejected() {
let mut heap = Heap::new().unwrap();
let reference = heap.allocate(Box::new(Record)).unwrap();
let invalid = ObjectRef {
index: usize::MAX,
..reference
};
let stale = ObjectRef {
generation: 1,
..reference
};
assert!(matches!(heap.get(invalid), Err(VmError::InvalidHandle)));
assert!(matches!(heap.get_mut(stale), Err(VmError::InvalidHandle)));
}
#[test]
fn reused_slots_never_alias_and_exhausted_generations_retire() {
let mut heap = Heap::new().unwrap();
let first = heap.allocate(Box::new(Record)).unwrap();
heap.release(first).unwrap();
let second = heap.allocate(Box::new(Record)).unwrap();
assert_eq!(first.index, second.index);
assert_ne!(first.generation, second.generation);
assert!(matches!(heap.get(first), Err(VmError::InvalidHandle)));
heap.slots[second.index].generation = u64::MAX;
let last = ObjectRef {
generation: u64::MAX,
..second
};
heap.slots[last.index]
.object
.as_mut()
.unwrap()
.header
.identity = last;
heap.release(last).unwrap();
let next = heap.allocate(Box::new(Record)).unwrap();
assert_ne!(next.index, last.index);
}
#[test]
fn failed_reference_increments_leave_counts_and_attributes_unchanged() {
let mut heap = Heap::new().unwrap();
let owner = heap.allocate(Box::new(Record)).unwrap();
let target = heap.allocate(Box::new(Record)).unwrap();
heap.get_mut(target).unwrap().header.strong_refs = usize::MAX;
assert_eq!(heap.retain(target), Err(VmError::RefCountOverflow));
assert_eq!(heap.get(target).unwrap().header.external_refs, 1);
assert_eq!(
heap.set_attr(owner, "edge".into(), Value::Object(target)),
Err(VmError::RefCountOverflow)
);
assert!(heap.get(owner).unwrap().attributes.is_empty());
}
}