feat: add managed types, source classes and scoped native calls
This commit is contained in:
@@ -2,6 +2,8 @@ use std::collections::BTreeMap;
|
||||
use std::fmt;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use crate::changes::MAX_PENDING_CHANGES;
|
||||
use crate::{ChangeBatch, ChangeKey, ObjectChange};
|
||||
use crate::{EndorObject, ObjectHeader, ObjectPayload, Value, VmError};
|
||||
|
||||
static NEXT_HEAP_ID: AtomicU64 = AtomicU64::new(1);
|
||||
@@ -21,6 +23,11 @@ impl fmt::Display for ObjectRef {
|
||||
}
|
||||
}
|
||||
|
||||
/// A non-owning reference. Only the originating store can upgrade it; slot
|
||||
/// reuse never makes a dead weak reference point at a different object.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct WeakObjectRef(pub(crate) ObjectRef);
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Slot {
|
||||
generation: u64,
|
||||
@@ -33,6 +40,8 @@ pub(crate) struct Heap {
|
||||
slots: Vec<Slot>,
|
||||
free: Vec<usize>,
|
||||
live: usize,
|
||||
changes: BTreeMap<(ObjectRef, ChangeKey), u64>,
|
||||
changes_overflow: bool,
|
||||
}
|
||||
|
||||
impl Heap {
|
||||
@@ -45,6 +54,8 @@ impl Heap {
|
||||
slots: Vec::new(),
|
||||
free: Vec::new(),
|
||||
live: 0,
|
||||
changes: BTreeMap::new(),
|
||||
changes_overflow: false,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -72,6 +83,8 @@ impl Heap {
|
||||
identity: reference,
|
||||
strong_refs: 1,
|
||||
external_refs: 1,
|
||||
change_version: 0,
|
||||
type_object: None,
|
||||
},
|
||||
payload,
|
||||
attributes: BTreeMap::new(),
|
||||
@@ -92,6 +105,27 @@ impl Heap {
|
||||
.ok_or(VmError::InvalidHandle)
|
||||
}
|
||||
|
||||
pub(crate) fn attach_type(
|
||||
&mut self,
|
||||
reference: ObjectRef,
|
||||
type_object: ObjectRef,
|
||||
) -> Result<(), VmError> {
|
||||
if self.get(reference)?.header.type_object.is_some() {
|
||||
return Err(VmError::InvalidArgument("object already has a type"));
|
||||
}
|
||||
if self.get(reference)?.attributes.contains_key("type") {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"type attribute conflicts with managed type",
|
||||
));
|
||||
}
|
||||
let increments = self.prepare_increments(&[type_object])?;
|
||||
self.prepare_change(reference)?;
|
||||
self.apply_increments(increments);
|
||||
self.get_mut(reference)?.header.type_object = Some(type_object);
|
||||
self.record_change(reference, ChangeKey::Contents);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 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.
|
||||
@@ -104,10 +138,12 @@ impl Heap {
|
||||
let mut edges = Vec::new();
|
||||
payload.trace(&mut |target| edges.push(target));
|
||||
let increments = self.prepare_increments(&edges)?;
|
||||
self.prepare_change(reference)?;
|
||||
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.record_change(reference, ChangeKey::Contents);
|
||||
self.release_edges(old_edges);
|
||||
drop(old_payload);
|
||||
Ok(())
|
||||
@@ -194,8 +230,13 @@ impl Heap {
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let increments = self.prepare_increments(&edges)?;
|
||||
self.prepare_change(reference)?;
|
||||
self.apply_increments(increments);
|
||||
let old = self.get_mut(reference)?.attributes.insert(name, value);
|
||||
let old = self
|
||||
.get_mut(reference)?
|
||||
.attributes
|
||||
.insert(name.clone(), value);
|
||||
self.record_change(reference, ChangeKey::Attribute(name));
|
||||
if let Some(Value::Object(target)) = old {
|
||||
self.release_edges(vec![target]);
|
||||
}
|
||||
@@ -213,17 +254,58 @@ impl Heap {
|
||||
|
||||
pub(crate) fn del_attr(&mut self, reference: ObjectRef, name: &str) -> Result<(), VmError> {
|
||||
self.check_attributes(reference)?;
|
||||
self.prepare_change(reference)?;
|
||||
let old = self
|
||||
.get_mut(reference)?
|
||||
.attributes
|
||||
.remove(name)
|
||||
.ok_or_else(|| VmError::AttributeNotFound(name.into()))?;
|
||||
self.record_change(reference, ChangeKey::Attribute(name.into()));
|
||||
if let Value::Object(target) = old {
|
||||
self.release_edges(vec![target]);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn prepare_change(&self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
self.get(reference)?
|
||||
.header
|
||||
.change_version
|
||||
.checked_add(1)
|
||||
.ok_or(VmError::ExecutionLimit("object change version"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn record_change(&mut self, reference: ObjectRef, key: ChangeKey) {
|
||||
let object = self.get_mut(reference).expect("validated change target");
|
||||
object.header.change_version += 1;
|
||||
let version = object.header.change_version;
|
||||
if self.changes_overflow {
|
||||
return;
|
||||
}
|
||||
let entry = (reference, key);
|
||||
if self.changes.len() >= MAX_PENDING_CHANGES && !self.changes.contains_key(&entry) {
|
||||
self.changes.clear();
|
||||
self.changes_overflow = true;
|
||||
} else {
|
||||
self.changes.insert(entry, version);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn take_changes(&mut self) -> ChangeBatch {
|
||||
ChangeBatch {
|
||||
changes: std::mem::take(&mut self.changes)
|
||||
.into_iter()
|
||||
.map(|((object, key), version)| ObjectChange {
|
||||
object,
|
||||
key,
|
||||
version,
|
||||
})
|
||||
.collect(),
|
||||
rescan_required: std::mem::take(&mut self.changes_overflow),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_attributes(&self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
if !self.get(reference)?.payload.allows_attributes() {
|
||||
return Err(VmError::UnsupportedOperation("attributes"));
|
||||
|
||||
Reference in New Issue
Block a user