feat(rfc-cm): baseline P0-P3 compute machine, stdlib and resource slices
Implements the first vertical slices of RFC-CM-0001/0002 on top of a113d89:
- P1: opaque Memory regions (64 KiB pages, budgets, grow-only), byte
read/write, Memory-index place assignment, wire/host-boundary rejection.
- CM-A04/A05: value-semantics List/Map/Text/Table primitives and the
recoverable Result map convention.
- CM-A06: opaque Resource handles, resource.open/read/write/close, stdout
write, granted project-file read and buffered write, strict fail-closed.
- CM-A07 Compat-A: explicit .mq.md format/utf8/io chain matching builtin
print for the covered value types; builtin remains default.
- P2 fixtures: allocators, list/tree/graph/hash, integer codecs, UTF-8
encode/decode, CSV/JSON subsets, table filter/sort/join, bytecode VM.
- ADRs 0022-0027, spec updates, evidence reports and 68 semantic goldens.
Gate: cargo fmt --check, clippy -D warnings, 407 tests passed.
This commit is contained in:
1 parent
a113d89496
commit
92bfbf2568
127 files changed
+11351
-141
No files matched your search
@@ -6,13 +6,13 @@
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use marqdo_host::HostOp;
|
||||
use marqdo_host::{HostOp, ResourceRead};
|
||||
use marqdo_ir::builtins::Builtin;
|
||||
use marqdo_ir::Resource;
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{
|
||||
float_to_bigint, CodeValue, ErrorCategory, FormulaValue, FunctionRef, RuntimeError, Table,
|
||||
Value,
|
||||
float_to_bigint, CodeValue, ErrorCategory, FormulaValue, FunctionRef, ResourceHandle,
|
||||
RuntimeError, Table, Value,
|
||||
};
|
||||
|
||||
use crate::interpreter::Interpreter;
|
||||
@@ -187,6 +187,292 @@ pub(crate) fn dispatch(
|
||||
&module,
|
||||
)
|
||||
}
|
||||
"memory.new" => {
|
||||
let initial_pages = page_count(take(&bound, "initial_pages", builtin, span)?, span)?;
|
||||
let max_pages = page_count(take(&bound, "max_pages", builtin, span)?, span)?;
|
||||
let handle = interpreter
|
||||
.memory_mut()
|
||||
.create(initial_pages, max_pages, span)?;
|
||||
interpreter.record_memory_event(
|
||||
"memory.new",
|
||||
&module,
|
||||
span,
|
||||
&format!("initial_pages={initial_pages} max_pages={max_pages}"),
|
||||
);
|
||||
Ok(Value::Memory(handle))
|
||||
}
|
||||
"memory.size" => {
|
||||
let memory = take(&bound, "memory", builtin, span)?;
|
||||
let memory_type = memory.type_name();
|
||||
let Value::Memory(handle) = memory else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory.size expects a Memory value, got {memory_type}"),
|
||||
));
|
||||
};
|
||||
let pages = interpreter.memory().size(handle, span)?;
|
||||
Ok(pages_value(pages, span)?)
|
||||
}
|
||||
"memory.grow" => {
|
||||
let memory = take(&bound, "memory", builtin, span)?;
|
||||
let memory_type = memory.type_name();
|
||||
let Value::Memory(handle) = memory else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory.grow expects a Memory value, got {memory_type}"),
|
||||
));
|
||||
};
|
||||
let pages = page_count(take(&bound, "pages", builtin, span)?, span)?;
|
||||
let old_pages = interpreter.memory_mut().grow(handle, pages, span)?;
|
||||
interpreter.record_memory_event(
|
||||
"memory.grow",
|
||||
&module,
|
||||
span,
|
||||
&format!("pages={pages} old_pages={old_pages}"),
|
||||
);
|
||||
Ok(pages_value(old_pages, span)?)
|
||||
}
|
||||
"list.append" => {
|
||||
let list = take(&bound, "list", builtin, span)?;
|
||||
let value = take(&bound, "value", builtin, span)?;
|
||||
let list_type = list.type_name();
|
||||
let Value::List(mut items) = list else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.append expects a List, got {list_type}"),
|
||||
));
|
||||
};
|
||||
items.push(value);
|
||||
Ok(Value::List(items))
|
||||
}
|
||||
"list.concat" => {
|
||||
let left = take(&bound, "left", builtin, span)?;
|
||||
let right = take(&bound, "right", builtin, span)?;
|
||||
let left_type = left.type_name();
|
||||
let Value::List(mut items) = left else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.concat left operand must be a List, got {left_type}"),
|
||||
));
|
||||
};
|
||||
let right_type = right.type_name();
|
||||
let Value::List(other) = right else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.concat right operand must be a List, got {right_type}"),
|
||||
));
|
||||
};
|
||||
items.extend(other);
|
||||
Ok(Value::List(items))
|
||||
}
|
||||
"map.keys" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.keys expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
map.keys().cloned().map(Value::Text).collect::<Vec<_>>(),
|
||||
))
|
||||
}
|
||||
"map.has" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.has", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.has expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::Bool(map.contains_key(&key)))
|
||||
}
|
||||
"map.get" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.get", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.get expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(map.get(&key).cloned().unwrap_or(Value::None))
|
||||
}
|
||||
"map.set" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.set", span)?;
|
||||
let new_value = take(&bound, "value", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(mut map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.set expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
map.insert(key, new_value);
|
||||
Ok(Value::Map(map))
|
||||
}
|
||||
"map.remove" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.remove", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(mut map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.remove expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
map.remove(&key);
|
||||
Ok(Value::Map(map))
|
||||
}
|
||||
"text.codepoints" => {
|
||||
let value = take(&bound, "text", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Text(text) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("text.codepoints expects Text, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
text.chars()
|
||||
.map(|character| Value::int(i64::from(character as u32)))
|
||||
.collect(),
|
||||
))
|
||||
}
|
||||
"text.from_codepoint" => {
|
||||
let value = take(&bound, "codepoint", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(codepoint) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("text.from_codepoint expects an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let Some(codepoint) = num_traits::ToPrimitive::to_u32(&codepoint) else {
|
||||
return Ok(Value::None);
|
||||
};
|
||||
Ok(match char::from_u32(codepoint) {
|
||||
Some(character) => Value::Text(character.to_string()),
|
||||
None => Value::None,
|
||||
})
|
||||
}
|
||||
"table.columns" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.columns expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
table.header.into_iter().map(Value::Text).collect(),
|
||||
))
|
||||
}
|
||||
"table.row" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let row = take(&bound, "row", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.row expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let position = table_index(row, table.rows.len(), "row", span)?;
|
||||
Ok(Value::List(table.rows[position].clone()))
|
||||
}
|
||||
"table.cell" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let row = take(&bound, "row", builtin, span)?;
|
||||
let column = take(&bound, "column", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.cell expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let row = table_index(row, table.rows.len(), "row", span)?;
|
||||
let column = table_index(column, table.header.len(), "column", span)?;
|
||||
Ok(table.rows[row][column].clone())
|
||||
}
|
||||
"resource.open" => {
|
||||
let kind = expect_text_value(take(&bound, "kind", builtin, span)?, span)?;
|
||||
let descriptor = expect_text_value(take(&bound, "descriptor", builtin, span)?, span)?;
|
||||
let rights = rights_list(take(&bound, "rights", builtin, span)?, span)?;
|
||||
interpreter.resource_open(&kind, &descriptor, &rights, &module, span)
|
||||
}
|
||||
"resource.read" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
let memory = memory_handle(
|
||||
take(&bound, "memory", builtin, span)?,
|
||||
"resource.read",
|
||||
span,
|
||||
)?;
|
||||
let offset = take(&bound, "offset", builtin, span)?;
|
||||
let offset_int = int_value(offset, "resource.read offset", span)?;
|
||||
let offset_value = Value::Int(offset_int.clone());
|
||||
let max_bytes = positive_count(
|
||||
take(&bound, "max_bytes", builtin, span)?,
|
||||
"resource.read max_bytes",
|
||||
span,
|
||||
)?;
|
||||
let available = interpreter.memory().byte_len(memory, span)?;
|
||||
let start = non_negative_usize(&offset_value, "resource.read offset", span)?;
|
||||
if start >= available {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("resource.read offset {start} is at or beyond the Memory length {available}"),
|
||||
));
|
||||
}
|
||||
let limit = max_bytes.min(available - start);
|
||||
let result = interpreter.resource_read(handle, limit, &module, span);
|
||||
match result {
|
||||
Ok(read) => {
|
||||
interpreter
|
||||
.memory_mut()
|
||||
.write_bytes(memory, &offset_int, &read.bytes, span)?;
|
||||
Ok(resource_ok(resource_read_payload(&read)))
|
||||
}
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
"resource.write" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
let memory = memory_handle(
|
||||
take(&bound, "memory", builtin, span)?,
|
||||
"resource.write",
|
||||
span,
|
||||
)?;
|
||||
let offset = take(&bound, "offset", builtin, span)?;
|
||||
let offset_int = int_value(offset, "resource.write offset", span)?;
|
||||
let length = non_negative_usize(
|
||||
&take(&bound, "length", builtin, span)?,
|
||||
"resource.write length",
|
||||
span,
|
||||
)?;
|
||||
let bytes = interpreter
|
||||
.memory()
|
||||
.read_bytes(memory, &offset_int, length, span)?;
|
||||
match interpreter.resource_write(handle, &bytes, &module, span) {
|
||||
Ok(count) => Ok(resource_ok(resource_write_payload(count))),
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
"resource.close" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
match interpreter.resource_close(handle, &module, span) {
|
||||
Ok(()) => Ok(resource_ok(Value::None)),
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
other => Err(RuntimeError::new(
|
||||
ErrorCategory::KernelUnavailable,
|
||||
span,
|
||||
@@ -210,6 +496,228 @@ fn take(
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate a page-count argument: an `Int` in the non-negative `u64` range.
|
||||
fn page_count(value: Value, span: Option<Span>) -> Result<u64, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(count) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory page count must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
num_traits::ToPrimitive::to_u64(&count).ok_or_else(|| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::MemoryFault,
|
||||
span,
|
||||
format!("memory page count {count} must be a non-negative integer"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Convert a page count back to a language `Int`.
|
||||
fn pages_value(pages: u64, span: Option<Span>) -> Result<Value, RuntimeError> {
|
||||
i64::try_from(pages).map(Value::int).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::MemoryFault,
|
||||
span,
|
||||
format!("page count {pages} does not fit an Int"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Require a `Text` map key and return it.
|
||||
fn map_key(value: Value, builtin: &str, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
match value {
|
||||
Value::Text(key) => Ok(key),
|
||||
_ => Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{builtin} key must be Text, got {value_type}"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Require a Text value.
|
||||
fn expect_text_value(value: Value, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Text(text) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("expected Text, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(text)
|
||||
}
|
||||
|
||||
/// Require a List of Text rights.
|
||||
fn rights_list(value: Value, span: Option<Span>) -> Result<Vec<String>, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::List(items) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("resource rights must be a List, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let mut rights = Vec::with_capacity(items.len());
|
||||
for item in items {
|
||||
let item_type = item.type_name();
|
||||
let Value::Text(right) = item else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("resource rights must contain Text, got {item_type}"),
|
||||
));
|
||||
};
|
||||
rights.push(right);
|
||||
}
|
||||
Ok(rights)
|
||||
}
|
||||
|
||||
/// Require an opaque resource handle.
|
||||
fn resource_handle(value: Value, span: Option<Span>) -> Result<ResourceHandle, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Resource(handle) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("expected a Resource handle, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(handle)
|
||||
}
|
||||
|
||||
/// Require an opaque Memory handle.
|
||||
fn memory_handle(
|
||||
value: Value,
|
||||
builtin: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<marqdo_value::MemoryHandle, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Memory(handle) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{builtin} memory must be a Memory value, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(handle)
|
||||
}
|
||||
|
||||
/// Require an Int value.
|
||||
fn int_value(
|
||||
value: Value,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<num_bigint::BigInt, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(value) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(value)
|
||||
}
|
||||
|
||||
/// Require a non-negative usize.
|
||||
fn non_negative_usize(
|
||||
value: &Value,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(value) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
num_traits::ToPrimitive::to_usize(value).ok_or_else(|| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("{what} {value} must be a non-negative integer in range"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Require a strictly positive byte count.
|
||||
fn positive_count(value: Value, what: &str, span: Option<Span>) -> Result<usize, RuntimeError> {
|
||||
let count = non_negative_usize(&value, what, span)?;
|
||||
if count == 0 {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be greater than zero"),
|
||||
));
|
||||
}
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn resource_ok(value: Value) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(true));
|
||||
map.insert("value".to_string(), value);
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_err(code: &str, message: &str) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(false));
|
||||
map.insert("code".to_string(), Value::Text(code.to_string()));
|
||||
map.insert("message".to_string(), Value::Text(message.to_string()));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_read_payload(read: &ResourceRead) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("count".to_string(), Value::int(read.bytes.len() as i64));
|
||||
map.insert("eof".to_string(), Value::Bool(read.eof));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_write_payload(count: usize) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("count".to_string(), Value::int(count as i64));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
/// Convert a closed-handle failure into a recoverable Result; other errors are
|
||||
/// fatal (ADR-0025).
|
||||
fn resource_recoverable(error: RuntimeError) -> Result<Value, RuntimeError> {
|
||||
if error.category == ErrorCategory::ResourceClosed {
|
||||
return Ok(resource_err("resource.closed", &error.message));
|
||||
}
|
||||
Err(error)
|
||||
}
|
||||
|
||||
/// Validate a non-negative table row/column coordinate.
|
||||
fn table_index(
|
||||
value: Value,
|
||||
len: usize,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(index) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table {what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let Some(position) = num_traits::ToPrimitive::to_usize(&index) else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("table {what} {index} is out of bounds for length {len}"),
|
||||
));
|
||||
};
|
||||
if position >= len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("table {what} {position} is out of bounds for length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(position)
|
||||
}
|
||||
|
||||
fn formula_text(value: Value, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
match value {
|
||||
Value::Formula(formula) => Ok(formula.latex),
|
||||
|
||||
@@ -3,12 +3,13 @@
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use marqdo_expression::{BinaryOp, Expr, RecordEntry};
|
||||
use marqdo_host::{ExecutionContext, Host, HostOp};
|
||||
use marqdo_ir::{builtins, CallTarget, Function, FunctionId, ModuleId, Program, Stmt};
|
||||
use marqdo_host::{ExecutionContext, Host, HostOp, ResourceRead};
|
||||
use marqdo_ir::{builtins, CallTarget, Function, FunctionId, ModuleId, PlaceTarget, Program, Stmt};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, RuntimeError, Value};
|
||||
use marqdo_value::{ErrorCategory, ResourceHandle, RuntimeError, Value};
|
||||
|
||||
use crate::builtins_impl::FrameView;
|
||||
use crate::memory::{MemoryLimits, MemoryStore};
|
||||
|
||||
use crate::value_ops;
|
||||
|
||||
@@ -68,6 +69,7 @@ pub struct Interpreter<'a> {
|
||||
program: &'a Program,
|
||||
host: &'a mut dyn Host,
|
||||
depth: usize,
|
||||
memory: MemoryStore,
|
||||
}
|
||||
|
||||
/// Run a named function with already-evaluated arguments.
|
||||
@@ -77,11 +79,31 @@ pub fn run(
|
||||
module: &ModuleId,
|
||||
function: &str,
|
||||
args: Vec<EvaluatedArg>,
|
||||
) -> Result<RunOutcome, RuntimeError> {
|
||||
run_with_limits(
|
||||
program,
|
||||
host,
|
||||
module,
|
||||
function,
|
||||
args,
|
||||
MemoryLimits::default(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Run with explicit addressable-memory limits (ADR-0022).
|
||||
pub fn run_with_limits(
|
||||
program: &Program,
|
||||
host: &mut dyn Host,
|
||||
module: &ModuleId,
|
||||
function: &str,
|
||||
args: Vec<EvaluatedArg>,
|
||||
limits: MemoryLimits,
|
||||
) -> Result<RunOutcome, RuntimeError> {
|
||||
let mut interpreter = Interpreter {
|
||||
program,
|
||||
host,
|
||||
depth: 0,
|
||||
memory: MemoryStore::new(limits),
|
||||
};
|
||||
let value = interpreter.call_by_name(module, function, args, None)?;
|
||||
Ok(RunOutcome { value })
|
||||
@@ -300,10 +322,25 @@ impl<'a> Interpreter<'a> {
|
||||
self.host.consume_fuel(1, Some(stmt.span()))?;
|
||||
self.host.check_deadline(Some(stmt.span()))?;
|
||||
match stmt {
|
||||
Stmt::Assign { name, value, .. } => {
|
||||
let value = self.eval_expr(value, frame)?;
|
||||
frame.locals.insert(name.clone(), value);
|
||||
}
|
||||
Stmt::Assign { target, value, .. } => match target {
|
||||
PlaceTarget::Local { name, .. } => {
|
||||
let value = self.eval_expr(value, frame)?;
|
||||
frame.locals.insert(name.clone(), value);
|
||||
}
|
||||
PlaceTarget::Index { base, index, span } => {
|
||||
// Frozen order (ADR-0022): base, index, then RHS.
|
||||
let base_value = self.eval_expr(base, frame)?;
|
||||
let index_value = self.eval_expr(index, frame)?;
|
||||
let byte_value = self.eval_expr(value, frame)?;
|
||||
self.assign_memory_index(
|
||||
base_value,
|
||||
index_value,
|
||||
byte_value,
|
||||
Some(*span),
|
||||
frame,
|
||||
)?;
|
||||
}
|
||||
},
|
||||
Stmt::Eval { expr, .. } => {
|
||||
self.eval_expr(expr, frame)?;
|
||||
}
|
||||
@@ -417,6 +454,62 @@ impl<'a> Interpreter<'a> {
|
||||
self.call_by_name_from(&module, &name, args, Some(span), Some(&caller))
|
||||
}
|
||||
|
||||
/// Commit one byte into an addressable region after all operand checks.
|
||||
///
|
||||
/// The three operands are already evaluated, so a rejected value never
|
||||
/// produces a partial write (ADR-0022 §3).
|
||||
fn assign_memory_index(
|
||||
&mut self,
|
||||
base: Value,
|
||||
index: Value,
|
||||
byte: Value,
|
||||
span: Option<Span>,
|
||||
frame: &Frame,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let base_type = base.type_name();
|
||||
let Value::Memory(handle) = base else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
span,
|
||||
format!(
|
||||
"index assignment requires a Memory base in v1, got {base_type}; List, Map \
|
||||
and Table values keep their existing value semantics"
|
||||
),
|
||||
));
|
||||
};
|
||||
let index_type = index.type_name();
|
||||
let Value::Int(offset) = index else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory index must be an Int, got {index_type}"),
|
||||
));
|
||||
};
|
||||
let byte_type = byte.type_name();
|
||||
let byte_repr = byte.display();
|
||||
let Value::Int(byte) = byte else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory byte value must be an Int in 0..255, got {byte_type}"),
|
||||
));
|
||||
};
|
||||
let Some(byte) = num_traits::ToPrimitive::to_u8(&byte) else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory byte value {byte_repr} is outside 0..255"),
|
||||
));
|
||||
};
|
||||
self.memory.write(handle, &offset, byte, span)?;
|
||||
let module = frame.function.module.canonical();
|
||||
self.host.record_semantic(
|
||||
"memory.write",
|
||||
Some(&frame.function.to_string()),
|
||||
Some(&module),
|
||||
span,
|
||||
Some("byte"),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn eval_args(
|
||||
&mut self,
|
||||
args: &[marqdo_expression::Arg],
|
||||
@@ -528,7 +621,22 @@ impl<'a> Interpreter<'a> {
|
||||
Expr::Index { base, index, span } => {
|
||||
let base_value = self.eval_expr(base, frame)?;
|
||||
let index_value = self.eval_expr(index, frame)?;
|
||||
index_value_of(base_value, index_value, Some(*span))
|
||||
match base_value {
|
||||
Value::Memory(handle) => {
|
||||
let Value::Int(offset) = index_value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
Some(*span),
|
||||
format!(
|
||||
"Memory index must be an Int, got {}",
|
||||
index_value.type_name()
|
||||
),
|
||||
));
|
||||
};
|
||||
let byte = self.memory.read(handle, &offset, Some(*span))?;
|
||||
Ok(Value::int(i64::from(byte)))
|
||||
}
|
||||
other => index_value_of(other, index_value, Some(*span)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -701,6 +809,97 @@ impl<'a> Interpreter<'a> {
|
||||
self.program
|
||||
}
|
||||
|
||||
/// Addressable-memory store for builtins and place writes.
|
||||
pub(crate) fn memory(&self) -> &MemoryStore {
|
||||
&self.memory
|
||||
}
|
||||
|
||||
/// Mutable addressable-memory store for `memory.new`/`memory.grow`.
|
||||
pub(crate) fn memory_mut(&mut self) -> &mut MemoryStore {
|
||||
&mut self.memory
|
||||
}
|
||||
|
||||
/// Record a semantic event for a builtin that is not a host operation.
|
||||
pub(crate) fn record_memory_event(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
detail: &str,
|
||||
) {
|
||||
let module = module.canonical();
|
||||
self.host
|
||||
.record_semantic(kind, None, Some(&module), span, Some(detail));
|
||||
}
|
||||
|
||||
/// Open a resource/stream through the host boundary.
|
||||
pub(crate) fn resource_open(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
descriptor: &str,
|
||||
rights: &[String],
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_open(kind, descriptor, rights, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Read from a resource stream.
|
||||
pub(crate) fn resource_read(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
max_bytes: usize,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<ResourceRead, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_read(handle, max_bytes, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Write bytes to a resource stream.
|
||||
pub(crate) fn resource_write(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
bytes: &[u8],
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_write(handle, bytes, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Close a resource stream.
|
||||
pub(crate) fn resource_close(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_close(handle, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Call a builtin-read host operation on behalf of a frame's module.
|
||||
pub(crate) fn host_invoke(
|
||||
&mut self,
|
||||
|
||||
@@ -8,8 +8,12 @@
|
||||
|
||||
mod builtins_impl;
|
||||
mod interpreter;
|
||||
mod memory;
|
||||
mod value_ops;
|
||||
|
||||
pub use interpreter::{run, EvaluatedArg, Interpreter, RunOutcome};
|
||||
pub use interpreter::{run, run_with_limits, EvaluatedArg, Interpreter, RunOutcome};
|
||||
pub use memory::{
|
||||
MemoryLimits, MemoryStore, DEFAULT_MAX_REGION_BYTES, DEFAULT_MAX_TOTAL_BYTES, PAGE_SIZE,
|
||||
};
|
||||
|
||||
pub use marqdo_value::{RuntimeError, Value};
|
||||
@@ -0,0 +1,600 @@
|
||||
//! Runtime-owned addressable byte regions (RFC-CM-0001 / ADR-0022).
|
||||
//!
|
||||
//! A [`MemoryStore`] owns every region created during one run. Language values
|
||||
//! carry only an opaque [`MemoryHandle`]; offsets are region-relative integers
|
||||
//! and are never host pointers. Region identity is issued here and cannot be
|
||||
//! forged from a document, a number or wire data.
|
||||
//!
|
||||
//! Semantics frozen by ADR-0022:
|
||||
//!
|
||||
//! * a region is a byte array with a 64 KiB logical page size; new bytes are
|
||||
//! zero-filled;
|
||||
//! * regions grow only, never shrink; a failed grow leaves the region and the
|
||||
//! committed budget unchanged;
|
||||
//! * copies of a `Memory` value share one region, while different regions
|
||||
//! never alias;
|
||||
//! * every access is bounds-checked against the region and the run budget, and
|
||||
//! overflow in offset/page arithmetic is a structured error, never a panic;
|
||||
//! * regions live for the whole run and are dropped with the store. There is
|
||||
//! no user-visible `free(region)`.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, MemoryHandle, RuntimeError};
|
||||
use num_bigint::BigInt;
|
||||
use num_traits::ToPrimitive;
|
||||
|
||||
/// Logical page size for every region.
|
||||
pub const PAGE_SIZE: usize = 64 * 1024;
|
||||
|
||||
/// Default maximum committed bytes across all regions in one run (64 MiB).
|
||||
pub const DEFAULT_MAX_TOTAL_BYTES: usize = 64 * 1024 * 1024;
|
||||
|
||||
/// Default maximum committed bytes for one region (16 MiB).
|
||||
pub const DEFAULT_MAX_REGION_BYTES: usize = 16 * 1024 * 1024;
|
||||
|
||||
static NEXT_RUN_ID: AtomicU64 = AtomicU64::new(1);
|
||||
|
||||
/// Bounds for addressable memory in one run.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct MemoryLimits {
|
||||
/// Maximum bytes committed across all live regions.
|
||||
pub max_total_bytes: usize,
|
||||
/// Maximum bytes committed by a single region (`max_pages` is further
|
||||
/// capped by this value).
|
||||
pub max_region_bytes: usize,
|
||||
}
|
||||
|
||||
impl Default for MemoryLimits {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
max_total_bytes: DEFAULT_MAX_TOTAL_BYTES,
|
||||
max_region_bytes: DEFAULT_MAX_REGION_BYTES,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MemoryLimits {
|
||||
/// Maximum page count a single region may declare or reach.
|
||||
pub fn max_region_pages(&self) -> u64 {
|
||||
(self.max_region_bytes / PAGE_SIZE) as u64
|
||||
}
|
||||
}
|
||||
|
||||
struct Region {
|
||||
bytes: Vec<u8>,
|
||||
/// Declared maximum size for this region.
|
||||
max_bytes: usize,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
/// All addressable regions created by one run.
|
||||
pub struct MemoryStore {
|
||||
run_id: u64,
|
||||
next_region: u64,
|
||||
regions: BTreeMap<u64, Region>,
|
||||
committed_bytes: usize,
|
||||
limits: MemoryLimits,
|
||||
}
|
||||
|
||||
impl MemoryStore {
|
||||
/// Create an empty store with a fresh, unguessable run identity.
|
||||
pub fn new(limits: MemoryLimits) -> Self {
|
||||
Self {
|
||||
run_id: NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed),
|
||||
next_region: 1,
|
||||
regions: BTreeMap::new(),
|
||||
committed_bytes: 0,
|
||||
limits,
|
||||
}
|
||||
}
|
||||
|
||||
/// Limits in force for this store.
|
||||
pub fn limits(&self) -> MemoryLimits {
|
||||
self.limits
|
||||
}
|
||||
|
||||
/// Bytes currently committed across all regions.
|
||||
pub fn committed_bytes(&self) -> usize {
|
||||
self.committed_bytes
|
||||
}
|
||||
|
||||
/// Number of live regions.
|
||||
pub fn region_count(&self) -> usize {
|
||||
self.regions.len()
|
||||
}
|
||||
|
||||
/// Create a zero-filled region.
|
||||
///
|
||||
/// `initial_pages` is committed immediately; `max_pages` is the declared
|
||||
/// capacity that `grow` may not exceed. Both are checked against the
|
||||
/// region and total budgets before anything is allocated, so a rejected
|
||||
/// create leaves the store unchanged.
|
||||
pub fn create(
|
||||
&mut self,
|
||||
initial_pages: u64,
|
||||
max_pages: u64,
|
||||
span: Option<Span>,
|
||||
) -> Result<MemoryHandle, RuntimeError> {
|
||||
if initial_pages > max_pages {
|
||||
return Err(memory_error(
|
||||
span,
|
||||
format!(
|
||||
"memory.new initial_pages ({initial_pages}) must not exceed max_pages \
|
||||
({max_pages})"
|
||||
),
|
||||
));
|
||||
}
|
||||
if max_pages > self.limits.max_region_pages() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.new max_pages ({max_pages}) exceeds the per-region limit of {} \
|
||||
pages ({PAGE_SIZE} bytes each)",
|
||||
self.limits.max_region_pages()
|
||||
),
|
||||
));
|
||||
}
|
||||
let max_bytes = checked_bytes(max_pages, span, "region capacity")?;
|
||||
if max_bytes > self.limits.max_region_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.new max_pages ({max_pages}) exceeds the per-region byte budget of {}",
|
||||
self.limits.max_region_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
let initial_bytes = checked_bytes(initial_pages, span, "initial region size")?;
|
||||
let committed = self
|
||||
.committed_bytes
|
||||
.checked_add(initial_bytes)
|
||||
.ok_or_else(|| budget_error(span, "memory budget overflow"))?;
|
||||
if committed > self.limits.max_total_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory budget exceeded: committing {initial_bytes} bytes would reach \
|
||||
{committed} of {}",
|
||||
self.limits.max_total_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
|
||||
let mut bytes = Vec::new();
|
||||
bytes.try_reserve_exact(initial_bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("cannot allocate {initial_bytes} bytes of addressable memory"),
|
||||
)
|
||||
})?;
|
||||
bytes.resize(initial_bytes, 0);
|
||||
|
||||
let region_id = self.next_region;
|
||||
self.next_region = self
|
||||
.next_region
|
||||
.checked_add(1)
|
||||
.ok_or_else(|| memory_error(span, "memory region identity space exhausted"))?;
|
||||
self.regions.insert(
|
||||
region_id,
|
||||
Region {
|
||||
bytes,
|
||||
max_bytes,
|
||||
generation: 1,
|
||||
},
|
||||
);
|
||||
self.committed_bytes = committed;
|
||||
Ok(MemoryHandle::from_runtime(self.run_id, region_id, 1))
|
||||
}
|
||||
|
||||
/// Current length of a region in pages.
|
||||
pub fn size(&self, handle: MemoryHandle, span: Option<Span>) -> Result<u64, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
Ok((region.bytes.len() / PAGE_SIZE) as u64)
|
||||
}
|
||||
|
||||
/// Grow a region by whole pages and return its previous page count.
|
||||
///
|
||||
/// A failed grow is atomic: the region keeps its old length and bytes and
|
||||
/// the committed budget is unchanged.
|
||||
pub fn grow(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
pages: u64,
|
||||
span: Option<Span>,
|
||||
) -> Result<u64, RuntimeError> {
|
||||
if pages == 0 {
|
||||
return self.size(handle, span);
|
||||
}
|
||||
let region = self.region(handle, span)?;
|
||||
let old_bytes = region.bytes.len();
|
||||
let old_pages = (old_bytes / PAGE_SIZE) as u64;
|
||||
let additional = checked_bytes(pages, span, "memory.grow pages")?;
|
||||
let new_bytes = old_bytes
|
||||
.checked_add(additional)
|
||||
.ok_or_else(|| memory_error(span, "memory.grow size overflows the address space"))?;
|
||||
if new_bytes > region.max_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.grow would grow the region to {new_bytes} bytes, beyond its \
|
||||
declared maximum of {} bytes",
|
||||
region.max_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
let committed = self
|
||||
.committed_bytes
|
||||
.checked_add(additional)
|
||||
.ok_or_else(|| budget_error(span, "memory budget overflow"))?;
|
||||
if committed > self.limits.max_total_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory budget exceeded: growing by {additional} bytes would reach \
|
||||
{committed} of {}",
|
||||
self.limits.max_total_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes.try_reserve(additional).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("cannot grow addressable memory by {additional} bytes"),
|
||||
)
|
||||
})?;
|
||||
region.bytes.resize(new_bytes, 0);
|
||||
self.committed_bytes = committed;
|
||||
Ok(old_pages)
|
||||
}
|
||||
|
||||
/// Total byte length of a region.
|
||||
pub fn byte_len(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
Ok(self.region(handle, span)?.bytes.len())
|
||||
}
|
||||
|
||||
/// Read a contiguous byte range. Used by resource I/O adapters.
|
||||
pub fn read_bytes(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
length: usize,
|
||||
span: Option<Span>,
|
||||
) -> Result<Vec<u8>, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
let start = range_offset(offset, region.bytes.len(), length, span)?;
|
||||
Ok(region.bytes[start..start + length].to_vec())
|
||||
}
|
||||
|
||||
/// Write a contiguous byte range atomically after a full bounds check.
|
||||
pub fn write_bytes(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
bytes: &[u8],
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let len = self.region(handle, span)?.bytes.len();
|
||||
let start = range_offset(offset, len, bytes.len(), span)?;
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes[start..start + bytes.len()].copy_from_slice(bytes);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Read one byte. Offsets are non-negative and region-relative.
|
||||
pub fn read(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
span: Option<Span>,
|
||||
) -> Result<u8, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
let position = checked_offset(offset, region.bytes.len(), span)?;
|
||||
Ok(region.bytes[position])
|
||||
}
|
||||
|
||||
/// Write one byte. The caller must have validated the byte range.
|
||||
pub fn write(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
byte: u8,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let len = self.region(handle, span)?.bytes.len();
|
||||
let position = checked_offset(offset, len, span)?;
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes[position] = byte;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn region(&self, handle: MemoryHandle, span: Option<Span>) -> Result<&Region, RuntimeError> {
|
||||
if handle.run_id() != self.run_id {
|
||||
return Err(memory_error(
|
||||
span,
|
||||
"Memory handle belongs to a different execution run",
|
||||
));
|
||||
}
|
||||
let Some(region) = self.regions.get(&handle.region_id()) else {
|
||||
return Err(memory_error(span, "unknown Memory region handle"));
|
||||
};
|
||||
if region.generation != handle.generation() {
|
||||
return Err(memory_error(span, "stale Memory region handle"));
|
||||
}
|
||||
Ok(region)
|
||||
}
|
||||
}
|
||||
|
||||
fn checked_bytes(pages: u64, span: Option<Span>, what: &str) -> Result<usize, RuntimeError> {
|
||||
let bytes = pages
|
||||
.checked_mul(PAGE_SIZE as u64)
|
||||
.ok_or_else(|| memory_error(span, format!("{what} overflows the address space")))?;
|
||||
usize::try_from(bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("{what} ({pages} pages) does not fit this platform's address space"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate an offset plus a byte count against the region length.
|
||||
fn range_offset(
|
||||
offset: &BigInt,
|
||||
len: usize,
|
||||
length: usize,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
if offset.sign() == num_bigint::Sign::Minus {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
"Memory offset must be a non-negative integer",
|
||||
));
|
||||
}
|
||||
let Some(start) = offset.to_usize() else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
};
|
||||
let end = start.checked_add(length).ok_or_else(|| {
|
||||
memory_error(
|
||||
span,
|
||||
"Memory offset plus length overflows the address space",
|
||||
)
|
||||
})?;
|
||||
if end > len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory range {start}..{end} is out of bounds for region length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(start)
|
||||
}
|
||||
|
||||
fn checked_offset(offset: &BigInt, len: usize, span: Option<Span>) -> Result<usize, RuntimeError> {
|
||||
if offset.sign() == num_bigint::Sign::Minus {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
"Memory offset must be a non-negative integer",
|
||||
));
|
||||
}
|
||||
let Some(position) = offset.to_usize() else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
};
|
||||
if position >= len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(position)
|
||||
}
|
||||
|
||||
fn memory_error(span: Option<Span>, message: impl Into<String>) -> RuntimeError {
|
||||
RuntimeError::new(ErrorCategory::MemoryFault, span, message)
|
||||
}
|
||||
|
||||
fn budget_error(span: Option<Span>, message: impl Into<String>) -> RuntimeError {
|
||||
RuntimeError::new(ErrorCategory::ResourceExhausted, span, message)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn int(value: impl Into<BigInt>) -> BigInt {
|
||||
value.into()
|
||||
}
|
||||
|
||||
fn store() -> MemoryStore {
|
||||
MemoryStore::new(MemoryLimits::default())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regions_are_isolated_and_handles_share_identity() {
|
||||
let mut store = store();
|
||||
let first = store.create(1, 2, None).unwrap();
|
||||
let second = store.create(1, 2, None).unwrap();
|
||||
let alias = first;
|
||||
store.write(first, &int(0), 7, None).unwrap();
|
||||
store.write(second, &int(0), 9, None).unwrap();
|
||||
assert_eq!(store.read(first, &int(0), None).unwrap(), 7);
|
||||
assert_eq!(store.read(alias, &int(0), None).unwrap(), 7);
|
||||
assert_eq!(store.read(second, &int(0), None).unwrap(), 9);
|
||||
assert_eq!(first, alias);
|
||||
assert_ne!(first, second);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_is_zero_filled_and_reports_pages() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 4, None).unwrap();
|
||||
assert_eq!(store.size(memory, None).unwrap(), 1);
|
||||
assert_eq!(PAGE_SIZE, 64 * 1024);
|
||||
for offset in [0usize, 1, PAGE_SIZE - 1] {
|
||||
assert_eq!(store.read(memory, &int(offset as u64), None).unwrap(), 0);
|
||||
}
|
||||
// Zero-page creation is legal but every access is out of bounds.
|
||||
let empty = store.create(0, 1, None).unwrap();
|
||||
assert_eq!(store.size(empty, None).unwrap(), 0);
|
||||
assert_eq!(
|
||||
store.read(empty, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn grow_keeps_old_bytes_and_zero_fills_new_pages() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 2, None).unwrap();
|
||||
store.write(memory, &int(3), 200, None).unwrap();
|
||||
assert_eq!(store.grow(memory, 1, None).unwrap(), 1);
|
||||
assert_eq!(store.size(memory, None).unwrap(), 2);
|
||||
assert_eq!(store.read(memory, &int(3), None).unwrap(), 200);
|
||||
assert_eq!(store.read(memory, &int(PAGE_SIZE as u64), None).unwrap(), 0);
|
||||
store
|
||||
.write(memory, &int(PAGE_SIZE as u64 + 5), 42, None)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
store
|
||||
.read(memory, &int(PAGE_SIZE as u64 + 5), None)
|
||||
.unwrap(),
|
||||
42
|
||||
);
|
||||
// Zero-page growth is a no-op returning the old count.
|
||||
assert_eq!(store.grow(memory, 0, None).unwrap(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_grow_does_not_change_region_or_budget() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: PAGE_SIZE * 2,
|
||||
max_region_bytes: PAGE_SIZE * 4,
|
||||
});
|
||||
let memory = store.create(1, 2, None).unwrap();
|
||||
store.write(memory, &int(0), 1, None).unwrap();
|
||||
let before = store.committed_bytes();
|
||||
let error = store.grow(memory, 2, None).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::ResourceExhausted);
|
||||
assert_eq!(store.size(memory, None).unwrap(), 1);
|
||||
assert_eq!(store.read(memory, &int(0), None).unwrap(), 1);
|
||||
assert_eq!(store.committed_bytes(), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_offsets_are_structured_errors() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 1, None).unwrap();
|
||||
for offset in [int(-1), int(PAGE_SIZE as u64)] {
|
||||
let error = store.read(memory, &offset, None).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::IndexOutOfBounds);
|
||||
}
|
||||
let huge: BigInt = "999999999999999999999999999999999999999".parse().unwrap();
|
||||
assert_eq!(
|
||||
store.read(memory, &huge, None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
assert_eq!(
|
||||
store.write(memory, &huge, 1, None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
assert_eq!(
|
||||
store
|
||||
.write(memory, &int(PAGE_SIZE as u64), 1, None)
|
||||
.unwrap_err()
|
||||
.category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_validates_page_counts_and_budget() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: PAGE_SIZE * 3,
|
||||
max_region_bytes: PAGE_SIZE * 2,
|
||||
});
|
||||
assert_eq!(
|
||||
store.create(2, 1, None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
assert_eq!(
|
||||
store.create(1, 3, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
let _first = store.create(2, 2, None).unwrap();
|
||||
let _second = store.create(1, 1, None).unwrap();
|
||||
// Total budget is now exactly three pages.
|
||||
assert_eq!(
|
||||
store.create(1, 1, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
assert_eq!(store.committed_bytes(), PAGE_SIZE * 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forged_and_stale_handles_are_rejected() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 1, None).unwrap();
|
||||
let forged = MemoryHandle::from_runtime(memory.run_id() + 1, memory.region_id(), 1);
|
||||
assert_eq!(
|
||||
store.read(forged, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
let stale = MemoryHandle::from_runtime(memory.run_id(), memory.region_id(), 2);
|
||||
assert_eq!(
|
||||
store.read(stale, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
let unknown = MemoryHandle::from_runtime(memory.run_id(), 999, 1);
|
||||
assert_eq!(
|
||||
store.write(unknown, &int(0), 1, None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_arithmetic_never_overflows() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: usize::MAX,
|
||||
max_region_bytes: usize::MAX,
|
||||
});
|
||||
assert_eq!(
|
||||
store.create(u64::MAX, u64::MAX, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -107,6 +107,32 @@ fn compare(
|
||||
}
|
||||
}))
|
||||
}
|
||||
(Value::Resource(a), Value::Resource(b)) => {
|
||||
return Ok(Value::Bool(match op {
|
||||
BinaryOp::Eq => a == b,
|
||||
BinaryOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(type_error(
|
||||
span,
|
||||
"Resource ordering comparisons are not supported".to_string(),
|
||||
))
|
||||
}
|
||||
}));
|
||||
}
|
||||
(Value::Memory(a), Value::Memory(b)) => {
|
||||
// Identity, not byte content: two handles for the same region are
|
||||
// equal, regions with identical bytes are not (ADR-0022 §1).
|
||||
return Ok(Value::Bool(match op {
|
||||
BinaryOp::Eq => a == b,
|
||||
BinaryOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(type_error(
|
||||
span,
|
||||
"Memory ordering comparisons are not supported".to_string(),
|
||||
))
|
||||
}
|
||||
}));
|
||||
}
|
||||
(a, b) => {
|
||||
if op == BinaryOp::Eq {
|
||||
return Ok(Value::Bool(false));
|
||||
|
||||
Reference in new issue
Block a user