Compare commits
27
Commits
e0e01ed1de
...
master
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a32f834b2b
|
||
|
|
f1adf86dd5
|
||
|
|
2d5735cb13
|
||
|
|
dccf4d0775
|
||
|
|
c3589be1ad
|
||
|
|
49d7fca0b7
|
||
|
|
c649e02816
|
||
|
|
09d8778f04
|
||
|
|
1aa939eca8 | ||
|
|
a4bec5bc45
|
||
|
|
dcf6561ea7
|
||
|
|
69ad1931de
|
||
|
|
57992cf214
|
||
|
|
d9b9eeb171
|
||
|
|
f7d7c16753
|
||
|
|
07b69314b1 | ||
|
|
4669ced98e
|
||
|
|
a2275932a5
|
||
|
|
39468740c3
|
||
|
|
3f9d235546
|
||
|
|
bb6f212779
|
||
|
|
418e574ac8
|
||
|
|
461b554c1a
|
||
|
|
46bbad19c2
|
||
|
|
e09f1197bc
|
||
|
|
ff73f8ad39
|
||
|
|
bad942fb25
|
@@ -13,17 +13,27 @@ jobs:
|
|||||||
with:
|
with:
|
||||||
submodules: recursive
|
submodules: recursive
|
||||||
|
|
||||||
- uses: dtolnay/rust-toolchain@stable
|
- name: Install repository Rust toolchain
|
||||||
with:
|
run: |
|
||||||
components: rustfmt, clippy
|
toolchain=$(python3 -c 'import tomllib; print(tomllib.load(open("rust-toolchain.toml", "rb"))["toolchain"]["channel"])')
|
||||||
|
rustup toolchain install "$toolchain" --profile minimal
|
||||||
|
|
||||||
- uses: Swatinem/rust-cache@v2
|
- uses: Swatinem/rust-cache@v2
|
||||||
|
|
||||||
- name: Format check
|
- name: Discard reports from previous runs
|
||||||
run: cargo fmt -- --check
|
run: rm -rf target/llvm-cov
|
||||||
|
|
||||||
- name: Clippy
|
- name: Provision quality-gate tools and native dependencies
|
||||||
run: cargo clippy --workspace --all-features
|
run: bash scripts/provision-quality-gate.sh
|
||||||
|
|
||||||
- name: Test
|
- name: Repository quality gate
|
||||||
run: cargo test --workspace --all-targets --all-features --no-fail-fast
|
run: make ci-domains
|
||||||
|
|
||||||
|
- name: Publish gate evidence (including failures)
|
||||||
|
if: always()
|
||||||
|
uses: actions/upload-artifact@v4
|
||||||
|
with:
|
||||||
|
name: quality-gate-${{ runner.os }}-${{ github.sha }}
|
||||||
|
path: |
|
||||||
|
target/llvm-cov/**
|
||||||
|
if-no-files-found: warn
|
||||||
|
|||||||
@@ -66,7 +66,3 @@ AGENTS.md
|
|||||||
|
|
||||||
.python-version
|
.python-version
|
||||||
.venv
|
.venv
|
||||||
|
|
||||||
discussion/*
|
|
||||||
!discussion/lessons/
|
|
||||||
!discussion/lessons/**
|
|
||||||
|
|||||||
@@ -1,25 +1,32 @@
|
|||||||
.PHONY: fmt fmt-check clippy test-local test-debugger-socket clean coverage coverage-xml coverage-json coverage-report-json coverage-domain-list coverage-domain-evidence coverage-domain-audit coverage-domain-gate test ci ci-domains cobertura
|
.PHONY: fmt fmt-check clippy test-unit test-local test-integration test-debugger-socket clean coverage coverage-xml coverage-json coverage-report-json coverage-domain-list coverage-domain-evidence coverage-domain-audit coverage-domain-gate test ci ci-domains cobertura
|
||||||
|
|
||||||
fmt:
|
fmt:
|
||||||
cargo fmt
|
cargo fmt --all
|
||||||
|
|
||||||
fmt-check:
|
fmt-check:
|
||||||
cargo fmt -- --check
|
cargo fmt --all -- --check
|
||||||
|
|
||||||
clippy:
|
clippy:
|
||||||
cargo clippy --workspace --all-features
|
cargo clippy --workspace --all-targets --all-features -- -D warnings
|
||||||
|
|
||||||
test-local:
|
test-unit:
|
||||||
cargo test --workspace --all-targets --all-features --no-fail-fast
|
cargo test --workspace --lib --bins --all-features --no-fail-fast
|
||||||
|
|
||||||
|
# Compatibility entry point: repository-local verification is unit-only.
|
||||||
|
test-local: test-unit
|
||||||
|
|
||||||
|
# Explicit opt-in, orchestrated by ../tooling; test sources stay in this repository.
|
||||||
|
test-integration:
|
||||||
|
cargo test --workspace --tests --all-features --no-fail-fast
|
||||||
|
|
||||||
test-debugger-socket:
|
test-debugger-socket:
|
||||||
cargo test -p prometeu-host-desktop-winit --lib -- --ignored
|
cargo test -p prometeu-host-desktop-winit --lib runner::tests -- --ignored
|
||||||
|
|
||||||
clean:
|
clean:
|
||||||
cargo llvm-cov clean --workspace
|
cargo llvm-cov clean --workspace
|
||||||
|
|
||||||
coverage:
|
coverage:
|
||||||
cargo llvm-cov --workspace --all-features --html --output-dir target/llvm-cov
|
cargo llvm-cov --workspace --lib --bins --all-features --html --output-dir target/llvm-cov
|
||||||
|
|
||||||
coverage-report-json:
|
coverage-report-json:
|
||||||
cargo llvm-cov report --json --output-path target/llvm-cov/report.json
|
cargo llvm-cov report --json --output-path target/llvm-cov/report.json
|
||||||
@@ -46,7 +53,13 @@ coverage-domain-evidence:
|
|||||||
coverage-domain-gate:
|
coverage-domain-gate:
|
||||||
./scripts/coverage-domain-evidence.sh --check-all
|
./scripts/coverage-domain-evidence.sh --check-all
|
||||||
|
|
||||||
test: fmt-check clippy test-local test-debugger-socket
|
test: fmt-check clippy test-unit
|
||||||
ci: clean fmt-check clippy coverage coverage-report-json
|
# Local and GitHub entry point; Jenkins exposes the same targets as stages.
|
||||||
ci-domains: clean fmt-check clippy coverage coverage-report-json coverage-xml coverage-json coverage-domain-gate
|
CI_DOMAIN_STEPS = clean fmt-check clippy test-unit coverage coverage-report-json coverage-xml coverage-json coverage-domain-audit coverage-domain-gate
|
||||||
|
|
||||||
|
ci: ci-domains
|
||||||
|
ci-domains:
|
||||||
|
rm -rf target/llvm-cov
|
||||||
|
+@set -e; for step in $(CI_DOMAIN_STEPS); do $(MAKE) --no-print-directory -j1 $$step; done
|
||||||
|
|
||||||
cobertura: coverage-xml coverage-json
|
cobertura: coverage-xml coverage-json
|
||||||
|
|||||||
@@ -1,14 +1,14 @@
|
|||||||
# PROMETEU Runtime
|
# PROMETEU Runtime
|
||||||
|
|
||||||
PROMETEU is an educational and experimental fantasy handheld / fantasy console.
|
PROMETEU is an educational and experimental fantasy handheld / fantasy console.
|
||||||
This repository contains the Rust runtime workspace for the machine: VM-facing components, virtual peripherals, firmware/system services, host integration, CLI entrypoints, development utilities, specs, and discussion artifacts.
|
This repository contains the Rust runtime workspace for the machine: VM-facing components, virtual peripherals, firmware/system services, host integration, CLI entrypoints, development utilities, specs, and engineering lessons.
|
||||||
|
|
||||||
The VM is only one subsystem of the machine. The canonical docs in this repository intentionally distinguish:
|
The VM is only one subsystem of the machine. The canonical docs in this repository intentionally distinguish:
|
||||||
|
|
||||||
- machine-level specs;
|
- machine-level specs;
|
||||||
- VM/runtime internal architecture;
|
- VM/runtime internal architecture;
|
||||||
- implementation crates;
|
- implementation crates;
|
||||||
- discussion workflow and lessons learned.
|
- engineering lessons learned.
|
||||||
|
|
||||||
## What This Repository Contains
|
## What This Repository Contains
|
||||||
|
|
||||||
@@ -19,7 +19,7 @@ The VM is only one subsystem of the machine. The canonical docs in this reposito
|
|||||||
- `docs/specs/runtime/`: canonical PROMETEU machine specs
|
- `docs/specs/runtime/`: canonical PROMETEU machine specs
|
||||||
- `docs/vm-arch/`: canonical VM/runtime architecture and ISA references
|
- `docs/vm-arch/`: canonical VM/runtime architecture and ISA references
|
||||||
- `devtools/`: debugger protocol material
|
- `devtools/`: debugger protocol material
|
||||||
- `discussion/`: agendas, decisions, plans, and lessons for architectural work
|
- `discussion/lessons/`: published engineering lessons and supporting assets
|
||||||
- `test-cartridges/`: cartridge fixtures used for validation and manual runs
|
- `test-cartridges/`: cartridge fixtures used for validation and manual runs
|
||||||
|
|
||||||
## Canonical Documentation
|
## Canonical Documentation
|
||||||
@@ -29,7 +29,11 @@ Use these entrypoints instead of inferring the model from isolated source files:
|
|||||||
- [Machine specs](docs/specs/runtime/README.md): authoritative contract for the PROMETEU machine, peripherals, firmware, cartridge format, timing, and host ABI
|
- [Machine specs](docs/specs/runtime/README.md): authoritative contract for the PROMETEU machine, peripherals, firmware, cartridge format, timing, and host ABI
|
||||||
- [VM architecture](docs/vm-arch/ARCHITECTURE.md): authoritative internal architecture for VM/runtime invariants
|
- [VM architecture](docs/vm-arch/ARCHITECTURE.md): authoritative internal architecture for VM/runtime invariants
|
||||||
- [ISA reference](docs/vm-arch/ISA_CORE.md): bytecode-level instruction set authority
|
- [ISA reference](docs/vm-arch/ISA_CORE.md): bytecode-level instruction set authority
|
||||||
- [Discussion workflow](discussion/index.ndjson): architectural agenda, decision, and execution traceability
|
- [Engineering lessons](discussion/lessons/): published results and rationale
|
||||||
|
|
||||||
|
Engineering discussions, decisions, plans and execution evidence are maintained in
|
||||||
|
the enclosing [Prometeu Engineering workspace](../README.md) using
|
||||||
|
[AI Engineering](../.ai-engineering/README.md).
|
||||||
|
|
||||||
## Workspace Layout
|
## Workspace Layout
|
||||||
|
|
||||||
@@ -60,11 +64,21 @@ Other ecosystem commands, such as build, pack, and verification tooling, are not
|
|||||||
|
|
||||||
## Requirements
|
## Requirements
|
||||||
|
|
||||||
- Rust toolchain from [rust-toolchain.toml](rust-toolchain.toml)
|
- Rust **1.98.1**, pinned in [rust-toolchain.toml](rust-toolchain.toml)
|
||||||
- `rustup` for toolchain installation and management
|
- `rustup` for toolchain installation and management
|
||||||
- `cargo-llvm-cov` for coverage targets such as `make coverage` and `make ci-domains`
|
- `cargo-llvm-cov` for coverage targets such as `make coverage` and `make ci-domains`
|
||||||
- a local graphical environment for desktop runtime commands
|
- a local graphical environment for desktop runtime commands
|
||||||
|
|
||||||
|
From the repository root, install and verify the pinned toolchain:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
rustup toolchain install 1.98.1 --profile minimal --component rustfmt,clippy
|
||||||
|
rustc --version
|
||||||
|
```
|
||||||
|
|
||||||
|
Rustup selects the pinned version automatically for commands run in this repository.
|
||||||
|
CI installs the toolchain from the same file.
|
||||||
|
|
||||||
## Quick Start
|
## Quick Start
|
||||||
|
|
||||||
Build the workspace:
|
Build the workspace:
|
||||||
@@ -107,19 +121,26 @@ Format, lint, and test the workspace:
|
|||||||
make test
|
make test
|
||||||
```
|
```
|
||||||
|
|
||||||
Run the CI-oriented non-domain gate:
|
Run the shared strict CI gate (`make ci` is an alias):
|
||||||
|
|
||||||
```bash
|
```bash
|
||||||
make ci
|
make ci
|
||||||
```
|
```
|
||||||
|
|
||||||
Run the CI-oriented domain coverage gate:
|
The authoritative target used by both GitHub and Jenkins is:
|
||||||
|
|
||||||
```bash
|
```bash
|
||||||
make ci-domains
|
make ci-domains
|
||||||
```
|
```
|
||||||
|
|
||||||
The debugger socket tests bind localhost sockets and are marked ignored in Rust test metadata; `make test` includes them through the dedicated `test-debugger-socket` target.
|
`make test-unit` selects library and binary unit-test harnesses with
|
||||||
|
`--lib --bins --all-features`; `test-local` remains an alias. Both `make test`
|
||||||
|
and `make ci-domains` run only this suite. Integration targets under `tests/`,
|
||||||
|
installed-process qualification and the five ignored debugger socket tests are
|
||||||
|
excluded from the pipeline. They remain available explicitly through
|
||||||
|
`make test-integration` and `make test-debugger-socket`, orchestrated by
|
||||||
|
`../tooling`. Tests and fixtures stay in this repository. Physical audio and manual probes remain opt-in. See
|
||||||
|
[quality-gate prerequisites and commands](docs/vm-arch/COVERAGE_DOMAINS.md#commands-and-ci).
|
||||||
|
|
||||||
## Coverage Governance
|
## Coverage Governance
|
||||||
|
|
||||||
@@ -128,20 +149,14 @@ The repository uses a two-layer runtime-edge coverage model:
|
|||||||
- a mandatory CI gate based on canonical runtime-edge domains;
|
- a mandatory CI gate based on canonical runtime-edge domains;
|
||||||
- domain-oriented review evidence for the canonical runtime-edge domains.
|
- domain-oriented review evidence for the canonical runtime-edge domains.
|
||||||
|
|
||||||
Current canonical domains:
|
The fifteen canonical domains and fixed floors are defined in
|
||||||
|
[the repository configuration](files/config/runtime-edge-coverage-domains.json).
|
||||||
- `system/runtime`
|
Use `make coverage-domain-list` or the [ownership documentation](docs/vm-arch/COVERAGE_DOMAINS.md)
|
||||||
- `fs`
|
to inspect the current map.
|
||||||
- `asset/bank`
|
|
||||||
- `firmware`
|
|
||||||
- `host-dependent`
|
|
||||||
- `host/headless`
|
|
||||||
|
|
||||||
Global coverage artifacts:
|
Global coverage artifacts:
|
||||||
|
|
||||||
```bash
|
```bash
|
||||||
make ci
|
|
||||||
make cobertura
|
|
||||||
make ci-domains
|
make ci-domains
|
||||||
```
|
```
|
||||||
|
|
||||||
@@ -161,12 +176,12 @@ make coverage-domain-evidence DOMAIN=host-dependent
|
|||||||
make coverage-domain-evidence DOMAIN=host/headless
|
make coverage-domain-evidence DOMAIN=host/headless
|
||||||
```
|
```
|
||||||
|
|
||||||
Per-domain baselines currently start around `60`.
|
`make ci-domains` runs formatting, strict workspace/all-target/all-feature Clippy,
|
||||||
That does not waive test obligations. It means the project is adopting explicit domain evidence immediately while tightening quantitative expectations incrementally over time.
|
library/binary unit tests, fresh unit-only coverage and every domain
|
||||||
|
ownership/evidence gate. Both CI providers archive available evidence on failure.
|
||||||
`make ci-domains` is the CI entrypoint used by Jenkins.
|
A failing run never lowers a configured floor; local and CI checks use the same
|
||||||
It runs the standard coverage pipeline, produces the HTML/XML/JSON artifacts, and fails when any canonical domain falls below its configured `baseline_percent`.
|
repository-owned commands. Reports identify their revision, source/configuration
|
||||||
The CI gate currently compares domain `lines` coverage against each domain baseline.
|
and actual execution platform.
|
||||||
|
|
||||||
When a PR changes the observable contract of a canonical domain, it is expected to:
|
When a PR changes the observable contract of a canonical domain, it is expected to:
|
||||||
|
|
||||||
@@ -179,7 +194,7 @@ Improving the global percentage alone is not sufficient review evidence when the
|
|||||||
|
|
||||||
The project is still in active architectural and implementation convergence.
|
The project is still in active architectural and implementation convergence.
|
||||||
|
|
||||||
- the machine contract is being clarified through the specs and discussion workflow;
|
- the machine contract is being clarified through the specs and AI Engineering;
|
||||||
- the workspace already contains concrete runtime and host code;
|
- the workspace already contains concrete runtime and host code;
|
||||||
- the CLI dispatcher currently exposes the runtime paths that are backed by binaries in this workspace.
|
- the CLI dispatcher currently exposes the runtime paths that are backed by binaries in this workspace.
|
||||||
|
|
||||||
|
|||||||
@@ -179,7 +179,7 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
|||||||
emit_u16(CoreOpCode::Ret as u16, &mut out);
|
emit_u16(CoreOpCode::Ret as u16, &mut out);
|
||||||
}
|
}
|
||||||
"YIELD" | "SLEEP" | "SPAWN" => {
|
"YIELD" | "SLEEP" | "SPAWN" => {
|
||||||
return Err(AsmError::InvalidOperand("retired coroutine instruction".into()))
|
return Err(AsmError::InvalidOperand("retired coroutine instruction".into()));
|
||||||
}
|
}
|
||||||
"FRAME_SYNC" => {
|
"FRAME_SYNC" => {
|
||||||
emit_u16(CoreOpCode::FrameSync as u16, &mut out);
|
emit_u16(CoreOpCode::FrameSync as u16, &mut out);
|
||||||
@@ -345,7 +345,7 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
|||||||
emit_u32(ty, &mut out);
|
emit_u32(ty, &mut out);
|
||||||
emit_u32(field, &mut out);
|
emit_u32(field, &mut out);
|
||||||
}
|
}
|
||||||
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" => {
|
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" | "ARRAY_COPY" => {
|
||||||
if ops.is_empty() {
|
if ops.is_empty() {
|
||||||
return Err(AsmError::MissingOperand(line.into()));
|
return Err(AsmError::MissingOperand(line.into()));
|
||||||
}
|
}
|
||||||
@@ -354,23 +354,32 @@ pub fn assemble(src: &str) -> Result<Vec<u8>, AsmError> {
|
|||||||
"ARRAY_NEW" => CoreOpCode::ArrayNew,
|
"ARRAY_NEW" => CoreOpCode::ArrayNew,
|
||||||
"ARRAY_LEN" => CoreOpCode::ArrayLen,
|
"ARRAY_LEN" => CoreOpCode::ArrayLen,
|
||||||
"ARRAY_GET" => CoreOpCode::ArrayGet,
|
"ARRAY_GET" => CoreOpCode::ArrayGet,
|
||||||
|
"ARRAY_COPY" => CoreOpCode::ArrayCopy,
|
||||||
_ => CoreOpCode::ArraySet,
|
_ => CoreOpCode::ArraySet,
|
||||||
};
|
};
|
||||||
emit_u16(op as u16, &mut out);
|
emit_u16(op as u16, &mut out);
|
||||||
emit_u32(parse_u32_any(ops)?, &mut out);
|
emit_u32(parse_u32_any(ops)?, &mut out);
|
||||||
}
|
}
|
||||||
"DYN_PACK" | "DYN_UNPACK" | "DYN_CAN_UNPACK" => {
|
"DYN_PACK" | "DYN_UNPACK" | "DYN_CAN_UNPACK" | "REF_IDENTITY_HASH" => {
|
||||||
if ops.is_empty() {
|
if ops.is_empty() {
|
||||||
return Err(AsmError::MissingOperand(line.into()));
|
return Err(AsmError::MissingOperand(line.into()));
|
||||||
}
|
}
|
||||||
let opcode = match mn {
|
let opcode = match mn {
|
||||||
"DYN_PACK" => CoreOpCode::DynPack,
|
"DYN_PACK" => CoreOpCode::DynPack,
|
||||||
"DYN_UNPACK" => CoreOpCode::DynUnpack,
|
"DYN_UNPACK" => CoreOpCode::DynUnpack,
|
||||||
|
"REF_IDENTITY_HASH" => CoreOpCode::RefIdentityHash,
|
||||||
_ => CoreOpCode::DynCanUnpack,
|
_ => CoreOpCode::DynCanUnpack,
|
||||||
};
|
};
|
||||||
emit_u16(opcode as u16, &mut out);
|
emit_u16(opcode as u16, &mut out);
|
||||||
emit_u32(parse_u32_any(ops)?, &mut out);
|
emit_u32(parse_u32_any(ops)?, &mut out);
|
||||||
}
|
}
|
||||||
|
"REF_IDENTITY_EQ" => {
|
||||||
|
let (a, b) = parse_keyvals(ops)?;
|
||||||
|
let (left, right) = parse_pair(a, "left", b, "right")?;
|
||||||
|
emit_u16(CoreOpCode::RefIdentityEq as u16, &mut out);
|
||||||
|
emit_u32(left, &mut out);
|
||||||
|
emit_u32(right, &mut out);
|
||||||
|
}
|
||||||
"REF_IS_EXACT" | "REF_IMPLEMENTS" | "REF_TO_TRAIT" | "REF_CAST" => {
|
"REF_IS_EXACT" | "REF_IMPLEMENTS" | "REF_TO_TRAIT" | "REF_CAST" => {
|
||||||
if ops.is_empty() {
|
if ops.is_empty() {
|
||||||
return Err(AsmError::MissingOperand(line.into()));
|
return Err(AsmError::MissingOperand(line.into()));
|
||||||
|
|||||||
@@ -65,12 +65,14 @@ fn format_operand(op: CoreOpCode, imm: &[u8]) -> String {
|
|||||||
| CoreOpCode::Hostcall
|
| CoreOpCode::Hostcall
|
||||||
| CoreOpCode::DynPack
|
| CoreOpCode::DynPack
|
||||||
| CoreOpCode::DynUnpack
|
| CoreOpCode::DynUnpack
|
||||||
|
| CoreOpCode::RefIdentityHash
|
||||||
| CoreOpCode::DynCanUnpack
|
| CoreOpCode::DynCanUnpack
|
||||||
| CoreOpCode::StructNew
|
| CoreOpCode::StructNew
|
||||||
| CoreOpCode::ArrayNew
|
| CoreOpCode::ArrayNew
|
||||||
| CoreOpCode::ArrayLen
|
| CoreOpCode::ArrayLen
|
||||||
| CoreOpCode::ArrayGet
|
| CoreOpCode::ArrayGet
|
||||||
| CoreOpCode::ArraySet => {
|
| CoreOpCode::ArraySet
|
||||||
|
| CoreOpCode::ArrayCopy => {
|
||||||
let v = u32::from_le_bytes(imm.try_into().unwrap());
|
let v = u32::from_le_bytes(imm.try_into().unwrap());
|
||||||
format!("{}", v)
|
format!("{}", v)
|
||||||
}
|
}
|
||||||
@@ -79,6 +81,11 @@ fn format_operand(op: CoreOpCode, imm: &[u8]) -> String {
|
|||||||
let field = u32::from_le_bytes(imm[4..].try_into().unwrap());
|
let field = u32::from_le_bytes(imm[4..].try_into().unwrap());
|
||||||
format!("type={}, field={}", ty, field)
|
format!("type={}, field={}", ty, field)
|
||||||
}
|
}
|
||||||
|
CoreOpCode::RefIdentityEq => {
|
||||||
|
let left = u32::from_le_bytes(imm[..4].try_into().unwrap());
|
||||||
|
let right = u32::from_le_bytes(imm[4..].try_into().unwrap());
|
||||||
|
format!("left={}, right={}", left, right)
|
||||||
|
}
|
||||||
CoreOpCode::RefIsExact
|
CoreOpCode::RefIsExact
|
||||||
| CoreOpCode::RefImplements
|
| CoreOpCode::RefImplements
|
||||||
| CoreOpCode::RefToTrait
|
| CoreOpCode::RefToTrait
|
||||||
|
|||||||
@@ -1,4 +1,4 @@
|
|||||||
//! Shared PBX v1 resource limits and structured validation failures.
|
//! Shared PBX v0 resource limits and structured validation failures.
|
||||||
//! Counters are deterministic; a failed reservation never changes usage.
|
//! Counters are deterministic; a failed reservation never changes usage.
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
use std::fmt;
|
use std::fmt;
|
||||||
|
|||||||
@@ -192,6 +192,10 @@ pub enum OpCode {
|
|||||||
RefToTrait = 0x95,
|
RefToTrait = 0x95,
|
||||||
/// REF_CAST: source:TypeId, target:TypeId; requires validated Registry metadata.
|
/// REF_CAST: source:TypeId, target:TypeId; requires validated Registry metadata.
|
||||||
RefCast = 0x96,
|
RefCast = 0x96,
|
||||||
|
/// Query a complete typed reference identity; source TypeId.
|
||||||
|
RefIdentityHash = 0x97,
|
||||||
|
/// Compare two complete typed references; left/right TypeIds.
|
||||||
|
RefIdentityEq = 0x98,
|
||||||
|
|
||||||
// Registry-backed collection operations. cycles() is their base component.
|
// Registry-backed collection operations. cycles() is their base component.
|
||||||
StructNew = 0xA0,
|
StructNew = 0xA0,
|
||||||
@@ -201,6 +205,8 @@ pub enum OpCode {
|
|||||||
ArrayLen = 0xA4,
|
ArrayLen = 0xA4,
|
||||||
ArrayGet = 0xA5,
|
ArrayGet = 0xA5,
|
||||||
ArraySet = 0xA6,
|
ArraySet = 0xA6,
|
||||||
|
/// Complete stored groups, overlap-safe; Array TypeId:u32.
|
||||||
|
ArrayCopy = 0xA9,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl TryFrom<u16> for OpCode {
|
impl TryFrom<u16> for OpCode {
|
||||||
@@ -267,6 +273,8 @@ impl TryFrom<u16> for OpCode {
|
|||||||
0x94 => Ok(OpCode::RefImplements),
|
0x94 => Ok(OpCode::RefImplements),
|
||||||
0x95 => Ok(OpCode::RefToTrait),
|
0x95 => Ok(OpCode::RefToTrait),
|
||||||
0x96 => Ok(OpCode::RefCast),
|
0x96 => Ok(OpCode::RefCast),
|
||||||
|
0x97 => Ok(OpCode::RefIdentityHash),
|
||||||
|
0x98 => Ok(OpCode::RefIdentityEq),
|
||||||
0xA0 => Ok(OpCode::StructNew),
|
0xA0 => Ok(OpCode::StructNew),
|
||||||
0xA1 => Ok(OpCode::StructGet),
|
0xA1 => Ok(OpCode::StructGet),
|
||||||
0xA2 => Ok(OpCode::StructSet),
|
0xA2 => Ok(OpCode::StructSet),
|
||||||
@@ -274,6 +282,7 @@ impl TryFrom<u16> for OpCode {
|
|||||||
0xA4 => Ok(OpCode::ArrayLen),
|
0xA4 => Ok(OpCode::ArrayLen),
|
||||||
0xA5 => Ok(OpCode::ArrayGet),
|
0xA5 => Ok(OpCode::ArrayGet),
|
||||||
0xA6 => Ok(OpCode::ArraySet),
|
0xA6 => Ok(OpCode::ArraySet),
|
||||||
|
0xA9 => Ok(OpCode::ArrayCopy),
|
||||||
|
|
||||||
_ => Err(format!("Invalid OpCode: 0x{:04X}", value)),
|
_ => Err(format!("Invalid OpCode: 0x{:04X}", value)),
|
||||||
}
|
}
|
||||||
@@ -344,6 +353,8 @@ impl OpCode {
|
|||||||
OpCode::RefImplements => 4,
|
OpCode::RefImplements => 4,
|
||||||
OpCode::RefToTrait => 5,
|
OpCode::RefToTrait => 5,
|
||||||
OpCode::RefCast => 4,
|
OpCode::RefCast => 4,
|
||||||
|
OpCode::RefIdentityHash => 8,
|
||||||
|
OpCode::RefIdentityEq => 4,
|
||||||
OpCode::StructNew => 8,
|
OpCode::StructNew => 8,
|
||||||
OpCode::StructGet => 3,
|
OpCode::StructGet => 3,
|
||||||
OpCode::StructSet => 4,
|
OpCode::StructSet => 4,
|
||||||
@@ -351,6 +362,7 @@ impl OpCode {
|
|||||||
OpCode::ArrayLen => 3,
|
OpCode::ArrayLen => 3,
|
||||||
OpCode::ArrayGet => 3,
|
OpCode::ArrayGet => 3,
|
||||||
OpCode::ArraySet => 4,
|
OpCode::ArraySet => 4,
|
||||||
|
OpCode::ArrayCopy => 4,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -596,6 +596,26 @@ impl OpCodeSpecExt for OpCode {
|
|||||||
may_trap: true,
|
may_trap: true,
|
||||||
is_safepoint: false,
|
is_safepoint: false,
|
||||||
},
|
},
|
||||||
|
OpCode::RefIdentityHash => OpcodeSpec {
|
||||||
|
name: "REF_IDENTITY_HASH",
|
||||||
|
imm_bytes: 4,
|
||||||
|
pops: None,
|
||||||
|
pushes: None,
|
||||||
|
is_branch: false,
|
||||||
|
is_terminator: false,
|
||||||
|
may_trap: true,
|
||||||
|
is_safepoint: false,
|
||||||
|
},
|
||||||
|
OpCode::RefIdentityEq => OpcodeSpec {
|
||||||
|
name: "REF_IDENTITY_EQ",
|
||||||
|
imm_bytes: 8,
|
||||||
|
pops: None,
|
||||||
|
pushes: None,
|
||||||
|
is_branch: false,
|
||||||
|
is_terminator: false,
|
||||||
|
may_trap: true,
|
||||||
|
is_safepoint: false,
|
||||||
|
},
|
||||||
OpCode::StructNew => OpcodeSpec {
|
OpCode::StructNew => OpcodeSpec {
|
||||||
name: "STRUCT_NEW",
|
name: "STRUCT_NEW",
|
||||||
imm_bytes: 4,
|
imm_bytes: 4,
|
||||||
@@ -666,6 +686,16 @@ impl OpCodeSpecExt for OpCode {
|
|||||||
may_trap: true,
|
may_trap: true,
|
||||||
is_safepoint: false,
|
is_safepoint: false,
|
||||||
},
|
},
|
||||||
|
OpCode::ArrayCopy => OpcodeSpec {
|
||||||
|
name: "ARRAY_COPY",
|
||||||
|
imm_bytes: 4,
|
||||||
|
pops: None,
|
||||||
|
pushes: None,
|
||||||
|
is_branch: false,
|
||||||
|
is_terminator: false,
|
||||||
|
may_trap: true,
|
||||||
|
is_safepoint: false,
|
||||||
|
},
|
||||||
OpCode::FrameSync => OpcodeSpec {
|
OpCode::FrameSync => OpcodeSpec {
|
||||||
name: "FRAME_SYNC",
|
name: "FRAME_SYNC",
|
||||||
imm_bytes: 0,
|
imm_bytes: 0,
|
||||||
|
|||||||
@@ -52,6 +52,19 @@ pub enum TypeKind {
|
|||||||
Trait(Vec<MethodDecl>),
|
Trait(Vec<MethodDecl>),
|
||||||
Fn(Signature),
|
Fn(Signature),
|
||||||
}
|
}
|
||||||
|
impl TypeKind {
|
||||||
|
/// Categories supported by identity queries, not by legacy REF_* conversions.
|
||||||
|
pub fn is_identity_reference(&self) -> bool {
|
||||||
|
matches!(
|
||||||
|
self,
|
||||||
|
Self::Struct(_)
|
||||||
|
| Self::Array(_)
|
||||||
|
| Self::Fn(_)
|
||||||
|
| Self::Trait(_)
|
||||||
|
| Self::Builtin(BuiltinId::RANDOM)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
pub struct TypeDecl {
|
pub struct TypeDecl {
|
||||||
pub name: Option<String>,
|
pub name: Option<String>,
|
||||||
|
|||||||
@@ -1,4 +1,4 @@
|
|||||||
//! Strict PBX v1 envelope and Registry sections. No legacy fallback.
|
//! Strict PBX v0 envelope and Registry sections. No legacy fallback.
|
||||||
//! Envelope parsing is structural only: non-Registry sections and instructions
|
//! Envelope parsing is structural only: non-Registry sections and instructions
|
||||||
//! must be validated by their consumers before an executable image is published.
|
//! must be validated by their consumers before an executable image is published.
|
||||||
use crate::load_limits::{
|
use crate::load_limits::{
|
||||||
@@ -32,7 +32,7 @@ impl<'a> PbxEnvelope<'a> {
|
|||||||
if &bytes[..4] != b"PBX\0" {
|
if &bytes[..4] != b"PBX\0" {
|
||||||
return Err(E::new(C::InvalidFormat, R::Magic));
|
return Err(E::new(C::InvalidFormat, R::Magic));
|
||||||
}
|
}
|
||||||
if bytes[4..6] != [1, 0] {
|
if bytes[4..6] != [0, 0] {
|
||||||
return Err(E::new(C::UnsupportedFormat, R::Version));
|
return Err(E::new(C::UnsupportedFormat, R::Version));
|
||||||
}
|
}
|
||||||
if bytes[6] != 0 {
|
if bytes[6] != 0 {
|
||||||
@@ -314,14 +314,14 @@ impl<'a, 'b> Reader<'a, 'b> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Raw section input for a v1 envelope writer. Non-Registry section bytes must
|
/// Raw section input for a v0 envelope writer. Non-Registry section bytes must
|
||||||
/// come from their own validated writers; this API never invents defaults.
|
/// come from their own validated writers; this API never invents defaults.
|
||||||
#[derive(Clone, Copy)]
|
#[derive(Clone, Copy)]
|
||||||
pub struct SectionData<'a> {
|
pub struct SectionData<'a> {
|
||||||
pub kind: u32,
|
pub kind: u32,
|
||||||
pub bytes: &'a [u8],
|
pub bytes: &'a [u8],
|
||||||
}
|
}
|
||||||
/// Assemble strict v1 sections. The output buffer is charged to temporary load storage.
|
/// Assemble strict v0 sections. The output buffer is charged to temporary load storage.
|
||||||
pub fn encode_envelope(sections: &[SectionData<'_>], b: &mut LoadBudget) -> Result<Vec<u8>, E> {
|
pub fn encode_envelope(sections: &[SectionData<'_>], b: &mut LoadBudget) -> Result<Vec<u8>, E> {
|
||||||
b.transaction(|b| {
|
b.transaction(|b| {
|
||||||
let mut by_kind = [None; 9];
|
let mut by_kind = [None; 9];
|
||||||
@@ -349,7 +349,7 @@ pub fn encode_envelope(sections: &[SectionData<'_>], b: &mut LoadBudget) -> Resu
|
|||||||
b.work(total)?;
|
b.work(total)?;
|
||||||
let mut out = b.vector(total, Q::TemporaryBytes)?;
|
let mut out = b.vector(total, Q::TemporaryBytes)?;
|
||||||
out.extend_from_slice(b"PBX\0");
|
out.extend_from_slice(b"PBX\0");
|
||||||
out.extend_from_slice(&[1, 0, 0, 0]);
|
out.extend_from_slice(&[0, 0, 0, 0]);
|
||||||
out.extend_from_slice(&(count as u32).to_le_bytes());
|
out.extend_from_slice(&(count as u32).to_le_bytes());
|
||||||
out.extend_from_slice(&[0; 20]);
|
out.extend_from_slice(&[0; 20]);
|
||||||
let mut offset = directory_end;
|
let mut offset = directory_end;
|
||||||
|
|||||||
@@ -6,7 +6,7 @@ use crate::load_limits::IdDomain;
|
|||||||
use crate::model::{ConstantPoolEntry, DebugInfo, Export, SyscallDecl};
|
use crate::model::{ConstantPoolEntry, DebugInfo, Export, SyscallDecl};
|
||||||
use std::cmp::Ordering;
|
use std::cmp::Ordering;
|
||||||
|
|
||||||
/// Owned, bounded PBX v1 tables for the executable loader. This is not an
|
/// Owned, bounded PBX v0 tables for the executable loader. This is not an
|
||||||
/// executable image: bindings and instruction/type verification are still due.
|
/// executable image: bindings and instruction/type verification are still due.
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct OwnedPbx {
|
pub struct OwnedPbx {
|
||||||
|
|||||||
@@ -1,5 +1,5 @@
|
|||||||
//! Producer-side serialization of a complete typed module. This writer emits
|
//! Producer-side serialization of a complete typed module. This writer emits
|
||||||
//! only v1; executable consumers still need bindings and code verification.
|
//! only v0; executable consumers still need bindings and code verification.
|
||||||
use super::*;
|
use super::*;
|
||||||
use crate::load_limits::IdDomain;
|
use crate::load_limits::IdDomain;
|
||||||
use crate::model::{ConstantPoolEntry, DebugInfo, Export, SyscallDecl};
|
use crate::model::{ConstantPoolEntry, DebugInfo, Export, SyscallDecl};
|
||||||
|
|||||||
@@ -86,7 +86,7 @@ impl DecodedInstr<'_> {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
Op::GetCapture => {
|
Op::GetCapture => {
|
||||||
return Err(LoadFailure::new(LoadCode::InvalidReference, LoadReason::CaptureIndex))
|
return Err(LoadFailure::new(LoadCode::InvalidReference, LoadReason::CaptureIndex));
|
||||||
}
|
}
|
||||||
Op::CallTrait => {
|
Op::CallTrait => {
|
||||||
let (ty, method) = self.imm_u32x2().map_err(|_| malformed())?;
|
let (ty, method) = self.imm_u32x2().map_err(|_| malformed())?;
|
||||||
@@ -133,6 +133,29 @@ impl DecodedInstr<'_> {
|
|||||||
};
|
};
|
||||||
(source_layout.storage.slots, pushes)
|
(source_layout.storage.slots, pushes)
|
||||||
}
|
}
|
||||||
|
Op::RefIdentityHash | Op::RefIdentityEq => {
|
||||||
|
let (left, right) = if self.opcode == Op::RefIdentityHash {
|
||||||
|
(self.imm_u32().map_err(|_| malformed())?, None)
|
||||||
|
} else {
|
||||||
|
let (a, b) = self.imm_u32x2().map_err(|_| malformed())?;
|
||||||
|
(a, Some(b))
|
||||||
|
};
|
||||||
|
let mut pops = 0;
|
||||||
|
for id in std::iter::once(left).chain(right) {
|
||||||
|
let (decl, layout) = type_info(id)?;
|
||||||
|
if !decl.kind.is_identity_reference() {
|
||||||
|
return Err(bad_category(id));
|
||||||
|
}
|
||||||
|
pops += layout.storage.slots;
|
||||||
|
}
|
||||||
|
(pops, 1)
|
||||||
|
}
|
||||||
|
Op::ArrayCopy => {
|
||||||
|
let array = self.imm_u32().map_err(|_| malformed())?;
|
||||||
|
let (_, layout) = type_info(array)?;
|
||||||
|
layout.array.ok_or_else(|| bad_category(array))?;
|
||||||
|
(5, 0)
|
||||||
|
}
|
||||||
Op::StructNew
|
Op::StructNew
|
||||||
| Op::StructGet
|
| Op::StructGet
|
||||||
| Op::StructSet
|
| Op::StructSet
|
||||||
|
|||||||
@@ -34,6 +34,8 @@ fn all_typed_instructions_match_independent_bytes_and_costs() {
|
|||||||
("REF_IMPLEMENTS source=16909060, target=84281096", &[0x94, 0, 4, 3, 2, 1, 8, 7, 6, 5], 4),
|
("REF_IMPLEMENTS source=16909060, target=84281096", &[0x94, 0, 4, 3, 2, 1, 8, 7, 6, 5], 4),
|
||||||
("REF_TO_TRAIT source=16909060, target=84281096", &[0x95, 0, 4, 3, 2, 1, 8, 7, 6, 5], 5),
|
("REF_TO_TRAIT source=16909060, target=84281096", &[0x95, 0, 4, 3, 2, 1, 8, 7, 6, 5], 5),
|
||||||
("REF_CAST source=16909060, target=84281096", &[0x96, 0, 4, 3, 2, 1, 8, 7, 6, 5], 4),
|
("REF_CAST source=16909060, target=84281096", &[0x96, 0, 4, 3, 2, 1, 8, 7, 6, 5], 4),
|
||||||
|
("REF_IDENTITY_HASH 16909060", &[0x97, 0, 4, 3, 2, 1], 8),
|
||||||
|
("REF_IDENTITY_EQ left=16909060, right=84281096", &[0x98, 0, 4, 3, 2, 1, 8, 7, 6, 5], 4),
|
||||||
];
|
];
|
||||||
for &(text, bytes, cycles) in cases {
|
for &(text, bytes, cycles) in cases {
|
||||||
assert_eq!(assemble(text).unwrap(), bytes);
|
assert_eq!(assemble(text).unwrap(), bytes);
|
||||||
@@ -49,8 +51,8 @@ fn all_typed_instructions_match_independent_bytes_and_costs() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
assert!(matches!(
|
assert!(matches!(
|
||||||
decode_next(0, &[0x97, 0]),
|
decode_next(0, &[0x99, 0]),
|
||||||
Err(DecodeError::UnknownOpcode { opcode: 0x97, .. })
|
Err(DecodeError::UnknownOpcode { opcode: 0x99, .. })
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
@@ -68,6 +70,8 @@ fn slot_effects_resolve_semantic_widths_and_reference_categories() {
|
|||||||
("REF_TO_TRAIT source=4, target=6", 1, 2),
|
("REF_TO_TRAIT source=4, target=6", 1, 2),
|
||||||
("REF_TO_TRAIT source=6, target=6", 2, 2),
|
("REF_TO_TRAIT source=6, target=6", 2, 2),
|
||||||
("REF_CAST source=6, target=4", 2, 1),
|
("REF_CAST source=6, target=4", 2, 1),
|
||||||
|
("REF_IDENTITY_HASH 6", 2, 1),
|
||||||
|
("REF_IDENTITY_EQ left=6, right=4", 3, 1),
|
||||||
] {
|
] {
|
||||||
let bytes = assemble(text).unwrap();
|
let bytes = assemble(text).unwrap();
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
@@ -94,6 +98,9 @@ fn invalid_type_immediates_are_contextual_load_errors() {
|
|||||||
"REF_IS_EXACT source=4, target=6",
|
"REF_IS_EXACT source=4, target=6",
|
||||||
"REF_TO_TRAIT source=4, target=0",
|
"REF_TO_TRAIT source=4, target=0",
|
||||||
"REF_IMPLEMENTS source=0, target=6",
|
"REF_IMPLEMENTS source=0, target=6",
|
||||||
|
"REF_IDENTITY_HASH 0",
|
||||||
|
"REF_IDENTITY_HASH 3",
|
||||||
|
"REF_IDENTITY_EQ left=4, right=1",
|
||||||
] {
|
] {
|
||||||
let bytes = assemble(text).unwrap();
|
let bytes = assemble(text).unwrap();
|
||||||
let e = decode_next(0, &bytes).unwrap().registry_stack_effect(®istry).unwrap_err();
|
let e = decode_next(0, &bytes).unwrap().registry_stack_effect(®istry).unwrap_err();
|
||||||
@@ -114,6 +121,10 @@ fn assembler_rejects_missing_overflowing_or_ambiguous_type_ids() {
|
|||||||
"REF_CAST source=4",
|
"REF_CAST source=4",
|
||||||
"REF_CAST source=4, target=5, target=6",
|
"REF_CAST source=4, target=5, target=6",
|
||||||
"REF_CAST source=4, trait=6",
|
"REF_CAST source=4, trait=6",
|
||||||
|
"REF_IDENTITY_HASH",
|
||||||
|
"REF_IDENTITY_HASH -1",
|
||||||
|
"REF_IDENTITY_EQ left=4",
|
||||||
|
"REF_IDENTITY_EQ left=4, target=5",
|
||||||
] {
|
] {
|
||||||
assert!(assemble(text).is_err(), "{text}");
|
assert!(assemble(text).is_err(), "{text}");
|
||||||
}
|
}
|
||||||
@@ -204,3 +215,62 @@ fn collection_effects_and_cached_initialization_width_are_exact() {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn removed_storage_encodings_and_mnemonics_are_unsupported() {
|
||||||
|
for opcode in [0xa7u16, 0xa8, 0xaa, 0xab] {
|
||||||
|
assert!(Op::try_from(opcode).is_err());
|
||||||
|
let bytes = opcode.to_le_bytes();
|
||||||
|
assert!(
|
||||||
|
matches!(decode_next(0,&bytes),Err(DecodeError::UnknownOpcode{pc:0,opcode: actual}) if actual == opcode)
|
||||||
|
);
|
||||||
|
assert!(disassemble(&bytes).is_err());
|
||||||
|
}
|
||||||
|
for text in
|
||||||
|
["INDEX_GUARD", "ARRAY_CHECK_LENGTH 1", "STORAGE_PUBLISH 1,2,0,1", "FIELDS_PUBLISH 1"]
|
||||||
|
{
|
||||||
|
assert!(assemble(text).is_err(), "{text}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn range_copy_encoding_effects_and_registry_categories_are_independent_oracles() {
|
||||||
|
let bytes = [0xa9, 0, 4, 3, 2, 1];
|
||||||
|
assert_eq!(assemble("ARRAY_COPY 16909060").unwrap(), bytes);
|
||||||
|
assert_eq!(disassemble(&bytes).unwrap(), "ARRAY_COPY 16909060");
|
||||||
|
let instruction = decode_next(0, &bytes).unwrap();
|
||||||
|
assert_eq!(instruction.opcode, Op::ArrayCopy);
|
||||||
|
assert_eq!(instruction.opcode.cycles(), 4);
|
||||||
|
let spec = instruction.opcode.spec();
|
||||||
|
assert_eq!((spec.imm_bytes, spec.pops, spec.pushes), (4, None, None));
|
||||||
|
assert!(instruction.opcode.requires_registry() && spec.may_trap);
|
||||||
|
assert!(!spec.is_safepoint && !spec.is_branch && !spec.is_terminator);
|
||||||
|
for end in 0..6 {
|
||||||
|
assert!(decode_next(0, &bytes[..end]).is_err());
|
||||||
|
}
|
||||||
|
let registry = registry();
|
||||||
|
let bytes = assemble("ARRAY_COPY 5").unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
decode_next(0, &bytes).unwrap().registry_stack_effect(®istry).unwrap(),
|
||||||
|
Some(RegistryStackEffect { pops: 5, pushes: 0 })
|
||||||
|
);
|
||||||
|
for (id, reason) in [
|
||||||
|
(0, LoadReason::Category),
|
||||||
|
(4, LoadReason::Category),
|
||||||
|
(6, LoadReason::Category),
|
||||||
|
(99, LoadReason::TypeId),
|
||||||
|
] {
|
||||||
|
let bytes = assemble(&format!("ARRAY_COPY {id}")).unwrap();
|
||||||
|
let error = decode_next(0, &bytes).unwrap().registry_stack_effect(®istry).unwrap_err();
|
||||||
|
assert_eq!(
|
||||||
|
(error.code, error.reason, error.pc),
|
||||||
|
(LoadCode::InvalidReference, reason, Some(0))
|
||||||
|
);
|
||||||
|
}
|
||||||
|
for text in ["ARRAY_COPY", "ARRAY_COPY -1", "ARRAY_COPY 4294967296", "ARRAY_COPY 1 2"] {
|
||||||
|
assert!(assemble(text).is_err());
|
||||||
|
}
|
||||||
|
// These are legal immediate bytes, not instruction boundaries.
|
||||||
|
let bytes = assemble("PUSH_I64 18735214094965159\nHALT").unwrap();
|
||||||
|
assert!(disassemble(&bytes).is_ok());
|
||||||
|
}
|
||||||
|
|||||||
+3
-3
@@ -172,7 +172,7 @@ fn hex(s: &str) -> Vec<u8> {
|
|||||||
// syscalls=168/4, types=172/10, implementations=182/4, captures=186/8. Total=194.
|
// syscalls=168/4, types=172/10, implementations=182/4, captures=186/8. Total=194.
|
||||||
fn minimal_bytes() -> Vec<u8> {
|
fn minimal_bytes() -> Vec<u8> {
|
||||||
hex("
|
hex("
|
||||||
50 42 58 00 01 00 00 00 08 00 00 00
|
50 42 58 00 00 00 00 00 08 00 00 00
|
||||||
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
||||||
00 00 00 00 80 00 00 00 04 00 00 00
|
00 00 00 00 80 00 00 00 04 00 00 00
|
||||||
01 00 00 00 84 00 00 00 1e 00 00 00
|
01 00 00 00 84 00 00 00 1e 00 00 00
|
||||||
@@ -241,7 +241,7 @@ fn writer_matches_independent_minimal_envelope() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn owned_v1_decoder_accepts_independent_bytes_without_publishing_an_image() {
|
fn owned_v0_decoder_accepts_independent_bytes_without_publishing_an_image() {
|
||||||
let mut b = budget();
|
let mut b = budget();
|
||||||
let owned = OwnedPbx::parse(&minimal_bytes(), &mut b).unwrap();
|
let owned = OwnedPbx::parse(&minimal_bytes(), &mut b).unwrap();
|
||||||
assert_eq!(owned.registry.declarations(), minimal_registry().declarations());
|
assert_eq!(owned.registry.declarations(), minimal_registry().declarations());
|
||||||
@@ -536,7 +536,7 @@ fn every_truncated_envelope_is_rejected_without_panic() {
|
|||||||
fn envelope_mutations_have_typed_reasons() {
|
fn envelope_mutations_have_typed_reasons() {
|
||||||
for (offset, value, code, reason) in [
|
for (offset, value, code, reason) in [
|
||||||
(0, 0, LoadCode::InvalidFormat, LoadReason::Magic),
|
(0, 0, LoadCode::InvalidFormat, LoadReason::Magic),
|
||||||
(4, 0, LoadCode::UnsupportedFormat, LoadReason::Version),
|
(4, 1, LoadCode::UnsupportedFormat, LoadReason::Version),
|
||||||
(6, 1, LoadCode::InvalidFormat, LoadReason::Endianness),
|
(6, 1, LoadCode::InvalidFormat, LoadReason::Endianness),
|
||||||
(7, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
(7, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
||||||
(31, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
(31, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
||||||
@@ -0,0 +1,185 @@
|
|||||||
|
//! Controlled graphics measurement. This is not a cartridge stress-suite replacement.
|
||||||
|
use prometeu_drivers::{Gfx, GlyphBankPoolInstaller, MemoryBanks, hardware::Hardware};
|
||||||
|
use prometeu_hal::color::Color;
|
||||||
|
use prometeu_hal::glyph::Glyph;
|
||||||
|
use prometeu_hal::glyph_bank::{GlyphBank, TileSize};
|
||||||
|
use prometeu_hal::scene_bank::SceneBank;
|
||||||
|
use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer};
|
||||||
|
use prometeu_hal::scene_viewport_cache::SceneViewportCache;
|
||||||
|
use prometeu_hal::scene_viewport_resolver::SceneViewportResolver;
|
||||||
|
use prometeu_hal::sprite::Sprite;
|
||||||
|
use prometeu_hal::tile::Tile;
|
||||||
|
use prometeu_hal::tilemap::TileMap;
|
||||||
|
use prometeu_hal::{FrameId, OwnedRgba8888Frame, RenderOwnership, app_mode::AppMode};
|
||||||
|
use std::alloc::{GlobalAlloc, Layout, System};
|
||||||
|
use std::sync::{
|
||||||
|
Arc,
|
||||||
|
atomic::{AtomicUsize, Ordering},
|
||||||
|
};
|
||||||
|
use std::time::Instant;
|
||||||
|
|
||||||
|
struct CountingAllocator;
|
||||||
|
static LIVE: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
static PEAK: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
// Only the measurement executable pays the atomic allocation instrumentation cost.
|
||||||
|
unsafe impl GlobalAlloc for CountingAllocator {
|
||||||
|
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
||||||
|
let ptr = unsafe { System.alloc(layout) };
|
||||||
|
if !ptr.is_null() {
|
||||||
|
let live = LIVE.fetch_add(layout.size(), Ordering::Relaxed) + layout.size();
|
||||||
|
PEAK.fetch_max(live, Ordering::Relaxed);
|
||||||
|
ALLOCATIONS.fetch_add(1, Ordering::Relaxed);
|
||||||
|
}
|
||||||
|
ptr
|
||||||
|
}
|
||||||
|
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
||||||
|
LIVE.fetch_sub(layout.size(), Ordering::Relaxed);
|
||||||
|
unsafe { System.dealloc(ptr, layout) };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[global_allocator]
|
||||||
|
static ALLOCATOR: CountingAllocator = CountingAllocator;
|
||||||
|
|
||||||
|
fn summary(samples: &mut [u64]) -> serde_json::Value {
|
||||||
|
samples.sort_unstable();
|
||||||
|
let n = samples.len();
|
||||||
|
serde_json::json!({"mean_us": samples.iter().sum::<u64>() as f64 / n as f64 / 1000.0,
|
||||||
|
"p95_us": samples[(n * 95).div_ceil(100) - 1] as f64 / 1000.0,
|
||||||
|
"p99_us": samples[(n * 99).div_ceil(100) - 1] as f64 / 1000.0,
|
||||||
|
"max_us": samples[n-1] as f64 / 1000.0,
|
||||||
|
"over_60hz_budget": samples.iter().filter(|&&v| v > 1_000_000_000 / 60).count()})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
let count: usize =
|
||||||
|
std::env::args().nth(1).map(|v| v.parse().expect("frame count")).unwrap_or(600);
|
||||||
|
assert!(count > 0);
|
||||||
|
let (w, h) = (Hardware::W, Hardware::H);
|
||||||
|
let banks = Arc::new(MemoryBanks::new());
|
||||||
|
let mixed = std::env::args().nth(2).as_deref() == Some("mixed");
|
||||||
|
let sizes = if mixed {
|
||||||
|
[TileSize::Size8, TileSize::Size16, TileSize::Size32, TileSize::Size8]
|
||||||
|
} else {
|
||||||
|
[TileSize::Size16; 4]
|
||||||
|
};
|
||||||
|
for (i, size) in sizes.iter().enumerate() {
|
||||||
|
let edge = *size as usize;
|
||||||
|
let mut bank = GlyphBank::new(*size, edge, edge);
|
||||||
|
bank.palettes[0][1] = Color::rgba((i * 47 + 30) as u8, 120, 210, 255);
|
||||||
|
// Transparent holes make all four layers participate in the visible output.
|
||||||
|
for (p, pixel) in bank.pixel_indices.iter_mut().enumerate() {
|
||||||
|
*pixel = u8::from(i == 0 || (p + i) % 3 != 0);
|
||||||
|
}
|
||||||
|
banks.install_glyph_bank(i, Arc::new(bank));
|
||||||
|
}
|
||||||
|
let scene = SceneBank {
|
||||||
|
layers: std::array::from_fn(|i| SceneLayer {
|
||||||
|
active: true,
|
||||||
|
glyph_asset_id: i as i32,
|
||||||
|
tile_size: sizes[i],
|
||||||
|
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
||||||
|
tilemap: TileMap {
|
||||||
|
width: 160,
|
||||||
|
height: 100,
|
||||||
|
tiles: vec![
|
||||||
|
Tile {
|
||||||
|
active: true,
|
||||||
|
glyph: Glyph { glyph_id: 0, palette_id: 0 },
|
||||||
|
flip_x: false,
|
||||||
|
flip_y: false,
|
||||||
|
};
|
||||||
|
160 * 100
|
||||||
|
],
|
||||||
|
},
|
||||||
|
}),
|
||||||
|
};
|
||||||
|
let min_tile = if mixed { 8 } else { 16 };
|
||||||
|
let (cw, ch) = (w.div_ceil(min_tile) + 5, h.div_ceil(min_tile) + 4);
|
||||||
|
let mut cache = SceneViewportCache::new(&scene, cw, ch);
|
||||||
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
w as i32,
|
||||||
|
h as i32,
|
||||||
|
cw,
|
||||||
|
ch,
|
||||||
|
min_tile as i32 - 4,
|
||||||
|
min_tile as i32 + 4,
|
||||||
|
);
|
||||||
|
let mut gfx = Gfx::new(w, h, banks);
|
||||||
|
let sprites: Vec<_> = (0..512)
|
||||||
|
.map(|i| Sprite {
|
||||||
|
glyph: Glyph { glyph_id: 0, palette_id: 0 },
|
||||||
|
x: ((i * 37) % w) as i32,
|
||||||
|
y: ((i * 53) % h) as i32,
|
||||||
|
layer: (i % 4) as u8,
|
||||||
|
bank_id: (i % 4) as u8,
|
||||||
|
active: true,
|
||||||
|
flip_x: i % 2 == 0,
|
||||||
|
flip_y: i % 3 == 0,
|
||||||
|
priority: (i % 4) as u8,
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
gfx.load_frame_sprites(&sprites);
|
||||||
|
let mut compose = Vec::with_capacity(count);
|
||||||
|
let mut publish = Vec::with_capacity(count);
|
||||||
|
let mut upload = Vec::with_capacity(count);
|
||||||
|
let mut total = Vec::with_capacity(count);
|
||||||
|
let mut rgba = vec![0u8; w * h * 4];
|
||||||
|
let ownership = RenderOwnership::new(1, AppMode::Game, 1);
|
||||||
|
let mut checksum = 0u32;
|
||||||
|
for frame_id in 0..(count + 120) {
|
||||||
|
// Resolve/materialize cache outside the raster timing; total includes it.
|
||||||
|
let start = Instant::now();
|
||||||
|
let update = resolver.update(&scene, (frame_id % 71) as i32, (frame_id % 43) as i32);
|
||||||
|
for request in &update.copy_requests {
|
||||||
|
cache.move_layer_window_to(
|
||||||
|
request.layer_index,
|
||||||
|
request.cache_origin_tile_x,
|
||||||
|
request.cache_origin_tile_y,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
cache.materialize_all_layers(&scene);
|
||||||
|
let t = Instant::now();
|
||||||
|
gfx.render_scene_from_cache(&cache, &update, &[0, 1, 2, 3]);
|
||||||
|
gfx.fill_rect(0, h as i32 - 8, w as i32, 8, Color::WHITE);
|
||||||
|
let raster = t.elapsed().as_nanos() as u64;
|
||||||
|
let t = Instant::now();
|
||||||
|
gfx.present();
|
||||||
|
let frame = OwnedRgba8888Frame::packed(
|
||||||
|
FrameId::new(frame_id as u64),
|
||||||
|
ownership,
|
||||||
|
w,
|
||||||
|
h,
|
||||||
|
gfx.front_buffer().to_vec(),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let publication = t.elapsed().as_nanos() as u64;
|
||||||
|
let t = Instant::now();
|
||||||
|
for (pixel, bytes) in frame.pixels.iter().zip(rgba.as_chunks_mut::<4>().0.iter_mut()) {
|
||||||
|
bytes.copy_from_slice(&pixel.to_be_bytes());
|
||||||
|
}
|
||||||
|
std::hint::black_box(&rgba);
|
||||||
|
let staging = t.elapsed().as_nanos() as u64;
|
||||||
|
checksum ^= frame.pixels[(frame_id * 173) % (w * h)];
|
||||||
|
if frame_id >= 120 {
|
||||||
|
compose.push(raster);
|
||||||
|
publish.push(publication);
|
||||||
|
upload.push(staging);
|
||||||
|
total.push(start.elapsed().as_nanos() as u64);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let live = LIVE.load(Ordering::Relaxed);
|
||||||
|
let peak = PEAK.load(Ordering::Relaxed);
|
||||||
|
let allocations = ALLOCATIONS.load(Ordering::Relaxed);
|
||||||
|
println!(
|
||||||
|
"{}",
|
||||||
|
serde_json::json!({"schema":1,"width":w,"height":h,"frames":count,
|
||||||
|
"warmup_frames":120,"tiles":sizes.map(|s|s as u32),"sprites_accepted":512,"layers":4,
|
||||||
|
"framebuffer_bytes":w*h*4,"front_back_bytes":w*h*8,"host_staging_bytes":rgba.len(),
|
||||||
|
"compose":summary(&mut compose),"publish_owned":summary(&mut publish),
|
||||||
|
"rgba_staging":summary(&mut upload),"total":summary(&mut total),
|
||||||
|
"allocated_live_bytes":live,"allocated_peak_bytes":peak,"allocation_count":allocations,
|
||||||
|
"checksum":checksum,"vm_hz":null,"physical_display_hz":null,
|
||||||
|
"limitations":"unpaced controlled raster/cache/owned publication/staging; no VM, IPC or GPU present; allocator instrumented; RSS is measured by the process wrapper"})
|
||||||
|
);
|
||||||
|
}
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
#![allow(clippy::collapsible_if)]
|
#![allow(clippy::collapsible_if)]
|
||||||
|
mod decode;
|
||||||
mod resumable;
|
mod resumable;
|
||||||
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
|
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
|
||||||
use prometeu_hal::AssetBridge;
|
use prometeu_hal::AssetBridge;
|
||||||
@@ -634,62 +635,13 @@ impl AssetManager {
|
|||||||
fn decode_glyph_bank_layout(
|
fn decode_glyph_bank_layout(
|
||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
) -> Result<(TileSize, usize, usize, usize, usize, usize), String> {
|
) -> Result<(TileSize, usize, usize, usize, usize, usize), String> {
|
||||||
let meta = entry.metadata_as_glyph_bank()?;
|
decode::glyph_layout(entry)
|
||||||
|
|
||||||
let tile_size = match meta.tile_size {
|
|
||||||
8 => TileSize::Size8,
|
|
||||||
16 => TileSize::Size16,
|
|
||||||
32 => TileSize::Size32,
|
|
||||||
_ => return Err(format!("Invalid tile_size: {}", meta.tile_size)),
|
|
||||||
};
|
|
||||||
|
|
||||||
let palette_count = meta.palette_count as usize;
|
|
||||||
if !(1..=GLYPH_BANK_MAX_PALETTE_COUNT_V1).contains(&palette_count) {
|
|
||||||
return Err(format!("Invalid palette_count: {}", meta.palette_count));
|
|
||||||
}
|
|
||||||
|
|
||||||
let width = meta.width as usize;
|
|
||||||
let height = meta.height as usize;
|
|
||||||
|
|
||||||
let logical_pixels = width.checked_mul(height).ok_or("GlyphBank dimensions overflow")?;
|
|
||||||
let serialized_pixel_bytes = logical_pixels.div_ceil(2);
|
|
||||||
let palette_bytes = palette_count
|
|
||||||
.checked_mul(GLYPH_BANK_PALETTE_BYTES_PER_PALETTE)
|
|
||||||
.ok_or("GlyphBank palette size overflow")?;
|
|
||||||
let serialized_size = serialized_pixel_bytes
|
|
||||||
.checked_add(palette_bytes)
|
|
||||||
.ok_or("GlyphBank serialized size overflow")?;
|
|
||||||
let decoded_size =
|
|
||||||
logical_pixels.checked_add(palette_bytes).ok_or("GlyphBank decoded size overflow")?;
|
|
||||||
|
|
||||||
if entry.size != serialized_size as u64 {
|
|
||||||
return Err(format!(
|
|
||||||
"Invalid GLYPHBANK serialized size: expected {}, got {}",
|
|
||||||
serialized_size, entry.size
|
|
||||||
));
|
|
||||||
}
|
|
||||||
|
|
||||||
if entry.decoded_size != decoded_size as u64 {
|
|
||||||
return Err(format!(
|
|
||||||
"Invalid GLYPHBANK decoded_size: expected {}, got {}",
|
|
||||||
decoded_size, entry.decoded_size
|
|
||||||
));
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok((tile_size, width, height, serialized_pixel_bytes, palette_count, palette_bytes))
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn unpack_glyph_bank_pixels(packed_pixels: &[u8], logical_pixels: usize) -> Vec<u8> {
|
fn unpack_glyph_bank_pixels(packed_pixels: &[u8], logical_pixels: usize) -> Vec<u8> {
|
||||||
let mut pixel_indices = Vec::with_capacity(logical_pixels);
|
let mut pixels = Vec::with_capacity(logical_pixels);
|
||||||
for &packed in packed_pixels {
|
decode::append_pixels(&mut pixels, packed_pixels, logical_pixels);
|
||||||
if pixel_indices.len() < logical_pixels {
|
pixels
|
||||||
pixel_indices.push(packed >> 4);
|
|
||||||
}
|
|
||||||
if pixel_indices.len() < logical_pixels {
|
|
||||||
pixel_indices.push(packed & 0x0f);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pixel_indices
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
|
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
|
||||||
@@ -1260,17 +1212,7 @@ impl AssetManager {
|
|||||||
let palette_data = &buffer[packed_pixel_bytes..packed_pixel_bytes + palette_bytes];
|
let palette_data = &buffer[packed_pixel_bytes..packed_pixel_bytes + palette_bytes];
|
||||||
|
|
||||||
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
||||||
for (p, pal) in palettes.iter_mut().enumerate() {
|
decode::write_palettes(&mut palettes, 0, palette_data);
|
||||||
for (c, slot) in pal.iter_mut().enumerate() {
|
|
||||||
let offset = (p * 16 + c) * 4;
|
|
||||||
*slot = Color::rgba(
|
|
||||||
palette_data[offset],
|
|
||||||
palette_data[offset + 1],
|
|
||||||
palette_data[offset + 2],
|
|
||||||
palette_data[offset + 3],
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
||||||
}
|
}
|
||||||
@@ -1295,17 +1237,7 @@ impl AssetManager {
|
|||||||
.map_err(|_| "Buffer too small for GLYPHBANK".to_string())?;
|
.map_err(|_| "Buffer too small for GLYPHBANK".to_string())?;
|
||||||
|
|
||||||
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
||||||
for (p, pal) in palettes.iter_mut().enumerate() {
|
decode::write_palettes(&mut palettes, 0, &palette_data);
|
||||||
for (c, slot) in pal.iter_mut().enumerate() {
|
|
||||||
let offset = (p * 16 + c) * 4;
|
|
||||||
*slot = Color::rgba(
|
|
||||||
palette_data[offset],
|
|
||||||
palette_data[offset + 1],
|
|
||||||
palette_data[offset + 2],
|
|
||||||
palette_data[offset + 3],
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
||||||
}
|
}
|
||||||
@@ -1340,7 +1272,7 @@ impl AssetManager {
|
|||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
||||||
) -> Result<SceneBank, String> {
|
) -> Result<SceneBank, String> {
|
||||||
let _ = entry.metadata_as_scene_bank()?;
|
decode::scene_metadata(entry)?;
|
||||||
let op_mode = Self::op_mode_for(entry)?;
|
let op_mode = Self::op_mode_for(entry)?;
|
||||||
let slice = {
|
let slice = {
|
||||||
let assets_data = assets_data.read().unwrap();
|
let assets_data = assets_data.read().unwrap();
|
||||||
@@ -1367,152 +1299,25 @@ impl AssetManager {
|
|||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
buffer: &[u8],
|
buffer: &[u8],
|
||||||
) -> Result<SceneBank, String> {
|
) -> Result<SceneBank, String> {
|
||||||
let _ = entry.metadata_as_scene_bank()?;
|
decode::scene_metadata(entry)?;
|
||||||
|
decode::payload_size(entry, buffer.len())?;
|
||||||
if buffer.len() < SCENE_HEADER_BYTES_V1 {
|
decode::scene_header(buffer)?;
|
||||||
return Err("Buffer too small for SCENE".to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
if buffer[0..4] != SCENE_PAYLOAD_MAGIC_V1 {
|
|
||||||
return Err("Invalid SCENE magic".to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
let version = u16::from_le_bytes([buffer[4], buffer[5]]);
|
|
||||||
if version != SCENE_PAYLOAD_VERSION_V1 {
|
|
||||||
return Err(format!("Unsupported SCENE version: {}", version));
|
|
||||||
}
|
|
||||||
|
|
||||||
let layer_count = u16::from_le_bytes([buffer[6], buffer[7]]) as usize;
|
|
||||||
if layer_count != SCENE_LAYER_COUNT_V1 {
|
|
||||||
return Err(format!("Invalid SCENE layer count: {}", layer_count));
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut offset = SCENE_HEADER_BYTES_V1;
|
let mut offset = SCENE_HEADER_BYTES_V1;
|
||||||
let mut decoded_size = 0_usize;
|
let mut decoded = 0;
|
||||||
let layers = std::array::from_fn(|_| SceneLayer {
|
let mut layers = decode::empty_layers();
|
||||||
active: false,
|
|
||||||
glyph_asset_id: 0,
|
|
||||||
tile_size: TileSize::Size8,
|
|
||||||
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
|
||||||
tilemap: TileMap { width: 0, height: 0, tiles: Vec::new() },
|
|
||||||
});
|
|
||||||
let mut layers = layers;
|
|
||||||
|
|
||||||
for layer in &mut layers {
|
for layer in &mut layers {
|
||||||
let header_end = offset
|
let end = offset
|
||||||
.checked_add(SCENE_LAYER_HEADER_BYTES_V1)
|
.checked_add(SCENE_LAYER_HEADER_BYTES_V1)
|
||||||
.ok_or("SCENE layer header offset overflow")?;
|
.ok_or("SCENE header offset overflow")?;
|
||||||
if header_end > buffer.len() {
|
let header =
|
||||||
return Err("Buffer too small for SCENE layer header".to_string());
|
buffer.get(offset..end).ok_or("Buffer too small for SCENE layer header")?;
|
||||||
|
*layer = decode::scene_layer(header, end, entry.size, &mut decoded)?;
|
||||||
|
let tile_bytes =
|
||||||
|
layer.tilemap.width * layer.tilemap.height * SCENE_TILE_RECORD_BYTES_V1;
|
||||||
|
offset = end + tile_bytes; // checked by scene_layer before allocation
|
||||||
|
decode::append_tiles(&mut layer.tilemap.tiles, &buffer[end..offset]);
|
||||||
}
|
}
|
||||||
|
decode::scene_finish(entry, offset, decoded)?;
|
||||||
let flags = buffer[offset];
|
|
||||||
let glyph_asset_id = i32::from_le_bytes([
|
|
||||||
buffer[offset + 1],
|
|
||||||
buffer[offset + 2],
|
|
||||||
buffer[offset + 3],
|
|
||||||
buffer[offset + 4],
|
|
||||||
]);
|
|
||||||
let tile_size_raw = buffer[offset + 5];
|
|
||||||
let tile_size = match tile_size_raw {
|
|
||||||
8 => TileSize::Size8,
|
|
||||||
16 => TileSize::Size16,
|
|
||||||
32 => TileSize::Size32,
|
|
||||||
other => return Err(format!("Invalid SCENE tile size: {}", other)),
|
|
||||||
};
|
|
||||||
let parallax_factor_x = f32::from_le_bytes([
|
|
||||||
buffer[offset + 8],
|
|
||||||
buffer[offset + 9],
|
|
||||||
buffer[offset + 10],
|
|
||||||
buffer[offset + 11],
|
|
||||||
]);
|
|
||||||
let parallax_factor_y = f32::from_le_bytes([
|
|
||||||
buffer[offset + 12],
|
|
||||||
buffer[offset + 13],
|
|
||||||
buffer[offset + 14],
|
|
||||||
buffer[offset + 15],
|
|
||||||
]);
|
|
||||||
if !parallax_factor_x.is_finite() || !parallax_factor_y.is_finite() {
|
|
||||||
return Err("Invalid SCENE parallax_factor".to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
let width = u32::from_le_bytes([
|
|
||||||
buffer[offset + 16],
|
|
||||||
buffer[offset + 17],
|
|
||||||
buffer[offset + 18],
|
|
||||||
buffer[offset + 19],
|
|
||||||
]) as usize;
|
|
||||||
let height = u32::from_le_bytes([
|
|
||||||
buffer[offset + 20],
|
|
||||||
buffer[offset + 21],
|
|
||||||
buffer[offset + 22],
|
|
||||||
buffer[offset + 23],
|
|
||||||
]) as usize;
|
|
||||||
let tile_count = u32::from_le_bytes([
|
|
||||||
buffer[offset + 24],
|
|
||||||
buffer[offset + 25],
|
|
||||||
buffer[offset + 26],
|
|
||||||
buffer[offset + 27],
|
|
||||||
]) as usize;
|
|
||||||
|
|
||||||
let expected_tile_count =
|
|
||||||
width.checked_mul(height).ok_or("SCENE tile count overflow")?;
|
|
||||||
if tile_count != expected_tile_count {
|
|
||||||
return Err(format!(
|
|
||||||
"Invalid SCENE tile count for layer: expected {}, got {}",
|
|
||||||
expected_tile_count, tile_count
|
|
||||||
));
|
|
||||||
}
|
|
||||||
|
|
||||||
offset = header_end;
|
|
||||||
|
|
||||||
let tile_bytes = tile_count
|
|
||||||
.checked_mul(SCENE_TILE_RECORD_BYTES_V1)
|
|
||||||
.ok_or("SCENE tile payload overflow")?;
|
|
||||||
let tiles_end = offset.checked_add(tile_bytes).ok_or("SCENE payload overflow")?;
|
|
||||||
if tiles_end > buffer.len() {
|
|
||||||
return Err("Buffer too small for SCENE tile data".to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut tiles = Vec::with_capacity(tile_count);
|
|
||||||
for _ in 0..tile_count {
|
|
||||||
let tile_flags = buffer[offset];
|
|
||||||
let palette_id = buffer[offset + 1];
|
|
||||||
let glyph_id = u16::from_le_bytes([buffer[offset + 2], buffer[offset + 3]]);
|
|
||||||
tiles.push(Tile {
|
|
||||||
active: (tile_flags & 0b0000_0001) != 0,
|
|
||||||
glyph: Glyph { glyph_id, palette_id },
|
|
||||||
flip_x: (tile_flags & 0b0000_0010) != 0,
|
|
||||||
flip_y: (tile_flags & 0b0000_0100) != 0,
|
|
||||||
});
|
|
||||||
offset += SCENE_TILE_RECORD_BYTES_V1;
|
|
||||||
}
|
|
||||||
|
|
||||||
decoded_size = decoded_size
|
|
||||||
.checked_add(SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1)
|
|
||||||
.and_then(|size| size.checked_add(tile_count * size_of::<Tile>()))
|
|
||||||
.ok_or("SCENE decoded_size overflow")?;
|
|
||||||
|
|
||||||
*layer = SceneLayer {
|
|
||||||
active: (flags & 0b0000_0001) != 0,
|
|
||||||
glyph_asset_id,
|
|
||||||
tile_size,
|
|
||||||
parallax_factor: ParallaxFactor { x: parallax_factor_x, y: parallax_factor_y },
|
|
||||||
tilemap: TileMap { width, height, tiles },
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
if offset != buffer.len() {
|
|
||||||
return Err("Trailing bytes in SCENE payload".to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
if entry.decoded_size != decoded_size as u64 {
|
|
||||||
return Err(format!(
|
|
||||||
"Invalid SCENE decoded_size: expected {}, got {}",
|
|
||||||
decoded_size, entry.decoded_size
|
|
||||||
));
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(SceneBank { layers })
|
Ok(SceneBank { layers })
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1529,15 +1334,10 @@ impl AssetManager {
|
|||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
buffer: &[u8],
|
buffer: &[u8],
|
||||||
) -> Result<SoundBank, String> {
|
) -> Result<SoundBank, String> {
|
||||||
let meta = entry.metadata_as_sound_bank()?;
|
let sample_rate = decode::sound_rate(entry)?;
|
||||||
let sample_rate = meta.sample_rate;
|
decode::payload_size(entry, buffer.len())?;
|
||||||
|
|
||||||
let mut data = Vec::with_capacity(buffer.len() / 2);
|
let mut data = Vec::with_capacity(buffer.len() / 2);
|
||||||
for i in (0..buffer.len()).step_by(2) {
|
decode::append_pcm(&mut data, buffer);
|
||||||
if i + 1 < buffer.len() {
|
|
||||||
data.push(i16::from_le_bytes([buffer[i], buffer[i + 1]]));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
let sample = Arc::new(Sample::new(sample_rate, data));
|
let sample = Arc::new(Sample::new(sample_rate, data));
|
||||||
Ok(SoundBank::new(vec![sample]))
|
Ok(SoundBank::new(vec![sample]))
|
||||||
|
|||||||
@@ -0,0 +1,187 @@
|
|||||||
|
//! Format authority shared by complete-buffer and bounded resumable decoding.
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
pub(super) fn glyph_layout(
|
||||||
|
entry: &AssetEntry,
|
||||||
|
) -> Result<(TileSize, usize, usize, usize, usize, usize), String> {
|
||||||
|
let meta = entry.metadata_as_glyph_bank()?;
|
||||||
|
|
||||||
|
let tile_size = match meta.tile_size {
|
||||||
|
8 => TileSize::Size8,
|
||||||
|
16 => TileSize::Size16,
|
||||||
|
32 => TileSize::Size32,
|
||||||
|
_ => return Err(format!("Invalid tile_size: {}", meta.tile_size)),
|
||||||
|
};
|
||||||
|
|
||||||
|
let palette_count = meta.palette_count as usize;
|
||||||
|
if !(1..=GLYPH_BANK_MAX_PALETTE_COUNT_V1).contains(&palette_count) {
|
||||||
|
return Err(format!("Invalid palette_count: {}", meta.palette_count));
|
||||||
|
}
|
||||||
|
|
||||||
|
let width = meta.width as usize;
|
||||||
|
let height = meta.height as usize;
|
||||||
|
|
||||||
|
let logical_pixels = width.checked_mul(height).ok_or("GlyphBank dimensions overflow")?;
|
||||||
|
let serialized_pixel_bytes = logical_pixels.div_ceil(2);
|
||||||
|
let palette_bytes = palette_count
|
||||||
|
.checked_mul(GLYPH_BANK_PALETTE_BYTES_PER_PALETTE)
|
||||||
|
.ok_or("GlyphBank palette size overflow")?;
|
||||||
|
let serialized_size = serialized_pixel_bytes
|
||||||
|
.checked_add(palette_bytes)
|
||||||
|
.ok_or("GlyphBank serialized size overflow")?;
|
||||||
|
let decoded_size =
|
||||||
|
logical_pixels.checked_add(palette_bytes).ok_or("GlyphBank decoded size overflow")?;
|
||||||
|
|
||||||
|
if entry.size != serialized_size as u64 {
|
||||||
|
return Err(format!(
|
||||||
|
"Invalid GLYPHBANK serialized size: expected {}, got {}",
|
||||||
|
serialized_size, entry.size
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
if entry.decoded_size != decoded_size as u64 {
|
||||||
|
return Err(format!(
|
||||||
|
"Invalid GLYPHBANK decoded_size: expected {}, got {}",
|
||||||
|
decoded_size, entry.decoded_size
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok((tile_size, width, height, serialized_pixel_bytes, palette_count, palette_bytes))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn append_pixels(pixels: &mut Vec<u8>, bytes: &[u8], logical: usize) {
|
||||||
|
for &packed in bytes {
|
||||||
|
if pixels.len() < logical {
|
||||||
|
pixels.push(packed >> 4);
|
||||||
|
}
|
||||||
|
if pixels.len() < logical {
|
||||||
|
pixels.push(packed & 15);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(super) fn write_palettes(
|
||||||
|
palettes: &mut [[Color; GLYPH_BANK_COLORS_PER_PALETTE]],
|
||||||
|
position: usize,
|
||||||
|
bytes: &[u8],
|
||||||
|
) {
|
||||||
|
for (i, rgba) in bytes.as_chunks::<4>().0.iter().enumerate() {
|
||||||
|
let at = position / 4 + i;
|
||||||
|
palettes[at / 16][at % 16] = Color::rgba(rgba[0], rgba[1], rgba[2], rgba[3]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(super) fn sound_rate(entry: &AssetEntry) -> Result<u32, String> {
|
||||||
|
Ok(entry.metadata_as_sound_bank()?.sample_rate)
|
||||||
|
}
|
||||||
|
// Callers split on even chunk boundaries. Only the final odd byte is ignored.
|
||||||
|
pub(super) fn append_pcm(data: &mut Vec<i16>, bytes: &[u8]) {
|
||||||
|
data.extend(bytes.as_chunks::<2>().0.iter().map(|p| i16::from_le_bytes(*p)));
|
||||||
|
}
|
||||||
|
pub(super) fn payload_size(entry: &AssetEntry, actual: usize) -> Result<(), String> {
|
||||||
|
if actual as u64 != entry.size {
|
||||||
|
return Err("Invalid asset payload size".into());
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
pub(super) fn scene_metadata(entry: &AssetEntry) -> Result<(), String> {
|
||||||
|
entry.metadata_as_scene_bank().map(|_| ())
|
||||||
|
}
|
||||||
|
pub(super) fn empty_layers() -> [SceneLayer; SCENE_LAYER_COUNT_V1] {
|
||||||
|
std::array::from_fn(|_| SceneLayer {
|
||||||
|
active: false,
|
||||||
|
glyph_asset_id: 0,
|
||||||
|
tile_size: TileSize::Size8,
|
||||||
|
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
||||||
|
tilemap: TileMap { width: 0, height: 0, tiles: Vec::new() },
|
||||||
|
})
|
||||||
|
}
|
||||||
|
pub(super) fn scene_header(bytes: &[u8]) -> Result<(), String> {
|
||||||
|
if bytes.len() < SCENE_HEADER_BYTES_V1 {
|
||||||
|
return Err("Buffer too small for SCENE".into());
|
||||||
|
}
|
||||||
|
if bytes[..4] != SCENE_PAYLOAD_MAGIC_V1 {
|
||||||
|
return Err("Invalid SCENE magic".into());
|
||||||
|
}
|
||||||
|
let version = u16::from_le_bytes([bytes[4], bytes[5]]);
|
||||||
|
if version != SCENE_PAYLOAD_VERSION_V1 {
|
||||||
|
return Err(format!("Unsupported SCENE version: {version}"));
|
||||||
|
}
|
||||||
|
let count = u16::from_le_bytes([bytes[6], bytes[7]]) as usize;
|
||||||
|
if count != SCENE_LAYER_COUNT_V1 {
|
||||||
|
return Err(format!("Invalid SCENE layer count: {count}"));
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
pub(super) fn scene_layer(
|
||||||
|
bytes: &[u8],
|
||||||
|
position: usize,
|
||||||
|
payload_len: u64,
|
||||||
|
decoded: &mut usize,
|
||||||
|
) -> Result<SceneLayer, String> {
|
||||||
|
if bytes.len() < SCENE_LAYER_HEADER_BYTES_V1 {
|
||||||
|
return Err("Buffer too small for SCENE layer header".into());
|
||||||
|
}
|
||||||
|
let u32at = |at| u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap());
|
||||||
|
let tile_size = match bytes[5] {
|
||||||
|
8 => TileSize::Size8,
|
||||||
|
16 => TileSize::Size16,
|
||||||
|
32 => TileSize::Size32,
|
||||||
|
other => return Err(format!("Invalid SCENE tile size: {other}")),
|
||||||
|
};
|
||||||
|
let x = f32::from_le_bytes(bytes[8..12].try_into().unwrap());
|
||||||
|
let y = f32::from_le_bytes(bytes[12..16].try_into().unwrap());
|
||||||
|
if !x.is_finite() || !y.is_finite() {
|
||||||
|
return Err("Invalid SCENE parallax_factor".into());
|
||||||
|
}
|
||||||
|
let width = u32at(16) as usize;
|
||||||
|
let height = u32at(20) as usize;
|
||||||
|
let count = u32at(24) as usize;
|
||||||
|
let expected = width.checked_mul(height).ok_or("SCENE tile count overflow")?;
|
||||||
|
if count != expected {
|
||||||
|
return Err(format!(
|
||||||
|
"Invalid SCENE tile count for layer: expected {expected}, got {count}"
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let end = count
|
||||||
|
.checked_mul(SCENE_TILE_RECORD_BYTES_V1)
|
||||||
|
.and_then(|n| position.checked_add(n))
|
||||||
|
.ok_or("SCENE payload overflow")?;
|
||||||
|
if end as u64 > payload_len {
|
||||||
|
return Err("Buffer too small for SCENE tile data".into());
|
||||||
|
}
|
||||||
|
*decoded = decoded
|
||||||
|
.checked_add(SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1)
|
||||||
|
.and_then(|n| count.checked_mul(size_of::<Tile>()).and_then(|b| n.checked_add(b)))
|
||||||
|
.ok_or("SCENE decoded_size overflow")?;
|
||||||
|
Ok(SceneLayer {
|
||||||
|
active: bytes[0] & 1 != 0,
|
||||||
|
glyph_asset_id: i32::from_le_bytes(bytes[1..5].try_into().unwrap()),
|
||||||
|
tile_size,
|
||||||
|
parallax_factor: ParallaxFactor { x, y },
|
||||||
|
tilemap: TileMap { width, height, tiles: Vec::with_capacity(count) },
|
||||||
|
})
|
||||||
|
}
|
||||||
|
pub(super) fn append_tiles(tiles: &mut Vec<Tile>, bytes: &[u8]) {
|
||||||
|
tiles.extend(bytes.as_chunks::<SCENE_TILE_RECORD_BYTES_V1>().0.iter().map(|b| Tile {
|
||||||
|
active: b[0] & 1 != 0,
|
||||||
|
glyph: Glyph { glyph_id: u16::from_le_bytes([b[2], b[3]]), palette_id: b[1] },
|
||||||
|
flip_x: b[0] & 2 != 0,
|
||||||
|
flip_y: b[0] & 4 != 0,
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
pub(super) fn scene_finish(
|
||||||
|
entry: &AssetEntry,
|
||||||
|
position: usize,
|
||||||
|
decoded: usize,
|
||||||
|
) -> Result<(), String> {
|
||||||
|
payload_size(entry, position)?;
|
||||||
|
if decoded as u64 != entry.decoded_size {
|
||||||
|
return Err(format!(
|
||||||
|
"Invalid SCENE decoded_size: expected {decoded}, got {}",
|
||||||
|
entry.decoded_size
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
pub(super) mod tests;
|
||||||
@@ -0,0 +1,432 @@
|
|||||||
|
use super::*;
|
||||||
|
use serde_json::{Value, json};
|
||||||
|
|
||||||
|
struct FileFixture(std::path::PathBuf);
|
||||||
|
impl FileFixture {
|
||||||
|
fn new(name: &str, bytes: &[u8]) -> Self {
|
||||||
|
let path = std::env::temp_dir()
|
||||||
|
.join(format!("prometeu-conformance-{}-{name}", std::process::id()));
|
||||||
|
std::fs::write(&path, bytes).unwrap();
|
||||||
|
Self(path)
|
||||||
|
}
|
||||||
|
fn source(&self, declared_len: u64) -> Arc<RwLock<AssetsPayloadSource>> {
|
||||||
|
Arc::new(RwLock::new(AssetsPayloadSource::from_file(self.0.clone(), 0, declared_len)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Drop for FileFixture {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
std::fs::remove_file(&self.0).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn pcm_entry(size: u64) -> AssetEntry {
|
||||||
|
AssetEntry {
|
||||||
|
asset_id: 1,
|
||||||
|
asset_name: "pcm".into(),
|
||||||
|
bank_type: BankType::SOUNDS,
|
||||||
|
offset: 0,
|
||||||
|
size,
|
||||||
|
decoded_size: size,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: json!({"sample_rate": 44100, "channels": 1}),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn pcm_chunk_edges_and_odd_tails_have_explicit_baseline_outputs() {
|
||||||
|
for len in [0, 1, 2, 3, 4095, 4096, 4097, 8191, 8192, 8193] {
|
||||||
|
let bytes: Vec<u8> = (0..len).map(|i| if i % 2 == 0 { 0x34 } else { 0x12 }).collect();
|
||||||
|
let entry = pcm_entry(len as u64);
|
||||||
|
let expected = json!([[vec![0x1234_i16; len / 2], 44100, null, null]]);
|
||||||
|
let buffer = AssetManager::decode_sound_bank_from_buffer(&entry, &bytes).unwrap();
|
||||||
|
let reader = AssetManager::decode_sound_bank_from_reader(&entry, &mut &bytes[..]).unwrap();
|
||||||
|
let source = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(bytes)));
|
||||||
|
let production = AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap();
|
||||||
|
assert_eq!(sound_snapshot(&buffer), expected, "buffer len={len}");
|
||||||
|
assert_eq!(sound_snapshot(&reader), expected, "reader len={len}");
|
||||||
|
assert_eq!(sound_snapshot(&production), expected, "legacy load len={len}");
|
||||||
|
assert_eq!(
|
||||||
|
resumable::conformance_result(&entry, &source).unwrap(),
|
||||||
|
expected,
|
||||||
|
"resumable len={len}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn physically_truncated_pcm_file_is_rejected_by_both_modes() {
|
||||||
|
// Two actual bytes, three declared bytes: the missing byte is an odd tail.
|
||||||
|
// The approved rule rejects missing declared bytes, including an odd tail.
|
||||||
|
let fixture = FileFixture::new("truncated-pcm", &[0x34, 0x12]);
|
||||||
|
let entry = pcm_entry(3);
|
||||||
|
let source = fixture.source(3);
|
||||||
|
assert!(AssetManager::perform_load_sound_bank(&entry, source.clone()).is_err());
|
||||||
|
assert!(resumable::conformance_result(&entry, &source).is_err());
|
||||||
|
// With the declared byte physically present, both accept and ignore it.
|
||||||
|
std::fs::write(&fixture.0, [0x34, 0x12, 0xff]).unwrap();
|
||||||
|
let expected = json!([[[0x1234], 44100, null, null]]);
|
||||||
|
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
||||||
|
assert_eq!(
|
||||||
|
sound_snapshot(&AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap()),
|
||||||
|
expected
|
||||||
|
);
|
||||||
|
// Memory carriers reject the range before either decoder can accept it.
|
||||||
|
let memory = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(vec![0x34, 0x12])));
|
||||||
|
assert!(AssetManager::perform_load_sound_bank(&entry, memory.clone()).is_err());
|
||||||
|
assert!(resumable::conformance_result(&entry, &memory).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn physically_short_scene_file_is_rejected_by_both_modes() {
|
||||||
|
// Minimal scene: four empty layers, 12-byte header + 4 * 32-byte headers.
|
||||||
|
let mut bytes = vec![0_u8; 140];
|
||||||
|
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
||||||
|
for start in [12, 44, 76, 108] {
|
||||||
|
bytes[start + 5] = 8;
|
||||||
|
}
|
||||||
|
let fixture = FileFixture::new("short-scene", &bytes);
|
||||||
|
let mut entry = AssetEntry {
|
||||||
|
asset_id: 2,
|
||||||
|
asset_name: "scene".into(),
|
||||||
|
bank_type: BankType::SCENE,
|
||||||
|
offset: 0,
|
||||||
|
size: 141,
|
||||||
|
decoded_size: 64,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: json!({}),
|
||||||
|
};
|
||||||
|
let expected = json!(vec![json!([false, 0, 8, 0.0, 0.0, 0, 0, []]); 4]);
|
||||||
|
let source = fixture.source(141);
|
||||||
|
assert!(AssetManager::perform_load_scene_bank(&entry, source.clone()).is_err());
|
||||||
|
assert!(resumable::conformance_result(&entry, &source).is_err());
|
||||||
|
// Exact physical/declared size is accepted by both.
|
||||||
|
entry.size = 140;
|
||||||
|
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
||||||
|
assert_eq!(
|
||||||
|
scene_snapshot(&AssetManager::perform_load_scene_bank(&entry, source.clone()).unwrap()),
|
||||||
|
expected
|
||||||
|
);
|
||||||
|
// An actual trailing byte is rejected by both.
|
||||||
|
entry.size = 141;
|
||||||
|
bytes.push(0);
|
||||||
|
std::fs::write(&fixture.0, bytes).unwrap();
|
||||||
|
assert!(AssetManager::perform_load_scene_bank(&entry, source.clone()).is_err());
|
||||||
|
assert!(resumable::conformance_result(&entry, &source).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Every mode sees the same declared slice, just as it does in production.
|
||||||
|
fn check_case(name: &str, entry: &AssetEntry, bytes: Vec<u8>, expected: Option<Value>) {
|
||||||
|
let source = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(bytes)));
|
||||||
|
for mode in 0..4 {
|
||||||
|
let result = (|| -> Result<Value, String> {
|
||||||
|
if mode == 3 {
|
||||||
|
return resumable::conformance_result(entry, &source);
|
||||||
|
}
|
||||||
|
if mode == 2 {
|
||||||
|
return match entry.bank_type {
|
||||||
|
BankType::GLYPH => AssetManager::perform_load_glyph_bank(entry, source.clone())
|
||||||
|
.map(|b| glyph_snapshot(&b)),
|
||||||
|
BankType::SOUNDS => {
|
||||||
|
AssetManager::perform_load_sound_bank(entry, source.clone())
|
||||||
|
.map(|b| sound_snapshot(&b))
|
||||||
|
}
|
||||||
|
BankType::SCENE => AssetManager::perform_load_scene_bank(entry, source.clone())
|
||||||
|
.map(|b| scene_snapshot(&b)),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
let slice = source
|
||||||
|
.read()
|
||||||
|
.unwrap()
|
||||||
|
.open_slice(entry.offset, entry.size)
|
||||||
|
.map_err(|e| e.to_string())?;
|
||||||
|
let bytes = slice.read_all().map_err(|e| e.to_string())?;
|
||||||
|
let mut reader = &bytes[..];
|
||||||
|
match (entry.bank_type, mode) {
|
||||||
|
(BankType::GLYPH, 0) => AssetManager::decode_glyph_bank_from_buffer(entry, &bytes)
|
||||||
|
.map(|b| glyph_snapshot(&b)),
|
||||||
|
(BankType::GLYPH, _) => {
|
||||||
|
AssetManager::decode_glyph_bank_from_reader(entry, &mut reader)
|
||||||
|
.map(|b| glyph_snapshot(&b))
|
||||||
|
}
|
||||||
|
(BankType::SOUNDS, 0) => AssetManager::decode_sound_bank_from_buffer(entry, &bytes)
|
||||||
|
.map(|b| sound_snapshot(&b)),
|
||||||
|
(BankType::SOUNDS, _) => {
|
||||||
|
AssetManager::decode_sound_bank_from_reader(entry, &mut reader)
|
||||||
|
.map(|b| sound_snapshot(&b))
|
||||||
|
}
|
||||||
|
(BankType::SCENE, 0) => AssetManager::decode_scene_bank_from_buffer(entry, &bytes)
|
||||||
|
.map(|b| scene_snapshot(&b)),
|
||||||
|
(BankType::SCENE, _) => {
|
||||||
|
AssetManager::decode_scene_bank_from_reader(entry, &mut reader)
|
||||||
|
.map(|b| scene_snapshot(&b))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})();
|
||||||
|
assert_eq!(result.ok(), expected, "{name}, mode={mode}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn glyph_layout_palette_nibbles_and_chunk_boundaries() {
|
||||||
|
for pixels in [0_usize, 1, 2, 8191, 8192, 8193, 16385] {
|
||||||
|
for palettes in [1, 3, 64] {
|
||||||
|
let mut bytes = vec![0x12; pixels.div_ceil(2)];
|
||||||
|
bytes.extend(std::iter::repeat_n([0x12, 0x34, 0x56, 0x78], palettes * 16).flatten());
|
||||||
|
let entry = AssetEntry {
|
||||||
|
asset_id: 1,
|
||||||
|
asset_name: "glyph".into(),
|
||||||
|
bank_type: BankType::GLYPH,
|
||||||
|
offset: 0,
|
||||||
|
size: bytes.len() as u64,
|
||||||
|
decoded_size: (pixels + palettes * 64) as u64,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: json!({"tile_size":16,"width":pixels,"height":1,"palette_count":palettes,"palette_authored":palettes}),
|
||||||
|
};
|
||||||
|
let expected = json!([
|
||||||
|
16,
|
||||||
|
pixels,
|
||||||
|
1,
|
||||||
|
(0..pixels).map(|i| 1 + i % 2).collect::<Vec<_>>(),
|
||||||
|
vec![vec![0x12345678_u32; 16]; palettes]
|
||||||
|
]);
|
||||||
|
check_case("glyph-valid", &entry, bytes.clone(), Some(expected));
|
||||||
|
for (key, value) in [
|
||||||
|
("tile_size", json!(7)),
|
||||||
|
("palette_count", json!(0)),
|
||||||
|
("palette_count", json!(65)),
|
||||||
|
("width", json!(-1)),
|
||||||
|
("height", json!("bad")),
|
||||||
|
] {
|
||||||
|
let mut invalid = entry.clone();
|
||||||
|
invalid.metadata[key] = value;
|
||||||
|
check_case(key, &invalid, bytes.clone(), None);
|
||||||
|
}
|
||||||
|
let mut invalid = entry.clone();
|
||||||
|
invalid.decoded_size += 1;
|
||||||
|
check_case("glyph-decoded-size", &invalid, bytes.clone(), None);
|
||||||
|
let mut invalid = entry.clone();
|
||||||
|
invalid.size += 1;
|
||||||
|
let mut extra = bytes.clone();
|
||||||
|
extra.push(0);
|
||||||
|
check_case("glyph-trailing", &invalid, extra, None);
|
||||||
|
bytes.pop();
|
||||||
|
check_case("glyph-truncated", &entry, bytes, None);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn empty_scene() -> (AssetEntry, Vec<u8>, Value) {
|
||||||
|
let mut bytes = vec![0_u8; 140];
|
||||||
|
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
||||||
|
for start in [12, 44, 76, 108] {
|
||||||
|
bytes[start + 5] = 8;
|
||||||
|
}
|
||||||
|
let entry = AssetEntry {
|
||||||
|
asset_id: 2,
|
||||||
|
asset_name: "scene".into(),
|
||||||
|
bank_type: BankType::SCENE,
|
||||||
|
offset: 0,
|
||||||
|
size: 140,
|
||||||
|
decoded_size: 64,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: json!({}),
|
||||||
|
};
|
||||||
|
(entry, bytes, json!(vec![json!([false, 0, 8, 0.0, 0.0, 0, 0, []]); 4]))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn scene_header_ranges_nonfinite_and_truncation_corpus() {
|
||||||
|
let (entry, bytes, expected) = empty_scene();
|
||||||
|
check_case("empty-scene", &entry, bytes.clone(), Some(expected));
|
||||||
|
for end in 0..bytes.len() {
|
||||||
|
let mut e = entry.clone();
|
||||||
|
e.size = end as u64;
|
||||||
|
check_case("scene-every-truncation", &e, bytes[..end].to_vec(), None);
|
||||||
|
}
|
||||||
|
for (offset, value) in [(0, 0xff), (4, 2), (6, 3), (17, 7), (36, 1)] {
|
||||||
|
let mut invalid = bytes.clone();
|
||||||
|
invalid[offset] = value;
|
||||||
|
check_case("scene-invalid-header-field", &entry, invalid, None);
|
||||||
|
}
|
||||||
|
for offset in [20, 24] {
|
||||||
|
for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
|
||||||
|
let mut invalid = bytes.clone();
|
||||||
|
invalid[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
|
||||||
|
check_case("scene-nonfinite", &entry, invalid, None);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut invalid = bytes.clone();
|
||||||
|
for offset in [28, 32, 36] {
|
||||||
|
invalid[offset..offset + 4].copy_from_slice(&u32::MAX.to_le_bytes());
|
||||||
|
}
|
||||||
|
check_case("scene-dimensions-overflow-or-count-mismatch", &entry, invalid, None);
|
||||||
|
let mut invalid = bytes.clone();
|
||||||
|
for offset in [28, 32, 36] {
|
||||||
|
invalid[offset..offset + 4].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
}
|
||||||
|
// Four layer headers no longer fit after the declared tile consumes bytes.
|
||||||
|
check_case("scene-tile-range", &entry, invalid, None);
|
||||||
|
let mut sequence_metadata = entry.clone();
|
||||||
|
sequence_metadata.metadata = json!([]);
|
||||||
|
check_case(
|
||||||
|
"scene-empty-sequence-metadata",
|
||||||
|
&sequence_metadata,
|
||||||
|
bytes.clone(),
|
||||||
|
Some(empty_scene().2),
|
||||||
|
);
|
||||||
|
let mut e = entry.clone();
|
||||||
|
e.decoded_size += 1;
|
||||||
|
check_case("scene-decoded-size", &e, bytes.clone(), None);
|
||||||
|
e = entry.clone();
|
||||||
|
e.size += 1;
|
||||||
|
let mut trailing = bytes.clone();
|
||||||
|
trailing.push(0);
|
||||||
|
check_case("scene-trailing", &e, trailing, None);
|
||||||
|
for metadata in [json!(null), json!("bad")] {
|
||||||
|
e = entry.clone();
|
||||||
|
e.metadata = metadata;
|
||||||
|
check_case("scene-metadata", &e, bytes.clone(), None);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn scene_tile_chunk_edges_flags_and_reserved_bytes() {
|
||||||
|
for count in [1_usize, 1023, 1024, 1025, 2049] {
|
||||||
|
let (mut entry, mut bytes, mut expected) = empty_scene();
|
||||||
|
bytes[12] = 0xff; // Only the active flag is meaningful.
|
||||||
|
bytes[13..17].copy_from_slice(&(-7_i32).to_le_bytes());
|
||||||
|
bytes[17] = 32;
|
||||||
|
bytes[18..20].copy_from_slice(&[0xff; 2]); // Reserved fields are ignored.
|
||||||
|
bytes[20..24].copy_from_slice(&(-0.5_f32).to_le_bytes());
|
||||||
|
bytes[24..28].copy_from_slice(&2.0_f32.to_le_bytes());
|
||||||
|
bytes[28..32].copy_from_slice(&(count as u32).to_le_bytes());
|
||||||
|
bytes[32..36].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
bytes[36..40].copy_from_slice(&(count as u32).to_le_bytes());
|
||||||
|
bytes.splice(44..44, std::iter::repeat_n([0xff, 255, 0x34, 0x12], count).flatten());
|
||||||
|
entry.size = bytes.len() as u64;
|
||||||
|
entry.decoded_size += (count * size_of::<Tile>()) as u64;
|
||||||
|
expected[0] = json!([
|
||||||
|
true,
|
||||||
|
-7,
|
||||||
|
32,
|
||||||
|
-0.5,
|
||||||
|
2.0,
|
||||||
|
count,
|
||||||
|
1,
|
||||||
|
vec![(true, 0x1234, 255, true, true); count]
|
||||||
|
]);
|
||||||
|
check_case("scene-chunks", &entry, bytes, Some(expected));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn pcm_metadata_and_source_range_corpus() {
|
||||||
|
for metadata in [
|
||||||
|
json!(null),
|
||||||
|
json!({}),
|
||||||
|
json!({"sample_rate":-1,"channels":1}),
|
||||||
|
json!({"sample_rate":44100,"channels":"bad"}),
|
||||||
|
] {
|
||||||
|
let mut e = pcm_entry(2);
|
||||||
|
e.metadata = metadata;
|
||||||
|
check_case("pcm-metadata", &e, vec![0x34, 0x12], None);
|
||||||
|
}
|
||||||
|
// These fields are currently descriptive, not extra PCM layout constraints.
|
||||||
|
let mut e = pcm_entry(2);
|
||||||
|
e.metadata = json!({"sample_rate":0,"channels":0});
|
||||||
|
e.decoded_size = 999;
|
||||||
|
check_case(
|
||||||
|
"pcm-permissive-metadata",
|
||||||
|
&e,
|
||||||
|
vec![0x34, 0x12],
|
||||||
|
Some(json!([[[0x1234], 0, null, null]])),
|
||||||
|
);
|
||||||
|
for offset in [1, u64::MAX] {
|
||||||
|
let mut e = pcm_entry(2);
|
||||||
|
e.offset = offset;
|
||||||
|
check_case("source-range", &e, vec![0x34, 0x12], None);
|
||||||
|
}
|
||||||
|
let mut e = pcm_entry(2);
|
||||||
|
e.size = u64::MAX;
|
||||||
|
check_case("source-size-overflow", &e, vec![0x34, 0x12], None);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(in crate::asset) fn glyph_snapshot(bank: &GlyphBank) -> Value {
|
||||||
|
json!([
|
||||||
|
bank.tile_size as u8,
|
||||||
|
bank.width,
|
||||||
|
bank.height,
|
||||||
|
bank.pixel_indices,
|
||||||
|
bank.palettes
|
||||||
|
.iter()
|
||||||
|
.map(|p| p.iter().map(|c| c.raw()).collect::<Vec<_>>())
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
])
|
||||||
|
}
|
||||||
|
pub(in crate::asset) fn sound_snapshot(bank: &SoundBank) -> Value {
|
||||||
|
json!(
|
||||||
|
bank.samples
|
||||||
|
.iter()
|
||||||
|
.map(|s| (&s.data, s.sample_rate, s.loop_start, s.loop_end))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
pub(in crate::asset) fn scene_snapshot(bank: &SceneBank) -> Value {
|
||||||
|
json!(
|
||||||
|
bank.layers
|
||||||
|
.iter()
|
||||||
|
.map(|l| json!([
|
||||||
|
l.active,
|
||||||
|
l.glyph_asset_id,
|
||||||
|
l.tile_size as u8,
|
||||||
|
l.parallax_factor.x,
|
||||||
|
l.parallax_factor.y,
|
||||||
|
l.tilemap.width,
|
||||||
|
l.tilemap.height,
|
||||||
|
l.tilemap
|
||||||
|
.tiles
|
||||||
|
.iter()
|
||||||
|
.map(|t| (t.active, t.glyph.glyph_id, t.glyph.palette_id, t.flip_x, t.flip_y))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
]))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn shared_scene_arithmetic_rejects_overflow_before_allocating() {
|
||||||
|
let (_, bytes, _) = empty_scene();
|
||||||
|
let mut header = bytes[12..44].to_vec();
|
||||||
|
header[16..20].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
header[20..24].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
header[24..28].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
assert!(scene_layer(&header, usize::MAX, u64::MAX, &mut 0).is_err());
|
||||||
|
let mut decoded = usize::MAX;
|
||||||
|
assert!(scene_layer(&header, 44, 48, &mut decoded).is_err());
|
||||||
|
assert!(scene_layer(&header, 44, 47, &mut 0).is_err());
|
||||||
|
assert!(scene_layer(&header[..31], 44, 48, &mut 0).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn physically_truncated_glyph_palette_is_rejected_by_both_modes() {
|
||||||
|
let fixture = FileFixture::new("truncated-glyph", &[0; 63]);
|
||||||
|
let entry = AssetEntry {
|
||||||
|
asset_id: 3,
|
||||||
|
asset_name: "empty-glyph".into(),
|
||||||
|
bank_type: BankType::GLYPH,
|
||||||
|
offset: 0,
|
||||||
|
size: 64,
|
||||||
|
decoded_size: 64,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: json!({"tile_size":8,"width":0,"height":0,"palette_count":1,"palette_authored":1}),
|
||||||
|
};
|
||||||
|
let source = fixture.source(64);
|
||||||
|
assert!(AssetManager::perform_load_glyph_bank(&entry, source.clone()).is_err());
|
||||||
|
assert!(resumable::conformance_result(&entry, &source).is_err());
|
||||||
|
std::fs::write(&fixture.0, [0; 64]).unwrap();
|
||||||
|
let expected = json!([8, 0, 0, [], vec![vec![0; 16]]]);
|
||||||
|
assert_eq!(
|
||||||
|
glyph_snapshot(&AssetManager::perform_load_glyph_bank(&entry, source.clone()).unwrap()),
|
||||||
|
expected
|
||||||
|
);
|
||||||
|
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
||||||
|
}
|
||||||
@@ -246,7 +246,7 @@ impl Decoder {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::SOUNDS => {
|
BankType::SOUNDS => {
|
||||||
let sample_rate = entry.metadata_as_sound_bank()?.sample_rate;
|
let sample_rate = decode::sound_rate(entry)?;
|
||||||
State::Sound {
|
State::Sound {
|
||||||
sample_rate,
|
sample_rate,
|
||||||
data: Vec::with_capacity(entry.size as usize / 2),
|
data: Vec::with_capacity(entry.size as usize / 2),
|
||||||
@@ -254,15 +254,9 @@ impl Decoder {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
entry.metadata_as_scene_bank()?;
|
decode::scene_metadata(entry)?;
|
||||||
State::Scene {
|
State::Scene {
|
||||||
layers: std::array::from_fn(|_| SceneLayer {
|
layers: decode::empty_layers(),
|
||||||
active: false,
|
|
||||||
glyph_asset_id: 0,
|
|
||||||
tile_size: TileSize::Size8,
|
|
||||||
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
|
||||||
tilemap: TileMap { width: 0, height: 0, tiles: Vec::new() },
|
|
||||||
}),
|
|
||||||
layer: 0,
|
layer: 0,
|
||||||
tiles_left: 0,
|
tiles_left: 0,
|
||||||
header: false,
|
header: false,
|
||||||
@@ -279,25 +273,18 @@ impl Decoder {
|
|||||||
if *position < *packed {
|
if *position < *packed {
|
||||||
let n = (*packed - *position).min(bytes.len());
|
let n = (*packed - *position).min(bytes.len());
|
||||||
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
||||||
for &v in &bytes[..n] {
|
decode::append_pixels(
|
||||||
if bank.pixel_indices.len() < bank.width * bank.height {
|
&mut bank.pixel_indices,
|
||||||
bank.pixel_indices.push(v >> 4)
|
&bytes[..n],
|
||||||
}
|
bank.width * bank.height,
|
||||||
if bank.pixel_indices.len() < bank.width * bank.height {
|
);
|
||||||
bank.pixel_indices.push(v & 15)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
*position += n;
|
*position += n;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
if *palette_position < *palette_bytes {
|
if *palette_position < *palette_bytes {
|
||||||
let n = (*palette_bytes - *palette_position).min(bytes.len());
|
let n = (*palette_bytes - *palette_position).min(bytes.len());
|
||||||
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
||||||
for (i, rgba) in bytes[..n].as_chunks::<4>().0.iter().enumerate() {
|
decode::write_palettes(&mut bank.palettes, *palette_position, &bytes[..n]);
|
||||||
let at = *palette_position / 4 + i;
|
|
||||||
bank.palettes[at / 16][at % 16] =
|
|
||||||
Color::rgba(rgba[0], rgba[1], rgba[2], rgba[3]);
|
|
||||||
}
|
|
||||||
*palette_position += n;
|
*palette_position += n;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
@@ -311,9 +298,7 @@ impl Decoder {
|
|||||||
if *remaining > 0 {
|
if *remaining > 0 {
|
||||||
let n = (*remaining).min(bytes.len());
|
let n = (*remaining).min(bytes.len());
|
||||||
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
||||||
for pair in bytes[..n].as_chunks::<2>().0 {
|
decode::append_pcm(data, &bytes[..n]);
|
||||||
data.push(i16::from_le_bytes([pair[0], pair[1]]));
|
|
||||||
}
|
|
||||||
*remaining -= n;
|
*remaining -= n;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
@@ -327,12 +312,7 @@ impl Decoder {
|
|||||||
self.reader
|
self.reader
|
||||||
.read_exact(&mut bytes[..SCENE_HEADER_BYTES_V1])
|
.read_exact(&mut bytes[..SCENE_HEADER_BYTES_V1])
|
||||||
.map_err(|e| e.to_string())?;
|
.map_err(|e| e.to_string())?;
|
||||||
if bytes[..4] != SCENE_PAYLOAD_MAGIC_V1
|
decode::scene_header(&bytes[..SCENE_HEADER_BYTES_V1])?;
|
||||||
|| u16::from_le_bytes([bytes[4], bytes[5]]) != SCENE_PAYLOAD_VERSION_V1
|
|
||||||
|| u16::from_le_bytes([bytes[6], bytes[7]]) as usize != SCENE_LAYER_COUNT_V1
|
|
||||||
{
|
|
||||||
return Err("Invalid scene header".into());
|
|
||||||
}
|
|
||||||
self.position += SCENE_HEADER_BYTES_V1;
|
self.position += SCENE_HEADER_BYTES_V1;
|
||||||
*header = true;
|
*header = true;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
@@ -341,17 +321,7 @@ impl Decoder {
|
|||||||
let n = (*tiles_left).min(bytes.len() / SCENE_TILE_RECORD_BYTES_V1);
|
let n = (*tiles_left).min(bytes.len() / SCENE_TILE_RECORD_BYTES_V1);
|
||||||
let count = n * SCENE_TILE_RECORD_BYTES_V1;
|
let count = n * SCENE_TILE_RECORD_BYTES_V1;
|
||||||
self.reader.read_exact(&mut bytes[..count]).map_err(|e| e.to_string())?;
|
self.reader.read_exact(&mut bytes[..count]).map_err(|e| e.to_string())?;
|
||||||
for b in bytes[..count].as_chunks::<SCENE_TILE_RECORD_BYTES_V1>().0 {
|
decode::append_tiles(&mut layers[*layer - 1].tilemap.tiles, &bytes[..count]);
|
||||||
layers[*layer - 1].tilemap.tiles.push(Tile {
|
|
||||||
active: b[0] & 1 != 0,
|
|
||||||
glyph: Glyph {
|
|
||||||
glyph_id: u16::from_le_bytes([b[2], b[3]]),
|
|
||||||
palette_id: b[1],
|
|
||||||
},
|
|
||||||
flip_x: b[0] & 2 != 0,
|
|
||||||
flip_y: b[0] & 4 != 0,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
*tiles_left -= n;
|
*tiles_left -= n;
|
||||||
self.position += count;
|
self.position += count;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
@@ -361,50 +331,18 @@ impl Decoder {
|
|||||||
.read_exact(&mut bytes[..SCENE_LAYER_HEADER_BYTES_V1])
|
.read_exact(&mut bytes[..SCENE_LAYER_HEADER_BYTES_V1])
|
||||||
.map_err(|e| e.to_string())?;
|
.map_err(|e| e.to_string())?;
|
||||||
self.position += SCENE_LAYER_HEADER_BYTES_V1;
|
self.position += SCENE_LAYER_HEADER_BYTES_V1;
|
||||||
let u32at = |at| u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap());
|
layers[*layer] = decode::scene_layer(
|
||||||
let width = u32at(16) as usize;
|
&bytes[..SCENE_LAYER_HEADER_BYTES_V1],
|
||||||
let height = u32at(20) as usize;
|
self.position,
|
||||||
let count = u32at(24) as usize;
|
self.entry.size,
|
||||||
let tile_size = match bytes[5] {
|
decoded,
|
||||||
8 => TileSize::Size8,
|
)?;
|
||||||
16 => TileSize::Size16,
|
let count = layers[*layer].tilemap.width * layers[*layer].tilemap.height;
|
||||||
32 => TileSize::Size32,
|
|
||||||
_ => return Err("Invalid scene tile size".into()),
|
|
||||||
};
|
|
||||||
let x = f32::from_le_bytes(bytes[8..12].try_into().unwrap());
|
|
||||||
let y = f32::from_le_bytes(bytes[12..16].try_into().unwrap());
|
|
||||||
if !x.is_finite()
|
|
||||||
|| !y.is_finite()
|
|
||||||
|| width.checked_mul(height) != Some(count)
|
|
||||||
|| count
|
|
||||||
.checked_mul(SCENE_TILE_RECORD_BYTES_V1)
|
|
||||||
.and_then(|n| n.checked_add(self.position))
|
|
||||||
.is_none_or(|n| n as u64 > self.entry.size)
|
|
||||||
{
|
|
||||||
return Err("Invalid scene layer range".into());
|
|
||||||
}
|
|
||||||
*decoded = decoded
|
|
||||||
.checked_add(SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1)
|
|
||||||
.and_then(|n| {
|
|
||||||
count.checked_mul(size_of::<Tile>()).and_then(|b| n.checked_add(b))
|
|
||||||
})
|
|
||||||
.ok_or("Scene size overflow")?;
|
|
||||||
layers[*layer] = SceneLayer {
|
|
||||||
active: bytes[0] & 1 != 0,
|
|
||||||
glyph_asset_id: i32::from_le_bytes(bytes[1..5].try_into().unwrap()),
|
|
||||||
tile_size,
|
|
||||||
parallax_factor: ParallaxFactor { x, y },
|
|
||||||
tilemap: TileMap { width, height, tiles: Vec::with_capacity(count) },
|
|
||||||
};
|
|
||||||
*layer += 1;
|
*layer += 1;
|
||||||
*tiles_left = count;
|
*tiles_left = count;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
if self.position as u64 != self.entry.size
|
decode::scene_finish(&self.entry, self.position, *decoded)?;
|
||||||
|| *decoded as u64 != self.entry.decoded_size
|
|
||||||
{
|
|
||||||
return Err("Invalid scene payload size".into());
|
|
||||||
}
|
|
||||||
let State::Scene { layers, .. } = std::mem::replace(&mut self.state, State::Done)
|
let State::Scene { layers, .. } = std::mem::replace(&mut self.state, State::Done)
|
||||||
else {
|
else {
|
||||||
unreachable!()
|
unreachable!()
|
||||||
@@ -416,6 +354,30 @@ impl Decoder {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Test-only access to the production state machine; no alternate decode rules.
|
||||||
|
#[cfg(test)]
|
||||||
|
pub(super) fn conformance_result(
|
||||||
|
entry: &AssetEntry,
|
||||||
|
source: &Arc<RwLock<AssetsPayloadSource>>,
|
||||||
|
) -> Result<serde_json::Value, String> {
|
||||||
|
use std::io::Seek;
|
||||||
|
let mut decoder = Decoder::new(entry, source)?;
|
||||||
|
for _ in 0..100 {
|
||||||
|
let before = decoder.reader.stream_position().unwrap();
|
||||||
|
let result = decoder.step();
|
||||||
|
let after = decoder.reader.stream_position().unwrap();
|
||||||
|
assert!(after >= before && after - before <= 4096, "unbounded or rewound decode step");
|
||||||
|
if let Some(bank) = result? {
|
||||||
|
return Ok(match bank {
|
||||||
|
Decoded::Glyph(bank) => super::decode::tests::glyph_snapshot(&bank),
|
||||||
|
Decoded::Sound(bank) => super::decode::tests::sound_snapshot(&bank),
|
||||||
|
Decoded::Scene(bank) => super::decode::tests::scene_snapshot(&bank),
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
panic!("conformance fixture exceeded its step budget")
|
||||||
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
@@ -556,4 +518,55 @@ mod tests {
|
|||||||
assert_eq!(manager.preloads_ready(), Ok(true));
|
assert_eq!(manager.preloads_ready(), Ok(true));
|
||||||
assert_eq!(manager.slot_info(SlotRef::audio(0)).asset_id, Some(1));
|
assert_eq!(manager.slot_info(SlotRef::audio(0)).asset_id, Some(1));
|
||||||
}
|
}
|
||||||
|
#[test]
|
||||||
|
fn canceled_and_superseded_partial_decoders_never_publish() {
|
||||||
|
use crate::memory_banks::SoundBankPoolAccess;
|
||||||
|
let bytes = vec![0x12; 16384];
|
||||||
|
let entry = AssetEntry {
|
||||||
|
asset_id: 1,
|
||||||
|
asset_name: "pcm".into(),
|
||||||
|
bank_type: BankType::SOUNDS,
|
||||||
|
offset: 0,
|
||||||
|
size: bytes.len() as u64,
|
||||||
|
decoded_size: bytes.len() as u64,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata: serde_json::json!({"sample_rate":44100,"channels":1}),
|
||||||
|
};
|
||||||
|
let mut newer = entry.clone();
|
||||||
|
newer.asset_id = 2;
|
||||||
|
let banks = Arc::new(crate::memory_banks::MemoryBanks::new());
|
||||||
|
let mut manager = AssetManager::new(
|
||||||
|
vec![entry, newer],
|
||||||
|
AssetsPayloadSource::from_bytes(bytes),
|
||||||
|
banks.clone(),
|
||||||
|
banks.clone(),
|
||||||
|
banks.clone(),
|
||||||
|
);
|
||||||
|
let lane = Arc::new(ManualLane::default());
|
||||||
|
assert!(manager.bind_background_work(lane.clone()));
|
||||||
|
let handle = manager.load(1, 0).unwrap();
|
||||||
|
assert!(lane.step());
|
||||||
|
assert!(lane.step());
|
||||||
|
assert_eq!(manager.status(handle), LoadStatus::LOADING);
|
||||||
|
assert_eq!(manager.cancel(handle), AssetOpStatus::Ok);
|
||||||
|
while lane.step() {}
|
||||||
|
assert_eq!(manager.status(handle), LoadStatus::CANCELED);
|
||||||
|
assert!(manager.sound_policy.staging.read().unwrap().is_empty());
|
||||||
|
manager.apply_commits();
|
||||||
|
assert!(banks.sound_bank_slot(0).is_none());
|
||||||
|
let old = manager.load(1, 0).unwrap();
|
||||||
|
assert!(lane.step());
|
||||||
|
assert!(lane.step());
|
||||||
|
let new = manager.load(2, 0).unwrap();
|
||||||
|
assert_eq!(old, new); // Stable slot handle, different request generation.
|
||||||
|
assert!(lane.step()); // Discard the in-flight old decoder.
|
||||||
|
assert!(manager.sound_policy.staging.read().unwrap().is_empty());
|
||||||
|
while lane.step() {}
|
||||||
|
assert_eq!(manager.status(new), LoadStatus::READY);
|
||||||
|
assert!(banks.sound_bank_slot(0).is_none());
|
||||||
|
assert_eq!(manager.commit(new), AssetOpStatus::Ok);
|
||||||
|
manager.apply_commits();
|
||||||
|
assert_eq!(manager.slot_info(SlotRef::audio(0)).asset_id, Some(2));
|
||||||
|
assert_eq!(banks.sound_bank_slot(0).unwrap().samples[0].data, vec![0x1212; 8192]);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -203,7 +203,8 @@ impl AudioBridge for Audio {
|
|||||||
fn begin_frame(&mut self) { /* Staging may already contain debugger steps. */
|
fn begin_frame(&mut self) { /* Staging may already contain debugger steps. */
|
||||||
}
|
}
|
||||||
fn finish_frame(&mut self) {
|
fn finish_frame(&mut self) {
|
||||||
self.transport.publish(std::mem::take(&mut self.commands), false);
|
let commands = std::mem::replace(&mut self.commands, self.transport.take_buffer());
|
||||||
|
self.transport.publish(commands, false);
|
||||||
self.frame_commands_admitted = 0;
|
self.frame_commands_admitted = 0;
|
||||||
}
|
}
|
||||||
fn abort_frame(&mut self) {
|
fn abort_frame(&mut self) {
|
||||||
@@ -221,7 +222,7 @@ impl AudioBridge for Audio {
|
|||||||
if success {
|
if success {
|
||||||
// Publish the earlier frame prefix first so a callback stop cannot
|
// Publish the earlier frame prefix first so a callback stop cannot
|
||||||
// be undone by an old play on resume. Do not replenish frame quota.
|
// be undone by an old play on resume. Do not replenish frame quota.
|
||||||
let mut commands = std::mem::take(&mut self.commands);
|
let mut commands = std::mem::replace(&mut self.commands, self.transport.take_buffer());
|
||||||
commands.append(&mut self.lifecycle_commands);
|
commands.append(&mut self.lifecycle_commands);
|
||||||
self.transport.publish(commands, true);
|
self.transport.publish(commands, true);
|
||||||
} else {
|
} else {
|
||||||
|
|||||||
@@ -14,6 +14,7 @@ struct Mailbox {
|
|||||||
paused: bool,
|
paused: bool,
|
||||||
frame: Option<Vec<AudioCommand>>,
|
frame: Option<Vec<AudioCommand>>,
|
||||||
lifecycle: Option<Vec<AudioCommand>>,
|
lifecycle: Option<Vec<AudioCommand>>,
|
||||||
|
recycled: [Option<Vec<AudioCommand>>; 4],
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct AudioDelivery {
|
pub struct AudioDelivery {
|
||||||
@@ -36,7 +37,31 @@ impl AudioTransport {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn consume_silently(&self) {
|
pub fn consume_silently(&self) {
|
||||||
let _ = self.try_take();
|
if let Some(delivery) = self.try_take() {
|
||||||
|
for batch in [delivery.frame, delivery.lifecycle].into_iter().flatten() {
|
||||||
|
self.recycle_commands(batch);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Main/service lane only: drop command owners and retain bounded empty storage.
|
||||||
|
pub fn recycle_commands(&self, mut commands: Vec<AudioCommand>) {
|
||||||
|
commands.clear();
|
||||||
|
let mut state = self.0.lock().expect("audio mailbox");
|
||||||
|
if let Some(slot) = state.recycled.iter_mut().find(|slot| slot.is_none()) {
|
||||||
|
*slot = Some(commands);
|
||||||
|
}
|
||||||
|
// Excess empty buffers are destroyed here, never in the data callback.
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn take_buffer(&self) -> Vec<AudioCommand> {
|
||||||
|
self.0
|
||||||
|
.lock()
|
||||||
|
.expect("audio mailbox")
|
||||||
|
.recycled
|
||||||
|
.iter_mut()
|
||||||
|
.find_map(Option::take)
|
||||||
|
.unwrap_or_default()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn ready(&self) -> bool {
|
pub fn ready(&self) -> bool {
|
||||||
@@ -84,3 +109,36 @@ mod tests {
|
|||||||
assert!(transport.try_take().is_some());
|
assert!(transport.try_take().is_some());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod reuse_tests {
|
||||||
|
use super::*;
|
||||||
|
#[test]
|
||||||
|
fn service_recycles_storage_and_releases_sample_owners() {
|
||||||
|
use prometeu_hal::{LoopMode, sample::Sample};
|
||||||
|
let transport = AudioTransport::default();
|
||||||
|
let sample = Arc::new(Sample::new(48000, vec![1]));
|
||||||
|
let weak = Arc::downgrade(&sample);
|
||||||
|
let mut batch = Vec::with_capacity(1024);
|
||||||
|
let allocation = batch.as_ptr();
|
||||||
|
batch.push(AudioCommand::Play {
|
||||||
|
sample,
|
||||||
|
voice_id: 0,
|
||||||
|
volume: 255,
|
||||||
|
pan: 0,
|
||||||
|
pitch: 1.0,
|
||||||
|
priority: 0,
|
||||||
|
loop_mode: LoopMode::Off,
|
||||||
|
});
|
||||||
|
transport.recycle_commands(batch);
|
||||||
|
assert!(weak.upgrade().is_none());
|
||||||
|
let reused = transport.take_buffer();
|
||||||
|
assert_eq!(reused.as_ptr(), allocation);
|
||||||
|
assert_eq!(reused.capacity(), 1024);
|
||||||
|
assert!(reused.is_empty());
|
||||||
|
for _ in 0..8 {
|
||||||
|
transport.recycle_commands(Vec::with_capacity(16));
|
||||||
|
}
|
||||||
|
assert_eq!(transport.0.lock().unwrap().recycled.iter().flatten().count(), 4);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -664,7 +664,7 @@ mod tests {
|
|||||||
assert!(frame_composer.bind_scene(0));
|
assert!(frame_composer.bind_scene(0));
|
||||||
|
|
||||||
let cache = frame_composer.cache().expect("cache should exist for bound scene");
|
let cache = frame_composer.cache().expect("cache should exist for bound scene");
|
||||||
assert_eq!((cache.width(), cache.height()), (65, 38));
|
assert_eq!((cache.width(), cache.height()), (85, 49));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|||||||
@@ -43,6 +43,8 @@ pub struct Gfx {
|
|||||||
front: Vec<u32>,
|
front: Vec<u32>,
|
||||||
/// Back buffer: the working buffer where canonical game frames are composed
|
/// Back buffer: the working buffer where canonical game frames are composed
|
||||||
back: Vec<u32>,
|
back: Vec<u32>,
|
||||||
|
/// Complete local framebuffer publications, including native Hub/Shell output.
|
||||||
|
publication_count: u64,
|
||||||
|
|
||||||
/// Shared access to graphical memory banks (tiles and palettes).
|
/// Shared access to graphical memory banks (tiles and palettes).
|
||||||
pub glyph_banks: Arc<dyn GlyphBankPoolAccess>,
|
pub glyph_banks: Arc<dyn GlyphBankPoolAccess>,
|
||||||
@@ -321,6 +323,7 @@ impl Gfx {
|
|||||||
h,
|
h,
|
||||||
front: vec![0; len],
|
front: vec![0; len],
|
||||||
back: vec![0; len],
|
back: vec![0; len],
|
||||||
|
publication_count: 0,
|
||||||
glyph_banks,
|
glyph_banks,
|
||||||
sprites: [EMPTY_SPRITE; 512],
|
sprites: [EMPTY_SPRITE; 512],
|
||||||
sprite_count: 0,
|
sprite_count: 0,
|
||||||
@@ -570,6 +573,11 @@ impl Gfx {
|
|||||||
/// Typically called by the Host when it's time to display the finished frame.
|
/// Typically called by the Host when it's time to display the finished frame.
|
||||||
pub fn present(&mut self) {
|
pub fn present(&mut self) {
|
||||||
std::mem::swap(&mut self.front, &mut self.back);
|
std::mem::swap(&mut self.front, &mut self.back);
|
||||||
|
self.publication_count = self.publication_count.wrapping_add(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn publication_count(&self) -> u64 {
|
||||||
|
self.publication_count
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn load_frame_sprites(&mut self, sprites: &[Sprite]) {
|
pub fn load_frame_sprites(&mut self, sprites: &[Sprite]) {
|
||||||
|
|||||||
@@ -28,7 +28,7 @@ use std::sync::Arc;
|
|||||||
/// for easier testing and different host implementations (Desktop, Web, etc.).
|
/// for easier testing and different host implementations (Desktop, Web, etc.).
|
||||||
///
|
///
|
||||||
/// ### Console Specifications:
|
/// ### Console Specifications:
|
||||||
/// - **Resolution**: 480x270 (16:9 Aspect Ratio).
|
/// - **Resolution**: 640x360 (16:9 Aspect Ratio).
|
||||||
/// - **Color Format**: RGBA8888.
|
/// - **Color Format**: RGBA8888.
|
||||||
/// - **Audio**: Stereo, Command-based mixing.
|
/// - **Audio**: Stereo, Command-based mixing.
|
||||||
/// - **Input**: 12-button Digital Gamepad + Absolute Touch/Mouse.
|
/// - **Input**: 12-button Digital Gamepad + Absolute Touch/Mouse.
|
||||||
@@ -201,9 +201,9 @@ impl RuntimePlatform for Hardware {
|
|||||||
|
|
||||||
impl Hardware {
|
impl Hardware {
|
||||||
/// Internal hardware width in pixels.
|
/// Internal hardware width in pixels.
|
||||||
pub const W: usize = 480;
|
pub const W: usize = prometeu_hal::graphics_contract::WIDTH;
|
||||||
/// Internal hardware height in pixels.
|
/// Internal hardware height in pixels.
|
||||||
pub const H: usize = 270;
|
pub const H: usize = prometeu_hal::graphics_contract::HEIGHT;
|
||||||
|
|
||||||
/// Creates a fresh hardware instance with default settings.
|
/// Creates a fresh hardware instance with default settings.
|
||||||
pub fn new(wall_clock: Arc<dyn WallClock>) -> Self {
|
pub fn new(wall_clock: Arc<dyn WallClock>) -> Self {
|
||||||
|
|||||||
@@ -5,6 +5,8 @@ mod gfx;
|
|||||||
pub mod hardware;
|
pub mod hardware;
|
||||||
mod local_render_backend;
|
mod local_render_backend;
|
||||||
mod memory_banks;
|
mod memory_banks;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod native_graphics_tests;
|
||||||
mod pad;
|
mod pad;
|
||||||
mod test_platform;
|
mod test_platform;
|
||||||
mod touch;
|
mod touch;
|
||||||
|
|||||||
@@ -13,7 +13,8 @@ fn io_error(e: std::io::Error) -> Error {
|
|||||||
use std::io::ErrorKind as K;
|
use std::io::ErrorKind as K;
|
||||||
match e.kind() {
|
match e.kind() {
|
||||||
K::NotFound => Error::Unavailable,
|
K::NotFound => Error::Unavailable,
|
||||||
K::PermissionDenied => Error::ReadOnly,
|
K::PermissionDenied => Error::AccessDenied,
|
||||||
|
K::AlreadyExists => Error::AlreadyExists,
|
||||||
K::StorageFull => Error::NoSpace,
|
K::StorageFull => Error::NoSpace,
|
||||||
K::InvalidInput | K::UnexpectedEof => Error::InvalidRange,
|
K::InvalidInput | K::UnexpectedEof => Error::InvalidRange,
|
||||||
K::Unsupported => Error::Unsupported,
|
K::Unsupported => Error::Unsupported,
|
||||||
@@ -21,8 +22,15 @@ fn io_error(e: std::io::Error) -> Error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl FileMemcard {
|
impl FileMemcard {
|
||||||
|
fn lock(file: &File) -> Result<(), Error> {
|
||||||
|
file.try_lock().map_err(|error| match error {
|
||||||
|
std::fs::TryLockError::WouldBlock => Error::Busy,
|
||||||
|
std::fs::TryLockError::Error(error) => io_error(error),
|
||||||
|
})
|
||||||
|
}
|
||||||
pub fn open(path: &Path, read_only: bool) -> Result<Self, Error> {
|
pub fn open(path: &Path, read_only: bool) -> Result<Self, Error> {
|
||||||
let file = OpenOptions::new().read(true).write(!read_only).open(path).map_err(io_error)?;
|
let file = OpenOptions::new().read(true).write(!read_only).open(path).map_err(io_error)?;
|
||||||
|
Self::lock(&file)?;
|
||||||
let length = file.metadata().map_err(io_error)?.len();
|
let length = file.metadata().map_err(io_error)?.len();
|
||||||
Ok(Self { file, length, read_only })
|
Ok(Self { file, length, read_only })
|
||||||
}
|
}
|
||||||
@@ -47,7 +55,9 @@ impl FileMemcard {
|
|||||||
.create_new(true)
|
.create_new(true)
|
||||||
.open(&temporary)
|
.open(&temporary)
|
||||||
.map_err(io_error)?;
|
.map_err(io_error)?;
|
||||||
|
let mut published = false;
|
||||||
let result = (|| {
|
let result = (|| {
|
||||||
|
Self::lock(&file)?;
|
||||||
let mut card = Self { file, length, read_only: false };
|
let mut card = Self { file, length, read_only: false };
|
||||||
let zeros = [0u8; 65_536];
|
let zeros = [0u8; 65_536];
|
||||||
let mut offset = 0;
|
let mut offset = 0;
|
||||||
@@ -64,6 +74,7 @@ impl FileMemcard {
|
|||||||
card.sync()?;
|
card.sync()?;
|
||||||
// hard_link publishes without replacing a user file; parent sync makes the name durable.
|
// hard_link publishes without replacing a user file; parent sync makes the name durable.
|
||||||
std::fs::hard_link(&temporary, path).map_err(io_error)?;
|
std::fs::hard_link(&temporary, path).map_err(io_error)?;
|
||||||
|
published = true;
|
||||||
File::open(parent).and_then(|f| f.sync_all()).map_err(io_error)?;
|
File::open(parent).and_then(|f| f.sync_all()).map_err(io_error)?;
|
||||||
Ok(card)
|
Ok(card)
|
||||||
})();
|
})();
|
||||||
@@ -71,10 +82,10 @@ impl FileMemcard {
|
|||||||
std::fs::remove_file(&temporary).and_then(|()| File::open(parent)?.sync_all());
|
std::fs::remove_file(&temporary).and_then(|()| File::open(parent)?.sync_all());
|
||||||
match result {
|
match result {
|
||||||
Ok(card) => {
|
Ok(card) => {
|
||||||
cleanup.map_err(io_error)?;
|
cleanup.map_err(|_| Error::Indeterminate)?;
|
||||||
Ok(card)
|
Ok(card)
|
||||||
}
|
}
|
||||||
Err(e) => Err(e),
|
Err(e) => Err(if published { Error::Indeterminate } else { e }),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[cfg(not(unix))]
|
#[cfg(not(unix))]
|
||||||
|
|||||||
@@ -0,0 +1,109 @@
|
|||||||
|
use crate::{Gfx, GlyphBankPoolInstaller, MemoryBanks};
|
||||||
|
use prometeu_hal::color::Color;
|
||||||
|
use prometeu_hal::glyph::Glyph;
|
||||||
|
use prometeu_hal::glyph_bank::{GlyphBank, TileSize};
|
||||||
|
use prometeu_hal::graphics_contract::{FRAME_BYTES, HEIGHT, PIXELS, WIDTH};
|
||||||
|
use prometeu_hal::scene_bank::SceneBank;
|
||||||
|
use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer};
|
||||||
|
use prometeu_hal::scene_viewport_cache::SceneViewportCache;
|
||||||
|
use prometeu_hal::scene_viewport_resolver::SceneViewportResolver;
|
||||||
|
use prometeu_hal::tile::Tile;
|
||||||
|
use prometeu_hal::tilemap::TileMap;
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn native_allocation_stride_corners_and_external_coordinates() {
|
||||||
|
let mut gfx = Gfx::new(WIDTH, HEIGHT, Arc::new(MemoryBanks::new()));
|
||||||
|
assert_eq!(gfx.publication_count(), 0);
|
||||||
|
gfx.clear(Color::BLACK);
|
||||||
|
for (x, y) in [(0, 0), (639, 0), (0, 359), (639, 359)] {
|
||||||
|
gfx.draw_pixel(x, y, Color::RED);
|
||||||
|
}
|
||||||
|
for (x, y) in [(-1, 0), (640, 359), (639, 360), (0, -1)] {
|
||||||
|
gfx.draw_pixel(x, y, Color::GREEN);
|
||||||
|
}
|
||||||
|
assert_eq!(gfx.publication_count(), 0, "drawing is not a complete publication");
|
||||||
|
gfx.present();
|
||||||
|
assert_eq!(gfx.publication_count(), 1);
|
||||||
|
let front = gfx.front_buffer();
|
||||||
|
assert_eq!(gfx.size(), (640, 360));
|
||||||
|
assert_eq!(front.len(), PIXELS);
|
||||||
|
assert_eq!(std::mem::size_of_val(front), FRAME_BYTES);
|
||||||
|
for index in [0, 639, 359 * WIDTH, PIXELS - 1] {
|
||||||
|
assert_eq!(front[index], Color::RED.raw());
|
||||||
|
}
|
||||||
|
assert_eq!(front.iter().filter(|&&p| p == Color::RED.raw()).count(), 4);
|
||||||
|
gfx.present();
|
||||||
|
assert_eq!(gfx.publication_count(), 2, "each complete swap is a publication");
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn native_tile_edges_and_mixed_camera_layers_cover_every_corner() {
|
||||||
|
for sizes in [
|
||||||
|
[TileSize::Size8; 4],
|
||||||
|
[TileSize::Size16; 4],
|
||||||
|
[TileSize::Size32; 4],
|
||||||
|
[TileSize::Size8, TileSize::Size16, TileSize::Size32, TileSize::Size8],
|
||||||
|
] {
|
||||||
|
let banks = Arc::new(MemoryBanks::new());
|
||||||
|
let colors = [Color::RED, Color::GREEN, Color::BLUE, Color::WHITE];
|
||||||
|
for i in 0..4 {
|
||||||
|
let n = sizes[i] as usize;
|
||||||
|
let mut bank = GlyphBank::new(sizes[i], n, n);
|
||||||
|
bank.palettes[0][1] = colors[i];
|
||||||
|
bank.pixel_indices.fill(1);
|
||||||
|
banks.install_glyph_bank(i, Arc::new(bank));
|
||||||
|
}
|
||||||
|
let scene = SceneBank {
|
||||||
|
layers: std::array::from_fn(|i| SceneLayer {
|
||||||
|
active: true,
|
||||||
|
glyph_asset_id: i as i32,
|
||||||
|
tile_size: sizes[i],
|
||||||
|
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
||||||
|
tilemap: TileMap {
|
||||||
|
width: 160,
|
||||||
|
height: 120,
|
||||||
|
tiles: vec![
|
||||||
|
Tile {
|
||||||
|
active: true,
|
||||||
|
glyph: Glyph { glyph_id: 0, palette_id: 0 },
|
||||||
|
flip_x: true,
|
||||||
|
flip_y: true,
|
||||||
|
};
|
||||||
|
160 * 120
|
||||||
|
],
|
||||||
|
},
|
||||||
|
}),
|
||||||
|
};
|
||||||
|
let min = sizes.iter().map(|s| *s as usize).min().unwrap();
|
||||||
|
let (cw, ch) = (WIDTH.div_ceil(min) + 5, HEIGHT.div_ceil(min) + 4);
|
||||||
|
let mut cache = SceneViewportCache::new(&scene, cw, ch);
|
||||||
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
WIDTH as i32,
|
||||||
|
HEIGHT as i32,
|
||||||
|
cw,
|
||||||
|
ch,
|
||||||
|
min as i32 - 4,
|
||||||
|
min as i32 + 4,
|
||||||
|
);
|
||||||
|
let mut gfx = Gfx::new(WIDTH, HEIGHT, banks);
|
||||||
|
for (x, y) in [(0, 0), (1, 1), (7, 7), (15, 15), (31, 31), (400, 300), (2, 3)] {
|
||||||
|
let update = resolver.update(&scene, x, y);
|
||||||
|
for request in &update.copy_requests {
|
||||||
|
cache.move_layer_window_to(
|
||||||
|
request.layer_index,
|
||||||
|
request.cache_origin_tile_x,
|
||||||
|
request.cache_origin_tile_y,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
cache.materialize_all_layers(&scene);
|
||||||
|
gfx.render_scene_from_cache(&cache, &update, &[0, 1, 2, 3]);
|
||||||
|
gfx.present();
|
||||||
|
// Every pixel, including rows 352..359, must be supplied by the last layer.
|
||||||
|
assert!(
|
||||||
|
gfx.front_buffer().iter().all(|&p| p == Color::WHITE.raw()),
|
||||||
|
"sizes={sizes:?}, camera=({x},{y})"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -18,6 +18,8 @@ impl ControlledWallClock {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Advance civil time explicitly, saturating at the largest timestamp.
|
/// Advance civil time explicitly, saturating at the largest timestamp.
|
||||||
|
// `try_update` requires Rust 1.95; keep older stable CI toolchains compatible.
|
||||||
|
#[allow(deprecated)]
|
||||||
pub fn advance(&self, seconds: u64) {
|
pub fn advance(&self, seconds: u64) {
|
||||||
// Harness control may retry on a concurrent update; reads remain a single load.
|
// Harness control may retry on a concurrent update; reads remain a single load.
|
||||||
let _ = self.seconds.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |current| {
|
let _ = self.seconds.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |current| {
|
||||||
|
|||||||
@@ -609,7 +609,7 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn front_buffer_pixel(platform: &TestPlatform, x: i32, y: i32) -> u32 {
|
fn front_buffer_pixel(platform: &TestPlatform, x: i32, y: i32) -> u32 {
|
||||||
const FRAMEBUFFER_WIDTH: usize = 480;
|
const FRAMEBUFFER_WIDTH: usize = prometeu_hal::graphics_contract::WIDTH;
|
||||||
let index = x as usize + y as usize * FRAMEBUFFER_WIDTH;
|
let index = x as usize + y as usize * FRAMEBUFFER_WIDTH;
|
||||||
platform.local_hardware().gfx.front_buffer()[index]
|
platform.local_hardware().gfx.front_buffer()[index]
|
||||||
}
|
}
|
||||||
@@ -1094,7 +1094,9 @@ mod tests {
|
|||||||
assert_eq!(dummy_ownership.app_id, 2);
|
assert_eq!(dummy_ownership.app_id, 2);
|
||||||
|
|
||||||
let front = platform.local_hardware().gfx.front_buffer();
|
let front = platform.local_hardware().gfx.front_buffer();
|
||||||
let center = 240 + 135 * 480;
|
let center = prometeu_hal::graphics_contract::WIDTH / 2
|
||||||
|
+ (prometeu_hal::graphics_contract::HEIGHT / 2)
|
||||||
|
* prometeu_hal::graphics_contract::WIDTH;
|
||||||
assert_eq!(front[center], Color::GREEN.raw());
|
assert_eq!(front[center], Color::GREEN.raw());
|
||||||
|
|
||||||
firmware.request_home_from_host();
|
firmware.request_home_from_host();
|
||||||
@@ -1512,8 +1514,12 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn shell_running_close_click_uses_lifecycle_and_returns_hub_home() {
|
fn shell_running_close_click_uses_lifecycle_and_returns_hub_home() {
|
||||||
let (mut firmware, mut platform, _signals, task_id) = load_shell_running_firmware();
|
let (mut firmware, mut platform, _signals, task_id) = load_shell_running_firmware();
|
||||||
let close_signals =
|
let close_signals = InputSignals {
|
||||||
InputSignals { f_signal: true, x_pos: 420, y_pos: 24, ..Default::default() };
|
f_signal: true,
|
||||||
|
x_pos: prometeu_hal::graphics_contract::WIDTH as i32 - 60,
|
||||||
|
y_pos: 24,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
|
||||||
firmware.tick(&close_signals, &mut platform);
|
firmware.tick(&close_signals, &mut platform);
|
||||||
|
|
||||||
|
|||||||
@@ -47,7 +47,12 @@ impl HubHomeStep {
|
|||||||
let id = ctx.os.windows().add_window(
|
let id = ctx.os.windows().add_window(
|
||||||
app.title().to_string(),
|
app.title().to_string(),
|
||||||
WindowOwner::Task(task_id),
|
WindowOwner::Task(task_id),
|
||||||
Rect { x: 40, y: 20, w: 400, h: 220 },
|
Rect {
|
||||||
|
x: 40,
|
||||||
|
y: 20,
|
||||||
|
w: prometeu_hal::graphics_contract::WIDTH as i32 - 80,
|
||||||
|
h: prometeu_hal::graphics_contract::HEIGHT as i32 - 50,
|
||||||
|
},
|
||||||
app.color(),
|
app.color(),
|
||||||
);
|
);
|
||||||
ctx.os.windows().set_focus(id);
|
ctx.os.windows().set_focus(id);
|
||||||
|
|||||||
@@ -48,6 +48,25 @@ impl LoadCartridgeStep {
|
|||||||
pub fn needs_memcard_choice(&self) -> bool {
|
pub fn needs_memcard_choice(&self) -> bool {
|
||||||
self.awaiting_memcard && !self.preparing_memcard
|
self.awaiting_memcard && !self.preparing_memcard
|
||||||
}
|
}
|
||||||
|
/// Typed host and UI admission share this single policy boundary.
|
||||||
|
pub fn choose_memcard(
|
||||||
|
&mut self,
|
||||||
|
os: &mut prometeu_system::SystemOS,
|
||||||
|
choice: prometeu_system::memcard::admission::Choice,
|
||||||
|
created_at: u64,
|
||||||
|
) -> prometeu_system::memcard::image::Result<()> {
|
||||||
|
if !self.needs_memcard_choice() {
|
||||||
|
return Err(prometeu_system::memcard::image::Error::InvalidState);
|
||||||
|
}
|
||||||
|
os.memcard().choose_for_game(
|
||||||
|
self.cartridge.app_id,
|
||||||
|
self.cartridge.memcard_slots.unwrap() as usize,
|
||||||
|
choice,
|
||||||
|
created_at,
|
||||||
|
)?;
|
||||||
|
self.preparing_memcard = true;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
pub fn new_game_switch(cartridge: Cartridge) -> Self {
|
pub fn new_game_switch(cartridge: Cartridge) -> Self {
|
||||||
Self { failure_recovery: LoadCartridgeFailureRecovery::ReturnToHub, ..Self::new(cartridge) }
|
Self { failure_recovery: LoadCartridgeFailureRecovery::ReturnToHub, ..Self::new(cartridge) }
|
||||||
@@ -128,13 +147,8 @@ impl LoadCartridgeStep {
|
|||||||
Choice::MemoryExisting
|
Choice::MemoryExisting
|
||||||
};
|
};
|
||||||
let created_at = ctx.platform.wall_clock().utc_unix_seconds();
|
let created_at = ctx.platform.wall_clock().utc_unix_seconds();
|
||||||
match ctx.os.memcard().choose_for_game(
|
match self.choose_memcard(ctx.os, choice, created_at) {
|
||||||
self.cartridge.app_id,
|
Ok(()) => {}
|
||||||
self.cartridge.memcard_slots.unwrap() as usize,
|
|
||||||
choice,
|
|
||||||
created_at,
|
|
||||||
) {
|
|
||||||
Ok(()) => self.preparing_memcard = true,
|
|
||||||
Err(error) => self.memcard_message = Self::preparation_message(error),
|
Err(error) => self.memcard_message = Self::preparation_message(error),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,20 @@
|
|||||||
|
//! Fixed machine graphics contract. Host surfaces never change these dimensions.
|
||||||
|
pub const WIDTH: usize = 640;
|
||||||
|
pub const HEIGHT: usize = 360;
|
||||||
|
pub const REFRESH_HZ: u32 = 60;
|
||||||
|
/// Canonical RGBA8888, with tightly packed native rows.
|
||||||
|
pub const BYTES_PER_PIXEL: usize = 4;
|
||||||
|
pub const PIXELS: usize = WIDTH * HEIGHT;
|
||||||
|
pub const STRIDE_PIXELS: usize = WIDTH;
|
||||||
|
pub const STRIDE_BYTES: usize = STRIDE_PIXELS * BYTES_PER_PIXEL;
|
||||||
|
pub const FRAME_BYTES: usize = STRIDE_BYTES * HEIGHT;
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
#[test]
|
||||||
|
fn native_graphics_contract_is_fixed() {
|
||||||
|
assert_eq!((WIDTH, HEIGHT, REFRESH_HZ), (640, 360, 60));
|
||||||
|
assert_eq!((PIXELS, STRIDE_BYTES, FRAME_BYTES), (230_400, 2_560, 921_600));
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -12,6 +12,7 @@ pub mod debugger_protocol;
|
|||||||
pub mod gfx_bridge;
|
pub mod gfx_bridge;
|
||||||
pub mod glyph;
|
pub mod glyph;
|
||||||
pub mod glyph_bank;
|
pub mod glyph_bank;
|
||||||
|
pub mod graphics_contract;
|
||||||
pub mod host_context;
|
pub mod host_context;
|
||||||
pub mod host_return;
|
pub mod host_return;
|
||||||
pub mod input_signals;
|
pub mod input_signals;
|
||||||
|
|||||||
@@ -57,6 +57,21 @@ impl LogService {
|
|||||||
self.events.iter().filter(|e| e.seq > seq).cloned().collect()
|
self.events.iter().filter(|e| e.seq > seq).cloned().collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Non-destructive page in native sequence order. A null cursor includes zero.
|
||||||
|
pub fn get_page(&self, after: Option<u64>, limit: usize) -> Vec<LogEvent> {
|
||||||
|
self.events
|
||||||
|
.iter()
|
||||||
|
.filter(|event| after.is_none_or(|seq| event.seq > seq))
|
||||||
|
.take(limit)
|
||||||
|
.cloned()
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retained bounds, independent of any reader's progress.
|
||||||
|
pub fn sequence_bounds(&self) -> (Option<u64>, Option<u64>) {
|
||||||
|
(self.events.front().map(|event| event.seq), self.last_seq())
|
||||||
|
}
|
||||||
|
|
||||||
pub fn last_seq(&self) -> Option<u64> {
|
pub fn last_seq(&self) -> Option<u64> {
|
||||||
self.events.back().map(|e| e.seq)
|
self.events.back().map(|e| e.seq)
|
||||||
}
|
}
|
||||||
@@ -107,4 +122,35 @@ mod tests {
|
|||||||
assert_eq!(after[0].msg, "Log 3");
|
assert_eq!(after[0].msg, "Log 3");
|
||||||
assert_eq!(after[1].msg, "Log 4");
|
assert_eq!(after[1].msg, "Log 4");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn pages_preserve_zero_requery_and_retained_bounds() {
|
||||||
|
let mut service = LogService::new(3);
|
||||||
|
assert_eq!(service.sequence_bounds(), (None, None));
|
||||||
|
assert!(service.get_page(None, 2).is_empty());
|
||||||
|
for i in 0..3 {
|
||||||
|
service.log(i, i, LogLevel::Info, LogSource::Pos, 7, format!("{i}"));
|
||||||
|
}
|
||||||
|
assert_eq!(service.sequence_bounds(), (Some(0), Some(2)));
|
||||||
|
for _ in 0..2 {
|
||||||
|
let page = service.get_page(None, 2);
|
||||||
|
assert_eq!(page.iter().map(|event| event.seq).collect::<Vec<_>>(), vec![0, 1]);
|
||||||
|
}
|
||||||
|
assert_eq!(service.get_page(Some(1), 2)[0].seq, 2);
|
||||||
|
assert!(service.get_page(Some(2), 2).is_empty());
|
||||||
|
service.log(3, 3, LogLevel::Info, LogSource::Pos, 7, "next".into());
|
||||||
|
assert_eq!(service.sequence_bounds(), (Some(1), Some(3)));
|
||||||
|
assert_eq!(service.get_page(Some(2), 2)[0].seq, 3);
|
||||||
|
assert_eq!(service.get_page(None, 10).len(), 3);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn page_cursors_preserve_large_unsigned_sequences() {
|
||||||
|
let mut service = LogService::new(3);
|
||||||
|
service.next_seq = u64::MAX - 2;
|
||||||
|
service.log(0, 0, LogLevel::Info, LogSource::Pos, 0, "first".into());
|
||||||
|
service.log(0, 0, LogLevel::Info, LogSource::Pos, 0, "second".into());
|
||||||
|
assert_eq!(service.get_page(Some(u64::MAX - 2), 1)[0].seq, u64::MAX - 1);
|
||||||
|
assert!(service.get_page(Some(u64::MAX), 1).is_empty());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -6,6 +6,10 @@ pub enum MemcardIoError {
|
|||||||
InvalidRange,
|
InvalidRange,
|
||||||
NoSpace,
|
NoSpace,
|
||||||
Unsupported,
|
Unsupported,
|
||||||
|
Busy,
|
||||||
|
AccessDenied,
|
||||||
|
AlreadyExists,
|
||||||
|
Indeterminate,
|
||||||
IoError,
|
IoError,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -64,7 +64,7 @@ pub trait RuntimePlatform {
|
|||||||
fn wall_clock(&self) -> &dyn WallClock;
|
fn wall_clock(&self) -> &dyn WallClock;
|
||||||
|
|
||||||
fn display_size(&self) -> (usize, usize) {
|
fn display_size(&self) -> (usize, usize) {
|
||||||
(480, 270)
|
(crate::graphics_contract::WIDTH, crate::graphics_contract::HEIGHT)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink;
|
fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink;
|
||||||
|
|||||||
@@ -224,6 +224,8 @@ impl SceneViewportResolver {
|
|||||||
scene_height_tiles: usize,
|
scene_height_tiles: usize,
|
||||||
) -> TileAnchor {
|
) -> TileAnchor {
|
||||||
let mut next = current;
|
let mut next = current;
|
||||||
|
// Mixed layers must not step past the center and immediately step back.
|
||||||
|
let trigger = self.hysteresis_trigger_px.max(tile_size_px / 2);
|
||||||
|
|
||||||
loop {
|
loop {
|
||||||
let center_x_px = next.x * tile_size_px + tile_size_px / 2;
|
let center_x_px = next.x * tile_size_px + tile_size_px / 2;
|
||||||
@@ -231,11 +233,11 @@ impl SceneViewportResolver {
|
|||||||
if drift_x.abs() <= self.hysteresis_safe_px {
|
if drift_x.abs() <= self.hysteresis_safe_px {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if drift_x > self.hysteresis_trigger_px {
|
if drift_x > trigger {
|
||||||
next.x += 1;
|
next.x += 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if drift_x < -self.hysteresis_trigger_px {
|
if drift_x < -trigger {
|
||||||
next.x -= 1;
|
next.x -= 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
@@ -248,11 +250,11 @@ impl SceneViewportResolver {
|
|||||||
if drift_y.abs() <= self.hysteresis_safe_px {
|
if drift_y.abs() <= self.hysteresis_safe_px {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if drift_y > self.hysteresis_trigger_px {
|
if drift_y > trigger {
|
||||||
next.y += 1;
|
next.y += 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if drift_y < -self.hysteresis_trigger_px {
|
if drift_y < -trigger {
|
||||||
next.y -= 1;
|
next.y -= 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
@@ -433,20 +435,34 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn first_update_initializes_master_and_layer_anchors() {
|
fn first_update_initializes_master_and_layer_anchors() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let update = resolver.update(&scene, 0, 0);
|
let update = resolver.update(&scene, 0, 0);
|
||||||
|
|
||||||
assert_eq!(update.master_anchor, TileAnchor { x: 17, y: 10 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 22, y: 13 });
|
||||||
assert_eq!(update.layer_anchors[0], TileAnchor { x: 17, y: 10 });
|
assert_eq!(update.layer_anchors[0], TileAnchor { x: 22, y: 13 });
|
||||||
assert_eq!(update.layer_anchors[1], TileAnchor { x: 17, y: 10 });
|
assert_eq!(update.layer_anchors[1], TileAnchor { x: 22, y: 13 });
|
||||||
assert_eq!(update.refresh_requests.len(), 4);
|
assert_eq!(update.refresh_requests.len(), 4);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn per_layer_copy_requests_follow_parallax_factor() {
|
fn per_layer_copy_requests_follow_parallax_factor() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let update = resolver.update(&scene, 32, 48);
|
let update = resolver.update(&scene, 32, 48);
|
||||||
|
|
||||||
@@ -461,24 +477,38 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn hysteresis_prevents_small_back_and_forth_refresh_churn() {
|
fn hysteresis_prevents_small_back_and_forth_refresh_churn() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let _ = resolver.update(&scene, 0, 0);
|
let _ = resolver.update(&scene, 0, 0);
|
||||||
let update = resolver.update(&scene, 8, 0);
|
let update = resolver.update(&scene, 8, 0);
|
||||||
|
|
||||||
assert!(update.refresh_requests.is_empty());
|
assert!(update.refresh_requests.is_empty());
|
||||||
assert_eq!(update.master_anchor, TileAnchor { x: 17, y: 10 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 22, y: 13 });
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn repeated_high_speed_movement_advances_in_tile_steps() {
|
fn repeated_high_speed_movement_advances_in_tile_steps() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let _ = resolver.update(&scene, 0, 0);
|
let _ = resolver.update(&scene, 0, 0);
|
||||||
let update = resolver.update(&scene, 64, 0);
|
let update = resolver.update(&scene, 64, 0);
|
||||||
|
|
||||||
assert!(update.master_anchor.x > 17);
|
assert!(update.master_anchor.x > 22);
|
||||||
assert!(update.refresh_requests.iter().any(|request| matches!(
|
assert!(update.refresh_requests.iter().any(|request| matches!(
|
||||||
request,
|
request,
|
||||||
CacheRefreshRequest::RefreshColumn { layer_index: 0, .. }
|
CacheRefreshRequest::RefreshColumn { layer_index: 0, .. }
|
||||||
@@ -489,18 +519,32 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn anchors_clamp_near_scene_edges() {
|
fn anchors_clamp_near_scene_edges() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let update = resolver.update(&scene, 10_000, 10_000);
|
let update = resolver.update(&scene, 10_000, 10_000);
|
||||||
|
|
||||||
assert_eq!(update.master_anchor, TileAnchor { x: 46, y: 53 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 41, y: 50 });
|
||||||
assert_eq!(update.layer_anchors[0], TileAnchor { x: 46, y: 53 });
|
assert_eq!(update.layer_anchors[0], TileAnchor { x: 41, y: 50 });
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn corner_trigger_converts_to_non_overlapping_region_requests() {
|
fn corner_trigger_converts_to_non_overlapping_region_requests() {
|
||||||
let scene = make_scene();
|
let scene = make_scene();
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let _ = resolver.update(&scene, 0, 0);
|
let _ = resolver.update(&scene, 0, 0);
|
||||||
let update = resolver.update(&scene, 64, 80);
|
let update = resolver.update(&scene, 64, 80);
|
||||||
@@ -515,15 +559,22 @@ mod tests {
|
|||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
assert_eq!(regions.len(), 2);
|
assert_eq!(regions.len(), 2);
|
||||||
assert_eq!(regions[0].x + regions[0].width, 35);
|
assert_eq!(regions[0].x + regions[0].width, 45);
|
||||||
assert_eq!(regions[0].height, 21);
|
assert_eq!(regions[0].height, 27);
|
||||||
assert_eq!(regions[1].width, 34);
|
assert_eq!(regions[1].width, 44);
|
||||||
assert_eq!(regions[1].height, 2);
|
assert_eq!(regions[1].height, 2);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn reset_scene_requests_full_invalidation_for_all_layers() {
|
fn reset_scene_requests_full_invalidation_for_all_layers() {
|
||||||
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
let mut resolver = SceneViewportResolver::new(
|
||||||
|
crate::graphics_contract::WIDTH as i32,
|
||||||
|
crate::graphics_contract::HEIGHT as i32,
|
||||||
|
45,
|
||||||
|
27,
|
||||||
|
12,
|
||||||
|
20,
|
||||||
|
);
|
||||||
|
|
||||||
let requests = resolver.reset_scene();
|
let requests = resolver.reset_scene();
|
||||||
|
|
||||||
|
|||||||
@@ -385,6 +385,14 @@ impl<'a> VmFacade<'a> {
|
|||||||
self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
|
self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn record_presented_render_worker_frame(
|
||||||
|
&self,
|
||||||
|
ownership: RenderOwnership,
|
||||||
|
frame_id: FrameId,
|
||||||
|
) {
|
||||||
|
self.os.vm_runtime.record_presented_render_worker_frame(ownership, frame_id);
|
||||||
|
}
|
||||||
|
|
||||||
pub fn active_render_ownership(&self) -> RenderOwnership {
|
pub fn active_render_ownership(&self) -> RenderOwnership {
|
||||||
if let Some(task_id) = self.foreground_session_task_id()
|
if let Some(task_id) = self.foreground_session_task_id()
|
||||||
&& let Some(session) = self.os.vm_sessions.for_task(task_id)
|
&& let Some(session) = self.os.vm_sessions.for_task(task_id)
|
||||||
|
|||||||
@@ -64,6 +64,14 @@ impl SystemOS {
|
|||||||
pub fn memcard(&mut self) -> &mut MemcardService {
|
pub fn memcard(&mut self) -> &mut MemcardService {
|
||||||
&mut self.memcard
|
&mut self.memcard
|
||||||
}
|
}
|
||||||
|
/// A successful return confirms the shared worker has stopped and joined.
|
||||||
|
pub fn stop_background_io(&mut self) -> Result<(), crate::AsyncWorkLaneError> {
|
||||||
|
if let Some(controller) = &mut self.io_controller {
|
||||||
|
controller.stop()?;
|
||||||
|
}
|
||||||
|
self.io_controller = None;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
/// Host/player operations are admitted only while gameplay is suspended.
|
/// Host/player operations are admitted only while gameplay is suspended.
|
||||||
pub fn replace_memcard(
|
pub fn replace_memcard(
|
||||||
@@ -162,6 +170,16 @@ impl SystemOS {
|
|||||||
self.log_service.get_after(seq)
|
self.log_service.get_after(seq)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Coherent non-destructive page and retained bounds; does not execute the VM.
|
||||||
|
pub fn log_snapshot(
|
||||||
|
&self,
|
||||||
|
after: Option<u64>,
|
||||||
|
limit: usize,
|
||||||
|
) -> (Vec<LogEvent>, Option<u64>, Option<u64>) {
|
||||||
|
let (oldest, newest) = self.log_service.sequence_bounds();
|
||||||
|
(self.log_service.get_page(after, limit), oldest, newest)
|
||||||
|
}
|
||||||
|
|
||||||
pub fn frame_index(&mut self) -> u64 {
|
pub fn frame_index(&mut self) -> u64 {
|
||||||
self.vm().logical_frame_index()
|
self.vm().logical_frame_index()
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -10,19 +10,41 @@ use prometeu_hal::{
|
|||||||
|
|
||||||
const SHELL_A_BUTTON: Rect = Rect { x: 112, y: 172, w: 112, h: 32 };
|
const SHELL_A_BUTTON: Rect = Rect { x: 112, y: 172, w: 112, h: 32 };
|
||||||
const SHELL_B_BUTTON: Rect = Rect { x: 256, y: 172, w: 112, h: 32 };
|
const SHELL_B_BUTTON: Rect = Rect { x: 256, y: 172, w: 112, h: 32 };
|
||||||
const CLOSE_BUTTON: Rect = Rect { x: 420, y: 24, w: 16, h: 16 };
|
const CLOSE_BUTTON: Rect =
|
||||||
const VIEWPORT: Rect = Rect { x: 0, y: 0, w: 480, h: 270 };
|
Rect { x: prometeu_hal::graphics_contract::WIDTH as i32 - 60, y: 24, w: 16, h: 16 };
|
||||||
const HOME_PANEL: Rect = Rect { x: 48, y: 58, w: 384, h: 154 };
|
const VIEWPORT: Rect = Rect {
|
||||||
const TITLE_PANEL: Rect = Rect { x: 72, y: 34, w: 336, h: 28 };
|
x: 0,
|
||||||
|
y: 0,
|
||||||
|
w: prometeu_hal::graphics_contract::WIDTH as i32,
|
||||||
|
h: prometeu_hal::graphics_contract::HEIGHT as i32,
|
||||||
|
};
|
||||||
|
const HOME_PANEL: Rect = Rect {
|
||||||
|
x: 48,
|
||||||
|
y: 58,
|
||||||
|
w: prometeu_hal::graphics_contract::WIDTH as i32 - 96,
|
||||||
|
h: prometeu_hal::graphics_contract::HEIGHT as i32 - 116,
|
||||||
|
};
|
||||||
|
const TITLE_PANEL: Rect =
|
||||||
|
Rect { x: 72, y: 34, w: prometeu_hal::graphics_contract::WIDTH as i32 - 144, h: 28 };
|
||||||
const GAME_ROW_X: i32 = 72;
|
const GAME_ROW_X: i32 = 72;
|
||||||
const GAME_ROW_Y: i32 = 90;
|
const GAME_ROW_Y: i32 = 90;
|
||||||
const GAME_ROW_W: i32 = 336;
|
const GAME_ROW_W: i32 = prometeu_hal::graphics_contract::WIDTH as i32 - 144;
|
||||||
const GAME_ROW_H: i32 = 22;
|
const GAME_ROW_H: i32 = 22;
|
||||||
const GAME_ROW_GAP: i32 = 6;
|
const GAME_ROW_GAP: i32 = 6;
|
||||||
const MAX_HOME_GAME_ROWS: usize = 3;
|
const MAX_HOME_GAME_ROWS: usize = 3;
|
||||||
pub const HUB_SUSPENDED_GAME_KILL_CONTROL: Rect = Rect { x: 288, y: 230, w: 168, h: 24 };
|
pub const HUB_SUSPENDED_GAME_KILL_CONTROL: Rect = Rect {
|
||||||
|
x: prometeu_hal::graphics_contract::WIDTH as i32 - 192,
|
||||||
|
y: prometeu_hal::graphics_contract::HEIGHT as i32 - 40,
|
||||||
|
w: 168,
|
||||||
|
h: 24,
|
||||||
|
};
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
const SHELL_FRAME: Rect = Rect { x: 40, y: 20, w: 400, h: 220 };
|
const SHELL_FRAME: Rect = Rect {
|
||||||
|
x: 40,
|
||||||
|
y: 20,
|
||||||
|
w: prometeu_hal::graphics_contract::WIDTH as i32 - 80,
|
||||||
|
h: prometeu_hal::graphics_contract::HEIGHT as i32 - 50,
|
||||||
|
};
|
||||||
|
|
||||||
const COLOR_BG: Color = Color::rgb(12, 14, 22);
|
const COLOR_BG: Color = Color::rgb(12, 14, 22);
|
||||||
const COLOR_PANEL: Color = Color::rgb(25, 31, 48);
|
const COLOR_PANEL: Color = Color::rgb(25, 31, 48);
|
||||||
|
|||||||
@@ -2,6 +2,7 @@
|
|||||||
//! shared IO worker owns storage during a publication. Legacy per-slot files are
|
//! shared IO worker owns storage during a publication. Legacy per-slot files are
|
||||||
//! intentionally neither read nor migrated by this service.
|
//! intentionally neither read nor migrated by this service.
|
||||||
pub mod admission;
|
pub mod admission;
|
||||||
|
pub mod diagnostics;
|
||||||
pub mod guest;
|
pub mod guest;
|
||||||
pub mod image;
|
pub mod image;
|
||||||
pub mod session;
|
pub mod session;
|
||||||
|
|||||||
@@ -37,6 +37,7 @@ pub struct Admission {
|
|||||||
pub state: PreparationState,
|
pub state: PreparationState,
|
||||||
pub snapshot_budget: usize,
|
pub snapshot_budget: usize,
|
||||||
faulted: bool,
|
faulted: bool,
|
||||||
|
replacement_observation: Option<super::diagnostics::SessionDiagnostics>,
|
||||||
}
|
}
|
||||||
impl Default for Admission {
|
impl Default for Admission {
|
||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
@@ -48,10 +49,26 @@ impl Default for Admission {
|
|||||||
state: PreparationState::Idle,
|
state: PreparationState::Idle,
|
||||||
snapshot_budget: DEFAULT_SNAPSHOT_BUDGET,
|
snapshot_budget: DEFAULT_SNAPSHOT_BUDGET,
|
||||||
faulted: false,
|
faulted: false,
|
||||||
|
replacement_observation: None,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl MemcardService {
|
impl MemcardService {
|
||||||
|
pub fn session_diagnostics(&self) -> super::diagnostics::SessionDiagnostics {
|
||||||
|
self.admission.replacement_observation.clone().unwrap_or_else(|| self.session.diagnostics())
|
||||||
|
}
|
||||||
|
pub fn preparation_active(&self) -> bool {
|
||||||
|
self.admission.receiver.is_some()
|
||||||
|
}
|
||||||
|
pub fn installed_card_id(&self) -> Option<[u8; 16]> {
|
||||||
|
self.admission.installed.as_ref().map(|c| c.current().card_id)
|
||||||
|
}
|
||||||
|
pub fn cancel_pending(&mut self) {
|
||||||
|
self.session.cancel_pending();
|
||||||
|
if let Some(control) = &self.admission.control {
|
||||||
|
control.cancel();
|
||||||
|
}
|
||||||
|
}
|
||||||
pub fn host_faulted(&self) -> bool {
|
pub fn host_faulted(&self) -> bool {
|
||||||
self.admission.faulted || self.session.host_faulted()
|
self.admission.faulted || self.session.host_faulted()
|
||||||
}
|
}
|
||||||
@@ -60,7 +77,11 @@ impl MemcardService {
|
|||||||
}
|
}
|
||||||
pub fn installed_health(&self) -> Option<(bool, bool, bool)> {
|
pub fn installed_health(&self) -> Option<(bool, bool, bool)> {
|
||||||
self.admission.installed.as_ref().map(|card| {
|
self.admission.installed.as_ref().map(|card| {
|
||||||
(card.recovered, card.degraded, card.write_blocked || card.storage_read_only())
|
(
|
||||||
|
card.recovered,
|
||||||
|
card.degraded,
|
||||||
|
card.write_blocked || card.storage_read_only() || card.uncertain,
|
||||||
|
)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn card_has_game(&self, app_id: u32) -> bool {
|
pub fn card_has_game(&self, app_id: u32) -> bool {
|
||||||
@@ -135,6 +156,9 @@ impl MemcardService {
|
|||||||
let owned =
|
let owned =
|
||||||
card.catalog.games.iter().find(|g| g.app_id == app_id).map_or(0, |g| g.slots.len());
|
card.catalog.games.iter().find(|g| g.app_id == app_id).map_or(0, |g| g.slots.len());
|
||||||
if choice == Choice::Persistent {
|
if choice == Choice::Persistent {
|
||||||
|
if card.uncertain {
|
||||||
|
return Err(Error::Indeterminate);
|
||||||
|
}
|
||||||
if card.storage_read_only() || card.write_blocked {
|
if card.storage_read_only() || card.write_blocked {
|
||||||
return Err(Error::ReadOnly);
|
return Err(Error::ReadOnly);
|
||||||
}
|
}
|
||||||
@@ -171,6 +195,10 @@ impl MemcardService {
|
|||||||
}
|
}
|
||||||
Choice::Persistent => {
|
Choice::Persistent => {
|
||||||
let mut card = card.take().unwrap();
|
let mut card = card.take().unwrap();
|
||||||
|
if card.uncertain {
|
||||||
|
session.retain_idle_card(card);
|
||||||
|
return Err(Error::Indeterminate);
|
||||||
|
}
|
||||||
if card.storage_read_only() || card.write_blocked {
|
if card.storage_read_only() || card.write_blocked {
|
||||||
session.retain_idle_card(card);
|
session.retain_idle_card(card);
|
||||||
return Err(Error::ReadOnly);
|
return Err(Error::ReadOnly);
|
||||||
@@ -256,9 +284,24 @@ impl MemcardService {
|
|||||||
&mut self,
|
&mut self,
|
||||||
storage: Box<dyn MemcardStorage>,
|
storage: Box<dyn MemcardStorage>,
|
||||||
load_existing: bool,
|
load_existing: bool,
|
||||||
|
) -> Result<()> {
|
||||||
|
self.replace_card_job(move |session, control| {
|
||||||
|
session.replace_storage(storage, load_existing, control)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
pub fn reconcile_card_with(
|
||||||
|
&mut self,
|
||||||
|
open: impl FnOnce() -> Result<Box<dyn MemcardStorage>> + Send + 'static,
|
||||||
|
) -> Result<()> {
|
||||||
|
self.replace_card_job(move |session, control| session.reconcile_storage_with(open, control))
|
||||||
|
}
|
||||||
|
fn replace_card_job(
|
||||||
|
&mut self,
|
||||||
|
operation: impl FnOnce(&mut Session, &PublicationControl) -> Result<()> + Send + 'static,
|
||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
if self.admission.receiver.is_some()
|
if self.admission.receiver.is_some()
|
||||||
|| self.session.has_in_flight()
|
|| self.session.io_active()
|
||||||
|
|| self.session.has_deferred_write()
|
||||||
|| self.session.is_boot_active()
|
|| self.session.is_boot_active()
|
||||||
{
|
{
|
||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
@@ -266,6 +309,7 @@ impl MemcardService {
|
|||||||
if self.admission.faulted {
|
if self.admission.faulted {
|
||||||
return Err(Error::ReadOnly);
|
return Err(Error::ReadOnly);
|
||||||
}
|
}
|
||||||
|
self.admission.replacement_observation = Some(self.session.diagnostics());
|
||||||
let handoff = Arc::new(Mutex::new(Some(std::mem::take(&mut self.session))));
|
let handoff = Arc::new(Mutex::new(Some(std::mem::take(&mut self.session))));
|
||||||
let worker = handoff.clone();
|
let worker = handoff.clone();
|
||||||
let control = Arc::new(PublicationControl::default());
|
let control = Arc::new(PublicationControl::default());
|
||||||
@@ -275,13 +319,14 @@ impl MemcardService {
|
|||||||
.lane
|
.lane
|
||||||
.submit_memcard_commit_write(move |_| {
|
.submit_memcard_commit_write(move |_| {
|
||||||
let mut session = worker.lock().unwrap().take().unwrap();
|
let mut session = worker.lock().unwrap().take().unwrap();
|
||||||
let result = session.replace_storage(storage, load_existing, &worker_control);
|
let result = operation(&mut session, &worker_control);
|
||||||
let _ = tx.send(Prepared::Replacement(session, result));
|
let _ = tx.send(Prepared::Replacement(session, result));
|
||||||
crate::AsyncWorkJobOutcome::Completed
|
crate::AsyncWorkJobOutcome::Completed
|
||||||
})
|
})
|
||||||
.is_err()
|
.is_err()
|
||||||
{
|
{
|
||||||
self.session = handoff.lock().unwrap().take().unwrap();
|
self.session = handoff.lock().unwrap().take().unwrap();
|
||||||
|
self.admission.replacement_observation = None;
|
||||||
return Err(Error::InvalidState);
|
return Err(Error::InvalidState);
|
||||||
}
|
}
|
||||||
self.admission.control = Some(control);
|
self.admission.control = Some(control);
|
||||||
@@ -331,6 +376,7 @@ impl MemcardService {
|
|||||||
}
|
}
|
||||||
self.admission.receiver = None;
|
self.admission.receiver = None;
|
||||||
self.admission.control = None;
|
self.admission.control = None;
|
||||||
|
self.admission.replacement_observation = None;
|
||||||
}
|
}
|
||||||
Err(mpsc::TryRecvError::Disconnected) => {
|
Err(mpsc::TryRecvError::Disconnected) => {
|
||||||
self.admission.state = PreparationState::Failed(Error::InvalidState);
|
self.admission.state = PreparationState::Failed(Error::InvalidState);
|
||||||
@@ -361,3 +407,37 @@ impl MemcardService {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(all(test, unix))]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
use prometeu_drivers::memcard::FileMemcard;
|
||||||
|
use prometeu_hal::memcard::MemcardIoError;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn idle_uncertain_media_remains_blocked_before_another_persistent_admission() {
|
||||||
|
let path = std::env::temp_dir().join(format!(
|
||||||
|
"memcard-uncertain-idle-{}-{}",
|
||||||
|
std::process::id(),
|
||||||
|
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
|
||||||
|
));
|
||||||
|
let io = FileMemcard::create(&path, IMAGE_BYTES, |io, id| {
|
||||||
|
Card::format(io, id).map_err(|_| MemcardIoError::IoError)
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
let mut card = Card::mount(Box::new(io)).unwrap();
|
||||||
|
card.uncertain = true;
|
||||||
|
let mut service = MemcardService::new();
|
||||||
|
// An ended session returns its backend to the same installed-card state.
|
||||||
|
service.admission.installed = Some(card);
|
||||||
|
assert_eq!(service.installed_health(), Some((false, false, true)));
|
||||||
|
assert_eq!(
|
||||||
|
service.choose_for_game(42, 1, Choice::Persistent, 0),
|
||||||
|
Err(Error::Indeterminate)
|
||||||
|
);
|
||||||
|
assert!(service.card_installed());
|
||||||
|
assert_eq!(service.lane.pending_depth(), 0);
|
||||||
|
service.uninstall_card().unwrap();
|
||||||
|
std::fs::remove_file(path).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -0,0 +1,31 @@
|
|||||||
|
//! Read-only native observations. These do not consume the guest request entry.
|
||||||
|
use super::{
|
||||||
|
image::Error,
|
||||||
|
session::{Mode, RequestResult},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct RequestDiagnostics {
|
||||||
|
pub result: RequestResult,
|
||||||
|
pub storage_error: Option<Error>,
|
||||||
|
pub slot: Option<usize>,
|
||||||
|
pub operation: &'static str,
|
||||||
|
pub retained: bool,
|
||||||
|
pub io_active: bool,
|
||||||
|
pub deferred: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct SessionDiagnostics {
|
||||||
|
pub app_id: Option<u32>,
|
||||||
|
pub card_id: Option<[u8; 16]>,
|
||||||
|
pub epoch: u64,
|
||||||
|
pub mode: Option<Mode>,
|
||||||
|
pub health: (bool, bool, bool),
|
||||||
|
pub dirty_slots: Vec<usize>,
|
||||||
|
pub request: Option<RequestDiagnostics>,
|
||||||
|
pub io_active: bool,
|
||||||
|
pub removal_pending: bool,
|
||||||
|
pub reconciliation_required: bool,
|
||||||
|
pub restart_required: bool,
|
||||||
|
}
|
||||||
@@ -31,12 +31,14 @@ pub fn status(e: Error) -> i64 {
|
|||||||
use prometeu_hal::memcard::MemcardIoError as I;
|
use prometeu_hal::memcard::MemcardIoError as I;
|
||||||
match e {
|
match e {
|
||||||
Error::NoSpace | Error::Io(I::NoSpace) => 3,
|
Error::NoSpace | Error::Io(I::NoSpace) => 3,
|
||||||
Error::AccessDenied => 4,
|
Error::AccessDenied
|
||||||
|
| Error::IdentityMismatch
|
||||||
|
| Error::Io(I::AccessDenied | I::AlreadyExists) => 4,
|
||||||
Error::Corrupt => 5,
|
Error::Corrupt => 5,
|
||||||
Error::Indeterminate => 6,
|
Error::Indeterminate | Error::Io(I::Indeterminate) => 6,
|
||||||
Error::Io(I::Unavailable) => 7,
|
Error::Io(I::Unavailable) => 7,
|
||||||
Error::InvalidState | Error::Canceled => 8,
|
Error::InvalidState | Error::Canceled => 8,
|
||||||
Error::Busy => 9,
|
Error::Busy | Error::Io(I::Busy) => 9,
|
||||||
Error::ReadOnly | Error::CounterExhausted | Error::Io(I::ReadOnly) => 10,
|
Error::ReadOnly | Error::CounterExhausted | Error::Io(I::ReadOnly) => 10,
|
||||||
Error::InvalidRange | Error::Io(I::InvalidRange) => 11,
|
Error::InvalidRange | Error::Io(I::InvalidRange) => 11,
|
||||||
Error::Unsupported | Error::Io(I::Unsupported) => 12,
|
Error::Unsupported | Error::Io(I::Unsupported) => 12,
|
||||||
|
|||||||
@@ -29,6 +29,7 @@ pub enum Error {
|
|||||||
OutOfMemory,
|
OutOfMemory,
|
||||||
AccessDenied,
|
AccessDenied,
|
||||||
InvalidState,
|
InvalidState,
|
||||||
|
IdentityMismatch,
|
||||||
}
|
}
|
||||||
impl From<MemcardIoError> for Error {
|
impl From<MemcardIoError> for Error {
|
||||||
fn from(e: MemcardIoError) -> Self {
|
fn from(e: MemcardIoError) -> Self {
|
||||||
|
|||||||
@@ -7,6 +7,8 @@ use std::time::{Duration, Instant};
|
|||||||
|
|
||||||
pub const GUEST_BYTES: usize = 4096;
|
pub const GUEST_BYTES: usize = 4096;
|
||||||
static NEXT_CONTEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
static NEXT_CONTEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
||||||
|
// `try_update` requires Rust 1.95; keep older stable CI toolchains compatible.
|
||||||
|
#[allow(deprecated)]
|
||||||
fn next_context() -> Result<u64> {
|
fn next_context() -> Result<u64> {
|
||||||
NEXT_CONTEXT
|
NEXT_CONTEXT
|
||||||
.fetch_update(
|
.fetch_update(
|
||||||
@@ -65,16 +67,20 @@ struct Request {
|
|||||||
control: Arc<PublicationControl>,
|
control: Arc<PublicationControl>,
|
||||||
receiver: mpsc::Receiver<Completion>,
|
receiver: mpsc::Receiver<Completion>,
|
||||||
admitted: Instant,
|
admitted: Instant,
|
||||||
|
watchdog_canceled_at: Option<Instant>,
|
||||||
|
worker_error: Option<Error>,
|
||||||
result: RequestResult,
|
result: RequestResult,
|
||||||
job: AsyncWorkJobId,
|
job: AsyncWorkJobId,
|
||||||
released: bool,
|
released: bool,
|
||||||
saves_payload: bool,
|
saves_payload: bool,
|
||||||
|
worker_returned: bool,
|
||||||
}
|
}
|
||||||
/// Main-lane control; the Card moves into the single worker while its source is protected.
|
/// Main-lane control; the Card moves into the single worker while its source is protected.
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
pub struct Session {
|
pub struct Session {
|
||||||
card_id: Option<[u8; 16]>,
|
card_id: Option<[u8; 16]>,
|
||||||
uncertain_target: Option<Map>,
|
uncertain_target: Option<Map>,
|
||||||
|
known_card_exclusions: Option<([u8; 16], [bool; BLOCK_COUNT])>,
|
||||||
health: (bool, bool, bool),
|
health: (bool, bool, bool),
|
||||||
context: u64,
|
context: u64,
|
||||||
epoch: u64,
|
epoch: u64,
|
||||||
@@ -98,6 +104,82 @@ pub struct Session {
|
|||||||
deferred: Option<(u64, usize, u64, Instant)>,
|
deferred: Option<(u64, usize, u64, Instant)>,
|
||||||
}
|
}
|
||||||
impl Session {
|
impl Session {
|
||||||
|
/// IO ownership, independent of a completed result retained for guest release.
|
||||||
|
pub fn io_active(&self) -> bool {
|
||||||
|
self.request.as_ref().is_some_and(|r| !r.worker_returned)
|
||||||
|
}
|
||||||
|
pub fn has_deferred_write(&self) -> bool {
|
||||||
|
self.deferred.is_some()
|
||||||
|
}
|
||||||
|
pub fn cancel_pending(&mut self) {
|
||||||
|
if let Some(r) = &self.request {
|
||||||
|
r.control.cancel();
|
||||||
|
}
|
||||||
|
if let Some((id, local, ..)) = self.deferred.take() {
|
||||||
|
self.slots[local].protected = false;
|
||||||
|
self.memory_result = Some(RequestResult {
|
||||||
|
id,
|
||||||
|
state: RequestState::Failure,
|
||||||
|
reason: RequestReason::Storage(Error::Canceled),
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn diagnostics(&self) -> super::diagnostics::SessionDiagnostics {
|
||||||
|
use super::diagnostics::{RequestDiagnostics, SessionDiagnostics};
|
||||||
|
let request = if let Some((id, local, ..)) = self.deferred {
|
||||||
|
Some(RequestDiagnostics {
|
||||||
|
result: RequestResult {
|
||||||
|
id,
|
||||||
|
state: RequestState::Pending,
|
||||||
|
reason: RequestReason::None,
|
||||||
|
},
|
||||||
|
storage_error: None,
|
||||||
|
slot: Some(local),
|
||||||
|
operation: "commit",
|
||||||
|
retained: true,
|
||||||
|
io_active: false,
|
||||||
|
deferred: true,
|
||||||
|
})
|
||||||
|
} else if let Some(r) = &self.request {
|
||||||
|
Some(RequestDiagnostics {
|
||||||
|
result: r.result,
|
||||||
|
storage_error: r.worker_error,
|
||||||
|
slot: r.saves_payload.then_some(r.local),
|
||||||
|
operation: if r.saves_payload { "commit" } else { "presentation" },
|
||||||
|
retained: !r.released,
|
||||||
|
io_active: self.io_active(),
|
||||||
|
deferred: false,
|
||||||
|
})
|
||||||
|
} else {
|
||||||
|
self.memory_result.map(|result| RequestDiagnostics {
|
||||||
|
result,
|
||||||
|
storage_error: None,
|
||||||
|
slot: None,
|
||||||
|
operation: "commit",
|
||||||
|
retained: true,
|
||||||
|
io_active: false,
|
||||||
|
deferred: false,
|
||||||
|
})
|
||||||
|
};
|
||||||
|
SessionDiagnostics {
|
||||||
|
app_id: self.mode.map(|_| self.app_id),
|
||||||
|
card_id: self.card_id,
|
||||||
|
epoch: self.epoch,
|
||||||
|
mode: self.mode,
|
||||||
|
health: self.health(),
|
||||||
|
dirty_slots: self
|
||||||
|
.slots
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.filter_map(|(i, s)| s.data.read().ok().filter(|s| s.dirty).map(|_| i))
|
||||||
|
.collect(),
|
||||||
|
request,
|
||||||
|
io_active: self.io_active(),
|
||||||
|
removal_pending: self.removal_pending,
|
||||||
|
reconciliation_required: self.reconcile_blocked,
|
||||||
|
restart_required: self.faulted,
|
||||||
|
}
|
||||||
|
}
|
||||||
pub fn context(&self) -> u64 {
|
pub fn context(&self) -> u64 {
|
||||||
self.context
|
self.context
|
||||||
}
|
}
|
||||||
@@ -523,10 +605,13 @@ impl Session {
|
|||||||
control,
|
control,
|
||||||
receiver,
|
receiver,
|
||||||
admitted,
|
admitted,
|
||||||
|
watchdog_canceled_at: None,
|
||||||
|
worker_error: None,
|
||||||
result: RequestResult { id, state: RequestState::Pending, reason: RequestReason::None },
|
result: RequestResult { id, state: RequestState::Pending, reason: RequestReason::None },
|
||||||
job,
|
job,
|
||||||
released: !saves_payload,
|
released: !saves_payload,
|
||||||
saves_payload,
|
saves_payload,
|
||||||
|
worker_returned: false,
|
||||||
});
|
});
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
@@ -664,10 +749,13 @@ impl Session {
|
|||||||
control,
|
control,
|
||||||
receiver,
|
receiver,
|
||||||
admitted: now,
|
admitted: now,
|
||||||
|
watchdog_canceled_at: None,
|
||||||
|
worker_error: None,
|
||||||
result: RequestResult { id, state: RequestState::Pending, reason: RequestReason::None },
|
result: RequestResult { id, state: RequestState::Pending, reason: RequestReason::None },
|
||||||
job,
|
job,
|
||||||
released: false,
|
released: false,
|
||||||
saves_payload: true,
|
saves_payload: true,
|
||||||
|
worker_returned: false,
|
||||||
});
|
});
|
||||||
Ok(id)
|
Ok(id)
|
||||||
}
|
}
|
||||||
@@ -686,27 +774,30 @@ impl Session {
|
|||||||
let Some(r) = &mut self.request else { return };
|
let Some(r) = &mut self.request else { return };
|
||||||
match r.receiver.try_recv() {
|
match r.receiver.try_recv() {
|
||||||
Ok(completion) => {
|
Ok(completion) => {
|
||||||
|
r.worker_returned = true;
|
||||||
|
r.worker_error = completion.result.error;
|
||||||
let current =
|
let current =
|
||||||
self.mode.is_some() && r.session == self.context && r.epoch == self.epoch;
|
self.mode.is_some() && r.session == self.context && r.epoch == self.epoch;
|
||||||
if current {
|
if current {
|
||||||
self.slots[r.local].protected = false;
|
self.slots[r.local].protected = false;
|
||||||
if r.result.reason == RequestReason::None {
|
if r.result.state == RequestState::Pending {
|
||||||
r.result.state = match completion.result.durable {
|
r.result.state = match completion.result.durable {
|
||||||
DurableResult::Success => RequestState::Success,
|
DurableResult::Success => RequestState::Success,
|
||||||
DurableResult::Failure => RequestState::Failure,
|
DurableResult::Failure => RequestState::Failure,
|
||||||
DurableResult::Indeterminate => RequestState::Indeterminate,
|
DurableResult::Indeterminate => RequestState::Indeterminate,
|
||||||
};
|
};
|
||||||
r.result.reason = completion
|
r.result.reason = if r.watchdog_canceled_at.is_some() {
|
||||||
.result
|
RequestReason::Timeout
|
||||||
.error
|
} else {
|
||||||
.map_or(RequestReason::None, RequestReason::Storage);
|
r.worker_error.map_or(RequestReason::None, RequestReason::Storage)
|
||||||
|
};
|
||||||
if completion.result.durable == DurableResult::Success && r.saves_payload {
|
if completion.result.durable == DurableResult::Success && r.saves_payload {
|
||||||
let mut s = r.source.write().unwrap();
|
let mut s = r.source.write().unwrap();
|
||||||
s.descriptor =
|
s.descriptor =
|
||||||
completion.card.current().slots[self.logical[r.local] as usize];
|
completion.card.current().slots[self.logical[r.local] as usize];
|
||||||
s.dirty = false;
|
s.dirty = false;
|
||||||
}
|
}
|
||||||
} // A timeout result is immutable; returned card requires explicit reconciliation.
|
} // A restart escalation is immutable; returned card requires explicit reconciliation.
|
||||||
if self.provisional && completion.result.durable != DurableResult::Success {
|
if self.provisional && completion.result.durable != DurableResult::Success {
|
||||||
self.boot_error =
|
self.boot_error =
|
||||||
Some(completion.result.error.unwrap_or(Error::InvalidState));
|
Some(completion.result.error.unwrap_or(Error::InvalidState));
|
||||||
@@ -755,7 +846,10 @@ impl Session {
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
let elapsed = now.saturating_duration_since(r.admitted);
|
let elapsed = now.saturating_duration_since(r.admitted);
|
||||||
if elapsed >= Duration::from_millis(500) {
|
if elapsed >= Duration::from_millis(500) && !r.control.canceled() {
|
||||||
|
// Main-lane cancellation cause is independent of the worker's durable
|
||||||
|
// outcome. Do not relabel an earlier removal or termination cancel.
|
||||||
|
r.watchdog_canceled_at = Some(now);
|
||||||
r.control.cancel();
|
r.control.cancel();
|
||||||
}
|
}
|
||||||
if elapsed >= Duration::from_secs(1) {
|
if elapsed >= Duration::from_secs(1) {
|
||||||
@@ -788,6 +882,12 @@ impl Session {
|
|||||||
.map(|r| r.result)
|
.map(|r| r.result)
|
||||||
.ok_or(Error::InvalidRange)
|
.ok_or(Error::InvalidRange)
|
||||||
}
|
}
|
||||||
|
/// Original worker error for native diagnostics, independent of guest deadline reason.
|
||||||
|
/// Pending and RAM-only requests have no worker error. Retention follows query/release.
|
||||||
|
pub fn request_storage_error(&self, context: u64, id: u64) -> Result<Option<Error>> {
|
||||||
|
self.query(context, id)?;
|
||||||
|
Ok(self.request.as_ref().filter(|r| r.id == id).and_then(|r| r.worker_error))
|
||||||
|
}
|
||||||
pub fn release_request(&mut self, context: u64, id: u64) -> Result<()> {
|
pub fn release_request(&mut self, context: u64, id: u64) -> Result<()> {
|
||||||
self.query(context, id)?;
|
self.query(context, id)?;
|
||||||
if self.deferred.is_some() {
|
if self.deferred.is_some() {
|
||||||
@@ -802,7 +902,7 @@ impl Session {
|
|||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
}
|
}
|
||||||
r.released = true;
|
r.released = true;
|
||||||
if self.card.is_some() {
|
if r.worker_returned {
|
||||||
self.request = None;
|
self.request = None;
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
@@ -816,7 +916,7 @@ impl Session {
|
|||||||
r.control.cancel();
|
r.control.cancel();
|
||||||
r.released = true;
|
r.released = true;
|
||||||
}
|
}
|
||||||
if self.card.is_some() {
|
if !self.io_active() {
|
||||||
self.request = None;
|
self.request = None;
|
||||||
}
|
}
|
||||||
self.removal_pending = false;
|
self.removal_pending = false;
|
||||||
@@ -852,7 +952,23 @@ impl Session {
|
|||||||
load_existing: bool,
|
load_existing: bool,
|
||||||
control: &PublicationControl,
|
control: &PublicationControl,
|
||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
if self.has_in_flight() || self.boot_active || self.mode.is_none() {
|
self.replace_storage_with(move || Ok(storage), load_existing, false, control)
|
||||||
|
}
|
||||||
|
pub(super) fn reconcile_storage_with(
|
||||||
|
&mut self,
|
||||||
|
open: impl FnOnce() -> Result<Box<dyn prometeu_hal::memcard::MemcardStorage>>,
|
||||||
|
control: &PublicationControl,
|
||||||
|
) -> Result<()> {
|
||||||
|
self.replace_storage_with(open, false, true, control)
|
||||||
|
}
|
||||||
|
fn replace_storage_with(
|
||||||
|
&mut self,
|
||||||
|
open: impl FnOnce() -> Result<Box<dyn prometeu_hal::memcard::MemcardStorage>>,
|
||||||
|
load_existing: bool,
|
||||||
|
same_only: bool,
|
||||||
|
control: &PublicationControl,
|
||||||
|
) -> Result<()> {
|
||||||
|
if self.io_active() || self.deferred.is_some() || self.boot_active || self.mode.is_none() {
|
||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
}
|
}
|
||||||
if self.icon.is_empty()
|
if self.icon.is_empty()
|
||||||
@@ -865,11 +981,18 @@ impl Session {
|
|||||||
{
|
{
|
||||||
self.uncertain_target = card.attempted_publication.clone();
|
self.uncertain_target = card.attempted_publication.clone();
|
||||||
}
|
}
|
||||||
let known = self.card.as_ref().map(|c| (c.current().card_id, c.known_exclusions()));
|
if let Some(card) = &self.card {
|
||||||
|
self.known_card_exclusions = Some((card.current().card_id, card.known_exclusions()));
|
||||||
|
}
|
||||||
|
let known = self.known_card_exclusions;
|
||||||
self.card.take(); // Release the old scratch before mounting another image.
|
self.card.take(); // Release the old scratch before mounting another image.
|
||||||
self.scratch = None;
|
self.scratch = None;
|
||||||
self.reconcile_blocked = true;
|
self.reconcile_blocked = true;
|
||||||
self.card = Some(Card::mount(storage)?);
|
let candidate = Card::mount(open()?)?;
|
||||||
|
if same_only && self.card_id != Some(candidate.current().card_id) {
|
||||||
|
return Err(Error::IdentityMismatch);
|
||||||
|
}
|
||||||
|
self.card = Some(candidate);
|
||||||
let card = self.card.as_mut().unwrap();
|
let card = self.card.as_mut().unwrap();
|
||||||
let same = self.card_id == Some(card.current().card_id);
|
let same = self.card_id == Some(card.current().card_id);
|
||||||
if let Some((id, known)) = known
|
if let Some((id, known)) = known
|
||||||
@@ -956,14 +1079,15 @@ impl Session {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
pub fn detach(&mut self) -> Result<()> {
|
pub fn detach(&mut self) -> Result<()> {
|
||||||
if self.deferred.is_some()
|
if self.deferred.is_some() || self.io_active() {
|
||||||
|| self
|
|
||||||
.request
|
|
||||||
.as_ref()
|
|
||||||
.is_some_and(|r| r.result.state == RequestState::Pending || self.card.is_none())
|
|
||||||
{
|
|
||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
}
|
}
|
||||||
|
if self.card.is_none() && self.scratch.is_none() {
|
||||||
|
let mut scratch = Vec::new();
|
||||||
|
scratch.try_reserve_exact(SLOT_BYTES).map_err(|_| Error::OutOfMemory)?;
|
||||||
|
scratch.resize(SLOT_BYTES, 0);
|
||||||
|
self.scratch = Some(scratch);
|
||||||
|
}
|
||||||
self.mode = Some(Mode::MemoryOnly);
|
self.mode = Some(Mode::MemoryOnly);
|
||||||
self.removal_pending = false;
|
self.removal_pending = false;
|
||||||
self.reconcile_blocked = false;
|
self.reconcile_blocked = false;
|
||||||
|
|||||||
@@ -16,6 +16,8 @@ impl PublicationControl {
|
|||||||
pub fn publication_attempted(&self) -> bool {
|
pub fn publication_attempted(&self) -> bool {
|
||||||
self.0.load(Ordering::SeqCst) & 1 != 0
|
self.0.load(Ordering::SeqCst) & 1 != 0
|
||||||
}
|
}
|
||||||
|
// `try_update` requires Rust 1.95; keep older stable CI toolchains compatible.
|
||||||
|
#[allow(deprecated)]
|
||||||
fn enter(&self) -> Result<()> {
|
fn enter(&self) -> Result<()> {
|
||||||
self.0
|
self.0
|
||||||
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |state| {
|
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |state| {
|
||||||
|
|||||||
@@ -280,8 +280,157 @@ fn async_commit_protects_only_source_and_retains_result_without_occupying_lane()
|
|||||||
controller.stop().unwrap();
|
controller.stop().unwrap();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The sentinel executes after the save on the single lane. Wall time only bounds
|
||||||
|
// a broken fixture; all watchdog observations use explicit simulated instants.
|
||||||
|
fn finish_queued_save(lane: Arc<crate::AsyncWorkLane>) {
|
||||||
|
let (tx, rx) = std::sync::mpsc::channel();
|
||||||
|
lane.submit_asset_load(move |_| {
|
||||||
|
tx.send(()).unwrap();
|
||||||
|
crate::services::async_work::AsyncWorkJobOutcome::Completed
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
let mut controller =
|
||||||
|
crate::AsyncWorkLaneController::start(crate::AsyncWorkLaneConfig::default(), lane);
|
||||||
|
rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
|
||||||
|
controller.stop().unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn assert_guest_query(
|
||||||
|
session: &mut super::super::session::Session,
|
||||||
|
id: u64,
|
||||||
|
state: i64,
|
||||||
|
reason: i64,
|
||||||
|
) {
|
||||||
|
use prometeu_bytecode::Value;
|
||||||
|
use prometeu_hal::{
|
||||||
|
HostReturn, host_return::GuestStringAllocator, syscalls::Syscall, vm_fault::VmFault,
|
||||||
|
};
|
||||||
|
struct NoStrings;
|
||||||
|
impl GuestStringAllocator for NoStrings {
|
||||||
|
fn byte_limit(&self) -> u64 {
|
||||||
|
0
|
||||||
|
}
|
||||||
|
fn build(
|
||||||
|
&mut self,
|
||||||
|
_: usize,
|
||||||
|
_: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
|
||||||
|
) -> std::result::Result<Arc<str>, VmFault> {
|
||||||
|
panic!("MemQuery must not allocate strings")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut service = super::super::MemcardService::new();
|
||||||
|
std::mem::swap(session, &mut service.session);
|
||||||
|
let args = [Value::Int64(service.session.context() as i64), Value::Int64(id as i64)];
|
||||||
|
let mut values = Vec::with_capacity(Syscall::MemQuery.results_count());
|
||||||
|
let mut strings = NoStrings;
|
||||||
|
let mut ret = HostReturn::new(&mut values, Syscall::MemQuery.results_count(), &mut strings);
|
||||||
|
service.guest(Syscall::MemQuery, &args, &mut ret, 4, 0, true).unwrap();
|
||||||
|
assert!(!ret.overflowed());
|
||||||
|
assert!(ret.failure().is_none());
|
||||||
|
assert_eq!(values, vec![Value::Int64(0), Value::Int64(state), Value::Int64(reason)]);
|
||||||
|
std::mem::swap(session, &mut service.session);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
fn queued_memcard_watchdog_preserves_timeout_and_guest_reason() {
|
||||||
|
use super::super::session::{RequestReason, RequestState, Session};
|
||||||
|
use std::time::{Duration, Instant};
|
||||||
|
for bootstrap in [false, true] {
|
||||||
|
let (mut card, disk) = formatted();
|
||||||
|
add(&mut card, 4, 1);
|
||||||
|
let before = card.current().slots[0];
|
||||||
|
let mut s = Session::default();
|
||||||
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
||||||
|
s.write(c, 0, 0, b"pending").unwrap();
|
||||||
|
let lane = Arc::new(crate::AsyncWorkLane::default());
|
||||||
|
let now = Instant::now();
|
||||||
|
if bootstrap {
|
||||||
|
s.begin_boot();
|
||||||
|
}
|
||||||
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
||||||
|
if bootstrap {
|
||||||
|
s.finish_boot(true, &lane, now).unwrap();
|
||||||
|
}
|
||||||
|
s.poll(now + Duration::from_millis(499));
|
||||||
|
assert_guest_query(&mut s, id, 0, 0);
|
||||||
|
for _ in 0..2 {
|
||||||
|
s.poll(now + Duration::from_millis(500));
|
||||||
|
}
|
||||||
|
assert_guest_query(&mut s, id, 0, 0);
|
||||||
|
assert_eq!(s.release_request(c, id), Err(Error::Busy));
|
||||||
|
assert_eq!(s.clear(c, 0), Err(Error::Busy));
|
||||||
|
finish_queued_save(lane);
|
||||||
|
s.poll(now + Duration::from_millis(501));
|
||||||
|
let result = s.query(c, id).unwrap();
|
||||||
|
assert_eq!(result.state, RequestState::Failure);
|
||||||
|
assert_eq!(result.reason, RequestReason::Timeout);
|
||||||
|
assert_eq!(s.request_storage_error(c, id), Ok(Some(Error::Canceled)));
|
||||||
|
assert_guest_query(&mut s, id, 2, 15);
|
||||||
|
assert!(s.unsaved());
|
||||||
|
assert_eq!(reboot(&disk).current().slots[0], before);
|
||||||
|
assert_eq!(s.query(c + 1, id), Err(Error::AccessDenied));
|
||||||
|
s.release_request(c, id).unwrap();
|
||||||
|
assert_eq!(s.query(c, id), Err(Error::InvalidRange));
|
||||||
|
s.clear(c, 0).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn lifecycle_cancellation_is_not_a_watchdog_timeout() {
|
||||||
|
use super::super::session::{RequestReason, RequestState, Session};
|
||||||
|
use std::time::{Duration, Instant};
|
||||||
|
for end in [false, true] {
|
||||||
|
let (mut card, _) = formatted();
|
||||||
|
add(&mut card, 4, 1);
|
||||||
|
let mut s = Session::default();
|
||||||
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
||||||
|
let lane = Arc::new(crate::AsyncWorkLane::default());
|
||||||
|
let now = Instant::now();
|
||||||
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
||||||
|
if end {
|
||||||
|
s.end_session();
|
||||||
|
} else {
|
||||||
|
s.notify_removal();
|
||||||
|
}
|
||||||
|
s.poll(now + Duration::from_millis(500));
|
||||||
|
finish_queued_save(lane);
|
||||||
|
s.poll(now + Duration::from_millis(501));
|
||||||
|
if end {
|
||||||
|
assert_eq!(s.query(c, id), Err(Error::AccessDenied));
|
||||||
|
let card = s.take_idle_card().unwrap().unwrap();
|
||||||
|
let new = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
||||||
|
assert_ne!(new, c);
|
||||||
|
assert_eq!(s.query(new, id), Err(Error::InvalidRange));
|
||||||
|
} else {
|
||||||
|
assert_eq!(s.query(c, id).unwrap().state, RequestState::Failure);
|
||||||
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Storage(Error::Canceled));
|
||||||
|
assert_guest_query(&mut s, id, 2, 8);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn deferred_boot_memcard_deadline_stays_timeout() {
|
||||||
|
use super::super::session::{RequestReason, Session};
|
||||||
|
use std::time::{Duration, Instant};
|
||||||
|
let (mut card, _) = formatted();
|
||||||
|
add(&mut card, 4, 1);
|
||||||
|
let mut s = Session::default();
|
||||||
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
||||||
|
s.begin_boot();
|
||||||
|
let lane = crate::AsyncWorkLane::default();
|
||||||
|
let now = Instant::now();
|
||||||
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
||||||
|
s.poll(now + Duration::from_millis(500));
|
||||||
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout);
|
||||||
|
assert_guest_query(&mut s, id, 2, 15);
|
||||||
|
assert_eq!(lane.pending_depth(), 0);
|
||||||
|
s.clear(c, 0).unwrap();
|
||||||
|
s.release_request(c, id).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn blocked_host_memcard_watchdog_preserves_outcome_and_escalation() {
|
||||||
use crate::services::async_work::{
|
use crate::services::async_work::{
|
||||||
AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController,
|
AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController,
|
||||||
};
|
};
|
||||||
@@ -290,6 +439,7 @@ fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
|||||||
struct Blocked {
|
struct Blocked {
|
||||||
store: Box<dyn MemcardStorage>,
|
store: Box<dyn MemcardStorage>,
|
||||||
publication: bool,
|
publication: bool,
|
||||||
|
fail_publication: bool,
|
||||||
entered: std::sync::mpsc::Sender<()>,
|
entered: std::sync::mpsc::Sender<()>,
|
||||||
resume: std::sync::mpsc::Receiver<()>,
|
resume: std::sync::mpsc::Receiver<()>,
|
||||||
}
|
}
|
||||||
@@ -310,12 +460,24 @@ fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
|||||||
if if self.publication { b.starts_with(b"PMMAP1\0\0") } else { o >= DATA_OFFSET } {
|
if if self.publication { b.starts_with(b"PMMAP1\0\0") } else { o >= DATA_OFFSET } {
|
||||||
self.entered.send(()).unwrap();
|
self.entered.send(()).unwrap();
|
||||||
self.resume.recv().unwrap();
|
self.resume.recv().unwrap();
|
||||||
|
if self.fail_publication {
|
||||||
|
return Err(MemcardIoError::IoError);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
self.store.write_at(o, b)
|
self.store.write_at(o, b)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
for publication in [false, true] {
|
for (publication, fail_publication, escalate, release_early) in [
|
||||||
let (mut card, _) = formatted();
|
(false, false, false, false),
|
||||||
|
(true, false, false, false),
|
||||||
|
(true, true, false, false),
|
||||||
|
(false, false, true, false),
|
||||||
|
(true, false, true, false),
|
||||||
|
(true, true, true, false),
|
||||||
|
(false, false, true, true),
|
||||||
|
(true, false, true, true),
|
||||||
|
] {
|
||||||
|
let (mut card, disk) = formatted();
|
||||||
add(&mut card, 4, 1);
|
add(&mut card, 4, 1);
|
||||||
let (et, er) = std::sync::mpsc::channel();
|
let (et, er) = std::sync::mpsc::channel();
|
||||||
let (rt, rr) = std::sync::mpsc::channel();
|
let (rt, rr) = std::sync::mpsc::channel();
|
||||||
@@ -324,6 +486,7 @@ fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
|||||||
entered: et,
|
entered: et,
|
||||||
resume: rr,
|
resume: rr,
|
||||||
publication,
|
publication,
|
||||||
|
fail_publication,
|
||||||
}))
|
}))
|
||||||
.unwrap();
|
.unwrap();
|
||||||
let mut s = Session::default();
|
let mut s = Session::default();
|
||||||
@@ -336,6 +499,8 @@ fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
|||||||
let id = s.commit(c, 0, 7, admitted, &lane).unwrap();
|
let id = s.commit(c, 0, 7, admitted, &lane).unwrap();
|
||||||
er.recv_timeout(Duration::from_secs(1)).unwrap();
|
er.recv_timeout(Duration::from_secs(1)).unwrap();
|
||||||
s.poll(admitted + Duration::from_millis(500));
|
s.poll(admitted + Duration::from_millis(500));
|
||||||
|
assert_guest_query(&mut s, id, 0, 0);
|
||||||
|
let terminal = if escalate {
|
||||||
s.poll(admitted + Duration::from_secs(1));
|
s.poll(admitted + Duration::from_secs(1));
|
||||||
let result = s.query(c, id).unwrap();
|
let result = s.query(c, id).unwrap();
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
@@ -344,14 +509,74 @@ fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
|||||||
);
|
);
|
||||||
assert_eq!(result.reason, RequestReason::RestartRequired);
|
assert_eq!(result.reason, RequestReason::RestartRequired);
|
||||||
assert!(s.host_faulted());
|
assert!(s.host_faulted());
|
||||||
|
if release_early {
|
||||||
s.release_request(c, id).unwrap();
|
s.release_request(c, id).unwrap();
|
||||||
|
}
|
||||||
|
Some(result)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
};
|
||||||
assert_eq!(s.write(c, 0, 0, b"unsafe"), Err(Error::Busy));
|
assert_eq!(s.write(c, 0, 0, b"unsafe"), Err(Error::Busy));
|
||||||
assert_eq!(s.commit(c, 0, 7, Instant::now(), &lane), Err(Error::Busy));
|
assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::Busy));
|
||||||
rt.send(()).unwrap();
|
rt.send(()).unwrap();
|
||||||
controller.stop().unwrap();
|
controller.stop().unwrap();
|
||||||
s.poll(Instant::now());
|
s.poll(admitted + Duration::from_millis(if escalate { 1001 } else { 501 }));
|
||||||
|
if let Some(terminal) = terminal {
|
||||||
|
if release_early {
|
||||||
|
assert_eq!(s.query(c, id), Err(Error::InvalidRange));
|
||||||
|
} else {
|
||||||
|
assert_eq!(s.query(c, id), Ok(terminal));
|
||||||
|
assert_guest_query(&mut s, id, if publication { 3 } else { 2 }, 15);
|
||||||
|
s.release_request(c, id).unwrap();
|
||||||
|
}
|
||||||
assert!(s.unsaved());
|
assert!(s.unsaved());
|
||||||
assert!(s.host_faulted());
|
assert!(s.host_faulted());
|
||||||
|
assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::ReadOnly));
|
||||||
|
} else {
|
||||||
|
let expected = if fail_publication {
|
||||||
|
RequestState::Indeterminate
|
||||||
|
} else if publication {
|
||||||
|
RequestState::Success
|
||||||
|
} else {
|
||||||
|
RequestState::Failure
|
||||||
|
};
|
||||||
|
assert_eq!(s.query(c, id).unwrap().state, expected);
|
||||||
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout);
|
||||||
|
assert_guest_query(
|
||||||
|
&mut s,
|
||||||
|
id,
|
||||||
|
if fail_publication {
|
||||||
|
3
|
||||||
|
} else if publication {
|
||||||
|
1
|
||||||
|
} else {
|
||||||
|
2
|
||||||
|
},
|
||||||
|
15,
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
s.request_storage_error(c, id),
|
||||||
|
Ok(if fail_publication {
|
||||||
|
Some(Error::Io(MemcardIoError::IoError))
|
||||||
|
} else if publication {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
Some(Error::Canceled)
|
||||||
|
})
|
||||||
|
);
|
||||||
|
assert_eq!(s.unsaved(), expected != RequestState::Success);
|
||||||
|
assert_eq!(s.removal_pending(), fail_publication);
|
||||||
|
assert!(!s.host_faulted());
|
||||||
|
s.release_request(c, id).unwrap();
|
||||||
|
}
|
||||||
|
let mut durable = reboot(&disk);
|
||||||
|
let mut bytes = [0; 7];
|
||||||
|
let n = durable.read_slot(0, &mut bytes).unwrap();
|
||||||
|
if publication && !fail_publication {
|
||||||
|
assert_eq!(&bytes[..n], b"pending");
|
||||||
|
} else {
|
||||||
|
assert_eq!(n, 0);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -660,3 +885,232 @@ fn ending_a_session_releases_a_completed_unconsumed_request() {
|
|||||||
assert!(s.take_idle_card().unwrap().is_some());
|
assert!(s.take_idle_card().unwrap().is_some());
|
||||||
controller.stop().unwrap();
|
controller.stop().unwrap();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
||||||
|
use crate::memcard::session::{RequestState, Session};
|
||||||
|
use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController};
|
||||||
|
use prometeu_drivers::{
|
||||||
|
AssetManager, GlyphBankPoolAccess, MemoryBanks, SceneBankPoolAccess, SoundBankPoolAccess,
|
||||||
|
};
|
||||||
|
use prometeu_hal::{
|
||||||
|
AssetBridge,
|
||||||
|
asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus},
|
||||||
|
background_work::{AssetWork, BackgroundWork, WorkUnavailable},
|
||||||
|
cartridge::AssetsPayloadSource,
|
||||||
|
};
|
||||||
|
use std::{
|
||||||
|
sync::mpsc,
|
||||||
|
thread,
|
||||||
|
time::{Duration, Instant},
|
||||||
|
};
|
||||||
|
type Events = Arc<Mutex<Vec<(&'static str, thread::ThreadId)>>>;
|
||||||
|
struct ObservedLane {
|
||||||
|
lane: Arc<AsyncWorkLane>,
|
||||||
|
events: Events,
|
||||||
|
paused: mpsc::Sender<()>,
|
||||||
|
resume: Mutex<Option<mpsc::Receiver<()>>>,
|
||||||
|
}
|
||||||
|
impl BackgroundWork for ObservedLane {
|
||||||
|
fn submit_asset(&self, mut work: AssetWork) -> std::result::Result<(), WorkUnavailable> {
|
||||||
|
let events = self.events.clone();
|
||||||
|
let paused = self.paused.clone();
|
||||||
|
let resume = self.resume.lock().unwrap().take().unwrap();
|
||||||
|
let mut step = 0;
|
||||||
|
self.lane.submit_asset(Box::new(move |canceled| {
|
||||||
|
let result = work(canceled);
|
||||||
|
step += 1;
|
||||||
|
events.lock().unwrap().push(("asset", thread::current().id()));
|
||||||
|
if step == 4 {
|
||||||
|
paused.send(()).unwrap();
|
||||||
|
resume.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||||
|
}
|
||||||
|
result
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
struct ObservedStore {
|
||||||
|
inner: Store,
|
||||||
|
events: Events,
|
||||||
|
}
|
||||||
|
impl MemcardStorage for ObservedStore {
|
||||||
|
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
||||||
|
self.inner.len()
|
||||||
|
}
|
||||||
|
fn read_only(&self) -> bool {
|
||||||
|
false
|
||||||
|
}
|
||||||
|
fn read_at(
|
||||||
|
&mut self,
|
||||||
|
offset: u64,
|
||||||
|
out: &mut [u8],
|
||||||
|
) -> std::result::Result<(), MemcardIoError> {
|
||||||
|
self.inner.read_at(offset, out)
|
||||||
|
}
|
||||||
|
fn write_at(
|
||||||
|
&mut self,
|
||||||
|
offset: u64,
|
||||||
|
bytes: &[u8],
|
||||||
|
) -> std::result::Result<(), MemcardIoError> {
|
||||||
|
self.events.lock().unwrap().push(("save write", thread::current().id()));
|
||||||
|
self.inner.write_at(offset, bytes)
|
||||||
|
}
|
||||||
|
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
||||||
|
self.events.lock().unwrap().push(("save sync", thread::current().id()));
|
||||||
|
self.inner.sync()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] {
|
||||||
|
let (card, disk) = formatted();
|
||||||
|
drop(card);
|
||||||
|
let events: Events = Arc::default();
|
||||||
|
let mut card = Card::mount(Box::new(ObservedStore {
|
||||||
|
inner: Store(disk.clone()),
|
||||||
|
events: events.clone(),
|
||||||
|
}))
|
||||||
|
.unwrap();
|
||||||
|
add(&mut card, 1, 1);
|
||||||
|
let mut session = Session::default();
|
||||||
|
let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap();
|
||||||
|
session.write(context, 0, 0, b"persistent under asset pressure").unwrap();
|
||||||
|
events.lock().unwrap().clear();
|
||||||
|
let (bytes, decoded_size, metadata) = match kind {
|
||||||
|
BankType::GLYPH => {
|
||||||
|
let mut bytes = vec![0x12; 16384];
|
||||||
|
bytes.extend([255; 64]);
|
||||||
|
(
|
||||||
|
bytes,
|
||||||
|
32768 + 64,
|
||||||
|
serde_json::json!({"tile_size":8,"width":256,"height":128,"palette_count":1,"palette_authored":1}),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
BankType::SOUNDS => {
|
||||||
|
(vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1}))
|
||||||
|
}
|
||||||
|
BankType::SCENE => {
|
||||||
|
let mut bytes = vec![0; 140];
|
||||||
|
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
||||||
|
for start in [12, 44, 76, 108] {
|
||||||
|
bytes[start + 5] = 8;
|
||||||
|
}
|
||||||
|
bytes[12] = 1;
|
||||||
|
bytes[28..32].copy_from_slice(&4097_u32.to_le_bytes());
|
||||||
|
bytes[32..36].copy_from_slice(&1_u32.to_le_bytes());
|
||||||
|
bytes[36..40].copy_from_slice(&4097_u32.to_le_bytes());
|
||||||
|
bytes.splice(44..44, std::iter::repeat_n([7, 3, 0x34, 0x12], 4097).flatten());
|
||||||
|
(
|
||||||
|
bytes,
|
||||||
|
64 + 4097 * size_of::<prometeu_hal::tile::Tile>() as u64,
|
||||||
|
serde_json::json!({}),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
let entry = AssetEntry {
|
||||||
|
asset_id: 1,
|
||||||
|
asset_name: "pressure".into(),
|
||||||
|
bank_type: kind,
|
||||||
|
offset: 0,
|
||||||
|
size: bytes.len() as u64,
|
||||||
|
decoded_size,
|
||||||
|
codec: AssetCodec::None,
|
||||||
|
metadata,
|
||||||
|
};
|
||||||
|
let banks = Arc::new(MemoryBanks::new());
|
||||||
|
let mut manager = AssetManager::new(
|
||||||
|
vec![entry],
|
||||||
|
AssetsPayloadSource::from_bytes(bytes),
|
||||||
|
banks.clone(),
|
||||||
|
banks.clone(),
|
||||||
|
banks.clone(),
|
||||||
|
);
|
||||||
|
let lane = Arc::new(AsyncWorkLane::default());
|
||||||
|
let (paused_tx, paused_rx) = mpsc::channel();
|
||||||
|
let (resume_tx, resume_rx) = mpsc::channel();
|
||||||
|
let observed = Arc::new(ObservedLane {
|
||||||
|
lane: lane.clone(),
|
||||||
|
events: events.clone(),
|
||||||
|
paused: paused_tx,
|
||||||
|
resume: Mutex::new(Some(resume_rx)),
|
||||||
|
});
|
||||||
|
assert!(manager.bind_background_work(observed));
|
||||||
|
let mut controller =
|
||||||
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
||||||
|
let handle = manager.load(1, 0).unwrap();
|
||||||
|
paused_rx.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||||
|
assert_eq!(manager.status(handle), LoadStatus::LOADING);
|
||||||
|
assert!(
|
||||||
|
banks.glyph_bank_slot(0).is_none()
|
||||||
|
&& banks.sound_bank_slot(0).is_none()
|
||||||
|
&& banks.scene_bank_slot(0).is_none()
|
||||||
|
);
|
||||||
|
let request = session.commit(context, 0, 7, Instant::now(), &lane).unwrap();
|
||||||
|
resume_tx.send(()).unwrap();
|
||||||
|
let deadline = Instant::now() + Duration::from_secs(10);
|
||||||
|
loop {
|
||||||
|
session.poll(Instant::now());
|
||||||
|
if session.query(context, request).unwrap().state != RequestState::Pending
|
||||||
|
&& manager.status(handle) == LoadStatus::READY
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
assert!(Instant::now() < deadline, "save/asset did not complete for {kind:?}");
|
||||||
|
thread::yield_now();
|
||||||
|
}
|
||||||
|
assert_eq!(session.query(context, request).unwrap().state, RequestState::Success);
|
||||||
|
assert!(
|
||||||
|
banks.glyph_bank_slot(0).is_none()
|
||||||
|
&& banks.sound_bank_slot(0).is_none()
|
||||||
|
&& banks.scene_bank_slot(0).is_none()
|
||||||
|
);
|
||||||
|
assert_eq!(manager.commit(handle), AssetOpStatus::Ok);
|
||||||
|
manager.apply_commits();
|
||||||
|
match kind {
|
||||||
|
BankType::GLYPH => {
|
||||||
|
let bank = banks.glyph_bank_slot(0).unwrap();
|
||||||
|
assert_eq!((bank.width, bank.height), (256, 128));
|
||||||
|
assert_eq!(
|
||||||
|
bank.pixel_indices,
|
||||||
|
(0..32768).map(|i| 1 + (i % 2) as u8).collect::<Vec<_>>()
|
||||||
|
);
|
||||||
|
assert!(bank.palettes[0].iter().all(|c| c.raw() == 0xffffffff));
|
||||||
|
}
|
||||||
|
BankType::SOUNDS => {
|
||||||
|
let bank = banks.sound_bank_slot(0).unwrap();
|
||||||
|
assert_eq!(bank.samples[0].sample_rate, 44100);
|
||||||
|
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
|
||||||
|
}
|
||||||
|
BankType::SCENE => {
|
||||||
|
let bank = banks.scene_bank_slot(0).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
(bank.layers[0].tilemap.width, bank.layers[0].tilemap.height),
|
||||||
|
(4097, 1)
|
||||||
|
);
|
||||||
|
assert!(bank.layers[0].active);
|
||||||
|
assert_eq!(bank.layers[0].tilemap.tiles.len(), 4097);
|
||||||
|
assert!(bank.layers[0].tilemap.tiles.iter().all(|t| t.active
|
||||||
|
&& t.flip_x
|
||||||
|
&& t.flip_y
|
||||||
|
&& t.glyph.glyph_id == 0x1234
|
||||||
|
&& t.glyph.palette_id == 3));
|
||||||
|
assert!(bank.layers[1..].iter().all(|l| l.tilemap.tiles.is_empty()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
controller.stop().unwrap();
|
||||||
|
let observed = events.lock().unwrap();
|
||||||
|
assert_eq!(observed[..4].iter().map(|e| e.0).collect::<Vec<_>>(), vec!["asset"; 4]);
|
||||||
|
assert_eq!(observed[4].0, "save write");
|
||||||
|
let resumed = observed[4..].iter().position(|e| e.0 == "asset").unwrap() + 4;
|
||||||
|
assert_eq!(observed[resumed - 1].0, "save sync");
|
||||||
|
assert!(observed[resumed..].iter().all(|e| e.0 == "asset"));
|
||||||
|
let worker = observed[0].1;
|
||||||
|
assert_ne!(worker, thread::current().id());
|
||||||
|
assert!(observed.iter().all(|e| e.1 == worker));
|
||||||
|
drop(observed);
|
||||||
|
drop(session);
|
||||||
|
let mut recovered = Session::default();
|
||||||
|
let c = recovered.load_card(reboot(&disk), 1, 1, 1024 * 1024).unwrap();
|
||||||
|
let mut saved = [0; 64];
|
||||||
|
let n = recovered.read(c, 0, 0, &mut saved).unwrap();
|
||||||
|
assert_eq!(&saved[..n], b"persistent under asset pressure");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -187,6 +187,16 @@ impl VirtualMachineRuntime {
|
|||||||
self.render_worker_ownership.set(self.render_manager.active_ownership());
|
self.render_worker_ownership.set(self.render_manager.active_ownership());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn record_presented_render_worker_frame(
|
||||||
|
&self,
|
||||||
|
ownership: prometeu_hal::RenderOwnership,
|
||||||
|
frame_id: FrameId,
|
||||||
|
) {
|
||||||
|
if let Some(controller) = self.render_worker_controller.as_ref() {
|
||||||
|
controller.record_presented_frame(ownership, frame_id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
|
pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
|
||||||
if let Some(controller) = self.render_worker_controller.as_ref() {
|
if let Some(controller) = self.render_worker_controller.as_ref() {
|
||||||
controller.record_repeated_frame(frame_id);
|
controller.record_repeated_frame(frame_id);
|
||||||
|
|||||||
@@ -25,6 +25,7 @@ impl Default for RenderWorkerConfig {
|
|||||||
struct RenderWorkerState {
|
struct RenderWorkerState {
|
||||||
telemetry: RenderWorkerTelemetry,
|
telemetry: RenderWorkerTelemetry,
|
||||||
last_error: Option<RenderWorkerError>,
|
last_error: Option<RenderWorkerError>,
|
||||||
|
last_presented: Option<(RenderOwnership, FrameId)>,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default)]
|
#[derive(Clone, Debug, Default)]
|
||||||
@@ -40,6 +41,19 @@ impl LatestRenderFrameStore {
|
|||||||
pub fn latest_frame(&self) -> Option<OwnedRgba8888Frame> {
|
pub fn latest_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||||
self.latest.lock().unwrap().clone()
|
self.latest.lock().unwrap().clone()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Copy only a different complete publication; paused observers need not copy pixels.
|
||||||
|
pub fn latest_frame_after(
|
||||||
|
&self,
|
||||||
|
previous: Option<(RenderOwnership, FrameId)>,
|
||||||
|
) -> Option<OwnedRgba8888Frame> {
|
||||||
|
self.latest
|
||||||
|
.lock()
|
||||||
|
.unwrap()
|
||||||
|
.as_ref()
|
||||||
|
.filter(|frame| previous != Some((frame.ownership, frame.frame_id)))
|
||||||
|
.cloned()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl RenderWorkerFrameSink for LatestRenderFrameStore {
|
impl RenderWorkerFrameSink for LatestRenderFrameStore {
|
||||||
@@ -144,6 +158,7 @@ impl RenderWorkerController {
|
|||||||
let mut telemetry = self.handoff.telemetry();
|
let mut telemetry = self.handoff.telemetry();
|
||||||
let state = self.state.lock().unwrap();
|
let state = self.state.lock().unwrap();
|
||||||
telemetry.published_frames = state.telemetry.published_frames;
|
telemetry.published_frames = state.telemetry.published_frames;
|
||||||
|
telemetry.presented_frames = state.telemetry.presented_frames;
|
||||||
telemetry.render_failures = state.telemetry.render_failures;
|
telemetry.render_failures = state.telemetry.render_failures;
|
||||||
telemetry.publish_failures = state.telemetry.publish_failures;
|
telemetry.publish_failures = state.telemetry.publish_failures;
|
||||||
telemetry.present_failures = state.telemetry.present_failures;
|
telemetry.present_failures = state.telemetry.present_failures;
|
||||||
@@ -166,6 +181,17 @@ impl RenderWorkerController {
|
|||||||
self.ownership.snapshot()
|
self.ownership.snapshot()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Record only after a successful host presentation, never on publication.
|
||||||
|
pub fn record_presented_frame(&self, ownership: RenderOwnership, frame_id: FrameId) {
|
||||||
|
let mut state = self.state.lock().unwrap();
|
||||||
|
if state.last_presented == Some((ownership, frame_id)) {
|
||||||
|
state.telemetry.record_repeated_frame(frame_id.get());
|
||||||
|
} else {
|
||||||
|
state.telemetry.record_presented(frame_id.get());
|
||||||
|
}
|
||||||
|
state.last_presented = Some((ownership, frame_id));
|
||||||
|
}
|
||||||
|
|
||||||
pub fn record_repeated_frame(&self, frame_id: FrameId) {
|
pub fn record_repeated_frame(&self, frame_id: FrameId) {
|
||||||
let mut state = self.state.lock().unwrap();
|
let mut state = self.state.lock().unwrap();
|
||||||
state.telemetry.record_repeated_frame(frame_id.get());
|
state.telemetry.record_repeated_frame(frame_id.get());
|
||||||
@@ -190,13 +216,13 @@ fn run_worker_loop<B, S>(
|
|||||||
B: RenderWorkerBackend,
|
B: RenderWorkerBackend,
|
||||||
S: RenderWorkerFrameSink,
|
S: RenderWorkerFrameSink,
|
||||||
{
|
{
|
||||||
loop {
|
let report_path = std::env::var_os("PROMETEU_GRAPHICS_METRICS").map(std::path::PathBuf::from);
|
||||||
let submission = match handoff.wait_take() {
|
let mut measurements = Vec::new();
|
||||||
RenderWorkerHandoffWait::Submission(submission) => submission,
|
let mut measured_frames = 0usize;
|
||||||
RenderWorkerHandoffWait::Shutdown => return,
|
while let RenderWorkerHandoffWait::Submission(submission) = handoff.wait_take() {
|
||||||
};
|
|
||||||
let frame_id = submission.frame_id;
|
let frame_id = submission.frame_id;
|
||||||
|
|
||||||
|
let render_begin = report_path.as_ref().map(|_| std::time::Instant::now());
|
||||||
let render_result = catch_unwind(AssertUnwindSafe(|| backend.render(&submission)))
|
let render_result = catch_unwind(AssertUnwindSafe(|| backend.render(&submission)))
|
||||||
.map_err(|_| RenderWorkerError::WorkerPanic);
|
.map_err(|_| RenderWorkerError::WorkerPanic);
|
||||||
let frame = match render_result {
|
let frame = match render_result {
|
||||||
@@ -212,13 +238,45 @@ fn run_worker_loop<B, S>(
|
|||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
let render_us = render_begin.map(|start| start.elapsed().as_micros() as u64);
|
||||||
|
let publish_begin = report_path.as_ref().map(|_| std::time::Instant::now());
|
||||||
let publish_result = catch_unwind(AssertUnwindSafe(|| sink.publish(frame)))
|
let publish_result = catch_unwind(AssertUnwindSafe(|| sink.publish(frame)))
|
||||||
.map_err(|_| RenderWorkerError::WorkerPanic);
|
.map_err(|_| RenderWorkerError::WorkerPanic);
|
||||||
|
if let (Some(render_us), Some(begin)) = (render_us, publish_begin) {
|
||||||
|
let sample = (frame_id.get(), render_us, begin.elapsed().as_micros() as u64);
|
||||||
|
if measurements.len() < 16384 {
|
||||||
|
measurements.push(sample);
|
||||||
|
} else {
|
||||||
|
measurements[measured_frames % 16384] = sample;
|
||||||
|
}
|
||||||
|
measured_frames += 1;
|
||||||
|
}
|
||||||
match publish_result {
|
match publish_result {
|
||||||
Ok(Ok(())) => record_published(&state, frame_id),
|
Ok(Ok(())) => record_published(&state, frame_id),
|
||||||
Ok(Err(error)) | Err(error) => record_error(&state, error, frame_id),
|
Ok(Err(error)) | Err(error) => record_error(&state, error, frame_id),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if let Some(path) = report_path {
|
||||||
|
use std::io::Write;
|
||||||
|
let worker = state.lock().unwrap();
|
||||||
|
let handoff = handoff.telemetry();
|
||||||
|
let report = serde_json::json!({"schema":1,"source":"async_render_worker",
|
||||||
|
"produced_submissions":handoff.produced_submissions,"consumed_submissions":handoff.consumed_submissions,
|
||||||
|
"replaced_before_consume":handoff.replaced_before_consume,
|
||||||
|
"published_frames":worker.telemetry.published_frames,"first_presentations":worker.telemetry.presented_frames,
|
||||||
|
"repeated_presentations":worker.telemetry.repeated_frames,
|
||||||
|
"render_failures":worker.telemetry.render_failures,"publish_failures":worker.telemetry.publish_failures,
|
||||||
|
"measured_frames":measured_frames,"samples_frame_render_publish_us":measurements,
|
||||||
|
"physical_display_hz":null,
|
||||||
|
"limitations":"last 16384 successful-render samples; render includes owned-frame copy; sink publication is not scanout; opt-in clock and storage overhead"});
|
||||||
|
if let Ok(mut file) = std::fs::OpenOptions::new()
|
||||||
|
.create(true)
|
||||||
|
.append(true)
|
||||||
|
.open(path.with_extension("renderer.jsonl"))
|
||||||
|
{
|
||||||
|
let _ = writeln!(file, "{report}");
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn record_published(state: &Arc<Mutex<RenderWorkerState>>, frame_id: FrameId) {
|
fn record_published(state: &Arc<Mutex<RenderWorkerState>>, frame_id: FrameId) {
|
||||||
@@ -333,6 +391,14 @@ mod tests {
|
|||||||
SharedFakeBackend(backend),
|
SharedFakeBackend(backend),
|
||||||
);
|
);
|
||||||
|
|
||||||
|
let first_session = RenderOwnership::new(1, AppMode::Game, 7);
|
||||||
|
controller.record_presented_frame(first_session, FrameId::ZERO);
|
||||||
|
controller.record_presented_frame(first_session, FrameId::ZERO);
|
||||||
|
// Frame zero in a new epoch is a new image, not a repeat of the old session.
|
||||||
|
controller.record_presented_frame(RenderOwnership::new(2, AppMode::Game, 7), FrameId::ZERO);
|
||||||
|
assert_eq!(controller.telemetry().presented_frames, 2);
|
||||||
|
assert_eq!(controller.telemetry().repeated_frames, 1);
|
||||||
|
|
||||||
assert_eq!(controller.stop(), Ok(()));
|
assert_eq!(controller.stop(), Ok(()));
|
||||||
assert_eq!(controller.last_error(), None);
|
assert_eq!(controller.last_error(), None);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -18,3 +18,7 @@ fpmath = { version = "=0.1.1", features = ["soft-float"] }
|
|||||||
|
|
||||||
[dev-dependencies]
|
[dev-dependencies]
|
||||||
prometeu-test-support = { path = "../../dev/prometeu-test-support" }
|
prometeu-test-support = { path = "../../dev/prometeu-test-support" }
|
||||||
|
|
||||||
|
[[example]]
|
||||||
|
name = "string_provenance_benchmark"
|
||||||
|
required-features = ["resource-diagnostics"]
|
||||||
|
|||||||
@@ -0,0 +1,83 @@
|
|||||||
|
//! Run in release with --features resource-diagnostics; query setup is excluded.
|
||||||
|
#[allow(dead_code)]
|
||||||
|
#[path = "../tests/support/callables.rs"]
|
||||||
|
mod callables;
|
||||||
|
use prometeu_bytecode::model::ConstantPoolEntry;
|
||||||
|
use prometeu_vm::string_provenance_qualification::Fixture;
|
||||||
|
use std::{
|
||||||
|
alloc::{GlobalAlloc, Layout, System},
|
||||||
|
sync::atomic::{AtomicUsize, Ordering},
|
||||||
|
time::Instant,
|
||||||
|
};
|
||||||
|
struct Counting;
|
||||||
|
static ALLOC: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
static REALLOC: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
static FREE: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
unsafe impl GlobalAlloc for Counting {
|
||||||
|
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
|
||||||
|
ALLOC.fetch_add(1, Ordering::Relaxed);
|
||||||
|
unsafe { System.alloc(l) }
|
||||||
|
}
|
||||||
|
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
|
||||||
|
FREE.fetch_add(1, Ordering::Relaxed);
|
||||||
|
unsafe { System.dealloc(p, l) }
|
||||||
|
}
|
||||||
|
unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 {
|
||||||
|
REALLOC.fetch_add(1, Ordering::Relaxed);
|
||||||
|
unsafe { System.realloc(p, l, n) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[global_allocator]
|
||||||
|
static GLOBAL: Counting = Counting;
|
||||||
|
fn counts() -> [usize; 3] {
|
||||||
|
[ALLOC.load(Ordering::Relaxed), REALLOC.load(Ordering::Relaxed), FREE.load(Ordering::Relaxed)]
|
||||||
|
}
|
||||||
|
fn main() {
|
||||||
|
for n in [1024, 16384, 65536] {
|
||||||
|
let constants = vec![ConstantPoolEntry::String("same".into()); n];
|
||||||
|
let start = Instant::now();
|
||||||
|
let image = callables::image_constants(
|
||||||
|
&[("RET", callables::sig(&[], &[]), vec![])],
|
||||||
|
vec![],
|
||||||
|
&constants,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let image_ns = start.elapsed().as_nanos();
|
||||||
|
let payload = image.payload_bytes();
|
||||||
|
let before = counts();
|
||||||
|
let start = Instant::now();
|
||||||
|
let mut fixture = Fixture::new(image, n);
|
||||||
|
let creation_ns = start.elapsed().as_nanos();
|
||||||
|
let after = counts();
|
||||||
|
println!(
|
||||||
|
"setup n={n} image_load_ns={image_ns} image_payload_bytes={payload} session_ns={creation_ns} session_allocs={} auxiliary_bytes={} work={:?}",
|
||||||
|
after[0] - before[0],
|
||||||
|
fixture.auxiliary_bytes(),
|
||||||
|
fixture.work()
|
||||||
|
);
|
||||||
|
for name in [
|
||||||
|
"image_hit",
|
||||||
|
"image_miss",
|
||||||
|
"session_hit",
|
||||||
|
"session_miss",
|
||||||
|
"import_hit",
|
||||||
|
"snapshot_mixed",
|
||||||
|
"import_miss",
|
||||||
|
] {
|
||||||
|
let before = counts();
|
||||||
|
let start = Instant::now();
|
||||||
|
for _ in 0..1000 {
|
||||||
|
fixture.run(name);
|
||||||
|
}
|
||||||
|
let ns = start.elapsed().as_nanos();
|
||||||
|
let after = counts();
|
||||||
|
let delta = std::array::from_fn::<_, 3, _>(|i| after[i] - before[i]);
|
||||||
|
if name.ends_with("hit") || name == "image_miss" || name == "session_miss" {
|
||||||
|
assert_eq!(delta, [0; 3]);
|
||||||
|
}
|
||||||
|
println!(
|
||||||
|
"query n={n} name={name} iterations=1000 ns={ns} alloc_realloc_free={delta:?}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -235,12 +235,13 @@ pub type IntrinsicHostImplementation =
|
|||||||
pub enum IntrinsicImplementation {
|
pub enum IntrinsicImplementation {
|
||||||
Host(IntrinsicHostImplementation),
|
Host(IntrinsicHostImplementation),
|
||||||
VmOwned,
|
VmOwned,
|
||||||
|
BorrowedInline(crate::IntrinsicInlineImplementation),
|
||||||
}
|
}
|
||||||
impl IntrinsicImplementation {
|
impl IntrinsicImplementation {
|
||||||
pub fn host_callback(self) -> Option<IntrinsicHostImplementation> {
|
pub fn host_callback(self) -> Option<IntrinsicHostImplementation> {
|
||||||
match self {
|
match self {
|
||||||
Self::Host(f) => Some(f),
|
Self::Host(f) => Some(f),
|
||||||
Self::VmOwned => None,
|
Self::VmOwned | Self::BorrowedInline(_) => None,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -249,12 +250,14 @@ impl IntrinsicImplementation {
|
|||||||
pub enum IntrinsicCostModel {
|
pub enum IntrinsicCostModel {
|
||||||
Fixed,
|
Fixed,
|
||||||
RandomRejectionV1,
|
RandomRejectionV1,
|
||||||
|
ArgumentUtf8BytesV1,
|
||||||
}
|
}
|
||||||
impl IntrinsicCostModel {
|
impl IntrinsicCostModel {
|
||||||
pub const fn name(self) -> &'static str {
|
pub const fn name(self) -> &'static str {
|
||||||
match self {
|
match self {
|
||||||
Self::Fixed => "fixed",
|
Self::Fixed => "fixed",
|
||||||
Self::RandomRejectionV1 => "random_rejection_v1",
|
Self::RandomRejectionV1 => "random_rejection_v1",
|
||||||
|
Self::ArgumentUtf8BytesV1 => "argument_utf8_bytes_v1",
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -266,11 +269,14 @@ pub struct IntrinsicMeta {
|
|||||||
pub name: &'static str,
|
pub name: &'static str,
|
||||||
pub version: u16,
|
pub version: u16,
|
||||||
pub arg_layout: &'static [AbiType],
|
pub arg_layout: &'static [AbiType],
|
||||||
|
pub arg_nullable: &'static [bool],
|
||||||
pub ret_layout: &'static [AbiType],
|
pub ret_layout: &'static [AbiType],
|
||||||
pub parameter_names: &'static [&'static str],
|
pub parameter_names: &'static [&'static str],
|
||||||
/// Full fixed cost, or base cost for a variable model.
|
/// Full fixed cost, or base cost for a variable model.
|
||||||
pub cost_cycles: u64,
|
pub cost_cycles: u64,
|
||||||
pub cost_model: IntrinsicCostModel,
|
pub cost_model: IntrinsicCostModel,
|
||||||
|
pub cost_arg_index: Option<usize>,
|
||||||
|
pub cost_per_byte: u64,
|
||||||
pub attempt_cost_cycles: u64,
|
pub attempt_cost_cycles: u64,
|
||||||
pub max_attempts: u32,
|
pub max_attempts: u32,
|
||||||
pub mutates_guest_state: bool,
|
pub mutates_guest_state: bool,
|
||||||
@@ -300,7 +306,16 @@ impl IntrinsicMeta {
|
|||||||
&self,
|
&self,
|
||||||
values: &[Value],
|
values: &[Value],
|
||||||
) -> Result<(), IntrinsicExecutionError> {
|
) -> Result<(), IntrinsicExecutionError> {
|
||||||
Self::validate_values(values, self.arg_layout)
|
Self::validate_values(values, self.arg_layout)?;
|
||||||
|
for (index, (value, nullable)) in values.iter().zip(self.arg_nullable).enumerate() {
|
||||||
|
if matches!(value, Value::Null) && !nullable {
|
||||||
|
return Err(IntrinsicExecutionError::TypeMismatch {
|
||||||
|
index,
|
||||||
|
expected: self.arg_layout[index],
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn validate_values(
|
fn validate_values(
|
||||||
@@ -563,10 +578,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "dot",
|
name: "dot",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &VEC2_DOT_ARGS,
|
arg_layout: &VEC2_DOT_ARGS,
|
||||||
|
arg_nullable: &[false; VEC2_DOT_ARGS.len()],
|
||||||
ret_layout: &SINGLE_FLOAT_RET,
|
ret_layout: &SINGLE_FLOAT_RET,
|
||||||
parameter_names: &["ax", "ay", "bx", "by"],
|
parameter_names: &["ax", "ay", "bx", "by"],
|
||||||
cost_cycles: 10,
|
cost_cycles: 10,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -580,10 +598,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "length",
|
name: "length",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &VEC2_LENGTH_ARGS,
|
arg_layout: &VEC2_LENGTH_ARGS,
|
||||||
|
arg_nullable: &[false; VEC2_LENGTH_ARGS.len()],
|
||||||
ret_layout: &SINGLE_FLOAT_RET,
|
ret_layout: &SINGLE_FLOAT_RET,
|
||||||
parameter_names: &["x", "y"],
|
parameter_names: &["x", "y"],
|
||||||
cost_cycles: 40,
|
cost_cycles: 40,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -597,10 +618,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "from_raw",
|
name: "from_raw",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &INT_RET,
|
arg_layout: &INT_RET,
|
||||||
|
arg_nullable: &[false; INT_RET.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &["raw"],
|
parameter_names: &["raw"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -614,10 +638,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "rgb",
|
name: "rgb",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &COLOR_RGB_ARGS,
|
arg_layout: &COLOR_RGB_ARGS,
|
||||||
|
arg_nullable: &[false; COLOR_RGB_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &["r", "g", "b"],
|
parameter_names: &["r", "g", "b"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -631,10 +658,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "rgba",
|
name: "rgba",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &COLOR_RGBA_ARGS,
|
arg_layout: &COLOR_RGBA_ARGS,
|
||||||
|
arg_nullable: &[false; COLOR_RGBA_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &["r", "g", "b", "a"],
|
parameter_names: &["r", "g", "b", "a"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -648,10 +678,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "html_rgba",
|
name: "html_rgba",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &COLOR_HTML_RGBA_ARGS,
|
arg_layout: &COLOR_HTML_RGBA_ARGS,
|
||||||
|
arg_nullable: &[false; COLOR_HTML_RGBA_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &["value"],
|
parameter_names: &["value"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -665,10 +698,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "gray_scale",
|
name: "gray_scale",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &INT_RET,
|
arg_layout: &INT_RET,
|
||||||
|
arg_nullable: &[false; INT_RET.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &["value"],
|
parameter_names: &["value"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -682,10 +718,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "hex",
|
name: "hex",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &COLOR_ARGS,
|
arg_layout: &COLOR_ARGS,
|
||||||
|
arg_nullable: &[false; COLOR_ARGS.len()],
|
||||||
ret_layout: &INT_RET,
|
ret_layout: &INT_RET,
|
||||||
parameter_names: &["color"],
|
parameter_names: &["color"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -699,10 +738,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "alpha",
|
name: "alpha",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &COLOR_ARGS,
|
arg_layout: &COLOR_ARGS,
|
||||||
|
arg_nullable: &[false; COLOR_ARGS.len()],
|
||||||
ret_layout: &INT_RET,
|
ret_layout: &INT_RET,
|
||||||
parameter_names: &["color"],
|
parameter_names: &["color"],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -716,10 +758,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "black",
|
name: "black",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -733,10 +778,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "white",
|
name: "white",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -750,10 +798,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "red",
|
name: "red",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -767,10 +818,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "green",
|
name: "green",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -784,10 +838,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "blue",
|
name: "blue",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -801,10 +858,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "yellow",
|
name: "yellow",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -818,10 +878,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "orange",
|
name: "orange",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -835,10 +898,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "indigo",
|
name: "indigo",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -852,10 +918,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "gray",
|
name: "gray",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -869,10 +938,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "cyan",
|
name: "cyan",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -886,10 +958,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "magenta",
|
name: "magenta",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -903,10 +978,13 @@ const INTRINSICS: [IntrinsicMeta; 21] = [
|
|||||||
name: "transparent",
|
name: "transparent",
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &NO_ARGS,
|
arg_layout: &NO_ARGS,
|
||||||
|
arg_nullable: &[false; NO_ARGS.len()],
|
||||||
ret_layout: &COLOR_RET,
|
ret_layout: &COLOR_RET,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
@@ -944,6 +1022,7 @@ pub fn lookup_intrinsic(owner: &str, name: &str, version: u16) -> Option<&'stati
|
|||||||
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
||||||
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
||||||
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
||||||
|
.chain(crate::hash_intrinsics::HASH_INTRINSICS.iter())
|
||||||
.find(|meta| meta.owner == owner && meta.name == name && meta.version == version)
|
.find(|meta| meta.owner == owner && meta.name == name && meta.version == version)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -953,6 +1032,7 @@ pub fn lookup_intrinsic_by_id(id: u32) -> Option<&'static IntrinsicMeta> {
|
|||||||
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
||||||
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
||||||
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
||||||
|
.chain(crate::hash_intrinsics::HASH_INTRINSICS.iter())
|
||||||
.find(|meta| meta.id == id)
|
.find(|meta| meta.id == id)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1254,15 +1334,36 @@ pub(crate) fn metered_lookup_intrinsic(
|
|||||||
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
||||||
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
||||||
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
||||||
|
.chain(crate::hash_intrinsics::HASH_INTRINSICS.iter())
|
||||||
{
|
{
|
||||||
budget.work(1)?;
|
budget.work(1)?;
|
||||||
if meta.id == id {
|
if meta.id == id {
|
||||||
|
budget.work(meta.arg_slots() + 1)?;
|
||||||
|
meta.validate_descriptor().map_err(|_| {
|
||||||
|
prometeu_bytecode::load_limits::LoadFailure::new(
|
||||||
|
prometeu_bytecode::load_limits::LoadCode::InvalidCode,
|
||||||
|
prometeu_bytecode::load_limits::LoadReason::NativeId,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
return Ok(Some(meta));
|
return Ok(Some(meta));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Ok(None)
|
Ok(None)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Runtime-owned catalogue, including input and scalar math.
|
||||||
|
pub fn intrinsic_catalog() -> impl Iterator<Item = &'static IntrinsicMeta> {
|
||||||
|
INTRINSICS
|
||||||
|
.iter()
|
||||||
|
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
||||||
|
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
||||||
|
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
||||||
|
.chain(crate::hash_intrinsics::HASH_INTRINSICS.iter())
|
||||||
|
}
|
||||||
|
pub fn builtin_constant_catalog() -> impl Iterator<Item = &'static BuiltinConstMeta> {
|
||||||
|
BUILTIN_CONSTS.iter()
|
||||||
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
@@ -1432,15 +1533,3 @@ mod tests {
|
|||||||
assert_eq!(pixel.field("color").map(|field| field.start_slot), Some(2));
|
assert_eq!(pixel.field("color").map(|field| field.start_slot), Some(2));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Runtime-owned catalogue, including input and scalar math.
|
|
||||||
pub fn intrinsic_catalog() -> impl Iterator<Item = &'static IntrinsicMeta> {
|
|
||||||
INTRINSICS
|
|
||||||
.iter()
|
|
||||||
.chain(crate::input_intrinsics::INPUT_INTRINSICS.iter())
|
|
||||||
.chain(crate::math_intrinsics::MATH_INTRINSICS.iter())
|
|
||||||
.chain(crate::random_intrinsics::RANDOM_INTRINSICS.iter())
|
|
||||||
}
|
|
||||||
pub fn builtin_constant_catalog() -> impl Iterator<Item = &'static BuiltinConstMeta> {
|
|
||||||
BUILTIN_CONSTS.iter()
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -16,14 +16,15 @@ fn atom(t: AbiType) -> String {
|
|||||||
}
|
}
|
||||||
pub fn intrinsic_catalog_csv() -> String {
|
pub fn intrinsic_catalog_csv() -> String {
|
||||||
let mut out = String::from(
|
let mut out = String::from(
|
||||||
"final_id_hex,final_id_dec,canonical_name,canonical_version,owner,name,arg_slots,ret_slots,arg_layout,ret_layout,deterministic,may_allocate,parameter_names,cost_cycles,mutates_guest_state,cost_model,attempt_cost_cycles,max_attempts\n",
|
"final_id_hex,final_id_dec,canonical_name,canonical_version,owner,name,arg_slots,ret_slots,arg_layout,ret_layout,deterministic,may_allocate,parameter_names,cost_cycles,mutates_guest_state,cost_model,attempt_cost_cycles,max_attempts,schema_version,arg_nullable,invocation_model,scratch_model,context_access,cost_arg_index,cost_per_byte\n",
|
||||||
);
|
);
|
||||||
let mut entries: Vec<_> = intrinsic_catalog().collect();
|
let mut entries: Vec<_> = intrinsic_catalog().collect();
|
||||||
entries.sort_by_key(|m| m.id);
|
entries.sort_by_key(|m| m.id);
|
||||||
for m in entries {
|
for m in entries {
|
||||||
|
m.validate_descriptor().expect("valid canonical intrinsic descriptor");
|
||||||
writeln!(
|
writeln!(
|
||||||
&mut out,
|
&mut out,
|
||||||
"0x{:04X},{},{}.{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
|
"0x{:04X},{},{}.{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},2,{},{},{},{},{},{}",
|
||||||
m.id,
|
m.id,
|
||||||
m.id,
|
m.id,
|
||||||
m.owner,
|
m.owner,
|
||||||
@@ -42,7 +43,13 @@ pub fn intrinsic_catalog_csv() -> String {
|
|||||||
m.mutates_guest_state,
|
m.mutates_guest_state,
|
||||||
m.cost_model.name(),
|
m.cost_model.name(),
|
||||||
m.attempt_cost_cycles,
|
m.attempt_cost_cycles,
|
||||||
m.max_attempts
|
m.max_attempts,
|
||||||
|
m.arg_nullable.iter().map(bool::to_string).collect::<Vec<_>>().join("|"),
|
||||||
|
m.invocation_model(),
|
||||||
|
m.scratch_model(),
|
||||||
|
m.context_access(),
|
||||||
|
m.cost_arg_index.map_or_else(String::new, |i| i.to_string()),
|
||||||
|
m.cost_per_byte
|
||||||
)
|
)
|
||||||
.unwrap();
|
.unwrap();
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,66 @@
|
|||||||
|
use crate::{
|
||||||
|
AbiType, BuiltinScalarType as S, IntrinsicCostModel as C, IntrinsicExecutionError as E,
|
||||||
|
IntrinsicImplementation as I, IntrinsicMeta, IntrinsicResults,
|
||||||
|
};
|
||||||
|
use prometeu_bytecode::Value;
|
||||||
|
|
||||||
|
const fn entry(
|
||||||
|
id: u32,
|
||||||
|
name: &'static str,
|
||||||
|
abi: AbiType,
|
||||||
|
nullable: bool,
|
||||||
|
handler: crate::IntrinsicInlineImplementation,
|
||||||
|
) -> IntrinsicMeta {
|
||||||
|
IntrinsicMeta {
|
||||||
|
id,
|
||||||
|
owner: "hash",
|
||||||
|
name,
|
||||||
|
version: 1,
|
||||||
|
arg_layout: match abi {
|
||||||
|
AbiType::Scalar(S::Int64) => &[AbiType::Scalar(S::Int64)],
|
||||||
|
AbiType::Scalar(S::Float) => &[AbiType::Scalar(S::Float)],
|
||||||
|
AbiType::Scalar(S::String) => &[AbiType::Scalar(S::String)],
|
||||||
|
_ => panic!("unsupported hash input ABI"),
|
||||||
|
},
|
||||||
|
ret_layout: &[AbiType::Scalar(S::Int64)],
|
||||||
|
arg_nullable: if nullable { &[true] } else { &[false] },
|
||||||
|
parameter_names: &["value"],
|
||||||
|
cost_cycles: 8,
|
||||||
|
cost_model: if matches!(abi, AbiType::Scalar(S::String)) {
|
||||||
|
C::ArgumentUtf8BytesV1
|
||||||
|
} else {
|
||||||
|
C::Fixed
|
||||||
|
},
|
||||||
|
cost_arg_index: if matches!(abi, AbiType::Scalar(S::String)) { Some(0) } else { None },
|
||||||
|
cost_per_byte: if matches!(abi, AbiType::Scalar(S::String)) { 1 } else { 0 },
|
||||||
|
attempt_cost_cycles: 0,
|
||||||
|
max_attempts: 0,
|
||||||
|
mutates_guest_state: false,
|
||||||
|
deterministic: true,
|
||||||
|
may_allocate: false,
|
||||||
|
implementation: I::BorrowedInline(handler),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) const HASH_INTRINSICS: [IntrinsicMeta; 3] = [
|
||||||
|
entry(0x4100, "i64", AbiType::Scalar(S::Int64), false, hash_i64),
|
||||||
|
entry(0x4101, "float", AbiType::Scalar(S::Float), false, hash_float),
|
||||||
|
entry(0x4102, "string", AbiType::Scalar(S::String), true, hash_string),
|
||||||
|
];
|
||||||
|
fn hash_i64(args: &[Value], out: &mut IntrinsicResults) -> Result<(), E> {
|
||||||
|
let Value::Int64(value) = args[0] else { unreachable!("exact validated Int64") };
|
||||||
|
out.push(Value::Int64(crate::hashing::xxh64(&value.to_le_bytes()) as i64))
|
||||||
|
}
|
||||||
|
fn hash_float(args: &[Value], out: &mut IntrinsicResults) -> Result<(), E> {
|
||||||
|
let Value::Float(value) = args[0] else { unreachable!("exact validated Float") };
|
||||||
|
crate::numeric::check_inputs(&[value])?;
|
||||||
|
let bits = if value == 0.0 { 0 } else { value.to_bits() };
|
||||||
|
out.push(Value::Int64(crate::hashing::xxh64(&bits.to_le_bytes()) as i64))
|
||||||
|
}
|
||||||
|
fn hash_string(args: &[Value], out: &mut IntrinsicResults) -> Result<(), E> {
|
||||||
|
let hash = match &args[0] {
|
||||||
|
Value::Null => 0,
|
||||||
|
Value::String(s) => crate::hashing::xxh64(s.as_bytes()) as i64,
|
||||||
|
_ => unreachable!("exact validated nullable String"),
|
||||||
|
};
|
||||||
|
out.push(Value::Int64(hash))
|
||||||
|
}
|
||||||
@@ -0,0 +1,131 @@
|
|||||||
|
//! Hash-v1: portable XXH64, seed zero, over explicit machine byte encodings.
|
||||||
|
use prometeu_bytecode::HeapRef;
|
||||||
|
|
||||||
|
const P1: u64 = 0x9E3779B185EBCA87;
|
||||||
|
const P2: u64 = 0xC2B2AE3D27D4EB4F;
|
||||||
|
const P3: u64 = 0x165667B19E3779F9;
|
||||||
|
const P4: u64 = 0x85EBCA77C2B2AE63;
|
||||||
|
const P5: u64 = 0x27D4EB2F165667C5;
|
||||||
|
|
||||||
|
fn word(bytes: &[u8]) -> u64 {
|
||||||
|
u64::from_le_bytes(bytes[..8].try_into().expect("complete XXH64 lane"))
|
||||||
|
}
|
||||||
|
fn round(acc: u64, lane: u64) -> u64 {
|
||||||
|
acc.wrapping_add(lane.wrapping_mul(P2)).rotate_left(31).wrapping_mul(P1)
|
||||||
|
}
|
||||||
|
fn merge(acc: u64, lane: u64) -> u64 {
|
||||||
|
(acc ^ round(0, lane)).wrapping_mul(P1).wrapping_add(P4)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn xxh64(mut bytes: &[u8]) -> u64 {
|
||||||
|
let length = bytes.len() as u64;
|
||||||
|
let mut hash = if bytes.len() >= 32 {
|
||||||
|
let mut acc = [P1.wrapping_add(P2), P2, 0, 0u64.wrapping_sub(P1)];
|
||||||
|
while bytes.len() >= 32 {
|
||||||
|
for (index, value) in acc.iter_mut().enumerate() {
|
||||||
|
*value = round(*value, word(&bytes[index * 8..]));
|
||||||
|
}
|
||||||
|
bytes = &bytes[32..];
|
||||||
|
}
|
||||||
|
let mut hash = acc[0]
|
||||||
|
.rotate_left(1)
|
||||||
|
.wrapping_add(acc[1].rotate_left(7))
|
||||||
|
.wrapping_add(acc[2].rotate_left(12))
|
||||||
|
.wrapping_add(acc[3].rotate_left(18));
|
||||||
|
for value in acc {
|
||||||
|
hash = merge(hash, value);
|
||||||
|
}
|
||||||
|
hash
|
||||||
|
} else {
|
||||||
|
P5
|
||||||
|
};
|
||||||
|
hash = hash.wrapping_add(length);
|
||||||
|
while bytes.len() >= 8 {
|
||||||
|
hash ^= round(0, word(bytes));
|
||||||
|
hash = hash.rotate_left(27).wrapping_mul(P1).wrapping_add(P4);
|
||||||
|
bytes = &bytes[8..];
|
||||||
|
}
|
||||||
|
if bytes.len() >= 4 {
|
||||||
|
hash ^= u64::from(u32::from_le_bytes(bytes[..4].try_into().unwrap())).wrapping_mul(P1);
|
||||||
|
hash = hash.rotate_left(23).wrapping_mul(P2).wrapping_add(P3);
|
||||||
|
bytes = &bytes[4..];
|
||||||
|
}
|
||||||
|
for byte in bytes {
|
||||||
|
hash ^= u64::from(*byte).wrapping_mul(P5);
|
||||||
|
hash = hash.rotate_left(11).wrapping_mul(P1);
|
||||||
|
}
|
||||||
|
hash ^= hash >> 33;
|
||||||
|
hash = hash.wrapping_mul(P2);
|
||||||
|
hash ^= hash >> 29;
|
||||||
|
hash = hash.wrapping_mul(P3);
|
||||||
|
hash ^ (hash >> 32)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn reference(value: Option<HeapRef>) -> i64 {
|
||||||
|
value.map_or(0, |reference| {
|
||||||
|
let mut bytes = [0; 8];
|
||||||
|
bytes[..4].copy_from_slice(&reference.index.to_le_bytes());
|
||||||
|
bytes[4..].copy_from_slice(&reference.generation.to_le_bytes());
|
||||||
|
xxh64(&bytes) as i64
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
#[test]
|
||||||
|
fn matches_all_independent_c_reference_vectors() {
|
||||||
|
let mut count = 0;
|
||||||
|
for row in include_str!("../tests/fixtures/hash-conformance.tsv").lines().skip(1) {
|
||||||
|
let f: Vec<_> = row.split('\t').collect();
|
||||||
|
let expected = u64::from_str_radix(f[2], 16).unwrap();
|
||||||
|
let actual = match f[0] {
|
||||||
|
"bytes" | "string" => {
|
||||||
|
let bytes: Vec<_> = (0..f[1].len())
|
||||||
|
.step_by(2)
|
||||||
|
.map(|i| u8::from_str_radix(&f[1][i..i + 2], 16).unwrap())
|
||||||
|
.collect();
|
||||||
|
xxh64(&bytes)
|
||||||
|
}
|
||||||
|
"i64" => xxh64(&f[1].parse::<i64>().unwrap().to_le_bytes()),
|
||||||
|
"float" => {
|
||||||
|
let bits = u64::from_str_radix(f[1], 16).unwrap();
|
||||||
|
let bits = if f64::from_bits(bits) == 0.0 { 0 } else { bits };
|
||||||
|
xxh64(&bits.to_le_bytes())
|
||||||
|
}
|
||||||
|
"reference" => {
|
||||||
|
let (index, generation) = f[1].split_once(',').unwrap();
|
||||||
|
reference(Some(HeapRef {
|
||||||
|
index: index.parse().unwrap(),
|
||||||
|
generation: generation.parse().unwrap(),
|
||||||
|
})) as u64
|
||||||
|
}
|
||||||
|
"null" => reference(None) as u64,
|
||||||
|
kind => panic!("unknown vector {kind}"),
|
||||||
|
};
|
||||||
|
assert_eq!(actual, expected, "{row}");
|
||||||
|
count += 1;
|
||||||
|
}
|
||||||
|
assert_eq!(count, 118);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn sequential_handles_spread_and_bucket_collisions_do_not_imply_identity() {
|
||||||
|
let mut buckets = [0; 256];
|
||||||
|
let mut first = [None; 256];
|
||||||
|
let mut collisions = 0;
|
||||||
|
for index in 1..=16384 {
|
||||||
|
let handle = HeapRef { index, generation: 1 };
|
||||||
|
let bucket = reference(Some(handle)) as u64 as usize & 255;
|
||||||
|
buckets[bucket] += 1;
|
||||||
|
if let Some(previous) = first[bucket] {
|
||||||
|
assert_ne!(previous, handle);
|
||||||
|
collisions += 1;
|
||||||
|
} else {
|
||||||
|
first[bucket] = Some(handle);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert!(buckets.iter().all(|&count| (32..=100).contains(&count)), "{buckets:?}");
|
||||||
|
assert_eq!(collisions, 16384 - 256);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -428,6 +428,34 @@ impl Heap {
|
|||||||
self.allocation_count.load(Ordering::Relaxed)
|
self.allocation_count.load(Ordering::Relaxed)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Host-side observations only, outside guest execution and atomic commits.
|
||||||
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
|
pub fn diagnostic_typed_storage(&self) -> Vec<crate::resource_diagnostics::StorageObject> {
|
||||||
|
use crate::resource_diagnostics::{StorageObject, StorageValue};
|
||||||
|
self.objects
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.filter_map(|(index, object)| {
|
||||||
|
let storage = object.as_ref()?.typed.as_ref()?;
|
||||||
|
let groups = (0..storage.len())
|
||||||
|
.map(|i| {
|
||||||
|
storage
|
||||||
|
.read(i)
|
||||||
|
.expect("initialized typed storage")
|
||||||
|
.as_slice()
|
||||||
|
.iter()
|
||||||
|
.map(StorageValue::observe)
|
||||||
|
.collect()
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
Some(StorageObject {
|
||||||
|
reference: HeapRef { index: index as u32, generation: self.generations[index] },
|
||||||
|
type_id: storage.type_id(),
|
||||||
|
groups,
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
#[cfg(feature = "resource-diagnostics")]
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
pub(crate) fn diagnostic_handles(&self) -> (usize, usize) {
|
pub(crate) fn diagnostic_handles(&self) -> (usize, usize) {
|
||||||
(self.free_list.len(), self.objects.len() - self.free_list.len() - self.len())
|
(self.free_list.len(), self.objects.len() - self.free_list.len() - self.len())
|
||||||
@@ -520,6 +548,18 @@ impl Heap {
|
|||||||
value_contract::validate(registry, self, storage.slot_type(index)?, values.as_slice())?;
|
value_contract::validate(registry, self, storage.slot_type(index)?, values.as_slice())?;
|
||||||
Ok(values)
|
Ok(values)
|
||||||
}
|
}
|
||||||
|
/// Caller has checked all receivers, bounds and groups for the entire attempt.
|
||||||
|
/// This commit path performs no allocation, provenance lookup or guest callback.
|
||||||
|
pub(crate) fn commit_typed(&mut self, r: HeapRef, index: usize, values: &[Value]) {
|
||||||
|
self.objects[r.index as usize]
|
||||||
|
.as_mut()
|
||||||
|
.unwrap()
|
||||||
|
.typed
|
||||||
|
.as_mut()
|
||||||
|
.unwrap()
|
||||||
|
.write_validated(index, values)
|
||||||
|
.expect("prevalidated storage publication");
|
||||||
|
}
|
||||||
pub(crate) fn store_typed(
|
pub(crate) fn store_typed(
|
||||||
&mut self,
|
&mut self,
|
||||||
registry: &Registry,
|
registry: &Registry,
|
||||||
|
|||||||
@@ -20,10 +20,13 @@ const fn query(
|
|||||||
name,
|
name,
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: &[],
|
arg_layout: &[],
|
||||||
|
arg_nullable: &[],
|
||||||
ret_layout,
|
ret_layout,
|
||||||
parameter_names: &[],
|
parameter_names: &[],
|
||||||
cost_cycles: 1,
|
cost_cycles: 1,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
|
|||||||
@@ -0,0 +1,143 @@
|
|||||||
|
//! The native handler variant and descriptor jointly define the invocation contract.
|
||||||
|
use crate::{
|
||||||
|
AbiType, BuiltinScalarType, IntrinsicCostModel, IntrinsicExecutionError as E,
|
||||||
|
IntrinsicImplementation as I, IntrinsicMeta,
|
||||||
|
};
|
||||||
|
use prometeu_bytecode::Value;
|
||||||
|
|
||||||
|
pub type IntrinsicInlineImplementation = fn(&[Value], &mut IntrinsicResults) -> Result<(), E>;
|
||||||
|
const INLINE_SLOTS: usize = 3;
|
||||||
|
|
||||||
|
/// Fixed native staging only; no heap buffer or mutable execution context.
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct IntrinsicResults {
|
||||||
|
values: [Value; INLINE_SLOTS],
|
||||||
|
len: usize,
|
||||||
|
limit: usize,
|
||||||
|
overflowed: bool,
|
||||||
|
}
|
||||||
|
impl IntrinsicResults {
|
||||||
|
pub(crate) fn new(limit: usize) -> Self {
|
||||||
|
assert!(limit <= INLINE_SLOTS);
|
||||||
|
Self { values: [const { Value::Null }; INLINE_SLOTS], len: 0, limit, overflowed: false }
|
||||||
|
}
|
||||||
|
pub fn push(&mut self, value: Value) -> Result<(), E> {
|
||||||
|
if self.len >= self.limit {
|
||||||
|
self.overflowed = true;
|
||||||
|
return Err(E::ArityMismatch { expected: self.limit, got: self.len + 1 });
|
||||||
|
}
|
||||||
|
self.values[self.len] = value;
|
||||||
|
self.len += 1;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
pub(crate) fn validate(&self, meta: &IntrinsicMeta) -> Result<(), E> {
|
||||||
|
if self.overflowed {
|
||||||
|
return Err(E::ArityMismatch { expected: self.limit, got: self.limit + 1 });
|
||||||
|
}
|
||||||
|
meta.validate_result_values(&self.values[..self.len])
|
||||||
|
}
|
||||||
|
pub(crate) fn as_slice(&self) -> &[Value] {
|
||||||
|
&self.values[..self.len]
|
||||||
|
}
|
||||||
|
pub(crate) fn into_values(self) -> impl Iterator<Item = Value> {
|
||||||
|
self.values.into_iter().take(self.len)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl IntrinsicMeta {
|
||||||
|
pub fn invocation_model(&self) -> &'static str {
|
||||||
|
match self.implementation {
|
||||||
|
I::Host(_) => "host_buffered_v1",
|
||||||
|
I::VmOwned => "vm_owned_v1",
|
||||||
|
I::BorrowedInline(_) => "borrowed_inline_v1",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn scratch_model(&self) -> &'static str {
|
||||||
|
match self.implementation {
|
||||||
|
I::BorrowedInline(_) => "none",
|
||||||
|
_ => "existing_contract_v1",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn context_access(&self) -> &'static str {
|
||||||
|
match self.implementation {
|
||||||
|
I::Host(_) => "host",
|
||||||
|
I::VmOwned => "vm_state",
|
||||||
|
I::BorrowedInline(_) => "none",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/// Derivation from the handler variant makes incompatible profile claims unrepresentable.
|
||||||
|
pub fn validate_descriptor(&self) -> Result<(), &'static str> {
|
||||||
|
if self.arg_nullable.len() != self.arg_slots()
|
||||||
|
|| self.parameter_names.len() != self.arg_slots()
|
||||||
|
{
|
||||||
|
return Err("argument metadata widths disagree");
|
||||||
|
}
|
||||||
|
for abi in self.arg_layout.iter().chain(self.ret_layout) {
|
||||||
|
if !matches!(abi, AbiType::Scalar(_))
|
||||||
|
&& !matches!(abi, AbiType::Builtin(key) if (key.name == "Random" || key.name == "color") && key.version == 1)
|
||||||
|
{
|
||||||
|
return Err("unsupported intrinsic ABI layout");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (abi, nullable) in self.arg_layout.iter().zip(self.arg_nullable) {
|
||||||
|
let permits_null = matches!(abi, AbiType::Scalar(BuiltinScalarType::String))
|
||||||
|
|| matches!(abi, AbiType::Builtin(key) if key.name == "Random" && key.version == 1);
|
||||||
|
if *nullable && !permits_null {
|
||||||
|
return Err("non-nullable ABI carrier declared nullable");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
match self.cost_model {
|
||||||
|
IntrinsicCostModel::Fixed => {
|
||||||
|
if self.cost_arg_index.is_some()
|
||||||
|
|| self.cost_per_byte != 0
|
||||||
|
|| self.attempt_cost_cycles != 0
|
||||||
|
|| self.max_attempts != 0
|
||||||
|
{
|
||||||
|
return Err("fixed cost has variable parameters");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
IntrinsicCostModel::RandomRejectionV1 => {
|
||||||
|
if !matches!(self.implementation, I::VmOwned)
|
||||||
|
|| self.cost_arg_index.is_some()
|
||||||
|
|| self.cost_per_byte != 0
|
||||||
|
|| self.attempt_cost_cycles == 0
|
||||||
|
|| self.max_attempts == 0
|
||||||
|
{
|
||||||
|
return Err("invalid random rejection cost parameters");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
IntrinsicCostModel::ArgumentUtf8BytesV1 => {
|
||||||
|
if !matches!(self.implementation, I::BorrowedInline(_))
|
||||||
|
|| self.cost_arg_index.and_then(|i| self.arg_layout.get(i))
|
||||||
|
!= Some(&AbiType::Scalar(BuiltinScalarType::String))
|
||||||
|
|| self.cost_per_byte == 0
|
||||||
|
|| self.attempt_cost_cycles != 0
|
||||||
|
|| self.max_attempts != 0
|
||||||
|
{
|
||||||
|
return Err("invalid String byte-cost parameters");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if matches!(self.implementation, I::BorrowedInline(_))
|
||||||
|
&& (self.ret_slots() > INLINE_SLOTS
|
||||||
|
|| self.ret_slots() > self.arg_slots()
|
||||||
|
|| self.may_allocate
|
||||||
|
|| self.mutates_guest_state
|
||||||
|
|| !self.deterministic)
|
||||||
|
{
|
||||||
|
return Err("handler violates bounded invocation capabilities");
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
/// None is checked cost overflow. Wrong/missing carriers have no inferred length.
|
||||||
|
pub(crate) fn attempted_cost(&self, args: &[Value]) -> Option<u64> {
|
||||||
|
if self.cost_model != IntrinsicCostModel::ArgumentUtf8BytesV1 {
|
||||||
|
return Some(self.cost_cycles);
|
||||||
|
}
|
||||||
|
let bytes = match self.cost_arg_index.and_then(|i| args.get(i)) {
|
||||||
|
Some(Value::String(value)) => value.len() as u64,
|
||||||
|
_ => 0,
|
||||||
|
};
|
||||||
|
bytes.checked_mul(self.cost_per_byte)?.checked_add(self.cost_cycles)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -2,7 +2,11 @@
|
|||||||
extern crate self as prometeu_vm;
|
extern crate self as prometeu_vm;
|
||||||
mod builtins;
|
mod builtins;
|
||||||
mod catalog;
|
mod catalog;
|
||||||
|
mod hash_intrinsics;
|
||||||
|
mod hashing;
|
||||||
|
mod intrinsic_contract;
|
||||||
pub use catalog::{builtin_constant_catalog_csv, intrinsic_catalog_csv};
|
pub use catalog::{builtin_constant_catalog_csv, intrinsic_catalog_csv};
|
||||||
|
pub use intrinsic_contract::{IntrinsicInlineImplementation, IntrinsicResults};
|
||||||
mod call_frame;
|
mod call_frame;
|
||||||
mod input_intrinsics;
|
mod input_intrinsics;
|
||||||
mod math_intrinsics;
|
mod math_intrinsics;
|
||||||
@@ -25,6 +29,7 @@ mod program_image;
|
|||||||
mod registry_verifier;
|
mod registry_verifier;
|
||||||
pub use program_image::{ImageStringLease, ValidatedProgramImage};
|
pub use program_image::{ImageStringLease, ValidatedProgramImage};
|
||||||
// Image/session creation and native provenance consume this in step 19.
|
// Image/session creation and native provenance consume this in step 19.
|
||||||
|
mod string_identity_index;
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
mod string_ledger;
|
mod string_ledger;
|
||||||
// Registry-backed consumers are integrated with executable images in PLN-0176.
|
// Registry-backed consumers are integrated with executable images in PLN-0176.
|
||||||
@@ -52,3 +57,6 @@ pub use virtual_machine::{BudgetReport, LogicalFrameEndingReason, VirtualMachine
|
|||||||
pub use vm_init_error::{LoaderPatchError, VmInitError};
|
pub use vm_init_error::{LoaderPatchError, VmInitError};
|
||||||
|
|
||||||
pub use verifier::VerifierError;
|
pub use verifier::VerifierError;
|
||||||
|
|
||||||
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
|
pub use virtual_machine::string_provenance_qualification;
|
||||||
|
|||||||
@@ -20,10 +20,17 @@ const fn entry<const ID: u32>(
|
|||||||
name,
|
name,
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout,
|
arg_layout,
|
||||||
|
arg_nullable: match arg_layout.len() {
|
||||||
|
1 => &[false],
|
||||||
|
2 => &[false, false],
|
||||||
|
_ => &[false, false, false],
|
||||||
|
},
|
||||||
ret_layout,
|
ret_layout,
|
||||||
parameter_names,
|
parameter_names,
|
||||||
cost_cycles,
|
cost_cycles,
|
||||||
cost_model: crate::IntrinsicCostModel::Fixed,
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: 0,
|
attempt_cost_cycles: 0,
|
||||||
max_attempts: 0,
|
max_attempts: 0,
|
||||||
mutates_guest_state: false,
|
mutates_guest_state: false,
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
//! PBX v1 publication: immutable metadata and shared payload, after bindings
|
//! PBX v0 publication: immutable metadata and shared payload, after bindings
|
||||||
//! and bounded whole-program verification. No public unchecked constructor.
|
//! and bounded whole-program verification. No public unchecked constructor.
|
||||||
|
use crate::string_identity_index::Identity;
|
||||||
use crate::{LoaderPatchError, VmInitError};
|
use crate::{LoaderPatchError, VmInitError};
|
||||||
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
use prometeu_bytecode::isa::core::CoreOpCode as Op;
|
||||||
use prometeu_bytecode::load_limits::{
|
use prometeu_bytecode::load_limits::{
|
||||||
@@ -107,8 +108,30 @@ impl ValidatedProgramImage {
|
|||||||
Some(ImageStringLease { content: content.clone(), domain: self.strings.clone() })
|
Some(ImageStringLease { content: content.clone(), domain: self.strings.clone() })
|
||||||
}
|
}
|
||||||
pub fn retains_string(&self, content: &Arc<str>) -> bool {
|
pub fn retains_string(&self, content: &Arc<str>) -> bool {
|
||||||
|
self.lookup_string(content, || {})
|
||||||
|
}
|
||||||
|
fn lookup_string(&self, content: &Arc<str>, mut compare: impl FnMut()) -> bool {
|
||||||
let strings = self.strings.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
let strings = self.strings.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||||
strings.records.iter().any(|(weak, _)| std::ptr::eq(weak.as_ptr(), Arc::as_ptr(content)))
|
let target = Identity::of(content);
|
||||||
|
let mut low = 0;
|
||||||
|
let mut high = strings.records.len();
|
||||||
|
while low < high {
|
||||||
|
let mid = low + (high - low) / 2;
|
||||||
|
compare();
|
||||||
|
match record_identity(&strings.records[mid]).cmp(&target) {
|
||||||
|
std::cmp::Ordering::Less => low = mid + 1,
|
||||||
|
std::cmp::Ordering::Greater => high = mid,
|
||||||
|
std::cmp::Ordering::Equal => return true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
false
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(test, feature = "resource-diagnostics"))]
|
||||||
|
pub(crate) fn lookup_work(&self, content: &Arc<str>) -> (bool, usize) {
|
||||||
|
let mut work = 0;
|
||||||
|
let found = self.lookup_string(content, || work += 1);
|
||||||
|
(found, work)
|
||||||
}
|
}
|
||||||
pub fn constant_content(&self) -> (u64, usize) {
|
pub fn constant_content(&self) -> (u64, usize) {
|
||||||
let mut strings = self.strings.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
let mut strings = self.strings.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||||
@@ -205,6 +228,7 @@ impl ValidatedProgramImage {
|
|||||||
};
|
};
|
||||||
values.push(value);
|
values.push(value);
|
||||||
}
|
}
|
||||||
|
sort_string_records(&mut records, b)?;
|
||||||
b.refund(Q::TemporaryBytes, constants_capacity);
|
b.refund(Q::TemporaryBytes, constants_capacity);
|
||||||
// Binding no longer needs source declarations. They were validated,
|
// Binding no longer needs source declarations. They were validated,
|
||||||
// used exactly, and can be released before final payload publication.
|
// used exactly, and can be released before final payload publication.
|
||||||
@@ -256,6 +280,48 @@ impl ValidatedProgramImage {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn record_identity(record: &(Weak<str>, usize)) -> Identity {
|
||||||
|
Identity { address: record.0.as_ptr() as *const u8 as usize, length: record.1 }
|
||||||
|
}
|
||||||
|
|
||||||
|
// In-place heapsort: every record comparison (four field reads + comparison)
|
||||||
|
// and swap (two record reads + writes) is precharged. No scratch allocation.
|
||||||
|
fn sort_string_records(records: &mut [(Weak<str>, usize)], b: &mut LoadBudget) -> Result<(), E> {
|
||||||
|
fn sift(
|
||||||
|
records: &mut [(Weak<str>, usize)],
|
||||||
|
mut root: usize,
|
||||||
|
end: usize,
|
||||||
|
b: &mut LoadBudget,
|
||||||
|
) -> Result<(), E> {
|
||||||
|
while root < end / 2 {
|
||||||
|
let mut child = root * 2 + 1;
|
||||||
|
if child + 1 < end {
|
||||||
|
b.work(5)?;
|
||||||
|
if record_identity(&records[child]) < record_identity(&records[child + 1]) {
|
||||||
|
child += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
b.work(5)?;
|
||||||
|
if record_identity(&records[root]) >= record_identity(&records[child]) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
b.work(4)?;
|
||||||
|
records.swap(root, child);
|
||||||
|
root = child;
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
for root in (0..records.len() / 2).rev() {
|
||||||
|
sift(records, root, records.len(), b)?;
|
||||||
|
}
|
||||||
|
for end in (1..records.len()).rev() {
|
||||||
|
b.work(4)?;
|
||||||
|
records.swap(0, end);
|
||||||
|
sift(records, 0, end, b)?;
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
pub(crate) fn scratch<T>(count: usize, b: &mut LoadBudget) -> Result<Vec<T>, E> {
|
pub(crate) fn scratch<T>(count: usize, b: &mut LoadBudget) -> Result<Vec<T>, E> {
|
||||||
let bytes = count
|
let bytes = count
|
||||||
.checked_mul(size_of::<T>())
|
.checked_mul(size_of::<T>())
|
||||||
|
|||||||
@@ -309,3 +309,65 @@ fn sealed_image_load_probe() {
|
|||||||
elapsed
|
elapsed
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn string_identity_binary_search_preserves_constant_order_and_lease_indices() {
|
||||||
|
let constants = (0..1024).map(|i| K::String(format!("owner-{i}"))).collect::<Vec<_>>();
|
||||||
|
let bytes = fixture(&[1, 0], 0, &constants, None, &[]);
|
||||||
|
let image = ValidatedProgramImage::load(&bytes, &mut budget(), caps::NONE).unwrap();
|
||||||
|
for (i, value) in image.constants().iter().enumerate() {
|
||||||
|
let Value::String(text) = value else { panic!() };
|
||||||
|
assert_eq!(&**text, format!("owner-{i}"));
|
||||||
|
let (found, work) = image.lookup_work(text);
|
||||||
|
assert!(found && work <= 11, "binary work={work}");
|
||||||
|
assert!(Arc::ptr_eq(text, image.lease_constant(i).unwrap().content()));
|
||||||
|
assert!(!image.lookup_work(&Arc::from(text.as_ref())).0);
|
||||||
|
}
|
||||||
|
let lease = image.lease_constant(1023).unwrap();
|
||||||
|
drop(image);
|
||||||
|
assert_eq!(lease.retained_content(), (10, 1));
|
||||||
|
let domain = lease.domain.lock().unwrap();
|
||||||
|
assert_eq!(record_identity(&domain.records[0]), Identity::of(lease.content()));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn string_heap_sort_precharges_each_comparison_and_swap_without_scratch() {
|
||||||
|
let owners = (0..16).map(|_| Arc::<str>::from("same")).collect::<Vec<_>>();
|
||||||
|
let source = owners.iter().rev().map(|v| (Arc::downgrade(v), v.len())).collect::<Vec<_>>();
|
||||||
|
let mut full = budget();
|
||||||
|
let mut records = source.clone();
|
||||||
|
sort_string_records(&mut records, &mut full).unwrap();
|
||||||
|
assert!(records.windows(2).all(|v| record_identity(&v[0]) < record_identity(&v[1])));
|
||||||
|
assert_eq!(full.used(Q::TemporaryBytes), 0);
|
||||||
|
for limit in 0..full.used(Q::Work) {
|
||||||
|
let mut b = LoadBudget::new(LoadLimits { work: limit, ..Default::default() });
|
||||||
|
let mut records = source.clone();
|
||||||
|
let error = sort_string_records(&mut records, &mut b).unwrap_err();
|
||||||
|
assert_eq!(error.resource, Some(Q::Work));
|
||||||
|
assert!(b.used(Q::Work) <= limit);
|
||||||
|
assert_eq!(b.used(Q::TemporaryBytes), 0);
|
||||||
|
// Failed sort still owns exactly the original Weak identities.
|
||||||
|
records.sort_unstable_by_key(record_identity);
|
||||||
|
let mut expected = source.clone();
|
||||||
|
expected.sort_unstable_by_key(record_identity);
|
||||||
|
assert!(records.iter().zip(&expected).all(|(a, b)| Weak::ptr_eq(&a.0, &b.0)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn string_sort_exhaustion_rolls_back_sealed_load_domains() {
|
||||||
|
let constants = vec![K::String("same".into()); 2];
|
||||||
|
let bytes = fixture(&[1, 0], 0, &constants, None, &[]);
|
||||||
|
let mut full = budget();
|
||||||
|
ValidatedProgramImage::load(&bytes, &mut full, caps::NONE).unwrap();
|
||||||
|
// Post-sort sharing costs 2 + 2 + 1 work units. Sorting two records
|
||||||
|
// costs 9 or 13 units, depending on their addresses. Removing another
|
||||||
|
// five leaves at most eight: failure is inside sorting for either order.
|
||||||
|
let mut b =
|
||||||
|
LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 5 - 5, ..Default::default() });
|
||||||
|
let error = ValidatedProgramImage::load(&bytes, &mut b, caps::NONE).unwrap_err();
|
||||||
|
assert!(matches!(error,VmInitError::RegistryLoadFailed(e) if e.resource==Some(Q::Work)));
|
||||||
|
for resource in DOMAINS {
|
||||||
|
assert_eq!(b.used(resource), 0, "{resource:?}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -21,6 +21,13 @@ const fn entry(
|
|||||||
name,
|
name,
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_layout: args,
|
arg_layout: args,
|
||||||
|
arg_nullable: if id == 0x4000 {
|
||||||
|
&[false]
|
||||||
|
} else if rejection {
|
||||||
|
&[true, false, false]
|
||||||
|
} else {
|
||||||
|
&[true]
|
||||||
|
},
|
||||||
ret_layout: ret,
|
ret_layout: ret,
|
||||||
parameter_names: names,
|
parameter_names: names,
|
||||||
cost_cycles: cost,
|
cost_cycles: cost,
|
||||||
@@ -29,6 +36,8 @@ const fn entry(
|
|||||||
} else {
|
} else {
|
||||||
IntrinsicCostModel::Fixed
|
IntrinsicCostModel::Fixed
|
||||||
},
|
},
|
||||||
|
cost_arg_index: None,
|
||||||
|
cost_per_byte: 0,
|
||||||
attempt_cost_cycles: if rejection { 8 } else { 0 },
|
attempt_cost_cycles: if rejection { 8 } else { 0 },
|
||||||
max_attempts: if rejection { crate::random::MAX_ATTEMPTS } else { 0 },
|
max_attempts: if rejection { crate::random::MAX_ATTEMPTS } else { 0 },
|
||||||
deterministic: true,
|
deterministic: true,
|
||||||
|
|||||||
@@ -485,6 +485,10 @@ fn transfer(
|
|||||||
group(&mut working[base..], registry, ty, (instruction.pc as u64) << 32, budget)?;
|
group(&mut working[base..], registry, ty, (instruction.pc as u64) << 32, budget)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
Op::RefIdentityHash => {
|
||||||
|
budget.work(1)?;
|
||||||
|
working[base] = Fact::Carrier(I64);
|
||||||
|
}
|
||||||
Op::RefCast | Op::RefToTrait => {
|
Op::RefCast | Op::RefToTrait => {
|
||||||
group(
|
group(
|
||||||
&mut working[base..],
|
&mut working[base..],
|
||||||
@@ -503,6 +507,7 @@ fn transfer(
|
|||||||
| Op::And
|
| Op::And
|
||||||
| Op::Or
|
| Op::Or
|
||||||
| Op::Not
|
| Op::Not
|
||||||
|
| Op::RefIdentityEq
|
||||||
| Op::RefIsExact
|
| Op::RefIsExact
|
||||||
| Op::RefImplements
|
| Op::RefImplements
|
||||||
| Op::DynCanUnpack => {
|
| Op::DynCanUnpack => {
|
||||||
@@ -705,6 +710,15 @@ fn check(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
Op::ArrayNew => require(working[end - 1], I64, 0, registry, budget)?,
|
Op::ArrayNew => require(working[end - 1], I64, 0, registry, budget)?,
|
||||||
|
Op::ArrayCopy => {
|
||||||
|
let array = TypeId(instruction.imm_u32().unwrap());
|
||||||
|
let base = end - 5;
|
||||||
|
check_group(&working[base..base + 1], array, registry, budget)?;
|
||||||
|
check_group(&working[base + 2..base + 3], array, registry, budget)?;
|
||||||
|
for i in [1, 3, 4] {
|
||||||
|
require(working[base + i], I64, i, registry, budget)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
Op::StructGet | Op::StructSet | Op::ArrayLen | Op::ArrayGet | Op::ArraySet => {
|
Op::StructGet | Op::StructSet | Op::ArrayLen | Op::ArrayGet | Op::ArraySet => {
|
||||||
budget.work(3)?;
|
budget.work(3)?;
|
||||||
let (id, field) = if matches!(instruction.opcode, Op::StructGet | Op::StructSet) {
|
let (id, field) = if matches!(instruction.opcode, Op::StructGet | Op::StructSet) {
|
||||||
@@ -760,6 +774,21 @@ fn check(
|
|||||||
return Err(mismatch(1));
|
return Err(mismatch(1));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
Op::RefIdentityHash | Op::RefIdentityEq => {
|
||||||
|
let (left, right) = if instruction.opcode == Op::RefIdentityHash {
|
||||||
|
(instruction.imm_u32().unwrap(), None)
|
||||||
|
} else {
|
||||||
|
let (a, b) = instruction.imm_u32x2().unwrap();
|
||||||
|
(a, Some(b))
|
||||||
|
};
|
||||||
|
let lw = registry.type_layout(TypeId(left)).unwrap().storage.slots as usize;
|
||||||
|
let rw = right
|
||||||
|
.map_or(0, |id| registry.type_layout(TypeId(id)).unwrap().storage.slots as usize);
|
||||||
|
check_group(&working[end - lw - rw..end - rw], TypeId(left), registry, budget)?;
|
||||||
|
if let Some(id) = right {
|
||||||
|
check_group(&working[end - rw..end], TypeId(id), registry, budget)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
Op::RefCast | Op::RefToTrait | Op::RefIsExact | Op::RefImplements => {
|
Op::RefCast | Op::RefToTrait | Op::RefIsExact | Op::RefImplements => {
|
||||||
budget.work(1)?;
|
budget.work(1)?;
|
||||||
let ty = TypeId(instruction.imm_u32x2().unwrap().0);
|
let ty = TypeId(instruction.imm_u32x2().unwrap().0);
|
||||||
@@ -772,7 +801,12 @@ fn check(
|
|||||||
.unwrap();
|
.unwrap();
|
||||||
let base = end - native.arg_slots();
|
let base = end - native.arg_slots();
|
||||||
for (part, abi) in native.arg_layout.iter().enumerate() {
|
for (part, abi) in native.arg_layout.iter().enumerate() {
|
||||||
require(working[base + part], abi_mask(*abi), part, registry, budget)?;
|
let accepted = if native.arg_nullable[part] {
|
||||||
|
abi_mask(*abi) | NULL
|
||||||
|
} else {
|
||||||
|
abi_mask(*abi) & !NULL
|
||||||
|
};
|
||||||
|
require(working[base + part], accepted, part, registry, budget)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Op::JmpIfTrue | Op::JmpIfFalse | Op::Not => {
|
Op::JmpIfTrue | Op::JmpIfFalse | Op::Not => {
|
||||||
|
|||||||
@@ -385,6 +385,10 @@ impl<T> BudgetVec<T> {
|
|||||||
let bytes = b.bytes::<T>(capacity, q)?;
|
let bytes = b.bytes::<T>(capacity, q)?;
|
||||||
let mut extra = b.reserve(q, bytes - self.charge.amount)?;
|
let mut extra = b.reserve(q, bytes - self.charge.amount)?;
|
||||||
let temporary = b.reserve(RuntimeResource::TemporaryBytes, self.charge.amount)?;
|
let temporary = b.reserve(RuntimeResource::TemporaryBytes, self.charge.amount)?;
|
||||||
|
#[cfg(test)]
|
||||||
|
if FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.replace(false)) {
|
||||||
|
return Err(b.failure(q, ResourceReason::AllocationFailed, bytes));
|
||||||
|
}
|
||||||
let mut candidate = Vec::new();
|
let mut candidate = Vec::new();
|
||||||
candidate
|
candidate
|
||||||
.try_reserve_exact(capacity)
|
.try_reserve_exact(capacity)
|
||||||
@@ -405,6 +409,21 @@ impl<T> BudgetVec<T> {
|
|||||||
self.charge.absorb(growth.extra);
|
self.charge.absorb(growth.extra);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
/// Rebuild a table with all fallible capacity/coexistence admission completed
|
||||||
|
/// before moving any old entry. The relocation callback must not allocate.
|
||||||
|
pub(crate) fn rebuild_with(
|
||||||
|
&mut self,
|
||||||
|
len: usize,
|
||||||
|
vacant: impl FnMut() -> T,
|
||||||
|
relocate: impl FnOnce(&mut [T], &mut [T]),
|
||||||
|
) -> Result<(), ResourceFailure> {
|
||||||
|
let mut growth = self.prepare_capacity(len.max(self.data.capacity()))?;
|
||||||
|
growth.candidate.resize_with(len, vacant);
|
||||||
|
relocate(&mut self.data, &mut growth.candidate);
|
||||||
|
self.data = growth.candidate;
|
||||||
|
self.charge.absorb(growth.extra);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
pub fn reserve(&mut self, additional: usize) -> Result<(), ResourceFailure> {
|
pub fn reserve(&mut self, additional: usize) -> Result<(), ResourceFailure> {
|
||||||
let growth = self.prepare_growth(additional)?;
|
let growth = self.prepare_growth(additional)?;
|
||||||
self.commit_growth(growth);
|
self.commit_growth(growth);
|
||||||
@@ -445,9 +464,6 @@ impl<T> BudgetVec<T> {
|
|||||||
pub fn clear(&mut self) {
|
pub fn clear(&mut self) {
|
||||||
self.data.clear();
|
self.data.clear();
|
||||||
}
|
}
|
||||||
pub(crate) fn retain(&mut self, keep: impl FnMut(&T) -> bool) {
|
|
||||||
self.data.retain(keep);
|
|
||||||
}
|
|
||||||
pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> Result<(), ResourceFailure>
|
pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> Result<(), ResourceFailure>
|
||||||
where
|
where
|
||||||
T: Clone,
|
T: Clone,
|
||||||
@@ -509,3 +525,8 @@ pub(crate) struct VecGrowth<T> {
|
|||||||
_temporary: Reservation,
|
_temporary: Reservation,
|
||||||
old_capacity: usize,
|
old_capacity: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
thread_local! {
|
||||||
|
pub(crate) static FAIL_NEXT_VEC_ALLOCATION: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
||||||
|
}
|
||||||
|
|||||||
@@ -87,3 +87,39 @@ mod tests {
|
|||||||
assert_eq!(h.max_ns, 99);
|
assert_eq!(h.max_ns, 99);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Non-owning storage observations for engineering qualification. These values
|
||||||
|
/// never retain a guest object or a native string owner and cannot write storage.
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub enum StorageValue {
|
||||||
|
Null,
|
||||||
|
Int32(i32),
|
||||||
|
Int64(i64),
|
||||||
|
FloatBits(u64),
|
||||||
|
Boolean(bool),
|
||||||
|
Reference(prometeu_bytecode::HeapRef),
|
||||||
|
StringIdentity { address: usize, bytes: usize },
|
||||||
|
}
|
||||||
|
impl StorageValue {
|
||||||
|
pub(crate) fn observe(value: &prometeu_bytecode::Value) -> Self {
|
||||||
|
use prometeu_bytecode::Value;
|
||||||
|
match value {
|
||||||
|
Value::Null => Self::Null,
|
||||||
|
Value::Int32(n) => Self::Int32(*n),
|
||||||
|
Value::Int64(n) => Self::Int64(*n),
|
||||||
|
Value::Float(n) => Self::FloatBits(n.to_bits()),
|
||||||
|
Value::Boolean(n) => Self::Boolean(*n),
|
||||||
|
Value::HeapRef(r) => Self::Reference(*r),
|
||||||
|
Value::String(s) => Self::StringIdentity {
|
||||||
|
address: std::sync::Arc::as_ptr(s) as *const () as usize,
|
||||||
|
bytes: s.len(),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct StorageObject {
|
||||||
|
pub reference: prometeu_bytecode::HeapRef,
|
||||||
|
pub type_id: prometeu_bytecode::registry::TypeId,
|
||||||
|
pub groups: Vec<Vec<StorageValue>>,
|
||||||
|
}
|
||||||
|
|||||||
@@ -0,0 +1,123 @@
|
|||||||
|
//! Private allocation identity index. Values retain Weak ownership, never content.
|
||||||
|
use crate::resource_budget::{
|
||||||
|
BudgetVec, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
|
||||||
|
};
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||||||
|
pub(crate) struct Identity {
|
||||||
|
pub(crate) address: usize,
|
||||||
|
pub(crate) length: usize,
|
||||||
|
}
|
||||||
|
impl Identity {
|
||||||
|
pub(crate) fn of(content: &Arc<str>) -> Self {
|
||||||
|
Self { address: Arc::as_ptr(content) as *const u8 as usize, length: content.len() }
|
||||||
|
}
|
||||||
|
fn hash(self) -> usize {
|
||||||
|
// Mix aligned addresses and lengths; collisions still compare both fields.
|
||||||
|
let mut n = (self.address as u64) ^ (self.length as u64).wrapping_mul(0x9e3779b97f4a7c15);
|
||||||
|
n = (n ^ (n >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
|
||||||
|
n = (n ^ (n >> 27)).wrapping_mul(0x94d049bb133111eb);
|
||||||
|
(n ^ (n >> 31)) as usize
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[derive(Debug)]
|
||||||
|
enum Bucket<T> {
|
||||||
|
Empty,
|
||||||
|
Tombstone,
|
||||||
|
Occupied(Identity, T),
|
||||||
|
}
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub(crate) struct IdentityIndex<T> {
|
||||||
|
buckets: BudgetVec<Bucket<T>>,
|
||||||
|
live: usize,
|
||||||
|
tombstones: usize,
|
||||||
|
}
|
||||||
|
impl<T> IdentityIndex<T> {
|
||||||
|
pub(crate) fn new(budget: &RuntimeBudget) -> Self {
|
||||||
|
Self { buckets: BudgetVec::new(budget, Q::AuxiliaryBytes), live: 0, tombstones: 0 }
|
||||||
|
}
|
||||||
|
pub(crate) fn len(&self) -> usize {
|
||||||
|
self.live
|
||||||
|
}
|
||||||
|
pub(crate) fn contains(&self, key: Identity, mut probe: impl FnMut()) -> bool {
|
||||||
|
let size = self.buckets.len();
|
||||||
|
if size == 0 {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
let mut at = key.hash() & (size - 1);
|
||||||
|
loop {
|
||||||
|
probe();
|
||||||
|
match &self.buckets[at] {
|
||||||
|
Bucket::Empty => return false,
|
||||||
|
Bucket::Occupied(found, _) if *found == key => return true,
|
||||||
|
_ => at = (at + 1) & (size - 1),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) fn prepare(&mut self, budget: &RuntimeBudget) -> Result<(), ResourceFailure> {
|
||||||
|
let size = self.buckets.len();
|
||||||
|
let next = self.live + 1;
|
||||||
|
let capacity = if size == 0 {
|
||||||
|
8
|
||||||
|
} else if next > size / 2 {
|
||||||
|
size.checked_mul(2).ok_or_else(|| {
|
||||||
|
budget.failure(Q::AuxiliaryBytes, ResourceReason::SizeOverflow, u64::MAX)
|
||||||
|
})?
|
||||||
|
} else if next + self.tombstones > size / 2 {
|
||||||
|
size
|
||||||
|
} else {
|
||||||
|
return Ok(());
|
||||||
|
};
|
||||||
|
self.buckets.rebuild_with(
|
||||||
|
capacity,
|
||||||
|
|| Bucket::Empty,
|
||||||
|
|old, new| {
|
||||||
|
for slot in old {
|
||||||
|
if let Bucket::Occupied(key, value) = std::mem::replace(slot, Bucket::Empty) {
|
||||||
|
Self::place(new, key, value);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
self.tombstones = 0;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
fn place(buckets: &mut [Bucket<T>], key: Identity, value: T) -> bool {
|
||||||
|
let mut at = key.hash() & (buckets.len() - 1);
|
||||||
|
loop {
|
||||||
|
match &buckets[at] {
|
||||||
|
Bucket::Empty | Bucket::Tombstone => {
|
||||||
|
let reused = matches!(buckets[at], Bucket::Tombstone);
|
||||||
|
buckets[at] = Bucket::Occupied(key, value);
|
||||||
|
return reused;
|
||||||
|
}
|
||||||
|
Bucket::Occupied(found, _) => {
|
||||||
|
assert_ne!(*found, key, "duplicate allocation identity")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
at = (at + 1) & (buckets.len() - 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) fn insert(&mut self, key: Identity, value: T) {
|
||||||
|
assert!(self.live < self.buckets.len() / 2, "prepare must precede publication");
|
||||||
|
if Self::place(&mut self.buckets, key, value) {
|
||||||
|
self.tombstones -= 1;
|
||||||
|
}
|
||||||
|
self.live += 1;
|
||||||
|
}
|
||||||
|
pub(crate) fn retain(&mut self, mut keep: impl FnMut(&T) -> bool) {
|
||||||
|
for slot in &mut *self.buckets {
|
||||||
|
if matches!(slot, Bucket::Occupied(_, value) if !keep(value)) {
|
||||||
|
// Erase the key before releasing the Weak/reservations. Its
|
||||||
|
// allocation address cannot be recycled while Weak survives.
|
||||||
|
let removed = std::mem::replace(slot, Bucket::Tombstone);
|
||||||
|
self.live -= 1;
|
||||||
|
self.tombstones += 1;
|
||||||
|
drop(removed);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests;
|
||||||
@@ -0,0 +1,72 @@
|
|||||||
|
use super::*;
|
||||||
|
#[test]
|
||||||
|
fn collision_chains_distinguish_full_identity_and_survive_tombstones() {
|
||||||
|
let b = RuntimeBudget::default();
|
||||||
|
let mut table = IdentityIndex::new(&b);
|
||||||
|
let keys: Vec<_> = (0..1000)
|
||||||
|
.map(|address| Identity { address, length: 4 })
|
||||||
|
.filter(|k| k.hash() & 7 == 0)
|
||||||
|
.take(4)
|
||||||
|
.collect();
|
||||||
|
for (i, key) in keys.iter().enumerate() {
|
||||||
|
table.prepare(&b).unwrap();
|
||||||
|
table.insert(*key, i);
|
||||||
|
}
|
||||||
|
for key in &keys {
|
||||||
|
assert!(table.contains(*key, || {}));
|
||||||
|
}
|
||||||
|
table.retain(|i| *i != 1);
|
||||||
|
assert!(!table.contains(keys[1], || {}));
|
||||||
|
assert!(table.contains(keys[3], || {}));
|
||||||
|
assert!(!table.contains(Identity { length: 5, ..keys[3] }, || {}));
|
||||||
|
table.prepare(&b).unwrap(); // Rebuild removes tombstones at half occupancy.
|
||||||
|
table.insert(keys[1], 1);
|
||||||
|
assert_eq!(table.len(), 4);
|
||||||
|
assert_eq!(table.tombstones, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn tombstone_reuse_keeps_collision_successors_and_length_is_part_of_key() {
|
||||||
|
let b = RuntimeBudget::default();
|
||||||
|
let mut t = IdentityIndex::new(&b);
|
||||||
|
let key = Identity { address: 16, length: 0 };
|
||||||
|
t.prepare(&b).unwrap();
|
||||||
|
t.insert(key, 1);
|
||||||
|
t.prepare(&b).unwrap();
|
||||||
|
t.insert(Identity { length: 1, ..key }, 2);
|
||||||
|
t.retain(|v| *v != 1);
|
||||||
|
assert_eq!(t.tombstones, 1);
|
||||||
|
t.prepare(&b).unwrap();
|
||||||
|
t.insert(key, 3);
|
||||||
|
assert_eq!(t.tombstones, 0);
|
||||||
|
assert!(t.contains(key, || {}));
|
||||||
|
assert!(t.contains(Identity { length: 1, ..key }, || {}));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn controlled_probe_counts_and_half_load_survive_growth_and_rebuild() {
|
||||||
|
let b = RuntimeBudget::default();
|
||||||
|
let mut table = IdentityIndex::new(&b);
|
||||||
|
for n in 0..1024 {
|
||||||
|
table.prepare(&b).unwrap();
|
||||||
|
table.insert(Identity { address: n * 16, length: n % 7 }, n);
|
||||||
|
assert!(table.live * 2 <= table.buckets.len());
|
||||||
|
}
|
||||||
|
let mut max_probes = 0;
|
||||||
|
for n in 0..2048 {
|
||||||
|
let mut probes = 0;
|
||||||
|
assert_eq!(
|
||||||
|
table.contains(Identity { address: n * 16, length: n % 7 }, || probes += 1),
|
||||||
|
n < 1024
|
||||||
|
);
|
||||||
|
max_probes = max_probes.max(probes);
|
||||||
|
}
|
||||||
|
// A reproducible synthetic-key bound for this fixture, not a hash-table
|
||||||
|
// worst-case claim or a constraint on allocator-selected real addresses.
|
||||||
|
assert!(max_probes <= 32, "fixture probes={max_probes}");
|
||||||
|
table.retain(|n| n % 2 == 0);
|
||||||
|
table.prepare(&b).unwrap();
|
||||||
|
for n in 0..1024 {
|
||||||
|
assert_eq!(table.contains(Identity { address: n * 16, length: n % 7 }, || {}), n % 2 == 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -4,6 +4,7 @@
|
|||||||
use crate::resource_budget::{
|
use crate::resource_budget::{
|
||||||
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
|
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
|
||||||
};
|
};
|
||||||
|
use crate::string_identity_index::{Identity, IdentityIndex};
|
||||||
use prometeu_bytecode::Value;
|
use prometeu_bytecode::Value;
|
||||||
use std::sync::{Arc, Mutex, MutexGuard, Weak};
|
use std::sync::{Arc, Mutex, MutexGuard, Weak};
|
||||||
|
|
||||||
@@ -17,7 +18,7 @@ struct Entry {
|
|||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
struct Domain {
|
struct Domain {
|
||||||
budget: RuntimeBudget,
|
budget: RuntimeBudget,
|
||||||
entries: BudgetVec<Entry>,
|
entries: IdentityIndex<Entry>,
|
||||||
_state: Reservation,
|
_state: Reservation,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -49,7 +50,7 @@ impl StringLedger {
|
|||||||
Q::AuxiliaryBytes,
|
Q::AuxiliaryBytes,
|
||||||
budget.bytes::<Mutex<Domain>>(1, Q::AuxiliaryBytes)? + 2 * size_of::<usize>() as u64,
|
budget.bytes::<Mutex<Domain>>(1, Q::AuxiliaryBytes)? + 2 * size_of::<usize>() as u64,
|
||||||
)?;
|
)?;
|
||||||
let entries = BudgetVec::new(&budget, Q::AuxiliaryBytes);
|
let entries = IdentityIndex::new(&budget);
|
||||||
Ok(Self(Arc::new(Mutex::new(Domain { budget, entries, _state: state }))))
|
Ok(Self(Arc::new(Mutex::new(Domain { budget, entries, _state: state }))))
|
||||||
}
|
}
|
||||||
fn domain(&self) -> MutexGuard<'_, Domain> {
|
fn domain(&self) -> MutexGuard<'_, Domain> {
|
||||||
@@ -57,7 +58,7 @@ impl StringLedger {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Safepoint reconciliation is bounded by the accepted allocation count.
|
/// Safepoint reconciliation is bounded by the accepted allocation count.
|
||||||
/// Retain compacts in place; unused capacity remains charged until drop.
|
/// Dead buckets become tombstones; retained capacity stays charged until drop.
|
||||||
pub(crate) fn reconcile(&self) -> usize {
|
pub(crate) fn reconcile(&self) -> usize {
|
||||||
self.domain().reconcile()
|
self.domain().reconcile()
|
||||||
}
|
}
|
||||||
@@ -65,9 +66,19 @@ impl StringLedger {
|
|||||||
self.domain().entries.len()
|
self.domain().entries.len()
|
||||||
}
|
}
|
||||||
pub(crate) fn retains(&self, content: &Arc<str>) -> bool {
|
pub(crate) fn retains(&self, content: &Arc<str>) -> bool {
|
||||||
let address = Arc::as_ptr(content);
|
self.lookup(content, || {})
|
||||||
self.domain().entries.iter().any(|entry| std::ptr::eq(entry.content.as_ptr(), address))
|
|
||||||
}
|
}
|
||||||
|
fn lookup(&self, content: &Arc<str>, mut probe: impl FnMut()) -> bool {
|
||||||
|
self.domain().entries.contains(Identity::of(content), &mut probe)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(test, feature = "resource-diagnostics"))]
|
||||||
|
pub(crate) fn lookup_work(&self, content: &Arc<str>) -> (bool, usize) {
|
||||||
|
let mut work = 0;
|
||||||
|
let found = self.lookup(content, || work += 1);
|
||||||
|
(found, work)
|
||||||
|
}
|
||||||
|
|
||||||
pub(crate) fn lease(&self, content: &Arc<str>) -> Option<StringLease> {
|
pub(crate) fn lease(&self, content: &Arc<str>) -> Option<StringLease> {
|
||||||
self.retains(content)
|
self.retains(content)
|
||||||
.then(|| StringLease { content: content.clone(), domain: self.clone() })
|
.then(|| StringLease { content: content.clone(), domain: self.clone() })
|
||||||
@@ -239,23 +250,24 @@ impl Domain {
|
|||||||
}
|
}
|
||||||
Err(failure) => return Err(failure),
|
Err(failure) => return Err(failure),
|
||||||
};
|
};
|
||||||
if let Err(failure) = self.entries.reserve(1) {
|
if let Err(failure) = self.entries.prepare(&self.budget) {
|
||||||
if failure.reason != ResourceReason::Limit {
|
if failure.reason != ResourceReason::Limit {
|
||||||
return Err(failure);
|
return Err(failure);
|
||||||
}
|
}
|
||||||
self.reconcile();
|
self.reconcile();
|
||||||
self.entries.reserve(1)?;
|
self.entries.prepare(&self.budget)?;
|
||||||
}
|
}
|
||||||
Ok(charges)
|
Ok(charges)
|
||||||
}
|
}
|
||||||
fn publish(&mut self, content: &Arc<str>, charges: Charges) {
|
fn publish(&mut self, content: &Arc<str>, charges: Charges) {
|
||||||
self.entries
|
self.entries.insert(
|
||||||
.push(Entry {
|
Identity::of(content),
|
||||||
|
Entry {
|
||||||
content: Arc::downgrade(content),
|
content: Arc::downgrade(content),
|
||||||
_bytes: charges.bytes,
|
_bytes: charges.bytes,
|
||||||
_allocation: charges.allocation,
|
_allocation: charges.allocation,
|
||||||
})
|
},
|
||||||
.expect("prepare reserved one ledger record before materialization");
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -259,3 +259,95 @@ fn formatting_refuses_result_and_temporary_limits_with_no_content_publication()
|
|||||||
assert_eq!(budget.used(Q::StringAllocations), 0);
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
||||||
assert_eq!(ledger.tracked_allocations(), 0);
|
assert_eq!(ledger.tracked_allocations(), 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn index_growth_refuses_auxiliary_temporary_and_allocator_before_materialization() {
|
||||||
|
for failure in [0, 1, 2] {
|
||||||
|
let (budget, ledger) = fixture(&[]);
|
||||||
|
let kept = (0..4).map(|_| ledger.import("kept").unwrap()).collect::<Vec<_>>();
|
||||||
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
||||||
|
match failure {
|
||||||
|
0 => budget.test_lower_limit(Q::AuxiliaryBytes, auxiliary),
|
||||||
|
1 => budget.test_lower_limit(Q::TemporaryBytes, 0),
|
||||||
|
_ => crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true)),
|
||||||
|
}
|
||||||
|
let mut called = false;
|
||||||
|
let result = ledger.build(4, &mut |w| {
|
||||||
|
called = true;
|
||||||
|
w.write_str("next")
|
||||||
|
});
|
||||||
|
let Err(MaterializeError::Resource(error)) = result else {
|
||||||
|
panic!("expected prepublication refusal")
|
||||||
|
};
|
||||||
|
assert!(!called);
|
||||||
|
assert_eq!(
|
||||||
|
error.resource,
|
||||||
|
if failure == 1 { Q::TemporaryBytes } else { Q::AuxiliaryBytes }
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
error.reason,
|
||||||
|
if failure == 2 { ResourceReason::AllocationFailed } else { ResourceReason::Limit }
|
||||||
|
);
|
||||||
|
assert_eq!(ledger.tracked_allocations(), 4);
|
||||||
|
assert_eq!(budget.used(Q::StringBytes), 16);
|
||||||
|
assert_eq!(budget.used(Q::StringAllocations), 4);
|
||||||
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
||||||
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
||||||
|
for value in &kept {
|
||||||
|
assert!(ledger.retains(value));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn index_initial_allocation_failure_and_rebuild_failure_refund_reservations() {
|
||||||
|
let (budget, ledger) = fixture(&[]);
|
||||||
|
let initial = budget.used(Q::AuxiliaryBytes);
|
||||||
|
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
|
||||||
|
assert_eq!(ledger.import("x").unwrap_err().reason, ResourceReason::AllocationFailed);
|
||||||
|
assert_eq!(ledger.tracked_allocations(), 0);
|
||||||
|
assert_eq!(budget.used(Q::AuxiliaryBytes), initial);
|
||||||
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
||||||
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
||||||
|
let mut kept = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
|
||||||
|
let old = Arc::downgrade(&kept.pop().unwrap());
|
||||||
|
assert_eq!(ledger.reconcile(), 1);
|
||||||
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
||||||
|
budget.test_lower_limit(Q::TemporaryBytes, 0);
|
||||||
|
assert_eq!(ledger.import("new").unwrap_err().resource, Q::TemporaryBytes);
|
||||||
|
assert_eq!(ledger.tracked_allocations(), 3);
|
||||||
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
||||||
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
||||||
|
assert_eq!(budget.used(Q::StringBytes), 12);
|
||||||
|
for value in &kept {
|
||||||
|
assert_eq!(Arc::strong_count(value), 1);
|
||||||
|
assert!(ledger.retains(value));
|
||||||
|
}
|
||||||
|
assert!(old.upgrade().is_none());
|
||||||
|
// Rebuild under a restored test budget; no production ceiling changes.
|
||||||
|
budget.test_lower_limit(Q::TemporaryBytes, 64 * 1024 * 1024);
|
||||||
|
let newer = ledger.import("same").unwrap();
|
||||||
|
assert!(ledger.retains(&newer));
|
||||||
|
assert!(!ledger.retains(&Arc::from("same")));
|
||||||
|
assert!(ledger.lookup_work(&newer).0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn tombstone_rebuild_allocator_refusal_preserves_live_keys_and_charges() {
|
||||||
|
let (budget, ledger) = fixture(&[]);
|
||||||
|
let mut owners = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
|
||||||
|
owners.pop();
|
||||||
|
assert_eq!(ledger.reconcile(), 1);
|
||||||
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
||||||
|
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
|
||||||
|
assert_eq!(ledger.import("new").unwrap_err().reason, ResourceReason::AllocationFailed);
|
||||||
|
assert_eq!(ledger.tracked_allocations(), 3);
|
||||||
|
assert_eq!(budget.used(Q::StringBytes), 12);
|
||||||
|
assert_eq!(budget.used(Q::StringAllocations), 3);
|
||||||
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
||||||
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
||||||
|
assert!(owners.iter().all(|v| ledger.retains(v)));
|
||||||
|
let new = ledger.import("new").unwrap();
|
||||||
|
assert!(ledger.retains(&new));
|
||||||
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
||||||
|
}
|
||||||
|
|||||||
@@ -221,6 +221,24 @@ pub(crate) fn unpack_dynamic(
|
|||||||
|
|
||||||
// All reference operations validate complete source values before querying the
|
// All reference operations validate complete source values before querying the
|
||||||
// underlying concrete object. Invalid handles/pairs never become false or null.
|
// underlying concrete object. Invalid handles/pairs never become false or null.
|
||||||
|
pub(crate) fn identity_reference(
|
||||||
|
registry: &Registry,
|
||||||
|
heap: &Heap,
|
||||||
|
source: TypeId,
|
||||||
|
values: &[Value],
|
||||||
|
) -> Result<Option<HeapRef>, ValueError> {
|
||||||
|
let kind = registry.declarations().types.get(source.0 as usize).ok_or(ValueError::Type)?;
|
||||||
|
if !kind.kind.is_identity_reference() {
|
||||||
|
return Err(ValueError::Type);
|
||||||
|
}
|
||||||
|
validate(registry, heap, source, values)?;
|
||||||
|
match values.first() {
|
||||||
|
Some(Value::Null) => Ok(None),
|
||||||
|
Some(Value::HeapRef(reference)) => Ok(Some(*reference)),
|
||||||
|
_ => Err(ValueError::Type),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn reference(
|
fn reference(
|
||||||
registry: &Registry,
|
registry: &Registry,
|
||||||
heap: &Heap,
|
heap: &Heap,
|
||||||
|
|||||||
@@ -1,12 +1,20 @@
|
|||||||
use crate::numeric;
|
use crate::numeric;
|
||||||
use crate::resource_budget::BudgetVec;
|
use crate::resource_budget::BudgetVec;
|
||||||
|
mod array_copy;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod array_copy_tests;
|
||||||
mod callable;
|
mod callable;
|
||||||
|
#[cfg(test)]
|
||||||
|
#[path = "../tests/support/collections.rs"]
|
||||||
|
mod collection_test_support;
|
||||||
mod collections;
|
mod collections;
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod collections_tests;
|
mod collections_tests;
|
||||||
mod control;
|
mod control;
|
||||||
mod dynamic;
|
mod dynamic;
|
||||||
mod gc;
|
mod gc;
|
||||||
|
mod identity;
|
||||||
|
mod intrinsic;
|
||||||
mod lifecycle;
|
mod lifecycle;
|
||||||
mod loader;
|
mod loader;
|
||||||
mod native_arrays;
|
mod native_arrays;
|
||||||
@@ -327,8 +335,10 @@ impl VirtualMachine {
|
|||||||
}
|
}
|
||||||
|
|
||||||
let charged_math = if opcode == OpCode::Intrinsic {
|
let charged_math = if opcode == OpCode::Intrinsic {
|
||||||
lookup_intrinsic_by_id(instr.imm_u32().unwrap())
|
lookup_intrinsic_by_id(instr.imm_u32().unwrap()).filter(|m| {
|
||||||
.filter(|m| m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
|
matches!(m.implementation, crate::IntrinsicImplementation::Host(_))
|
||||||
|
&& (m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
|
||||||
|
})
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
};
|
};
|
||||||
@@ -952,6 +962,12 @@ impl VirtualMachine {
|
|||||||
)
|
)
|
||||||
})?;
|
})?;
|
||||||
|
|
||||||
|
if matches!(
|
||||||
|
intrinsic.implementation,
|
||||||
|
crate::IntrinsicImplementation::BorrowedInline(_)
|
||||||
|
) {
|
||||||
|
return self.execute_inline_intrinsic(intrinsic, pc_at_intrinsic);
|
||||||
|
}
|
||||||
if matches!(intrinsic.implementation, crate::IntrinsicImplementation::VmOwned) {
|
if matches!(intrinsic.implementation, crate::IntrinsicImplementation::VmOwned) {
|
||||||
return self.execute_random(intrinsic, pc_at_intrinsic);
|
return self.execute_random(intrinsic, pc_at_intrinsic);
|
||||||
}
|
}
|
||||||
@@ -1083,6 +1099,18 @@ impl VirtualMachine {
|
|||||||
let (source, target) = instr.imm_u32x2().unwrap();
|
let (source, target) = instr.imm_u32x2().unwrap();
|
||||||
return self.execute_reference(opcode, source, target, start_pc as u32);
|
return self.execute_reference(opcode, source, target, start_pc as u32);
|
||||||
}
|
}
|
||||||
|
OpCode::RefIdentityHash | OpCode::RefIdentityEq => {
|
||||||
|
let (left, right) = if opcode == OpCode::RefIdentityHash {
|
||||||
|
(instr.imm_u32().unwrap(), None)
|
||||||
|
} else {
|
||||||
|
let (left, right) = instr.imm_u32x2().unwrap();
|
||||||
|
(left, Some(right))
|
||||||
|
};
|
||||||
|
return self.execute_identity(opcode, left, right, start_pc as u32);
|
||||||
|
}
|
||||||
|
OpCode::ArrayCopy => {
|
||||||
|
return self.execute_array_copy(instr.imm_u32().unwrap(), start_pc as u32);
|
||||||
|
}
|
||||||
OpCode::StructNew
|
OpCode::StructNew
|
||||||
| OpCode::StructGet
|
| OpCode::StructGet
|
||||||
| OpCode::StructSet
|
| OpCode::StructSet
|
||||||
@@ -2485,7 +2513,7 @@ mod tests {
|
|||||||
let mut vm = VirtualMachine::default();
|
let mut vm = VirtualMachine::default();
|
||||||
let mut header = vec![0u8; 32];
|
let mut header = vec![0u8; 32];
|
||||||
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
||||||
header[4..6].copy_from_slice(&0u16.to_le_bytes()); // retired version
|
header[4..6].copy_from_slice(&1u16.to_le_bytes()); // unsupported version
|
||||||
|
|
||||||
let res = vm.initialize(header);
|
let res = vm.initialize(header);
|
||||||
assert!(
|
assert!(
|
||||||
@@ -2494,11 +2522,11 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_loader_hardening_malformed_pbx_v1() {
|
fn test_loader_hardening_malformed_pbx_v0() {
|
||||||
let mut vm = VirtualMachine::default();
|
let mut vm = VirtualMachine::default();
|
||||||
let mut header = vec![0u8; 32];
|
let mut header = vec![0u8; 32];
|
||||||
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
||||||
header[4..6].copy_from_slice(&1u16.to_le_bytes());
|
header[4..6].copy_from_slice(&0u16.to_le_bytes());
|
||||||
header[8..12].copy_from_slice(&1u32.to_le_bytes()); // missing directory
|
header[8..12].copy_from_slice(&1u32.to_le_bytes()); // missing directory
|
||||||
|
|
||||||
let res = vm.initialize(header);
|
let res = vm.initialize(header);
|
||||||
@@ -3890,3 +3918,10 @@ mod tests {
|
|||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
#[path = "virtual_machine/callable_tests.rs"]
|
#[path = "virtual_machine/callable_tests.rs"]
|
||||||
mod callable_tests;
|
mod callable_tests;
|
||||||
|
|
||||||
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
|
pub mod string_provenance_qualification;
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
#[path = "virtual_machine/identity_tests.rs"]
|
||||||
|
mod identity_tests;
|
||||||
|
|||||||
@@ -0,0 +1,110 @@
|
|||||||
|
//! Complete-group snapshot copy: charge, validate, prepare, then commit.
|
||||||
|
use super::*;
|
||||||
|
use crate::value_contract::{ValueError, ValueGroup};
|
||||||
|
use prometeu_bytecode::registry::TypeId;
|
||||||
|
|
||||||
|
fn planned_cost(count: u32, width: u64) -> Option<u64> {
|
||||||
|
u64::from(count).checked_mul(2)?.checked_mul(width)?.checked_add(4)
|
||||||
|
}
|
||||||
|
|
||||||
|
impl VirtualMachine {
|
||||||
|
pub(super) fn execute_array_copy(
|
||||||
|
&mut self,
|
||||||
|
array_id: u32,
|
||||||
|
pc: u32,
|
||||||
|
) -> Result<(), LogicalFrameEndingReason> {
|
||||||
|
let opcode = OpCode::ArrayCopy;
|
||||||
|
self.cycles += opcode.cycles();
|
||||||
|
let image = self.validated_image.clone().expect("validated Array TypeId");
|
||||||
|
let registry = image.registry();
|
||||||
|
let array_ty = TypeId(array_id);
|
||||||
|
let element = registry.type_layout(array_ty).unwrap().array.unwrap().element_type_id;
|
||||||
|
let width = registry.type_layout(element).unwrap().storage.slots;
|
||||||
|
if self.temporary_slots() < 5 {
|
||||||
|
return Err(self.trap(
|
||||||
|
TRAP_STACK_UNDERFLOW,
|
||||||
|
opcode as u16,
|
||||||
|
"Incomplete array copy operands".into(),
|
||||||
|
pc,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let base = self.operand_stack.len() - 5;
|
||||||
|
// Inspect count only to select cost, without changing ordinary fault order.
|
||||||
|
if let Value::Int64(n) = self.operand_stack[base + 4]
|
||||||
|
&& let Ok(n) = u32::try_from(n)
|
||||||
|
{
|
||||||
|
let cost = planned_cost(n, u64::from(width))
|
||||||
|
.ok_or_else(|| self.collection_size_trap(opcode, pc, u64::MAX))?;
|
||||||
|
self.cycles += cost - opcode.cycles();
|
||||||
|
}
|
||||||
|
let receiver = |offset: usize| {
|
||||||
|
let r = match self.operand_stack[base + offset] {
|
||||||
|
Value::HeapRef(r) => r,
|
||||||
|
Value::Null => return Err(self.value_trap(ValueError::NullReference, opcode, pc)),
|
||||||
|
_ => return Err(self.value_trap(ValueError::Type, opcode, pc)),
|
||||||
|
};
|
||||||
|
if self.heap.concrete_type(r, registry).map_err(|e| self.value_trap(e, opcode, pc))?
|
||||||
|
!= array_ty
|
||||||
|
{
|
||||||
|
return Err(self.value_trap(ValueError::Type, opcode, pc));
|
||||||
|
}
|
||||||
|
Ok(r)
|
||||||
|
};
|
||||||
|
let source = receiver(0)?;
|
||||||
|
let target = receiver(2)?;
|
||||||
|
let integer = |offset: usize| match self.operand_stack[base + offset] {
|
||||||
|
Value::Int64(n) => Ok(n),
|
||||||
|
_ => Err(self.value_trap(ValueError::Type, opcode, pc)),
|
||||||
|
};
|
||||||
|
let source_start = integer(1)?;
|
||||||
|
let target_start = integer(3)?;
|
||||||
|
let count = integer(4)?;
|
||||||
|
let range = |r, start: i64| {
|
||||||
|
let len = self
|
||||||
|
.heap
|
||||||
|
.typed_array_len(r, registry)
|
||||||
|
.map_err(|e| self.value_trap(e, opcode, pc))?;
|
||||||
|
if start < 0 || count < 0 || start > len as i64 || count > len as i64 - start {
|
||||||
|
return Err(self.value_trap(ValueError::Bounds, opcode, pc));
|
||||||
|
}
|
||||||
|
Ok(start as usize)
|
||||||
|
};
|
||||||
|
let source_start = range(source, source_start)?;
|
||||||
|
let target_start = range(target, target_start)?;
|
||||||
|
let count = count as usize;
|
||||||
|
// Operands remain roots; every fallible operation precedes shared writes.
|
||||||
|
let mut prepared =
|
||||||
|
BudgetVec::<ValueGroup>::new(&self.budget, RuntimeResource::TemporaryBytes);
|
||||||
|
prepared.reserve(count).map_err(|e| self.resource_trap(e, opcode, pc))?;
|
||||||
|
for i in 0..count {
|
||||||
|
let group = self
|
||||||
|
.heap
|
||||||
|
.load_typed(registry, source, source_start + i)
|
||||||
|
.map_err(|e| self.value_trap(e, opcode, pc))?;
|
||||||
|
prepared.push(group).expect("complete scratch reservation");
|
||||||
|
}
|
||||||
|
// Snapshot captured. No allocation, validation, GC, callback or scheduler.
|
||||||
|
for (i, group) in prepared.iter().enumerate() {
|
||||||
|
self.heap.commit_typed(target, target_start + i, group.as_slice());
|
||||||
|
}
|
||||||
|
self.operand_stack.truncate(base);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::planned_cost;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn checked_cost_covers_the_full_sum_without_wrap_or_saturation() {
|
||||||
|
assert_eq!(planned_cost(10, 1), Some(24));
|
||||||
|
assert_eq!(planned_cost(10, 3), Some(64));
|
||||||
|
assert_eq!(planned_cost(0, u64::MAX), Some(4));
|
||||||
|
assert_eq!(planned_cost(u32::MAX, 3), Some(25_769_803_774));
|
||||||
|
// Synthetic widths exercise defensive overflow, not valid guest layouts.
|
||||||
|
assert_eq!(planned_cost(1, u64::MAX), None);
|
||||||
|
assert_eq!(planned_cost(1, u64::MAX / 2), None);
|
||||||
|
assert_eq!(planned_cost(u32::MAX, u64::MAX), None);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,487 @@
|
|||||||
|
use super::collection_test_support as support;
|
||||||
|
use super::*;
|
||||||
|
use crate::ValidatedProgramImage;
|
||||||
|
use prometeu_bytecode::{assemble, registry::TypeId};
|
||||||
|
use support::Native;
|
||||||
|
|
||||||
|
fn machine(instruction: &str, count: usize) -> VirtualMachine {
|
||||||
|
let mut text = String::new();
|
||||||
|
for i in 0..count {
|
||||||
|
text += &format!("GET_GLOBAL {i}\n");
|
||||||
|
}
|
||||||
|
text += instruction;
|
||||||
|
text += "\nHALT";
|
||||||
|
let mut vm = VirtualMachine::from_image(
|
||||||
|
support::load(&assemble(&text).unwrap()).unwrap(),
|
||||||
|
RuntimeLimits::default(),
|
||||||
|
);
|
||||||
|
vm.prepare_boot_call().unwrap();
|
||||||
|
vm
|
||||||
|
}
|
||||||
|
fn operands(vm: &mut VirtualMachine, values: &[Value]) {
|
||||||
|
vm.globals.extend_from_slice(values).unwrap();
|
||||||
|
for _ in values {
|
||||||
|
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn step(vm: &mut VirtualMachine) -> Result<(), LogicalFrameEndingReason> {
|
||||||
|
vm.step(&mut Native, &mut HostContext::new(None))
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn raw_copy_preserves_absence_and_box_identity_without_heap_allocations() {
|
||||||
|
let mut vm = machine("ARRAY_COPY 15", 5);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let a = vm.heap.allocate_typed_array(registry.clone(), TypeId(15), 4).unwrap();
|
||||||
|
let boxed = vm
|
||||||
|
.heap
|
||||||
|
.allocate_dynamic_box(registry.clone(), TypeId(5), &[Value::Float(1.), Value::Float(2.)])
|
||||||
|
.unwrap();
|
||||||
|
let present = [Value::Int64(5), Value::HeapRef(boxed)];
|
||||||
|
vm.heap.store_typed(®istry, a, 0, &present).unwrap();
|
||||||
|
operands(
|
||||||
|
&mut vm,
|
||||||
|
&[Value::HeapRef(a), Value::Int64(0), Value::HeapRef(a), Value::Int64(1), Value::Int64(3)],
|
||||||
|
);
|
||||||
|
let before = vm.heap.allocation_count();
|
||||||
|
vm.budget
|
||||||
|
.test_lower_limit(RuntimeResource::GuestBytes, vm.budget.used(RuntimeResource::GuestBytes));
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
assert_eq!(vm.heap.allocation_count(), before);
|
||||||
|
assert_eq!(vm.heap.load_typed(®istry, a, 1).unwrap().as_slice(), present);
|
||||||
|
for i in [2, 3] {
|
||||||
|
assert_eq!(
|
||||||
|
vm.heap.load_typed(®istry, a, i).unwrap().as_slice(),
|
||||||
|
[Value::Null, Value::Null]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn pair(ty: u32, len: u32) -> (VirtualMachine, HeapRef, HeapRef) {
|
||||||
|
let mut vm = machine(&format!("ARRAY_COPY {ty}"), 5);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let source = vm.heap.allocate_typed_array(registry.clone(), TypeId(ty), len).unwrap();
|
||||||
|
let target = vm.heap.allocate_typed_array(registry, TypeId(ty), len).unwrap();
|
||||||
|
(vm, source, target)
|
||||||
|
}
|
||||||
|
fn copy_inputs(source: HeapRef, target: HeapRef, count: i64) -> [Value; 5] {
|
||||||
|
[
|
||||||
|
Value::HeapRef(source),
|
||||||
|
Value::Int64(0),
|
||||||
|
Value::HeapRef(target),
|
||||||
|
Value::Int64(0),
|
||||||
|
Value::Int64(count),
|
||||||
|
]
|
||||||
|
}
|
||||||
|
fn refused(vm: &mut VirtualMachine, code: u32, cost: u64) {
|
||||||
|
let inputs = vm.operand_stack.as_slice().to_vec();
|
||||||
|
let (pc, cycles, temporary, objects) =
|
||||||
|
(vm.pc, vm.cycles, vm.budget.used(RuntimeResource::TemporaryBytes), vm.heap.len());
|
||||||
|
let LogicalFrameEndingReason::Trap(info) = step(vm).unwrap_err() else { panic!() };
|
||||||
|
assert_eq!((info.code, info.opcode, info.pc), (code, 0xa9, pc as u32));
|
||||||
|
assert_eq!(vm.cycles - cycles, cost);
|
||||||
|
assert_eq!(vm.operand_stack.as_slice(), inputs);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), temporary);
|
||||||
|
assert_eq!(vm.heap.len(), objects);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn calculable_work_is_precharged_on_receivers_carriers_and_ranges_in_fault_order() {
|
||||||
|
for case in 0..20 {
|
||||||
|
let (mut vm, source, target) = pair(11, 10);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let wrong = vm.heap.allocate_typed_struct(registry.clone(), TypeId(19)).unwrap();
|
||||||
|
let foreign = support::load(&assemble("HALT").unwrap()).unwrap();
|
||||||
|
let foreign_ref =
|
||||||
|
vm.heap.allocate_typed_array(foreign.registry().clone(), TypeId(11), 10).unwrap();
|
||||||
|
let stale = HeapRef { index: source.index, generation: source.generation + 1 };
|
||||||
|
let mut inputs = copy_inputs(source, target, 10);
|
||||||
|
let (offset, value, code) = match case {
|
||||||
|
0 => (0, Value::Null, TRAP_NULL_REFERENCE),
|
||||||
|
1 => (2, Value::Null, TRAP_NULL_REFERENCE),
|
||||||
|
2 => (0, Value::HeapRef(stale), TRAP_INVALID_HANDLE),
|
||||||
|
3 => (2, Value::HeapRef(stale), TRAP_INVALID_HANDLE),
|
||||||
|
4 => (0, Value::HeapRef(wrong), TRAP_TYPE),
|
||||||
|
5 => (2, Value::HeapRef(wrong), TRAP_TYPE),
|
||||||
|
6 => (0, Value::HeapRef(foreign_ref), TRAP_TYPE),
|
||||||
|
7 => (2, Value::Int32(0), TRAP_TYPE),
|
||||||
|
8 => (1, Value::Int32(0), TRAP_TYPE),
|
||||||
|
9 => (3, Value::Null, TRAP_TYPE),
|
||||||
|
10 => (1, Value::Int64(-1), TRAP_OOB),
|
||||||
|
11 => (3, Value::Int64(-1), TRAP_OOB),
|
||||||
|
12 => (1, Value::Int64(1), TRAP_OOB),
|
||||||
|
13 => (3, Value::Int64(1), TRAP_OOB),
|
||||||
|
14 => {
|
||||||
|
inputs[1] = Value::Int32(0); // Receiver fault precedes offset carrier.
|
||||||
|
(2, Value::Null, TRAP_NULL_REFERENCE)
|
||||||
|
}
|
||||||
|
15 => {
|
||||||
|
inputs[1] = Value::Int64(-1); // All carriers precede source range.
|
||||||
|
(3, Value::Int32(0), TRAP_TYPE)
|
||||||
|
}
|
||||||
|
16 => (0, Value::Int32(0), TRAP_TYPE),
|
||||||
|
17 => {
|
||||||
|
let wrong_array =
|
||||||
|
vm.heap.allocate_typed_array(registry.clone(), TypeId(22), 10).unwrap();
|
||||||
|
(2, Value::HeapRef(wrong_array), TRAP_TYPE)
|
||||||
|
}
|
||||||
|
18 => (1, Value::Int64(i64::MAX), TRAP_OOB),
|
||||||
|
_ => (3, Value::Int64(i64::MAX), TRAP_OOB),
|
||||||
|
};
|
||||||
|
inputs[offset] = value;
|
||||||
|
operands(&mut vm, &inputs);
|
||||||
|
// Quota refusal must not mask earlier faults, even with full cost selected.
|
||||||
|
vm.budget.test_lower_limit(
|
||||||
|
RuntimeResource::TemporaryBytes,
|
||||||
|
vm.budget.used(RuntimeResource::TemporaryBytes),
|
||||||
|
);
|
||||||
|
refused(&mut vm, code, 24);
|
||||||
|
for i in 0..10 {
|
||||||
|
assert_eq!(
|
||||||
|
vm.heap.load_typed(®istry, target, i).unwrap().as_slice(),
|
||||||
|
[Value::Int32(0)]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn invalid_count_selects_only_base_without_reordering_ordinary_faults() {
|
||||||
|
for count in [
|
||||||
|
Value::Int32(10),
|
||||||
|
Value::Null,
|
||||||
|
Value::Int64(-1),
|
||||||
|
Value::Int64(u32::MAX as i64 + 1),
|
||||||
|
Value::Int64(i64::MAX),
|
||||||
|
] {
|
||||||
|
for bad_receiver in [false, true] {
|
||||||
|
let (mut vm, source, target) = pair(11, 10);
|
||||||
|
let mut inputs = copy_inputs(source, target, 0);
|
||||||
|
inputs[4] = count.clone();
|
||||||
|
if bad_receiver {
|
||||||
|
inputs[0] = Value::Null;
|
||||||
|
}
|
||||||
|
operands(&mut vm, &inputs);
|
||||||
|
let code = if bad_receiver {
|
||||||
|
TRAP_NULL_REFERENCE
|
||||||
|
} else if matches!(count, Value::Int64(_)) {
|
||||||
|
TRAP_OOB
|
||||||
|
} else {
|
||||||
|
TRAP_TYPE
|
||||||
|
};
|
||||||
|
refused(&mut vm, code, 4);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn incomplete_temporary_operands_never_read_frame_locals_for_cost() {
|
||||||
|
let code = assemble(
|
||||||
|
"GET_GLOBAL 0\nGET_GLOBAL 1\nGET_GLOBAL 2\nGET_GLOBAL 3\nGET_GLOBAL 4\nARRAY_COPY 11\nHALT",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
for available in 0..5 {
|
||||||
|
let mut declarations = support::declarations(code.len());
|
||||||
|
declarations.functions[0].local_slots = 5;
|
||||||
|
let image = ValidatedProgramImage::load(
|
||||||
|
&support::bytes_with(&code, declarations),
|
||||||
|
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||||
|
prometeu_hal::syscalls::caps::NONE,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
|
||||||
|
vm.prepare_boot_call().unwrap();
|
||||||
|
// Internal defense: skip the verified producers, leaving only locals and
|
||||||
|
// an incomplete temporary group. This is not an admitted bad program.
|
||||||
|
vm.operand_stack[4] = Value::Int64(10);
|
||||||
|
vm.operand_stack.extend_from_slice(&vec![Value::Int64(10); available]).unwrap();
|
||||||
|
vm.pc = 30;
|
||||||
|
refused(&mut vm, TRAP_STACK_UNDERFLOW, 4);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn overlap_snapshots_complete_multislot_groups_and_has_no_identity_discount() {
|
||||||
|
for (source_start, target_start, count) in [(0, 1, 3), (1, 0, 3), (0, 0, 4)] {
|
||||||
|
for refuse in [false, true] {
|
||||||
|
let mut vm = machine("ARRAY_COPY 12", 5);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let array = vm.heap.allocate_typed_array(registry.clone(), TypeId(12), 4).unwrap();
|
||||||
|
for i in 0..4 {
|
||||||
|
vm.heap
|
||||||
|
.store_typed(
|
||||||
|
®istry,
|
||||||
|
array,
|
||||||
|
i,
|
||||||
|
&[Value::Float(i as f64), Value::Float(i as f64 + 10.)],
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
let before: Vec<_> = (0..4)
|
||||||
|
.map(|i| vm.heap.load_typed(®istry, array, i).unwrap().as_slice().to_vec())
|
||||||
|
.collect();
|
||||||
|
operands(
|
||||||
|
&mut vm,
|
||||||
|
&[
|
||||||
|
Value::HeapRef(array),
|
||||||
|
Value::Int64(source_start),
|
||||||
|
Value::HeapRef(array),
|
||||||
|
Value::Int64(target_start),
|
||||||
|
Value::Int64(count),
|
||||||
|
],
|
||||||
|
);
|
||||||
|
let temporary = vm.budget.used(RuntimeResource::TemporaryBytes);
|
||||||
|
if refuse {
|
||||||
|
vm.budget.test_lower_limit(RuntimeResource::TemporaryBytes, temporary);
|
||||||
|
refused(&mut vm, TRAP_RESOURCE_LIMIT, if count == 3 { 16 } else { 20 });
|
||||||
|
} else {
|
||||||
|
let cycles = vm.cycles;
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
assert_eq!(vm.cycles - cycles, if count == 3 { 16 } else { 20 });
|
||||||
|
assert!(vm.operand_stack.is_empty());
|
||||||
|
}
|
||||||
|
for i in 0..4 {
|
||||||
|
let expected =
|
||||||
|
if !refuse && i >= target_start as usize && i < (target_start + count) as usize
|
||||||
|
{
|
||||||
|
&before[(i as i64 - target_start + source_start) as usize]
|
||||||
|
} else {
|
||||||
|
&before[i]
|
||||||
|
};
|
||||||
|
assert_eq!(vm.heap.load_typed(®istry, array, i).unwrap().as_slice(), expected);
|
||||||
|
}
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), temporary);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn scratch_quota_and_allocator_refusals_preserve_all_destinations_and_work() {
|
||||||
|
for allocation_failure in [false, true] {
|
||||||
|
let (mut vm, source, target) = pair(11, 10);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
for i in 0..10 {
|
||||||
|
vm.heap.store_typed(®istry, source, i, &[Value::Int32(i as i32 + 1)]).unwrap();
|
||||||
|
}
|
||||||
|
operands(&mut vm, ©_inputs(source, target, 10));
|
||||||
|
if allocation_failure {
|
||||||
|
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
|
||||||
|
} else {
|
||||||
|
vm.budget.test_lower_limit(
|
||||||
|
RuntimeResource::TemporaryBytes,
|
||||||
|
vm.budget.used(RuntimeResource::TemporaryBytes),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
let (cycles, temporary) = (vm.cycles, vm.budget.used(RuntimeResource::TemporaryBytes));
|
||||||
|
let LogicalFrameEndingReason::Trap(info) = step(&mut vm).unwrap_err() else { panic!() };
|
||||||
|
assert_eq!((info.code, info.opcode, info.pc), (TRAP_RESOURCE_LIMIT, 0xa9, 30));
|
||||||
|
let resource = info.resource.unwrap();
|
||||||
|
assert_eq!(resource.resource, RuntimeResource::TemporaryBytes);
|
||||||
|
assert_eq!(
|
||||||
|
resource.reason,
|
||||||
|
if allocation_failure {
|
||||||
|
crate::resource_budget::ResourceReason::AllocationFailed
|
||||||
|
} else {
|
||||||
|
crate::resource_budget::ResourceReason::Limit
|
||||||
|
}
|
||||||
|
);
|
||||||
|
assert_eq!(vm.cycles - cycles, 24);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), temporary);
|
||||||
|
assert_eq!(vm.operand_stack.as_slice(), copy_inputs(source, target, 10));
|
||||||
|
for i in 0..10 {
|
||||||
|
assert_eq!(
|
||||||
|
vm.heap.load_typed(®istry, target, i).unwrap().as_slice(),
|
||||||
|
[Value::Int32(0)]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn late_invalid_source_group_releases_partial_preparation_without_any_write() {
|
||||||
|
let (mut vm, source, target) = pair(17, 10);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let node = vm.heap.allocate_typed_struct(registry.clone(), TypeId(9)).unwrap();
|
||||||
|
vm.heap.store_typed(®istry, source, 0, &[Value::HeapRef(node)]).unwrap();
|
||||||
|
// Internal corruption of the last stored handle exercises a late read fault.
|
||||||
|
vm.heap.commit_typed(
|
||||||
|
source,
|
||||||
|
9,
|
||||||
|
&[Value::HeapRef(HeapRef { index: node.index, generation: node.generation + 1 })],
|
||||||
|
);
|
||||||
|
operands(&mut vm, ©_inputs(source, target, 10));
|
||||||
|
refused(&mut vm, TRAP_INVALID_HANDLE, 24);
|
||||||
|
for i in 0..10 {
|
||||||
|
assert_eq!(vm.heap.load_typed(®istry, target, i).unwrap().as_slice(), [Value::Null]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn empty_copy_validates_both_receivers_and_strict_ranges_without_scratch() {
|
||||||
|
for case in 0..5 {
|
||||||
|
let (mut vm, source, target) = pair(11, 2);
|
||||||
|
let mut inputs = copy_inputs(source, target, 0);
|
||||||
|
inputs[1] = Value::Int64(2);
|
||||||
|
inputs[3] = Value::Int64(2);
|
||||||
|
let code = match case {
|
||||||
|
0 => None,
|
||||||
|
1 => {
|
||||||
|
inputs[0] = Value::Null;
|
||||||
|
Some(TRAP_NULL_REFERENCE)
|
||||||
|
}
|
||||||
|
2 => {
|
||||||
|
inputs[2] = Value::Null;
|
||||||
|
Some(TRAP_NULL_REFERENCE)
|
||||||
|
}
|
||||||
|
3 => {
|
||||||
|
inputs[1] = Value::Int64(3);
|
||||||
|
Some(TRAP_OOB)
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
inputs[3] = Value::Int64(-1);
|
||||||
|
Some(TRAP_OOB)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
operands(&mut vm, &inputs);
|
||||||
|
vm.budget.test_lower_limit(
|
||||||
|
RuntimeResource::TemporaryBytes,
|
||||||
|
vm.budget.used(RuntimeResource::TemporaryBytes),
|
||||||
|
);
|
||||||
|
if let Some(code) = code {
|
||||||
|
refused(&mut vm, code, 4);
|
||||||
|
} else {
|
||||||
|
let cycles = vm.cycles;
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
assert_eq!(vm.cycles - cycles, 4);
|
||||||
|
assert!(vm.operand_stack.is_empty());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn zero_budget_and_positive_overshoot_preserve_trap_priority_and_step_count() {
|
||||||
|
for fail in [false, true] {
|
||||||
|
let (mut vm, source, target) = pair(11, 10);
|
||||||
|
operands(&mut vm, ©_inputs(source, target, 10));
|
||||||
|
if fail {
|
||||||
|
vm.budget.test_lower_limit(
|
||||||
|
RuntimeResource::TemporaryBytes,
|
||||||
|
vm.budget.used(RuntimeResource::TemporaryBytes),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
let (pc, cycles, inputs) = (vm.pc, vm.cycles, vm.operand_stack.as_slice().to_vec());
|
||||||
|
let report = vm.run_budget(0, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!((report.cycles_used, report.steps_executed), (0, 0));
|
||||||
|
assert_eq!((vm.pc, vm.cycles), (pc, cycles));
|
||||||
|
assert_eq!(vm.operand_stack.as_slice(), inputs);
|
||||||
|
let report = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!((report.cycles_used, report.steps_executed), (24, if fail { 0 } else { 1 }));
|
||||||
|
if fail {
|
||||||
|
let LogicalFrameEndingReason::Trap(info) = report.reason else { panic!() };
|
||||||
|
assert_eq!((info.code, info.opcode, info.pc), (TRAP_RESOURCE_LIMIT, 0xa9, pc as u32));
|
||||||
|
assert_eq!(vm.operand_stack.as_slice(), inputs);
|
||||||
|
} else {
|
||||||
|
assert_eq!(report.reason, LogicalFrameEndingReason::BudgetExhausted);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn copied_groups_preserve_owners_and_references_through_collection_without_guest_growth() {
|
||||||
|
for ty in [11, 12, 13, 14, 15, 16, 17] {
|
||||||
|
let (mut vm, source, target) = pair(ty, 1);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let node = vm.heap.allocate_typed_struct(registry.clone(), TypeId(9)).unwrap();
|
||||||
|
vm.push(Value::String(std::sync::Arc::from("copy owner"))).unwrap();
|
||||||
|
let string = vm.pop().unwrap();
|
||||||
|
let group = match ty {
|
||||||
|
11 => vec![Value::Int32(7)],
|
||||||
|
12 => vec![Value::Float(1.), Value::Float(2.)],
|
||||||
|
13 => vec![Value::Int64(1), Value::Int64(2), Value::Int64(3)],
|
||||||
|
14 => vec![string.clone()],
|
||||||
|
15 => vec![Value::Int64(4), string.clone()],
|
||||||
|
16 => vec![Value::HeapRef(node), Value::Int64(0)],
|
||||||
|
_ => vec![Value::HeapRef(node)],
|
||||||
|
};
|
||||||
|
vm.heap.store_typed(®istry, source, 0, &group).unwrap();
|
||||||
|
operands(&mut vm, ©_inputs(source, target, 1));
|
||||||
|
let objects = vm.heap.allocation_count();
|
||||||
|
let guest = vm.budget.used(RuntimeResource::GuestBytes);
|
||||||
|
for q in [
|
||||||
|
RuntimeResource::GuestBytes,
|
||||||
|
RuntimeResource::HandleSlots,
|
||||||
|
RuntimeResource::AuxiliaryBytes,
|
||||||
|
] {
|
||||||
|
vm.budget.test_lower_limit(q, vm.budget.used(q));
|
||||||
|
}
|
||||||
|
let cycles = vm.cycles;
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
vm.cycles - cycles,
|
||||||
|
match ty {
|
||||||
|
12 | 15 | 16 => 8,
|
||||||
|
13 => 10,
|
||||||
|
_ => 6,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
assert_eq!(vm.heap.allocation_count(), objects);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::GuestBytes), guest);
|
||||||
|
assert_eq!(vm.heap.load_typed(®istry, target, 0).unwrap().as_slice(), group);
|
||||||
|
drop(group);
|
||||||
|
drop(string);
|
||||||
|
vm.globals.clear();
|
||||||
|
vm.globals.push(Value::HeapRef(target)).unwrap();
|
||||||
|
vm.gc_alloc_threshold = 1;
|
||||||
|
vm.handle_safepoint().unwrap();
|
||||||
|
assert!(!vm.heap.is_valid(source));
|
||||||
|
assert!(vm.heap.is_valid(target));
|
||||||
|
if [16, 17].contains(&ty) {
|
||||||
|
assert!(vm.heap.is_valid(node));
|
||||||
|
}
|
||||||
|
if [14, 15].contains(&ty) {
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 1);
|
||||||
|
}
|
||||||
|
// Remove all roots and collect using the actual session root traversal.
|
||||||
|
vm.globals.clear();
|
||||||
|
vm.last_gc_live_count = 0;
|
||||||
|
vm.handle_safepoint().unwrap();
|
||||||
|
assert_eq!(vm.heap.len(), 0);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn refused_copy_keeps_source_and_previous_target_native_owners_rooted() {
|
||||||
|
let (mut vm, source, target) = pair(14, 1);
|
||||||
|
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
for (array, text) in [(source, "candidate owner"), (target, "previous owner")] {
|
||||||
|
vm.push(Value::String(std::sync::Arc::from(text))).unwrap();
|
||||||
|
let value = vm.pop().unwrap();
|
||||||
|
vm.heap.store_typed(®istry, array, 0, &[value]).unwrap();
|
||||||
|
}
|
||||||
|
operands(&mut vm, ©_inputs(source, target, 1));
|
||||||
|
let temporary = vm.budget.used(RuntimeResource::TemporaryBytes);
|
||||||
|
vm.budget.test_lower_limit(RuntimeResource::TemporaryBytes, temporary);
|
||||||
|
refused(&mut vm, TRAP_RESOURCE_LIMIT, 6);
|
||||||
|
assert_eq!(
|
||||||
|
vm.heap.load_typed(®istry, source, 0).unwrap().as_slice(),
|
||||||
|
[Value::String(std::sync::Arc::from("candidate owner"))]
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
vm.heap.load_typed(®istry, target, 0).unwrap().as_slice(),
|
||||||
|
[Value::String(std::sync::Arc::from("previous owner"))]
|
||||||
|
);
|
||||||
|
vm.budget.test_lower_limit(
|
||||||
|
RuntimeResource::TemporaryBytes,
|
||||||
|
RuntimeLimits::default().get(RuntimeResource::TemporaryBytes),
|
||||||
|
);
|
||||||
|
vm.globals.clear(); // Failed operands are now the only session roots.
|
||||||
|
vm.gc_alloc_threshold = 1;
|
||||||
|
vm.handle_safepoint().unwrap();
|
||||||
|
assert!(vm.heap.is_valid(source) && vm.heap.is_valid(target));
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 2);
|
||||||
|
vm.operand_stack.clear();
|
||||||
|
vm.last_gc_live_count = 0;
|
||||||
|
vm.handle_safepoint().unwrap();
|
||||||
|
assert_eq!(vm.heap.len(), 0);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 0);
|
||||||
|
}
|
||||||
@@ -331,3 +331,45 @@ fn recursive_fn_calls_use_bounded_ordinary_frames() {
|
|||||||
);
|
);
|
||||||
assert_eq!(v.call_stack.len(), 4);
|
assert_eq!(v.call_stack.len(), 4);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn root_return_scratch_refusal_keeps_transferred_roots_without_partial_sweep() {
|
||||||
|
let mut v = vm(&[
|
||||||
|
("MAKE_CLOSURE fn=1,type=4\nPOP\nMAKE_CLOSURE fn=1,type=4\nRET", sig(&[], &[4]), vec![]),
|
||||||
|
("PUSH_I32 55\nRET", sig(&[], &[0]), vec![]),
|
||||||
|
]);
|
||||||
|
v.gc_alloc_threshold = 1;
|
||||||
|
for _ in 0..3 {
|
||||||
|
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
}
|
||||||
|
let Value::HeapRef(owner) = *v.operand_stack.last().unwrap() else { panic!() };
|
||||||
|
let live = v.heap.len();
|
||||||
|
v.budget.test_lower_limit(RuntimeResource::TemporaryBytes, 0);
|
||||||
|
assert!(matches!(v.step(&mut Native, &mut HostContext::new(None)),
|
||||||
|
Err(LogicalFrameEndingReason::Trap(t)) if t.code == TRAP_RESOURCE_LIMIT));
|
||||||
|
assert!(v.call_stack.is_empty());
|
||||||
|
assert_eq!(v.operand_stack.as_slice(), &[Value::HeapRef(owner)]);
|
||||||
|
assert!(v.heap.is_valid(owner));
|
||||||
|
assert_eq!(v.heap.len(), live);
|
||||||
|
v.budget.test_lower_limit(RuntimeResource::TemporaryBytes, 1024 * 1024);
|
||||||
|
v.handle_safepoint().unwrap();
|
||||||
|
assert_eq!(v.heap.len(), 1);
|
||||||
|
assert!(v.heap.is_valid(owner));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn bad_return_height_preserves_frame_and_owners() {
|
||||||
|
let mut v = vm(&[
|
||||||
|
("MAKE_CLOSURE fn=1,type=4\nRET", sig(&[], &[4]), vec![]),
|
||||||
|
("PUSH_I32 55\nRET", sig(&[], &[0]), vec![]),
|
||||||
|
]);
|
||||||
|
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
v.operand_stack.push(Value::Int32(9)).unwrap();
|
||||||
|
let before = v.operand_stack.as_slice().to_vec();
|
||||||
|
assert!(matches!(v.step(&mut Native, &mut HostContext::new(None)),
|
||||||
|
Err(LogicalFrameEndingReason::Trap(t)) if t.code == prometeu_bytecode::TRAP_BAD_RET_SLOTS));
|
||||||
|
assert_eq!(v.call_stack.len(), 1);
|
||||||
|
assert_eq!(v.operand_stack.as_slice(), before);
|
||||||
|
let Value::HeapRef(owner) = before[before.len() - 2] else { panic!() };
|
||||||
|
assert!(v.heap.is_valid(owner));
|
||||||
|
}
|
||||||
|
|||||||
@@ -175,7 +175,7 @@ impl VirtualMachine {
|
|||||||
.expect("result capacity reserved before publication");
|
.expect("result capacity reserved before publication");
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
fn collection_size_trap(
|
pub(super) fn collection_size_trap(
|
||||||
&self,
|
&self,
|
||||||
opcode: OpCode,
|
opcode: OpCode,
|
||||||
pc: u32,
|
pc: u32,
|
||||||
|
|||||||
@@ -1,6 +1,5 @@
|
|||||||
|
use super::collection_test_support as support;
|
||||||
use super::*;
|
use super::*;
|
||||||
#[path = "../../tests/support/collections.rs"]
|
|
||||||
mod support;
|
|
||||||
use crate::value_contract::ValueError;
|
use crate::value_contract::ValueError;
|
||||||
use prometeu_bytecode::assemble;
|
use prometeu_bytecode::assemble;
|
||||||
use support::Native;
|
use support::Native;
|
||||||
|
|||||||
@@ -46,21 +46,13 @@ impl VirtualMachine {
|
|||||||
)
|
)
|
||||||
.map_err(|(_, error)| self.value_trap(error, opcode, pc))?;
|
.map_err(|(_, error)| self.value_trap(error, opcode, pc))?;
|
||||||
|
|
||||||
// Copy return values (preserving order: pop return_slots values, then reverse to push back)
|
// Validation is complete. Move the ordered result suffix ahead of this
|
||||||
let mut return_vals = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
|
// frame's parameters/locals without cloning owners or reserving scratch.
|
||||||
return_vals.reserve(return_slots).map_err(|e| self.resource_trap(e, opcode, pc))?;
|
if return_slots != 0 {
|
||||||
for _ in 0..return_slots {
|
self.operand_stack[frame.stack_base..].rotate_right(return_slots);
|
||||||
return_vals
|
|
||||||
.push(self.pop().map_err(LogicalFrameEndingReason::Panic)?)
|
|
||||||
.map_err(|e| self.resource_trap(e, opcode, pc))?;
|
|
||||||
}
|
}
|
||||||
return_vals.reverse();
|
self.operand_stack.truncate(frame.stack_base + return_slots);
|
||||||
|
|
||||||
self.call_stack.pop();
|
self.call_stack.pop();
|
||||||
self.operand_stack.truncate(frame.stack_base);
|
|
||||||
for val in return_vals.drain(..) {
|
|
||||||
self.push_trap(val, opcode, pc)?;
|
|
||||||
}
|
|
||||||
self.pc = frame.return_pc as usize;
|
self.pc = frame.return_pc as usize;
|
||||||
if self.call_stack.is_empty() {
|
if self.call_stack.is_empty() {
|
||||||
self.handle_safepoint().map_err(|e| self.resource_trap(e, opcode, pc))?;
|
self.handle_safepoint().map_err(|e| self.resource_trap(e, opcode, pc))?;
|
||||||
|
|||||||
@@ -0,0 +1,59 @@
|
|||||||
|
use super::*;
|
||||||
|
use crate::value_contract;
|
||||||
|
use prometeu_bytecode::registry::TypeId;
|
||||||
|
|
||||||
|
impl VirtualMachine {
|
||||||
|
pub(super) fn execute_identity(
|
||||||
|
&mut self,
|
||||||
|
opcode: OpCode,
|
||||||
|
left: u32,
|
||||||
|
right: Option<u32>,
|
||||||
|
pc: u32,
|
||||||
|
) -> Result<(), LogicalFrameEndingReason> {
|
||||||
|
let image = self.validated_image.clone().ok_or_else(|| {
|
||||||
|
self.trap(
|
||||||
|
prometeu_bytecode::TRAP_ILLEGAL_INSTRUCTION,
|
||||||
|
opcode as u16,
|
||||||
|
"Identity instruction requires a validated Registry".into(),
|
||||||
|
pc,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
let registry = image.registry();
|
||||||
|
let left = TypeId(left);
|
||||||
|
let right = right.map(TypeId);
|
||||||
|
let lw = registry.type_layout(left).unwrap().storage.slots as usize;
|
||||||
|
let rw = right.map_or(0, |ty| registry.type_layout(ty).unwrap().storage.slots as usize);
|
||||||
|
self.cycles += opcode.cycles() + (lw + rw) as u64;
|
||||||
|
if self.temporary_slots() < lw + rw {
|
||||||
|
return Err(self.trap(
|
||||||
|
TRAP_STACK_UNDERFLOW,
|
||||||
|
opcode as u16,
|
||||||
|
"Incomplete identity operands".into(),
|
||||||
|
pc,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let base = self.operand_stack.len() - lw - rw;
|
||||||
|
let first = value_contract::identity_reference(
|
||||||
|
registry,
|
||||||
|
&self.heap,
|
||||||
|
left,
|
||||||
|
&self.operand_stack[base..base + lw],
|
||||||
|
)
|
||||||
|
.map_err(|e| self.value_trap(e, opcode, pc))?;
|
||||||
|
let result = if let Some(ty) = right {
|
||||||
|
let second = value_contract::identity_reference(
|
||||||
|
registry,
|
||||||
|
&self.heap,
|
||||||
|
ty,
|
||||||
|
&self.operand_stack[base + lw..],
|
||||||
|
)
|
||||||
|
.map_err(|e| self.value_trap(e, opcode, pc))?;
|
||||||
|
Value::Boolean(first == second)
|
||||||
|
} else {
|
||||||
|
Value::Int64(crate::hashing::reference(first))
|
||||||
|
};
|
||||||
|
self.operand_stack.truncate(base);
|
||||||
|
self.operand_stack.push(result).expect("identity result replaces existing inputs");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,236 @@
|
|||||||
|
use super::*;
|
||||||
|
#[path = "../../tests/support/identity.rs"]
|
||||||
|
mod support;
|
||||||
|
use crate::{
|
||||||
|
IntrinsicExecutionError, IntrinsicImplementation, IntrinsicMeta, IntrinsicResults,
|
||||||
|
hash_intrinsics::HASH_INTRINSICS,
|
||||||
|
};
|
||||||
|
use prometeu_bytecode::{HeapRef, RuntimeResource as Q, registry::TypeId};
|
||||||
|
use std::sync::Arc;
|
||||||
|
use support::*;
|
||||||
|
|
||||||
|
fn empty() -> VirtualMachine {
|
||||||
|
vm(&[("RET", sig(&[], &[]))], &[])
|
||||||
|
}
|
||||||
|
fn push(v: &mut VirtualMachine, values: &[Value]) {
|
||||||
|
for value in values {
|
||||||
|
v.operand_stack.push(value.clone()).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn usage(v: &VirtualMachine) -> Vec<u64> {
|
||||||
|
[
|
||||||
|
Q::GuestBytes,
|
||||||
|
Q::HandleSlots,
|
||||||
|
Q::AuxiliaryBytes,
|
||||||
|
Q::TemporaryBytes,
|
||||||
|
Q::StringBytes,
|
||||||
|
Q::StringAllocations,
|
||||||
|
]
|
||||||
|
.map(|q| v.budget.used(q))
|
||||||
|
.to_vec()
|
||||||
|
}
|
||||||
|
fn fault(result: Result<(), LogicalFrameEndingReason>, expected: u32) {
|
||||||
|
assert!(
|
||||||
|
matches!(result,Err(LogicalFrameEndingReason::Trap(ref t)) if t.code==expected),
|
||||||
|
"{result:?}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
fn hash(v: &mut VirtualMachine, ty: u32, values: &[Value]) -> i64 {
|
||||||
|
push(v, values);
|
||||||
|
v.execute_identity(OpCode::RefIdentityHash, ty, None, 0).unwrap();
|
||||||
|
let Value::Int64(value) = v.operand_stack.pop().unwrap() else { panic!() };
|
||||||
|
value
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn identity_faults_preserve_complete_groups_and_charge_once_in_left_to_right_order() {
|
||||||
|
let mut v = empty();
|
||||||
|
let registry = v.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let live = v.heap.allocate_typed_struct(registry.clone(), TypeId(5)).unwrap();
|
||||||
|
let wrong = v.heap.allocate_typed_struct(registry, TypeId(11)).unwrap();
|
||||||
|
let stale = HeapRef { index: 999999, generation: 1 };
|
||||||
|
for (left, right, values, code) in [
|
||||||
|
(5, None, vec![Value::HeapRef(stale)], TRAP_INVALID_HANDLE),
|
||||||
|
(5, None, vec![Value::HeapRef(wrong)], TRAP_TYPE),
|
||||||
|
(5, None, vec![Value::HeapRef(HeapRef::NULL)], TRAP_TYPE),
|
||||||
|
(6, None, vec![Value::HeapRef(live)], TRAP_TYPE),
|
||||||
|
(9, None, vec![Value::HeapRef(HeapRef::NULL)], TRAP_TYPE),
|
||||||
|
(10, None, vec![Value::HeapRef(HeapRef::NULL)], TRAP_INVALID_HANDLE),
|
||||||
|
(7, None, vec![Value::Null, Value::Int64(0)], TRAP_TYPE),
|
||||||
|
(7, None, vec![Value::HeapRef(live), Value::Null], TRAP_TYPE),
|
||||||
|
(7, None, vec![Value::HeapRef(live), Value::Int64(1)], TRAP_TYPE),
|
||||||
|
(7, None, vec![Value::HeapRef(live), Value::Int64(-1)], TRAP_TYPE),
|
||||||
|
(7, None, vec![Value::HeapRef(live), Value::Int64(999)], TRAP_TYPE),
|
||||||
|
(7, None, vec![Value::HeapRef(stale), Value::Int64(0)], TRAP_INVALID_HANDLE),
|
||||||
|
// A null left side still validates the complete right group.
|
||||||
|
(5, Some(7), vec![Value::Null, Value::HeapRef(live), Value::Int64(1)], TRAP_TYPE),
|
||||||
|
(5, Some(11), vec![Value::Null, Value::HeapRef(stale)], TRAP_INVALID_HANDLE),
|
||||||
|
// Both invalid: left TYPE takes precedence over right INVALID_HANDLE.
|
||||||
|
(5, Some(5), vec![Value::HeapRef(wrong), Value::HeapRef(stale)], TRAP_TYPE),
|
||||||
|
] {
|
||||||
|
v.operand_stack.truncate(8); // Entry's eight reserved local slots.
|
||||||
|
push(&mut v, &values);
|
||||||
|
let operands = v.operand_stack.as_slice().to_vec();
|
||||||
|
let before = usage(&v);
|
||||||
|
let cycles = v.cycles;
|
||||||
|
let op = if right.is_some() { OpCode::RefIdentityEq } else { OpCode::RefIdentityHash };
|
||||||
|
let width = if left == 7 { 2 } else { 1 } + right.map_or(0, |r| if r == 7 { 2 } else { 1 });
|
||||||
|
fault(v.execute_identity(op, left, right, 0), code);
|
||||||
|
assert_eq!(v.operand_stack.as_slice(), operands);
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
assert_eq!(v.cycles - cycles, op.cycles() + width);
|
||||||
|
}
|
||||||
|
v.operand_stack.truncate(8);
|
||||||
|
let before = v.cycles;
|
||||||
|
fault(v.execute_identity(OpCode::RefIdentityEq, 7, Some(7), 0), TRAP_STACK_UNDERFLOW);
|
||||||
|
assert_eq!(v.cycles - before, 8);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn gc_preserves_live_aliases_but_hashes_do_not_root_collected_handles() {
|
||||||
|
let mut v = empty();
|
||||||
|
let registry = v.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let live = v.heap.allocate_typed_struct(registry.clone(), TypeId(5)).unwrap();
|
||||||
|
let dead = v.heap.allocate_typed_struct(registry.clone(), TypeId(5)).unwrap();
|
||||||
|
let live_hash = hash(&mut v, 5, &[Value::HeapRef(live)]);
|
||||||
|
let dead_hash = hash(&mut v, 5, &[Value::HeapRef(dead)]);
|
||||||
|
v.globals.push(Value::HeapRef(live)).unwrap();
|
||||||
|
v.globals.push(Value::Int64(dead_hash)).unwrap();
|
||||||
|
v.gc_alloc_threshold = 1;
|
||||||
|
v.handle_safepoint().unwrap();
|
||||||
|
assert!(v.heap.is_valid(live));
|
||||||
|
assert!(!v.heap.is_valid(dead));
|
||||||
|
assert_eq!(hash(&mut v, 7, &[Value::HeapRef(live), Value::Int64(0)]), live_hash);
|
||||||
|
let replacement = v.heap.allocate_typed_struct(registry, TypeId(5)).unwrap();
|
||||||
|
assert_eq!(replacement.index, dead.index);
|
||||||
|
assert_ne!(replacement.generation, dead.generation);
|
||||||
|
push(&mut v, &[Value::HeapRef(dead), Value::HeapRef(replacement)]);
|
||||||
|
fault(v.execute_identity(OpCode::RefIdentityEq, 5, Some(5), 0), TRAP_INVALID_HANDLE);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn new_queries_ignore_exhausted_guest_and_scratch_quotas_and_do_not_collect() {
|
||||||
|
let mut v = empty();
|
||||||
|
let registry = v.validated_image.as_ref().unwrap().registry().clone();
|
||||||
|
let live = v.heap.allocate_typed_struct(registry, TypeId(5)).unwrap();
|
||||||
|
push(&mut v, &[Value::HeapRef(live)]);
|
||||||
|
for q in [
|
||||||
|
Q::GuestBytes,
|
||||||
|
Q::HandleSlots,
|
||||||
|
Q::AuxiliaryBytes,
|
||||||
|
Q::TemporaryBytes,
|
||||||
|
Q::StringBytes,
|
||||||
|
Q::StringAllocations,
|
||||||
|
] {
|
||||||
|
v.budget.test_lower_limit(q, v.budget.used(q));
|
||||||
|
}
|
||||||
|
let before = usage(&v);
|
||||||
|
let allocations = v.heap.allocation_count();
|
||||||
|
v.gc_alloc_threshold = 1;
|
||||||
|
v.execute_identity(OpCode::RefIdentityHash, 5, None, 0).unwrap();
|
||||||
|
v.execute_inline_intrinsic(&HASH_INTRINSICS[0], 0).unwrap();
|
||||||
|
assert_eq!(v.heap.allocation_count(), allocations);
|
||||||
|
assert!(v.heap.is_valid(live)); // No root remains, but neither operation is a safepoint.
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn inline_faults_preserve_float_bits_owners_and_attempted_cost() {
|
||||||
|
let mut v = empty();
|
||||||
|
for bits in [f64::INFINITY.to_bits(), f64::NEG_INFINITY.to_bits(), 0x7ff8000000001234] {
|
||||||
|
push(&mut v, &[Value::Float(f64::from_bits(bits))]);
|
||||||
|
let before = usage(&v);
|
||||||
|
let cycles = v.cycles;
|
||||||
|
fault(
|
||||||
|
v.execute_inline_intrinsic(&HASH_INTRINSICS[1], 0),
|
||||||
|
prometeu_bytecode::TRAP_NON_FINITE,
|
||||||
|
);
|
||||||
|
assert!(matches!(v.operand_stack.last(),Some(Value::Float(f)) if f.to_bits()==bits));
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
assert_eq!(v.cycles - cycles, 8);
|
||||||
|
v.operand_stack.pop();
|
||||||
|
}
|
||||||
|
let foreign: Arc<str> = Arc::from("owner outside image and session");
|
||||||
|
push(&mut v, &[Value::String(foreign.clone())]);
|
||||||
|
let refs = Arc::strong_count(&foreign);
|
||||||
|
let before = usage(&v);
|
||||||
|
let cycles = v.cycles;
|
||||||
|
fault(v.execute_inline_intrinsic(&HASH_INTRINSICS[2], 0), TRAP_TYPE);
|
||||||
|
assert_eq!(Arc::strong_count(&foreign), refs);
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
assert_eq!(v.cycles - cycles, 8 + foreign.len() as u64);
|
||||||
|
let mut overflow = HASH_INTRINSICS[2];
|
||||||
|
overflow.cost_per_byte = u64::MAX;
|
||||||
|
let cycles = v.cycles;
|
||||||
|
fault(v.execute_inline_intrinsic(&overflow, 0), TRAP_RESOURCE_LIMIT);
|
||||||
|
assert_eq!(v.cycles - cycles, 8);
|
||||||
|
assert_eq!(Arc::strong_count(&foreign), refs);
|
||||||
|
v.operand_stack.pop();
|
||||||
|
let cycles = v.cycles;
|
||||||
|
fault(v.execute_inline_intrinsic(&HASH_INTRINSICS[2], 0), TRAP_STACK_UNDERFLOW);
|
||||||
|
assert_eq!(v.cycles - cycles, 8);
|
||||||
|
push(&mut v, &[Value::Int64(7)]);
|
||||||
|
let cycles = v.cycles;
|
||||||
|
fault(v.execute_inline_intrinsic(&HASH_INTRINSICS[2], 0), TRAP_TYPE);
|
||||||
|
assert_eq!(v.cycles - cycles, 8);
|
||||||
|
assert_eq!(v.operand_stack.last(), Some(&Value::Int64(7)));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn equal_string_content_hashes_across_image_session_and_import_owners() {
|
||||||
|
use prometeu_bytecode::model::ConstantPoolEntry as K;
|
||||||
|
let mut v = vm(
|
||||||
|
&[("PUSH_CONST 0\nINTRINSIC 0x4102\nRET", sig(&[], &[0]))],
|
||||||
|
&[K::String("same\0π".into())],
|
||||||
|
);
|
||||||
|
step(&mut v).unwrap();
|
||||||
|
let Value::String(image_owner) = v.operand_stack.last().unwrap().clone() else { panic!() };
|
||||||
|
v.strings = Some(crate::string_ledger::StringLedger::new(v.budget.clone()).unwrap());
|
||||||
|
let session = v.strings.as_ref().unwrap().concat("same", "\0π").unwrap();
|
||||||
|
let imported = v.strings.as_ref().unwrap().import("same\0π").unwrap();
|
||||||
|
assert!(!Arc::ptr_eq(&session, &imported));
|
||||||
|
let mut hashes = vec![];
|
||||||
|
v.operand_stack.pop();
|
||||||
|
for owner in [&image_owner, &session, &imported] {
|
||||||
|
push(&mut v, &[Value::String(owner.clone())]);
|
||||||
|
let before = usage(&v);
|
||||||
|
let count = Arc::strong_count(owner);
|
||||||
|
v.execute_inline_intrinsic(&HASH_INTRINSICS[2], 0).unwrap();
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
assert_eq!(Arc::strong_count(owner), count - 1);
|
||||||
|
hashes.push(v.operand_stack.pop().unwrap());
|
||||||
|
}
|
||||||
|
assert!(hashes.windows(2).all(|pair| pair[0] == pair[1]));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn missing(_: &[Value], _: &mut IntrinsicResults) -> Result<(), IntrinsicExecutionError> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
fn wrong(_: &[Value], out: &mut IntrinsicResults) -> Result<(), IntrinsicExecutionError> {
|
||||||
|
out.push(Value::Boolean(true))
|
||||||
|
}
|
||||||
|
fn excess(_: &[Value], out: &mut IntrinsicResults) -> Result<(), IntrinsicExecutionError> {
|
||||||
|
out.push(Value::Int64(1))?;
|
||||||
|
let _ = out.push(Value::Int64(2)); // Ignoring the error cannot publish a partial result.
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn shared_invocation_rejects_bad_outputs_without_consuming_original_string_owner() {
|
||||||
|
let mut v = empty();
|
||||||
|
let Value::String(content) = v.import_string_value(&Value::String(Arc::from("kept"))).unwrap()
|
||||||
|
else {
|
||||||
|
panic!()
|
||||||
|
};
|
||||||
|
push(&mut v, &[Value::String(content.clone())]);
|
||||||
|
let count = Arc::strong_count(&content);
|
||||||
|
let before = usage(&v);
|
||||||
|
for handler in [missing, wrong, excess] {
|
||||||
|
let mut meta: IntrinsicMeta = HASH_INTRINSICS[2];
|
||||||
|
meta.owner = "test"; // The shared executor is independent of the hash namespace.
|
||||||
|
meta.implementation = IntrinsicImplementation::BorrowedInline(handler);
|
||||||
|
fault(v.execute_inline_intrinsic(&meta, 0), TRAP_INVALID_INTRINSIC);
|
||||||
|
assert_eq!(Arc::strong_count(&content), count);
|
||||||
|
assert_eq!(usage(&v), before);
|
||||||
|
assert!(matches!(v.operand_stack.last(),Some(Value::String(s)) if Arc::ptr_eq(s,&content)));
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,113 @@
|
|||||||
|
//! Shared borrowed invocation; algorithms receive no host/VM context.
|
||||||
|
use super::*;
|
||||||
|
use crate::{
|
||||||
|
AbiType, IntrinsicExecutionError as E, IntrinsicImplementation as I, IntrinsicMeta,
|
||||||
|
IntrinsicResults,
|
||||||
|
};
|
||||||
|
|
||||||
|
impl VirtualMachine {
|
||||||
|
fn inline_values(
|
||||||
|
&self,
|
||||||
|
values: &[Value],
|
||||||
|
layout: &[AbiType],
|
||||||
|
) -> Result<(), crate::value_contract::ValueError> {
|
||||||
|
use crate::value_contract::ValueError;
|
||||||
|
for (value, abi) in values.iter().zip(layout) {
|
||||||
|
match value {
|
||||||
|
Value::String(content) if self.validated_image.is_some() => {
|
||||||
|
if !self.validated_image.as_ref().unwrap().retains_string(content)
|
||||||
|
&& !self.strings.as_ref().is_some_and(|domain| domain.retains(content))
|
||||||
|
{
|
||||||
|
return Err(ValueError::Type);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Value::HeapRef(reference) if matches!(abi, AbiType::Builtin(key) if key.name == "Random") =>
|
||||||
|
{
|
||||||
|
self.heap.random_state(*reference)?;
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn execute_inline_intrinsic(
|
||||||
|
&mut self,
|
||||||
|
meta: &IntrinsicMeta,
|
||||||
|
pc: u32,
|
||||||
|
) -> Result<(), LogicalFrameEndingReason> {
|
||||||
|
let op = OpCode::Intrinsic;
|
||||||
|
let consumed = meta.arg_slots();
|
||||||
|
let enough = self.temporary_slots() >= consumed;
|
||||||
|
let args =
|
||||||
|
if enough { &self.operand_stack[self.operand_stack.len() - consumed..] } else { &[] };
|
||||||
|
let Some(cost) = meta.attempted_cost(args) else {
|
||||||
|
self.cycles += meta.cost_cycles;
|
||||||
|
return Err(self.trap(
|
||||||
|
TRAP_RESOURCE_LIMIT,
|
||||||
|
op as u16,
|
||||||
|
"Intrinsic attempted cost overflow".into(),
|
||||||
|
pc,
|
||||||
|
));
|
||||||
|
};
|
||||||
|
self.cycles += cost;
|
||||||
|
meta.validate_descriptor()
|
||||||
|
.map_err(|message| self.trap(TRAP_INVALID_INTRINSIC, op as u16, message.into(), pc))?;
|
||||||
|
if !enough {
|
||||||
|
return Err(self.trap(
|
||||||
|
TRAP_STACK_UNDERFLOW,
|
||||||
|
op as u16,
|
||||||
|
"Incomplete intrinsic operands".into(),
|
||||||
|
pc,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let I::BorrowedInline(handler) = meta.implementation else {
|
||||||
|
return Err(self.trap(
|
||||||
|
TRAP_INVALID_INTRINSIC,
|
||||||
|
op as u16,
|
||||||
|
"Wrong invocation profile".into(),
|
||||||
|
pc,
|
||||||
|
));
|
||||||
|
};
|
||||||
|
let base = self.operand_stack.len() - consumed;
|
||||||
|
let args = &self.operand_stack[base..];
|
||||||
|
meta.validate_argument_values(args).map_err(|_| {
|
||||||
|
self.trap(TRAP_TYPE, op as u16, "Invalid intrinsic argument carrier".into(), pc)
|
||||||
|
})?;
|
||||||
|
self.inline_values(args, meta.arg_layout)
|
||||||
|
.map_err(|error| self.value_trap(error, op, pc))?;
|
||||||
|
let mut out = IntrinsicResults::new(meta.ret_slots());
|
||||||
|
handler(args, &mut out).map_err(|error| match error {
|
||||||
|
E::Numeric(error) => {
|
||||||
|
self.trap(error.code, op as u16, format!("Intrinsic numeric fault: {error:?}"), pc)
|
||||||
|
}
|
||||||
|
_ => self.trap(
|
||||||
|
TRAP_INVALID_INTRINSIC,
|
||||||
|
op as u16,
|
||||||
|
format!("Invalid intrinsic handler output: {error:?}"),
|
||||||
|
pc,
|
||||||
|
),
|
||||||
|
})?;
|
||||||
|
out.validate(meta).map_err(|error| {
|
||||||
|
self.trap(
|
||||||
|
TRAP_INVALID_INTRINSIC,
|
||||||
|
op as u16,
|
||||||
|
format!("Invalid intrinsic result: {error:?}"),
|
||||||
|
pc,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
self.inline_values(out.as_slice(), meta.ret_layout).map_err(|_| {
|
||||||
|
self.trap(
|
||||||
|
TRAP_INVALID_INTRINSIC,
|
||||||
|
op as u16,
|
||||||
|
"Invalid intrinsic result ownership".into(),
|
||||||
|
pc,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
self.operand_stack.truncate(base);
|
||||||
|
for value in out.into_values() {
|
||||||
|
self.operand_stack.push(value).expect("bounded result replaces admitted inputs");
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -62,7 +62,7 @@ impl VirtualMachine {
|
|||||||
if self.temporary_slots() == 0 {
|
if self.temporary_slots() == 0 {
|
||||||
return Err("Stack underflow".into());
|
return Err("Stack underflow".into());
|
||||||
}
|
}
|
||||||
self.operand_stack.pop().ok_or("Stack underflow".into())
|
self.operand_stack.pop().ok_or_else(|| "Stack underflow".into())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn pop_number(&mut self) -> Result<f64, String> {
|
pub fn pop_number(&mut self) -> Result<f64, String> {
|
||||||
@@ -82,7 +82,7 @@ impl VirtualMachine {
|
|||||||
if self.temporary_slots() == 0 {
|
if self.temporary_slots() == 0 {
|
||||||
return Err("Stack underflow".into());
|
return Err("Stack underflow".into());
|
||||||
}
|
}
|
||||||
self.operand_stack.last().ok_or("Stack underflow".into())
|
self.operand_stack.last().ok_or_else(|| "Stack underflow".into())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(super) fn pop_trap<S: Into<String>>(
|
pub(super) fn pop_trap<S: Into<String>>(
|
||||||
@@ -112,8 +112,22 @@ impl VirtualMachine {
|
|||||||
where
|
where
|
||||||
F: FnOnce(Value, Value) -> Result<Value, OpError>,
|
F: FnOnce(Value, Value) -> Result<Value, OpError>,
|
||||||
{
|
{
|
||||||
let b = self.pop_trap(opcode, start_pc, format!("{:?} requires two operands", opcode))?;
|
let b = self.pop().map_err(|_| {
|
||||||
let a = self.pop_trap(opcode, start_pc, format!("{:?} requires two operands", opcode))?;
|
self.trap(
|
||||||
|
TRAP_STACK_UNDERFLOW,
|
||||||
|
opcode as u16,
|
||||||
|
format!("{:?} requires two operands", opcode),
|
||||||
|
start_pc,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
let a = self.pop().map_err(|_| {
|
||||||
|
self.trap(
|
||||||
|
TRAP_STACK_UNDERFLOW,
|
||||||
|
opcode as u16,
|
||||||
|
format!("{:?} requires two operands", opcode),
|
||||||
|
start_pc,
|
||||||
|
)
|
||||||
|
})?;
|
||||||
match f(a, b) {
|
match f(a, b) {
|
||||||
Ok(res) => {
|
Ok(res) => {
|
||||||
self.push_trap(res, opcode, start_pc)?;
|
self.push_trap(res, opcode, start_pc)?;
|
||||||
|
|||||||
@@ -0,0 +1,81 @@
|
|||||||
|
//! Opt-in diagnostics for the actual native provenance boundaries.
|
||||||
|
use super::*;
|
||||||
|
use crate::ValidatedProgramImage;
|
||||||
|
use std::{hint::black_box, sync::Arc};
|
||||||
|
|
||||||
|
pub struct Fixture {
|
||||||
|
vm: VirtualMachine,
|
||||||
|
owners: Vec<Arc<str>>,
|
||||||
|
image_hit: Arc<str>,
|
||||||
|
miss: Arc<str>,
|
||||||
|
}
|
||||||
|
impl Fixture {
|
||||||
|
pub fn new(image: Arc<ValidatedProgramImage>, count: usize) -> Self {
|
||||||
|
let Value::String(image_hit) = image.constants().last().unwrap() else { panic!() };
|
||||||
|
let image_hit = image_hit.clone();
|
||||||
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
||||||
|
let ledger = crate::string_ledger::StringLedger::new(vm.budget.clone()).unwrap();
|
||||||
|
let owners = (0..count).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
|
||||||
|
vm.strings = Some(ledger);
|
||||||
|
vm.operand_stack.push(Value::String(image_hit.clone())).unwrap();
|
||||||
|
vm.operand_stack.push(Value::String(owners.last().unwrap().clone())).unwrap();
|
||||||
|
Self { vm, owners, image_hit, miss: Arc::from("same") }
|
||||||
|
}
|
||||||
|
pub fn auxiliary_bytes(&self) -> u64 {
|
||||||
|
self.vm.budget.used(RuntimeResource::AuxiliaryBytes)
|
||||||
|
}
|
||||||
|
pub fn work(&self) -> [usize; 4] {
|
||||||
|
let image = self.vm.validated_image.as_ref().unwrap();
|
||||||
|
let session = self.vm.strings.as_ref().unwrap();
|
||||||
|
let (ih, iw) = image.lookup_work(&self.image_hit);
|
||||||
|
let (im, mw) = image.lookup_work(&self.miss);
|
||||||
|
let (sh, sw) = session.lookup_work(self.owners.last().unwrap());
|
||||||
|
let (sm, tw) = session.lookup_work(&self.miss);
|
||||||
|
assert!(ih && sh && !im && !sm);
|
||||||
|
[iw, mw, sw, tw]
|
||||||
|
}
|
||||||
|
pub fn run(&mut self, workload: &str) {
|
||||||
|
match workload {
|
||||||
|
"image_hit" => {
|
||||||
|
black_box(
|
||||||
|
self.vm
|
||||||
|
.validated_image
|
||||||
|
.as_ref()
|
||||||
|
.unwrap()
|
||||||
|
.retains_string(black_box(&self.image_hit)),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"image_miss" => {
|
||||||
|
black_box(
|
||||||
|
self.vm.validated_image.as_ref().unwrap().retains_string(black_box(&self.miss)),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"session_hit" => {
|
||||||
|
black_box(
|
||||||
|
self.vm
|
||||||
|
.strings
|
||||||
|
.as_ref()
|
||||||
|
.unwrap()
|
||||||
|
.retains(black_box(self.owners.last().unwrap())),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"session_miss" => {
|
||||||
|
black_box(self.vm.strings.as_ref().unwrap().retains(black_box(&self.miss)));
|
||||||
|
}
|
||||||
|
"import_hit" => {
|
||||||
|
black_box(
|
||||||
|
self.vm
|
||||||
|
.import_string_value(&Value::String(self.owners.last().unwrap().clone()))
|
||||||
|
.unwrap(),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"import_miss" => {
|
||||||
|
black_box(self.vm.import_string_value(&Value::String(self.miss.clone())).unwrap());
|
||||||
|
}
|
||||||
|
"snapshot_mixed" => {
|
||||||
|
black_box(self.vm.operand_stack_top(2));
|
||||||
|
}
|
||||||
|
_ => panic!("unknown workload"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -699,28 +699,28 @@ fn ordered_multi_group_return_preserves_native_owners_and_receiver_identity() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn unknown_return_and_late_return_resource_failures_keep_current_frame_and_operands() {
|
fn unknown_return_refusal_keeps_frame_but_valid_return_needs_no_scratch() {
|
||||||
let mut code = vec![];
|
let mut code = vec![];
|
||||||
arg(&mut code, OpCode::GetGlobal, 0);
|
arg(&mut code, OpCode::GetGlobal, 0);
|
||||||
op(&mut code, OpCode::Ret);
|
op(&mut code, OpCode::Ret);
|
||||||
let image = image(&code, vec![function(0, code.len(), &[], &[0], 0, 1)]);
|
let image = image(&code, vec![function(0, code.len(), &[], &[0], 0, 1)]);
|
||||||
for (value, limits, expected) in [
|
for value in [Value::Boolean(true), Value::Int32(3)] {
|
||||||
(Value::Boolean(true), RuntimeLimits::default(), TRAP_TYPE),
|
let limits = RuntimeLimits::default().lowered(RuntimeResource::TemporaryBytes, 0).unwrap();
|
||||||
(
|
|
||||||
Value::Int32(3),
|
|
||||||
RuntimeLimits::default().lowered(RuntimeResource::TemporaryBytes, 0).unwrap(),
|
|
||||||
TRAP_RESOURCE_LIMIT,
|
|
||||||
),
|
|
||||||
] {
|
|
||||||
let mut vm = VirtualMachine::from_image(image.clone(), limits);
|
let mut vm = VirtualMachine::from_image(image.clone(), limits);
|
||||||
vm.prepare_boot_call().unwrap();
|
vm.prepare_boot_call().unwrap();
|
||||||
vm.globals.push(value.clone()).unwrap();
|
vm.globals.push(value.clone()).unwrap();
|
||||||
let result = run(&mut vm);
|
let result = run(&mut vm);
|
||||||
|
if matches!(value, Value::Boolean(_)) {
|
||||||
assert!(
|
assert!(
|
||||||
matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==expected && info.pc==6)
|
matches!(result, LogicalFrameEndingReason::Trap(info) if info.code == TRAP_TYPE && info.pc == 6)
|
||||||
);
|
);
|
||||||
assert_eq!(vm.call_stack.len(), 1);
|
assert_eq!(vm.call_stack.len(), 1);
|
||||||
|
} else {
|
||||||
|
assert_eq!(result, LogicalFrameEndingReason::EndOfRom);
|
||||||
|
assert!(vm.call_stack.is_empty());
|
||||||
|
}
|
||||||
assert_eq!(vm.operand_stack.as_slice(), &[value]);
|
assert_eq!(vm.operand_stack.as_slice(), &[value]);
|
||||||
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -132,3 +132,39 @@ fn collection_load_limits_and_analysis_refusals_keep_context_and_refund_scratch(
|
|||||||
assert_eq!(budget.used(LoadResource::RegistryBytes), 0);
|
assert_eq!(budget.used(LoadResource::RegistryBytes), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn removed_storage_opcodes_reject_even_in_unreachable_instruction_positions() {
|
||||||
|
use prometeu_bytecode::load_limits::{LoadCode, LoadReason};
|
||||||
|
use prometeu_vm::VmInitError;
|
||||||
|
for opcode in [0xa7u16, 0xa8, 0xaa, 0xab] {
|
||||||
|
for dead in [false, true] {
|
||||||
|
let mut code = if dead { vec![1, 0] } else { vec![] };
|
||||||
|
let pc = code.len() as u32;
|
||||||
|
code.extend_from_slice(&opcode.to_le_bytes());
|
||||||
|
let VmInitError::RegistryLoadFailed(error) = load(&code).unwrap_err() else { panic!() };
|
||||||
|
assert_eq!(error.code, LoadCode::InvalidCode);
|
||||||
|
assert_eq!(error.reason, LoadReason::UnknownOpcode);
|
||||||
|
assert_eq!((error.function, error.pc), (Some(0), Some(pc)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// The same bytes are accepted as an Int64 immediate, never decoded as opcodes.
|
||||||
|
let code = [0x14, 0, 0xa7, 0, 0xa8, 0, 0xaa, 0, 0xab, 0, 1, 0];
|
||||||
|
assert_eq!(
|
||||||
|
run(&code),
|
||||||
|
[Value::Int64(i64::from_le_bytes([0xa7, 0, 0xa8, 0, 0xaa, 0, 0xab, 0]))]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn neutral_pbx_copy_moves_a_range_and_preserves_physical_length() {
|
||||||
|
let code=assemble("PUSH_I64 2\nARRAY_NEW 11\nSET_GLOBAL 0\nGET_GLOBAL 0\nPUSH_I64 0\nPUSH_I32 42\nARRAY_SET 11\nGET_GLOBAL 0\nPUSH_I64 0\nGET_GLOBAL 0\nPUSH_I64 1\nPUSH_I64 1\nARRAY_COPY 11\nGET_GLOBAL 0\nPUSH_I64 1\nARRAY_GET 11\nGET_GLOBAL 0\nARRAY_LEN 11\nHALT").unwrap();
|
||||||
|
assert_eq!(run(&code), [Value::Int64(2), Value::Int32(42)]);
|
||||||
|
for text in [
|
||||||
|
"HALT\nARRAY_COPY 9",
|
||||||
|
"HALT\nARRAY_COPY 99",
|
||||||
|
"PUSH_I64 1\nARRAY_NEW 11\nPUSH_I64 0\nPUSH_I64 1\nARRAY_NEW 11\nPUSH_I64 0\nPUSH_BOOL 1\nARRAY_COPY 11\nHALT",
|
||||||
|
] {
|
||||||
|
assert!(load(&assemble(text).unwrap()).is_err(), "{text}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -0,0 +1,229 @@
|
|||||||
|
//! Count only this thread's warmed instruction region, including reallocations.
|
||||||
|
use prometeu_bytecode::{assemble, load_limits::LoadBudget, registry::*};
|
||||||
|
use prometeu_hal::{HostContext, syscalls::caps};
|
||||||
|
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||||
|
use prometeu_vm::{ValidatedProgramImage, VirtualMachine};
|
||||||
|
use std::alloc::{GlobalAlloc, Layout, System};
|
||||||
|
use std::cell::Cell;
|
||||||
|
struct Native;
|
||||||
|
impl prometeu_hal::NativeInterface for Native {
|
||||||
|
fn syscall(
|
||||||
|
&mut self,
|
||||||
|
_: u32,
|
||||||
|
_: &[prometeu_bytecode::Value],
|
||||||
|
_: &mut prometeu_hal::HostReturn,
|
||||||
|
_: &mut HostContext,
|
||||||
|
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||||
|
panic!("no syscalls in allocation fixtures")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
thread_local! {
|
||||||
|
static COUNTS: Cell<Option<(usize, usize)>> = const { Cell::new(None) };
|
||||||
|
}
|
||||||
|
struct Counter;
|
||||||
|
fn count(alloc: usize, free: usize) {
|
||||||
|
let _ = COUNTS.try_with(|c| {
|
||||||
|
if let Some((a, d)) = c.get() {
|
||||||
|
c.set(Some((a + alloc, d + free)));
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
unsafe impl GlobalAlloc for Counter {
|
||||||
|
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
|
||||||
|
count(1, 0);
|
||||||
|
unsafe { System.alloc(l) }
|
||||||
|
}
|
||||||
|
unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {
|
||||||
|
count(1, 0);
|
||||||
|
unsafe { System.alloc_zeroed(l) }
|
||||||
|
}
|
||||||
|
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
|
||||||
|
count(0, 1);
|
||||||
|
unsafe { System.dealloc(p, l) }
|
||||||
|
}
|
||||||
|
unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 {
|
||||||
|
count(1, 1);
|
||||||
|
unsafe { System.realloc(p, l, n) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[global_allocator]
|
||||||
|
static ALLOCATOR: Counter = Counter;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn warmed_instruction_regions_do_not_allocate() {
|
||||||
|
let mut observations = vec![];
|
||||||
|
for (name, caller, callee, results, steps) in [
|
||||||
|
("scalar", "CALL 1\nPOP\nJMP 0", "PUSH_I64 42\nRET", 1, 5),
|
||||||
|
("void", "CALL 1\nJMP 0", "RET", 0, 3),
|
||||||
|
("multi", "CALL 1\nPOP\nPOP\nJMP 0", "PUSH_I64 11\nPUSH_I64 22\nRET", 2, 7),
|
||||||
|
("arithmetic_peek", "PUSH_I64 3\nDUP\nADD\nPOP\nJMP 0", "RET", 0, 5),
|
||||||
|
] {
|
||||||
|
let mut code = assemble(caller).unwrap();
|
||||||
|
let offset = code.len();
|
||||||
|
let body = assemble(callee).unwrap();
|
||||||
|
let mut program = TestProgram::single(code.clone(), int64_signature(0, 0), 4, 8);
|
||||||
|
program.functions.push(FunctionDecl {
|
||||||
|
signature: int64_signature(0, results),
|
||||||
|
code_offset: offset as u32,
|
||||||
|
code_len: body.len() as u32,
|
||||||
|
local_slots: 4,
|
||||||
|
max_stack_slots: 8,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
code.extend(body);
|
||||||
|
program.code = code;
|
||||||
|
let image = ValidatedProgramImage::load(
|
||||||
|
&program.serialize(),
|
||||||
|
&mut LoadBudget::new(Default::default()),
|
||||||
|
caps::NONE,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let mut vm = VirtualMachine::from_image(image, Default::default());
|
||||||
|
vm.prepare_boot_call().unwrap();
|
||||||
|
let mut host = HostContext::new(None);
|
||||||
|
for _ in 0..steps * 10 {
|
||||||
|
vm.step(&mut Native, &mut host).unwrap();
|
||||||
|
}
|
||||||
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
||||||
|
for _ in 0..steps * 1000 {
|
||||||
|
vm.step(&mut Native, &mut host).unwrap();
|
||||||
|
}
|
||||||
|
let counts = COUNTS.with(|c| c.replace(None).unwrap());
|
||||||
|
println!("{name}: 1000 iterations, {counts:?} allocations/deallocations");
|
||||||
|
observations.push((name, counts));
|
||||||
|
}
|
||||||
|
for (name, counts) in observations {
|
||||||
|
assert_eq!(counts, (0, 0), "{name}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
|
#[allow(dead_code)]
|
||||||
|
#[path = "support/callables.rs"]
|
||||||
|
mod provenance_callables;
|
||||||
|
|
||||||
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
|
#[test]
|
||||||
|
fn provenance_queries_allocate_nothing_at_all_qualification_sizes() {
|
||||||
|
use prometeu_bytecode::model::ConstantPoolEntry;
|
||||||
|
use prometeu_vm::string_provenance_qualification::Fixture;
|
||||||
|
for count in [1024_usize, 16384, 65536] {
|
||||||
|
let constants = vec![ConstantPoolEntry::String("same".into()); count];
|
||||||
|
let image = provenance_callables::image_constants(
|
||||||
|
&[("RET", provenance_callables::sig(&[], &[]), vec![])],
|
||||||
|
vec![],
|
||||||
|
&constants,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let mut fixture = Fixture::new(image, count);
|
||||||
|
let work = fixture.work();
|
||||||
|
let bound = count.ilog2() as usize + 1;
|
||||||
|
assert!(work[0] <= bound && work[1] <= bound);
|
||||||
|
for workload in ["image_hit", "image_miss", "session_hit", "session_miss", "import_hit"] {
|
||||||
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
||||||
|
for _ in 0..100 {
|
||||||
|
fixture.run(workload);
|
||||||
|
}
|
||||||
|
let counts = COUNTS.with(|c| c.replace(None)).unwrap();
|
||||||
|
assert_eq!(counts, (0, 0), "{workload}, owners={count}");
|
||||||
|
}
|
||||||
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
||||||
|
fixture.run("snapshot_mixed");
|
||||||
|
let counts = COUNTS.with(|c| c.replace(None)).unwrap();
|
||||||
|
assert_eq!(counts, (1, 1), "only snapshot Value storage allocates");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[path = "support/identity.rs"]
|
||||||
|
mod identity_support;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn identity_and_borrowed_hash_instruction_regions_do_not_allocate() {
|
||||||
|
use prometeu_bytecode::model::ConstantPoolEntry as K;
|
||||||
|
for (name, initialize, operand, operation, steps, closure) in [
|
||||||
|
("hash_i64", "PUSH_I64 -73\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4100", 4, false),
|
||||||
|
("hash_float", "PUSH_CONST 0\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4101", 4, false),
|
||||||
|
("hash_string", "PUSH_CONST 1\nSET_LOCAL 0", "GET_LOCAL 0", "INTRINSIC 0x4102", 4, false),
|
||||||
|
(
|
||||||
|
"struct_hash",
|
||||||
|
"STRUCT_NEW 5\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0",
|
||||||
|
"REF_IDENTITY_HASH 5",
|
||||||
|
4,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"array_hash",
|
||||||
|
"PUSH_I64 0\nARRAY_NEW 6\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0",
|
||||||
|
"REF_IDENTITY_HASH 6",
|
||||||
|
4,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"fn_hash",
|
||||||
|
"MAKE_CLOSURE fn=1,type=9\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0",
|
||||||
|
"REF_IDENTITY_HASH 9",
|
||||||
|
4,
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"random_hash",
|
||||||
|
"PUSH_I64 1\nINTRINSIC 0x4000\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0",
|
||||||
|
"REF_IDENTITY_HASH 10",
|
||||||
|
4,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"trait_hash",
|
||||||
|
"STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nSET_LOCAL 1\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0\nGET_LOCAL 1",
|
||||||
|
"REF_IDENTITY_HASH 7",
|
||||||
|
5,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"struct_eq",
|
||||||
|
"STRUCT_NEW 5\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0\nGET_LOCAL 0",
|
||||||
|
"REF_IDENTITY_EQ left=5,right=5",
|
||||||
|
5,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"trait_eq",
|
||||||
|
"STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nSET_LOCAL 1\nSET_LOCAL 0",
|
||||||
|
"GET_LOCAL 0\nGET_LOCAL 1\nGET_LOCAL 0\nGET_LOCAL 1",
|
||||||
|
"REF_IDENTITY_EQ left=7,right=7",
|
||||||
|
7,
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
] {
|
||||||
|
let start = assemble(initialize).unwrap().len();
|
||||||
|
let text = format!("{initialize}\n{operand}\n{operation}\nPOP\nJMP {start}");
|
||||||
|
let mut bodies = vec![(text.as_str(), identity_support::sig(&[], &[]))];
|
||||||
|
if closure {
|
||||||
|
bodies.push(("RET", identity_support::sig(&[], &[])));
|
||||||
|
}
|
||||||
|
let mut vm =
|
||||||
|
identity_support::vm(&bodies, &[K::Float64(-0.0), K::String("π\0".repeat(512))]);
|
||||||
|
let mut host = HostContext::new(None);
|
||||||
|
while vm.pc() != start {
|
||||||
|
vm.step(&mut identity_support::Native, &mut host).unwrap();
|
||||||
|
}
|
||||||
|
for _ in 0..steps * 10 {
|
||||||
|
vm.step(&mut identity_support::Native, &mut host).unwrap();
|
||||||
|
}
|
||||||
|
let heap_allocations = vm.heap().allocation_count();
|
||||||
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
||||||
|
for _ in 0..steps * 1000 {
|
||||||
|
vm.step(&mut identity_support::Native, &mut host).unwrap();
|
||||||
|
}
|
||||||
|
let counts = COUNTS.with(|c| c.replace(None).unwrap());
|
||||||
|
assert_eq!(counts, (0, 0), "{name}: allocations and deallocations");
|
||||||
|
assert_eq!(vm.heap().allocation_count(), heap_allocations, "{name}: guest allocations");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -216,3 +216,47 @@ fn integer_division_and_remainder_overflow_wrap_without_host_panic() {
|
|||||||
assert_eq!(machine.operand_stack_top(1), vec![Value::Int64(expected)]);
|
assert_eq!(machine.operand_stack_top(1), vec![Value::Int64(expected)]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn maximum_width_mixed_return_preserves_order_and_caller_locals() {
|
||||||
|
// TestProgram catalog: Int64, Vec2, Float = 0, 6, 2.
|
||||||
|
let mut caller = String::from("PUSH_I64 73\nSET_LOCAL 0\nCALL 1\n");
|
||||||
|
caller.push_str(&"POP\n".repeat(1024));
|
||||||
|
caller.push_str("GET_LOCAL 0\nRET");
|
||||||
|
let mut callee = String::new();
|
||||||
|
let mut results = vec![];
|
||||||
|
let mut expected = vec![];
|
||||||
|
for i in 0..256 {
|
||||||
|
callee.push_str(&format!("PUSH_I64 {i}\nPUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nPUSH_F64 f64:0x4008000000000000\n"));
|
||||||
|
results.extend([TypeId(0), TypeId(6), TypeId(2)]);
|
||||||
|
expected.extend([Value::Int64(i), Value::Float(1.), Value::Float(2.), Value::Float(3.)]);
|
||||||
|
}
|
||||||
|
callee.push_str("RET");
|
||||||
|
let caller_code = assemble(&caller).unwrap();
|
||||||
|
let body = assemble(&callee).unwrap();
|
||||||
|
let mut program = TestProgram::single(caller_code.clone(), int64_signature(0, 1), 1, 1024);
|
||||||
|
program.functions.push(FunctionDecl {
|
||||||
|
signature: Signature { parameters: vec![], results },
|
||||||
|
code_offset: caller_code.len() as u32,
|
||||||
|
code_len: body.len() as u32,
|
||||||
|
local_slots: 3,
|
||||||
|
max_stack_slots: 1024,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
program.code.extend(body);
|
||||||
|
let image = ValidatedProgramImage::load(
|
||||||
|
&program.serialize(),
|
||||||
|
&mut LoadBudget::new(Default::default()),
|
||||||
|
caps::NONE,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let mut machine = VirtualMachine::from_image(image, Default::default());
|
||||||
|
machine.prepare_boot_call().unwrap();
|
||||||
|
for _ in 0..3 + 1024 + 1 {
|
||||||
|
machine.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
}
|
||||||
|
expected.reverse();
|
||||||
|
assert_eq!(machine.operand_stack_top(1024), expected);
|
||||||
|
assert_eq!(run(&mut machine, 10000).reason, LogicalFrameEndingReason::EndOfRom);
|
||||||
|
assert_eq!(machine.operand_stack_top(1), vec![Value::Int64(73)]);
|
||||||
|
}
|
||||||
|
|||||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,23 @@
|
|||||||
|
# Hash-v1 oracle provenance
|
||||||
|
|
||||||
|
`hash-conformance.tsv` is generated by `hash-oracle.py` against the official C
|
||||||
|
XXH64 reference, not the Rust VM implementation. Ordinary tests read the checked-in
|
||||||
|
vectors and need no library, network or Python dependency.
|
||||||
|
|
||||||
|
Reference: https://github.com/Cyan4973/xxHash/blob/v0.8.3/xxhash.h
|
||||||
|
|
||||||
|
Header SHA-256: `17973c0dc49d9854ca26caa191f0e12f7a424b68858d9a78de3860d959d85e4b`.
|
||||||
|
The generator verifies both the header digest and `XXH_versionNumber()==803`.
|
||||||
|
|
||||||
|
Example reproduction on macOS, after downloading that pinned header:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
clang -dynamiclib -O2 -x c -DXXH_IMPLEMENTATION -DXXH_STATIC_LINKING_ONLY xxhash.h -o libxxhash-oracle.dylib
|
||||||
|
python3 hash-oracle.py --header xxhash.h --library ./libxxhash-oracle.dylib
|
||||||
|
```
|
||||||
|
|
||||||
|
On Linux, use `-shared -fPIC` instead of `-dynamiclib`. The generator explicitly
|
||||||
|
encodes little-endian integers/reference components and finite Float bit patterns,
|
||||||
|
canonicalizes signed zeros, and uses seed zero. The null row is the machine
|
||||||
|
contract's direct zero result, not a hash of an empty message. Arbitrary `bytes`
|
||||||
|
rows exercise the internal algorithm; they do not expose guest byte strings.
|
||||||
@@ -0,0 +1,51 @@
|
|||||||
|
"""Regenerate hash-v1 vectors using upstream XXH64, never the Rust executor."""
|
||||||
|
import argparse
|
||||||
|
import ctypes
|
||||||
|
import hashlib
|
||||||
|
from pathlib import Path
|
||||||
|
import struct
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__)
|
||||||
|
parser.add_argument("--library", required=True, type=Path)
|
||||||
|
parser.add_argument("--header", required=True, type=Path)
|
||||||
|
parser.add_argument("--output", type=Path, default=Path(__file__).with_name("hash-conformance.tsv"))
|
||||||
|
args = parser.parse_args()
|
||||||
|
expected = "17973c0dc49d9854ca26caa191f0e12f7a424b68858d9a78de3860d959d85e4b"
|
||||||
|
assert hashlib.sha256(args.header.read_bytes()).hexdigest() == expected
|
||||||
|
library = ctypes.CDLL(str(args.library.resolve()))
|
||||||
|
assert library.XXH_versionNumber() == 803
|
||||||
|
digest = library.XXH64
|
||||||
|
digest.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_uint64]
|
||||||
|
digest.restype = ctypes.c_uint64
|
||||||
|
rows = ["kind\tinput\texpected_hash_hex"]
|
||||||
|
|
||||||
|
def emit(kind, value, data):
|
||||||
|
buffer = ctypes.create_string_buffer(data)
|
||||||
|
result = digest(ctypes.cast(buffer, ctypes.c_void_p), len(data), 0)
|
||||||
|
rows.append(f"{kind}\t{value}\t{result:016X}")
|
||||||
|
|
||||||
|
for size in list(range(71)) + [95, 96, 97, 127, 128, 129, 255, 256, 257, 1024, 4097]:
|
||||||
|
data = bytes((i * 131 + 17) & 255 for i in range(size))
|
||||||
|
emit("bytes", data.hex(), data)
|
||||||
|
for value in [0, 1, -1, 2, -2, -(2**63), 2**63 - 1, 2**53 + 1, 2**32]:
|
||||||
|
emit("i64", value, struct.pack("<q", value))
|
||||||
|
for bits in [0, 0x8000000000000000, 0x3FF0000000000000, 0xBFF0000000000000,
|
||||||
|
0x3FE0000000000000, 0xBFE0000000000000, 1, 0x8000000000000001,
|
||||||
|
0x000FFFFFFFFFFFFF, 0x0010000000000000,
|
||||||
|
0x7FEFFFFFFFFFFFFF, 0xFFEFFFFFFFFFFFFF, 0x4340000000000000]:
|
||||||
|
canonical = 0 if bits & 0x7FFFFFFFFFFFFFFF == 0 else bits
|
||||||
|
emit("float", f"{bits:016X}", struct.pack("<Q", canonical))
|
||||||
|
for value in ["", "hello", "\0", "ação 😀", "a" * 31, "a" * 32, "a" * 33, "z" * 1025]:
|
||||||
|
data = value.encode("utf-8")
|
||||||
|
emit("string", data.hex(), data)
|
||||||
|
for index, generation in [(0, 1), (1, 1), (1, 2), (1024, 1), (2**32-1, 2**32-1)]:
|
||||||
|
emit("reference", f"{index},{generation}", struct.pack("<II", index, generation))
|
||||||
|
rows.append("null\tnull\t0000000000000000")
|
||||||
|
args.output.write_text("\n".join(rows) + "\n", encoding="utf-8")
|
||||||
|
print(f"Generated {len(rows)-1} vectors with upstream XXH64 v0.8.3, seed 0.")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
@@ -0,0 +1,152 @@
|
|||||||
|
#[path = "support/identity.rs"]
|
||||||
|
mod support;
|
||||||
|
use prometeu_bytecode::{Value, model::ConstantPoolEntry as K};
|
||||||
|
use prometeu_vm::{HostContext, LogicalFrameEndingReason as End};
|
||||||
|
use support::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn scalar_pbx_execution_matches_independent_c_reference_vectors() {
|
||||||
|
let mut count = 0;
|
||||||
|
for row in include_str!("fixtures/hash-conformance.tsv").lines().skip(1) {
|
||||||
|
let fields: Vec<_> = row.split('\t').collect();
|
||||||
|
let expected = u64::from_str_radix(fields[2], 16).unwrap() as i64;
|
||||||
|
let (value, id, bytes) = match fields[0] {
|
||||||
|
"i64" => (K::Int64(fields[1].parse().unwrap()), 0x4100, 0),
|
||||||
|
"float" => {
|
||||||
|
(K::Float64(f64::from_bits(u64::from_str_radix(fields[1], 16).unwrap())), 0x4101, 0)
|
||||||
|
}
|
||||||
|
"string" => {
|
||||||
|
let bytes = hex_bytes(fields[1]);
|
||||||
|
let size = bytes.len();
|
||||||
|
(K::String(String::from_utf8(bytes).unwrap()), 0x4102, size)
|
||||||
|
}
|
||||||
|
"null" => (K::Null, 0x4102, 0),
|
||||||
|
_ => continue,
|
||||||
|
};
|
||||||
|
let source = format!("PUSH_CONST 0\nINTRINSIC {id}\nRET");
|
||||||
|
let mut vm = vm(&[(&source, sig(&[], &[0]))], &[value]);
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
let report = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!(report.reason, End::BudgetExhausted);
|
||||||
|
assert_eq!(report.cycles_used, 8 + bytes as u64, "{row}");
|
||||||
|
assert_eq!(&*vm.operand_stack_top(1), &[Value::Int64(expected)], "{row}");
|
||||||
|
assert_eq!(run(&mut vm).reason, End::EndOfRom);
|
||||||
|
count += 1;
|
||||||
|
}
|
||||||
|
assert_eq!(count, 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn identities_survive_mutation_and_views_validate_implementation_zero() {
|
||||||
|
let source = "STRUCT_NEW 5\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 5\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 73\nSTRUCT_SET type=5,field=0\nGET_LOCAL 0\nREF_IDENTITY_HASH 5\nGET_LOCAL 1\nEQ\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=7\nREF_IDENTITY_HASH 7\nGET_LOCAL 1\nEQ\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=7\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=8\nREF_IDENTITY_EQ left=7,right=8\nGET_LOCAL 0\nSTRUCT_NEW 5\nREF_IDENTITY_EQ left=5,right=5\nRET";
|
||||||
|
let mut vm = vm(&[(source, sig(&[], &[2, 2, 2, 2]))], &[]);
|
||||||
|
assert_eq!(run(&mut vm).reason, End::EndOfRom);
|
||||||
|
assert_eq!(
|
||||||
|
&*vm.operand_stack_top(4),
|
||||||
|
&[Value::Boolean(false), Value::Boolean(true), Value::Boolean(true), Value::Boolean(true)]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn array_closure_and_random_have_instance_identity() {
|
||||||
|
for (source, bodies) in [
|
||||||
|
(
|
||||||
|
"PUSH_I64 1\nARRAY_NEW 6\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 6\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 0\nPUSH_I64 42\nARRAY_SET 6\nGET_LOCAL 0\nREF_IDENTITY_HASH 6\nGET_LOCAL 1\nEQ\nRET",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"PUSH_I64 42\nINTRINSIC 0x4000\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 10\nSET_LOCAL 1\nGET_LOCAL 0\nINTRINSIC 0x4001\nPOP\nGET_LOCAL 0\nREF_IDENTITY_HASH 10\nGET_LOCAL 1\nEQ\nRET",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"MAKE_CLOSURE fn=1,type=9\nSET_LOCAL 0\nGET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_EQ left=9,right=9\nGET_LOCAL 0\nMAKE_CLOSURE fn=1,type=9\nREF_IDENTITY_EQ left=9,right=9\nNOT\nAND\nRET",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
] {
|
||||||
|
let mut functions = vec![(source, sig(&[], &[2]))];
|
||||||
|
if bodies {
|
||||||
|
functions.push(("RET", sig(&[], &[])));
|
||||||
|
}
|
||||||
|
let mut vm = vm(&functions, &[]);
|
||||||
|
assert_eq!(run(&mut vm).reason, End::EndOfRom);
|
||||||
|
assert_eq!(&*vm.operand_stack_top(1), &[Value::Boolean(true)]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn canonical_null_groups_compare_and_hash_without_instance_faults() {
|
||||||
|
let source = "PUSH_CONST 0\nPUSH_CONST 0\nREF_IDENTITY_HASH 7\nPUSH_CONST 0\nPUSH_CONST 0\nPUSH_CONST 0\nREF_IDENTITY_EQ left=6,right=7\nRET";
|
||||||
|
let mut vm = vm(&[(source, sig(&[], &[0, 2]))], &[K::Null]);
|
||||||
|
assert_eq!(run(&mut vm).reason, End::EndOfRom);
|
||||||
|
assert_eq!(&*vm.operand_stack_top(2), &[Value::Boolean(true), Value::Int64(0)]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn admission_rejects_ineligible_sources_and_bad_native_ids_even_when_dead() {
|
||||||
|
for instruction in [
|
||||||
|
"REF_IDENTITY_HASH 0",
|
||||||
|
"REF_IDENTITY_HASH 3",
|
||||||
|
"REF_IDENTITY_HASH 4",
|
||||||
|
"REF_IDENTITY_HASH 12",
|
||||||
|
"REF_IDENTITY_HASH 13",
|
||||||
|
"REF_IDENTITY_HASH 14",
|
||||||
|
"REF_IDENTITY_HASH 9999",
|
||||||
|
"REF_IDENTITY_EQ left=5,right=3",
|
||||||
|
"INTRINSIC 0x41FF",
|
||||||
|
] {
|
||||||
|
let text = format!("HALT\n{instruction}");
|
||||||
|
assert!(image(&[(&text, sig(&[], &[]))], &[]).is_err(), "{instruction}");
|
||||||
|
}
|
||||||
|
assert!(image(&[("PUSH_CONST 0\nINTRINSIC 0x4102\nRET", sig(&[], &[0]))], &[K::Null]).is_ok());
|
||||||
|
for id in [0x1103, 0x4100, 0x4101] {
|
||||||
|
let text = format!("PUSH_CONST 0\nINTRINSIC {id}\nPOP\nRET");
|
||||||
|
assert!(image(&[(&text, sig(&[], &[]))], &[K::Null]).is_err(), "{id}");
|
||||||
|
}
|
||||||
|
assert!(image(&[("PUSH_I64 3\nREF_IDENTITY_HASH 5\nRET", sig(&[], &[0]))], &[]).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn whole_instruction_budget_admission_preserves_zero_and_overshoot() {
|
||||||
|
let mut vm = vm(
|
||||||
|
&[("PUSH_CONST 0\nINTRINSIC 0x4102\nRET", sig(&[], &[0]))],
|
||||||
|
&[K::String("x".repeat(65))],
|
||||||
|
);
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
let before = vm.pc();
|
||||||
|
let zero = vm.run_budget(0, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!(zero.cycles_used, 0);
|
||||||
|
assert_eq!(vm.pc(), before);
|
||||||
|
let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!(one.reason, End::BudgetExhausted);
|
||||||
|
assert_eq!(one.cycles_used, 73);
|
||||||
|
assert_eq!(one.steps_executed, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn every_eligible_absence_has_zero_hash_and_exact_identity_instruction_cost() {
|
||||||
|
for (ty, width) in [(5, 1), (6, 1), (7, 2), (9, 1), (10, 1)] {
|
||||||
|
let source = format!("{}REF_IDENTITY_HASH {ty}\nRET", "PUSH_CONST 0\n".repeat(width));
|
||||||
|
let mut vm = vm(&[(&source, sig(&[], &[0]))], &[K::Null]);
|
||||||
|
for _ in 0..width {
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
}
|
||||||
|
let before = vm.pc();
|
||||||
|
let zero = vm.run_budget(0, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0));
|
||||||
|
assert_eq!(vm.pc(), before);
|
||||||
|
let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!((one.cycles_used, one.steps_executed), (8 + width as u64, 1));
|
||||||
|
assert_eq!(&*vm.operand_stack_top(1), &[Value::Int64(0)]);
|
||||||
|
}
|
||||||
|
for source in [
|
||||||
|
"PUSH_CONST 0\nSTRUCT_NEW 5\nREF_IDENTITY_EQ left=6,right=5\nRET",
|
||||||
|
"STRUCT_NEW 5\nSTRUCT_NEW 11\nREF_IDENTITY_EQ left=5,right=11\nRET",
|
||||||
|
] {
|
||||||
|
let mut vm = vm(&[(source, sig(&[], &[2]))], &[K::Null]);
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
step(&mut vm).unwrap();
|
||||||
|
let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||||
|
assert_eq!((one.cycles_used, one.steps_executed), (6, 1));
|
||||||
|
assert_eq!(&*vm.operand_stack_top(1), &[Value::Boolean(false)]);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,105 @@
|
|||||||
|
use prometeu_bytecode::Value;
|
||||||
|
use prometeu_vm::{
|
||||||
|
AbiType, BuiltinScalarType as S, IntrinsicCostModel as C, intrinsic_catalog,
|
||||||
|
intrinsic_catalog_csv, lookup_intrinsic_by_id,
|
||||||
|
};
|
||||||
|
use std::collections::BTreeSet;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn schema_two_has_exact_columns_profiles_and_per_slot_nullable_lists() {
|
||||||
|
let csv = intrinsic_catalog_csv();
|
||||||
|
assert_eq!(csv, include_str!("../../../../docs/vm-arch/INTRINSICS.csv"));
|
||||||
|
let mut rows = csv.lines();
|
||||||
|
assert_eq!(
|
||||||
|
rows.next().unwrap(),
|
||||||
|
"final_id_hex,final_id_dec,canonical_name,canonical_version,owner,name,arg_slots,ret_slots,arg_layout,ret_layout,deterministic,may_allocate,parameter_names,cost_cycles,mutates_guest_state,cost_model,attempt_cost_cycles,max_attempts,schema_version,arg_nullable,invocation_model,scratch_model,context_access,cost_arg_index,cost_per_byte"
|
||||||
|
);
|
||||||
|
let mut ids = BTreeSet::new();
|
||||||
|
let mut keys = BTreeSet::new();
|
||||||
|
let mut previous = 0;
|
||||||
|
for row in rows {
|
||||||
|
let f: Vec<_> = row.split(',').collect();
|
||||||
|
assert_eq!(f.len(), 25);
|
||||||
|
assert_eq!(f[18], "2");
|
||||||
|
let id = f[1].parse::<u32>().unwrap();
|
||||||
|
assert!(id > previous);
|
||||||
|
previous = id;
|
||||||
|
assert!(ids.insert(id));
|
||||||
|
assert!(keys.insert((f[2], f[3])));
|
||||||
|
let meta = lookup_intrinsic_by_id(id).unwrap();
|
||||||
|
meta.validate_descriptor().unwrap();
|
||||||
|
assert_eq!(f[19].split('|').filter(|s| !s.is_empty()).count(), meta.arg_slots());
|
||||||
|
assert_eq!(f[20], meta.invocation_model());
|
||||||
|
assert_eq!(f[21], meta.scratch_model());
|
||||||
|
assert_eq!(f[22], meta.context_access());
|
||||||
|
if id < 0x4100 {
|
||||||
|
assert_eq!(f[21], "existing_contract_v1");
|
||||||
|
assert_eq!(f[23], "");
|
||||||
|
assert_eq!(f[24], "0");
|
||||||
|
assert_eq!(f[20], if f[4] == "random" { "vm_owned_v1" } else { "host_buffered_v1" });
|
||||||
|
for (abi, nullable) in meta.arg_layout.iter().zip(meta.arg_nullable) {
|
||||||
|
assert_eq!(*nullable, matches!(abi,AbiType::Builtin(key) if key.name=="Random"));
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
assert_eq!(&f[20..23], &["borrowed_inline_v1", "none", "none"]);
|
||||||
|
assert_eq!(meta.cost_cycles, 8);
|
||||||
|
assert_eq!(meta.ret_layout, &[AbiType::Scalar(S::Int64)]);
|
||||||
|
assert_eq!(meta.arg_nullable, &[id == 0x4102]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert_eq!(ids.len(), 108);
|
||||||
|
assert_eq!(intrinsic_catalog().count(), 108);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn incompatible_descriptors_fail_instead_of_gaining_implicit_capabilities() {
|
||||||
|
let original = *lookup_intrinsic_by_id(0x4102).unwrap();
|
||||||
|
for variant in 0..14 {
|
||||||
|
let mut meta = original;
|
||||||
|
match variant {
|
||||||
|
0 => meta.arg_nullable = &[],
|
||||||
|
1 => meta.parameter_names = &[],
|
||||||
|
2 => meta.cost_arg_index = None,
|
||||||
|
3 => meta.cost_arg_index = Some(1),
|
||||||
|
4 => meta.cost_per_byte = 0,
|
||||||
|
5 => meta.attempt_cost_cycles = 1,
|
||||||
|
6 => meta.max_attempts = 1,
|
||||||
|
7 => meta.may_allocate = true,
|
||||||
|
8 => meta.mutates_guest_state = true,
|
||||||
|
9 => meta.deterministic = false,
|
||||||
|
10 => meta.ret_layout = &[AbiType::Scalar(S::Int64); 4],
|
||||||
|
11 => meta.ret_layout = &[AbiType::Scalar(S::Int64); 2],
|
||||||
|
12 => meta.ret_layout = &[AbiType::DynamicPayload],
|
||||||
|
13 => meta.arg_layout = &[AbiType::DynamicTag],
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
assert!(meta.validate_descriptor().is_err(), "variant {variant}");
|
||||||
|
}
|
||||||
|
let mut meta = *lookup_intrinsic_by_id(0x4100).unwrap();
|
||||||
|
meta.arg_nullable = &[true];
|
||||||
|
assert!(meta.validate_descriptor().is_err());
|
||||||
|
meta.arg_nullable = &[false];
|
||||||
|
meta.cost_arg_index = Some(0);
|
||||||
|
assert!(meta.validate_descriptor().is_err());
|
||||||
|
meta.cost_model = C::ArgumentUtf8BytesV1;
|
||||||
|
meta.cost_per_byte = 1;
|
||||||
|
assert!(meta.validate_descriptor().is_err());
|
||||||
|
meta.cost_model = C::RandomRejectionV1;
|
||||||
|
meta.cost_arg_index = None;
|
||||||
|
meta.cost_per_byte = 0;
|
||||||
|
meta.attempt_cost_cycles = 8;
|
||||||
|
meta.max_attempts = 64;
|
||||||
|
assert!(meta.validate_descriptor().is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn nullability_does_not_relax_existing_string_or_numeric_arguments() {
|
||||||
|
for id in [0x4100, 0x4101, 0x1103] {
|
||||||
|
assert!(
|
||||||
|
lookup_intrinsic_by_id(id).unwrap().validate_argument_values(&[Value::Null]).is_err()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
assert!(
|
||||||
|
lookup_intrinsic_by_id(0x4102).unwrap().validate_argument_values(&[Value::Null]).is_ok()
|
||||||
|
);
|
||||||
|
}
|
||||||
@@ -61,7 +61,9 @@ fn integer_limits_are_exact_and_abs_does_not_wrap() {
|
|||||||
] {
|
] {
|
||||||
assert_eq!(call(base, &[b.clone(), a.clone()]).unwrap(), a);
|
assert_eq!(call(base, &[b.clone(), a.clone()]).unwrap(), a);
|
||||||
assert_eq!(call(base + 1, &[a.clone(), b.clone()]).unwrap(), b);
|
assert_eq!(call(base + 1, &[a.clone(), b.clone()]).unwrap(), b);
|
||||||
assert!(matches!(call(base+3,&[a.clone()]),Err(E::Numeric(e)) if e.code==RANGE));
|
assert!(
|
||||||
|
matches!(call(base+3,std::slice::from_ref(&a)),Err(E::Numeric(e)) if e.code==RANGE)
|
||||||
|
);
|
||||||
assert!(matches!(call(base+2,&[b.clone(),b,a]),Err(E::Numeric(e)) if e.code==DOMAIN));
|
assert!(matches!(call(base+2,&[b.clone(),b,a]),Err(E::Numeric(e)) if e.code==DOMAIN));
|
||||||
}
|
}
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
|
|||||||
@@ -45,7 +45,7 @@ fn independent_words_signed_and_float_bits_for_all_seed_patterns() {
|
|||||||
});
|
});
|
||||||
}
|
}
|
||||||
code.push_str("RET");
|
code.push_str("RET");
|
||||||
let mut v = vm(&[(&code, sig(&[], &vec![if floating { 2 } else { 0 }; 8]), vec![], 1)]);
|
let mut v = vm(&[(&code, sig(&[], &[if floating { 2 } else { 0 }; 8]), vec![], 1)]);
|
||||||
let r = run(&mut v, 10000);
|
let r = run(&mut v, 10000);
|
||||||
assert_eq!(r.reason, End::EndOfRom);
|
assert_eq!(r.reason, End::EndOfRom);
|
||||||
let expected: Vec<_> = vectors(seed)
|
let expected: Vec<_> = vectors(seed)
|
||||||
|
|||||||
@@ -9,7 +9,7 @@ use prometeu_vm::{
|
|||||||
// Independent executable oracle: 32-byte header, eight directory entries,
|
// Independent executable oracle: 32-byte header, eight directory entries,
|
||||||
// payload at 128, one Bool import, one zero-slot HALT function; total 194.
|
// payload at 128, one Bool import, one zero-slot HALT function; total 194.
|
||||||
fn minimal() -> Vec<u8> {
|
fn minimal() -> Vec<u8> {
|
||||||
"50 42 58 00 01 00 00 00 08 00 00 00
|
"50 42 58 00 00 00 00 00 08 00 00 00
|
||||||
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
||||||
00 00 00 00 80 00 00 00 04 00 00 00
|
00 00 00 00 80 00 00 00 04 00 00 00
|
||||||
01 00 00 00 84 00 00 00 1e 00 00 00
|
01 00 00 00 84 00 00 00 1e 00 00 00
|
||||||
@@ -46,7 +46,7 @@ impl NativeInterface for Native {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn independent_v1_bytes_load_publish_and_execute_through_the_public_sealed_boundary() {
|
fn independent_v0_bytes_load_publish_and_execute_through_the_public_sealed_boundary() {
|
||||||
let bytes = minimal();
|
let bytes = minimal();
|
||||||
assert_eq!(bytes.len(), 194);
|
assert_eq!(bytes.len(), 194);
|
||||||
let mut load = LoadBudget::new(Default::default());
|
let mut load = LoadBudget::new(Default::default());
|
||||||
@@ -64,7 +64,7 @@ fn independent_v1_bytes_load_publish_and_execute_through_the_public_sealed_bound
|
|||||||
#[test]
|
#[test]
|
||||||
fn single_violation_oracles_reject_before_image_publication_with_typed_context() {
|
fn single_violation_oracles_reject_before_image_publication_with_typed_context() {
|
||||||
for (offset, replacement, code, reason, pc) in [
|
for (offset, replacement, code, reason, pc) in [
|
||||||
(4, 0, LoadCode::UnsupportedFormat, LoadReason::Version, None),
|
(4, 1, LoadCode::UnsupportedFormat, LoadReason::Version, None),
|
||||||
(178, 0, LoadCode::UnsupportedFormat, LoadReason::Builtin, None),
|
(178, 0, LoadCode::UnsupportedFormat, LoadReason::Builtin, None),
|
||||||
(162, 0xff, LoadCode::InvalidCode, LoadReason::UnknownOpcode, Some(0)),
|
(162, 0xff, LoadCode::InvalidCode, LoadReason::UnknownOpcode, Some(0)),
|
||||||
(162, 0x11, LoadCode::InvalidCode, LoadReason::StackUnderflow, Some(0)),
|
(162, 0x11, LoadCode::InvalidCode, LoadReason::StackUnderflow, Some(0)),
|
||||||
|
|||||||
@@ -0,0 +1,114 @@
|
|||||||
|
#![allow(dead_code)]
|
||||||
|
use prometeu_bytecode::{
|
||||||
|
assemble, load_limits::LoadBudget, model::ConstantPoolEntry, registry::*,
|
||||||
|
registry_codec::PbxModule,
|
||||||
|
};
|
||||||
|
use prometeu_vm::{
|
||||||
|
HostContext, HostReturn, LogicalFrameEndingReason, NativeInterface, ValidatedProgramImage,
|
||||||
|
VirtualMachine, VmInitError,
|
||||||
|
};
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
pub struct Native;
|
||||||
|
impl NativeInterface for Native {
|
||||||
|
fn syscall(
|
||||||
|
&mut self,
|
||||||
|
_: u32,
|
||||||
|
_: &[prometeu_bytecode::Value],
|
||||||
|
_: &mut HostReturn,
|
||||||
|
_: &mut HostContext,
|
||||||
|
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||||
|
panic!("identity corpus uses no host syscall")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn sig(parameters: &[u32], results: &[u32]) -> Signature {
|
||||||
|
Signature {
|
||||||
|
parameters: parameters
|
||||||
|
.iter()
|
||||||
|
.map(|&id| NamedType { type_id: TypeId(id), name: None })
|
||||||
|
.collect(),
|
||||||
|
results: results.iter().copied().map(TypeId).collect(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn types() -> Vec<TypeDecl> {
|
||||||
|
let field = || NamedType { type_id: TypeId(0), name: None };
|
||||||
|
vec![
|
||||||
|
TypeKind::Builtin(BuiltinId::INT64),
|
||||||
|
TypeKind::Builtin(BuiltinId::FLOAT),
|
||||||
|
TypeKind::Builtin(BuiltinId::BOOL),
|
||||||
|
TypeKind::Builtin(BuiltinId::STRING),
|
||||||
|
TypeKind::Builtin(BuiltinId::DYNAMIC),
|
||||||
|
TypeKind::Struct(vec![field()]),
|
||||||
|
TypeKind::Array(TypeId(0)),
|
||||||
|
TypeKind::Trait(vec![]),
|
||||||
|
TypeKind::Trait(vec![]),
|
||||||
|
TypeKind::Fn(sig(&[], &[])),
|
||||||
|
TypeKind::Builtin(BuiltinId::RANDOM),
|
||||||
|
TypeKind::Struct(vec![field()]),
|
||||||
|
TypeKind::Builtin(BuiltinId::COLOR),
|
||||||
|
TypeKind::Builtin(BuiltinId::VEC2),
|
||||||
|
TypeKind::Builtin(BuiltinId::PIXEL),
|
||||||
|
TypeKind::Builtin(BuiltinId::INT32),
|
||||||
|
]
|
||||||
|
.into_iter()
|
||||||
|
.map(|kind| TypeDecl { name: None, kind })
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
pub fn image(
|
||||||
|
bodies: &[(&str, Signature)],
|
||||||
|
constants: &[ConstantPoolEntry],
|
||||||
|
) -> Result<Arc<ValidatedProgramImage>, VmInitError> {
|
||||||
|
let mut code = vec![];
|
||||||
|
let mut functions = vec![];
|
||||||
|
for (source, signature) in bodies {
|
||||||
|
let body = assemble(source).unwrap();
|
||||||
|
functions.push(FunctionDecl {
|
||||||
|
signature: signature.clone(),
|
||||||
|
local_slots: 8,
|
||||||
|
max_stack_slots: 64,
|
||||||
|
code_offset: code.len() as u32,
|
||||||
|
code_len: body.len() as u32,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
code.extend(body);
|
||||||
|
}
|
||||||
|
let mut budget = LoadBudget::new(Default::default());
|
||||||
|
let registry = Registry::resolve(
|
||||||
|
RegistryDeclarations {
|
||||||
|
types: types(),
|
||||||
|
functions,
|
||||||
|
implementations: vec![
|
||||||
|
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(7), methods: vec![] },
|
||||||
|
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(8), methods: vec![] },
|
||||||
|
],
|
||||||
|
},
|
||||||
|
code.len(),
|
||||||
|
&mut budget,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let bytes = PbxModule {
|
||||||
|
registry: ®istry,
|
||||||
|
code: &code,
|
||||||
|
constants,
|
||||||
|
debug: None,
|
||||||
|
exports: &[],
|
||||||
|
syscalls: &[],
|
||||||
|
}
|
||||||
|
.serialize(&mut budget)
|
||||||
|
.unwrap();
|
||||||
|
ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0)
|
||||||
|
}
|
||||||
|
pub fn vm(bodies: &[(&str, Signature)], constants: &[ConstantPoolEntry]) -> VirtualMachine {
|
||||||
|
let mut vm = VirtualMachine::from_image(image(bodies, constants).unwrap(), Default::default());
|
||||||
|
vm.prepare_boot_call().unwrap();
|
||||||
|
vm
|
||||||
|
}
|
||||||
|
pub fn run(vm: &mut VirtualMachine) -> prometeu_vm::BudgetReport {
|
||||||
|
vm.run_budget(1_000_000, &mut Native, &mut HostContext::new(None)).unwrap()
|
||||||
|
}
|
||||||
|
pub fn step(vm: &mut VirtualMachine) -> Result<(), LogicalFrameEndingReason> {
|
||||||
|
vm.step(&mut Native, &mut HostContext::new(None))
|
||||||
|
}
|
||||||
|
pub fn hex_bytes(value: &str) -> Vec<u8> {
|
||||||
|
(0..value.len()).step_by(2).map(|i| u8::from_str_radix(&value[i..i + 2], 16).unwrap()).collect()
|
||||||
|
}
|
||||||
@@ -114,6 +114,111 @@ fn repository_sources_have_exactly_one_coverage_owner() {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn repository_policy(script: &str) -> Output {
|
||||||
|
Command::new("python3")
|
||||||
|
.arg("-B")
|
||||||
|
.arg("-c")
|
||||||
|
.arg(format!(
|
||||||
|
r#"
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
root = Path(sys.argv[1])
|
||||||
|
spec = importlib.util.spec_from_file_location("coverage_auditor", root / "scripts/audit-coverage-domains.py")
|
||||||
|
auditor = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(auditor)
|
||||||
|
config = json.loads((root / "files/config/runtime-edge-coverage-domains.json").read_text())
|
||||||
|
domains = config["domains"]
|
||||||
|
trees = [
|
||||||
|
("crates/console/prometeu-system/src/services/memcard", "system/fs", "system/core"),
|
||||||
|
("crates/console/prometeu-drivers/src/asset", "asset/bank", "drivers/core"),
|
||||||
|
]
|
||||||
|
{script}
|
||||||
|
"#
|
||||||
|
))
|
||||||
|
.arg(repository())
|
||||||
|
.output()
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn specialized_entry_files_and_all_descendants_have_the_expected_owner() {
|
||||||
|
success(repository_policy(
|
||||||
|
r#"
|
||||||
|
for stem, expected, residual in trees:
|
||||||
|
names = [stem + ".rs"]
|
||||||
|
descendants = sorted((root / stem).rglob("*.rs"))
|
||||||
|
assert descendants, stem
|
||||||
|
names += [path.relative_to(root).as_posix() for path in descendants]
|
||||||
|
names += [stem + "/future.rs", stem + "/future/nested.rs"]
|
||||||
|
for name in names:
|
||||||
|
actual = auditor.owners(name, domains)
|
||||||
|
assert actual == [expected], (name, expected, actual)
|
||||||
|
# Exclusive residual fallback would pass the generic audit but is wrong.
|
||||||
|
import copy
|
||||||
|
fallback = copy.deepcopy(domains)
|
||||||
|
fallback[expected]["paths"].remove(stem + "/")
|
||||||
|
fallback[residual]["exclude_paths"].remove(stem + "/")
|
||||||
|
name = names[-1]
|
||||||
|
assert auditor.owners(name, fallback) == [residual]
|
||||||
|
assert auditor.owners(name, fallback) != [expected]
|
||||||
|
overlap = copy.deepcopy(domains)
|
||||||
|
overlap[residual]["exclude_paths"].remove(stem + "/")
|
||||||
|
assert set(auditor.owners(name, overlap)) == {expected, residual}
|
||||||
|
"#,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn specialized_ownership_survives_absent_and_zero_instrumentation() {
|
||||||
|
success(repository_policy(
|
||||||
|
r#"
|
||||||
|
import tempfile
|
||||||
|
with tempfile.TemporaryDirectory(prefix="prometeu-domain-trees-") as directory:
|
||||||
|
fixture = Path(directory)
|
||||||
|
records = []
|
||||||
|
# Use the real map and source layout, with independent synthetic evidence.
|
||||||
|
for source in (root / "crates").glob("**/src/**/*.rs"):
|
||||||
|
name = source.relative_to(root).as_posix()
|
||||||
|
path = fixture / name
|
||||||
|
path.parent.mkdir(parents=True, exist_ok=True)
|
||||||
|
path.write_text("// ownership fixture\n")
|
||||||
|
records.append({"filename": name, "summary": {"lines": {"count": 1, "covered": 1}}})
|
||||||
|
for stem, expected, residual in trees:
|
||||||
|
for suffix in ["future/absent.rs", "future/zero.rs"]:
|
||||||
|
path = fixture / stem / suffix
|
||||||
|
path.parent.mkdir(parents=True, exist_ok=True)
|
||||||
|
path.write_text("// no executable lines\n")
|
||||||
|
records.append({"filename": stem + "/future/zero.rs", "summary": {"lines": {"count": 0, "covered": 0}}})
|
||||||
|
config_path = fixture / "config.json"
|
||||||
|
config_path.write_text(json.dumps(config))
|
||||||
|
report_path = fixture / "report.json"
|
||||||
|
report_path.write_text(json.dumps({"data": [{"files": records}]}))
|
||||||
|
before = auditor.audit(root, root / "files/config/runtime-edge-coverage-domains.json")
|
||||||
|
result = auditor.audit(fixture, config_path, report_path)
|
||||||
|
assert len(result["domains"]) == 15
|
||||||
|
assert all(domain["gate_passed"] for domain in result["domains"].values())
|
||||||
|
for stem, expected, residual in trees:
|
||||||
|
domain = result["domains"][expected]
|
||||||
|
assert domain["source_files"] == before["domains"][expected]["source_files"] + 2
|
||||||
|
assert stem + "/future/zero.rs" in domain["files"]
|
||||||
|
assert stem + "/future/absent.rs" not in domain["files"]
|
||||||
|
assert result["domains"][residual]["source_files"] == before["domains"][residual]["source_files"]
|
||||||
|
# Missing residual exclusions must fail even for sources absent from reports.
|
||||||
|
for stem, expected, residual in trees:
|
||||||
|
domains[residual]["exclude_paths"].remove(stem + "/")
|
||||||
|
config_path.write_text(json.dumps(config))
|
||||||
|
try:
|
||||||
|
auditor.audit(fixture, config_path, report_path)
|
||||||
|
except auditor.AuditError as error:
|
||||||
|
assert "expected exactly one domain" in str(error), error
|
||||||
|
else:
|
||||||
|
raise AssertionError("overlapping module trees passed ownership audit")
|
||||||
|
"#,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn exclusions_and_absolute_relative_report_names_have_exclusive_ownership() {
|
fn exclusions_and_absolute_relative_report_names_have_exclusive_ownership() {
|
||||||
let fixture = Fixture::new();
|
let fixture = Fixture::new();
|
||||||
|
|||||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user