Compare commits
1
Commits
master
..
22769aa438
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
22769aa438
|
@@ -13,15 +13,14 @@ jobs:
|
|||||||
with:
|
with:
|
||||||
submodules: recursive
|
submodules: recursive
|
||||||
|
|
||||||
- name: Install repository Rust toolchain
|
- uses: dtolnay/rust-toolchain@stable
|
||||||
run: |
|
with:
|
||||||
toolchain=$(python3 -c 'import tomllib; print(tomllib.load(open("rust-toolchain.toml", "rb"))["toolchain"]["channel"])')
|
components: rustfmt, clippy, llvm-tools-preview
|
||||||
rustup toolchain install "$toolchain" --profile minimal
|
|
||||||
|
|
||||||
- uses: Swatinem/rust-cache@v2
|
- uses: Swatinem/rust-cache@v2
|
||||||
|
|
||||||
- name: Discard reports from previous runs
|
- name: Discard reports from previous runs
|
||||||
run: rm -rf target/llvm-cov
|
run: rm -rf target/quality-gate target/llvm-cov
|
||||||
|
|
||||||
- name: Provision quality-gate tools and native dependencies
|
- name: Provision quality-gate tools and native dependencies
|
||||||
run: bash scripts/provision-quality-gate.sh
|
run: bash scripts/provision-quality-gate.sh
|
||||||
@@ -35,5 +34,6 @@ jobs:
|
|||||||
with:
|
with:
|
||||||
name: quality-gate-${{ runner.os }}-${{ github.sha }}
|
name: quality-gate-${{ runner.os }}-${{ github.sha }}
|
||||||
path: |
|
path: |
|
||||||
|
target/quality-gate/**
|
||||||
target/llvm-cov/**
|
target/llvm-cov/**
|
||||||
if-no-files-found: warn
|
if-no-files-found: warn
|
||||||
|
|||||||
@@ -66,3 +66,7 @@ AGENTS.md
|
|||||||
|
|
||||||
.python-version
|
.python-version
|
||||||
.venv
|
.venv
|
||||||
|
|
||||||
|
discussion/*
|
||||||
|
!discussion/lessons/
|
||||||
|
!discussion/lessons/**
|
||||||
|
|||||||
Generated
-4
@@ -1883,7 +1883,6 @@ dependencies = [
|
|||||||
"anyhow",
|
"anyhow",
|
||||||
"prometeu-bytecode",
|
"prometeu-bytecode",
|
||||||
"prometeu-hal",
|
"prometeu-hal",
|
||||||
"prometeu-host-headless",
|
|
||||||
"serde_json",
|
"serde_json",
|
||||||
]
|
]
|
||||||
|
|
||||||
@@ -1893,10 +1892,7 @@ version = "0.1.0"
|
|||||||
dependencies = [
|
dependencies = [
|
||||||
"anyhow",
|
"anyhow",
|
||||||
"prometeu-bytecode",
|
"prometeu-bytecode",
|
||||||
"prometeu-drivers",
|
|
||||||
"prometeu-hal",
|
"prometeu-hal",
|
||||||
"prometeu-host-headless",
|
|
||||||
"prometeu-vm",
|
|
||||||
"serde_json",
|
"serde_json",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|||||||
@@ -1,4 +1,4 @@
|
|||||||
.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
|
.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 test-quality-gate cobertura
|
||||||
|
|
||||||
fmt:
|
fmt:
|
||||||
cargo fmt --all
|
cargo fmt --all
|
||||||
@@ -9,15 +9,8 @@ fmt-check:
|
|||||||
clippy:
|
clippy:
|
||||||
cargo clippy --workspace --all-targets --all-features -- -D warnings
|
cargo clippy --workspace --all-targets --all-features -- -D warnings
|
||||||
|
|
||||||
test-unit:
|
test-local:
|
||||||
cargo test --workspace --lib --bins --all-features --no-fail-fast
|
cargo test --workspace --all-targets --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 runner::tests -- --ignored
|
cargo test -p prometeu-host-desktop-winit --lib runner::tests -- --ignored
|
||||||
@@ -26,7 +19,7 @@ clean:
|
|||||||
cargo llvm-cov clean --workspace
|
cargo llvm-cov clean --workspace
|
||||||
|
|
||||||
coverage:
|
coverage:
|
||||||
cargo llvm-cov --workspace --lib --bins --all-features --html --output-dir target/llvm-cov
|
cargo llvm-cov --workspace --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
|
||||||
@@ -53,13 +46,15 @@ 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-unit
|
test: fmt-check clippy test-local test-debugger-socket
|
||||||
# Local and GitHub entry point; Jenkins exposes the same targets as stages.
|
# Keep the step list here: CI providers consume the repository contract.
|
||||||
CI_DOMAIN_STEPS = clean fmt-check clippy test-unit coverage coverage-report-json coverage-xml coverage-json coverage-domain-audit coverage-domain-gate
|
# The runner executes each step serially even if the caller supplies make -j.
|
||||||
|
CI_DOMAIN_STEPS = clean fmt-check clippy test-quality-gate test-local test-debugger-socket coverage coverage-report-json coverage-xml coverage-json coverage-domain-audit coverage-domain-gate
|
||||||
|
|
||||||
ci: ci-domains
|
ci: ci-domains
|
||||||
ci-domains:
|
ci-domains:
|
||||||
rm -rf target/llvm-cov
|
python3 scripts/run-quality-gate.py $(CI_DOMAIN_STEPS)
|
||||||
+@set -e; for step in $(CI_DOMAIN_STEPS); do $(MAKE) --no-print-directory -j1 $$step; done
|
|
||||||
|
|
||||||
|
test-quality-gate:
|
||||||
|
python3 -B -m unittest discover -s scripts/tests -p 'test_quality_gate.py'
|
||||||
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 engineering lessons.
|
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.
|
||||||
|
|
||||||
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;
|
||||||
- engineering lessons learned.
|
- discussion workflow and 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/lessons/`: published engineering lessons and supporting assets
|
- `discussion/`: agendas, decisions, plans, and lessons for architectural work
|
||||||
- `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,11 +29,7 @@ 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
|
||||||
- [Engineering lessons](discussion/lessons/): published results and rationale
|
- [Discussion workflow](discussion/index.ndjson): architectural agenda, decision, and execution traceability
|
||||||
|
|
||||||
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
|
||||||
|
|
||||||
@@ -64,21 +60,11 @@ Other ecosystem commands, such as build, pack, and verification tooling, are not
|
|||||||
|
|
||||||
## Requirements
|
## Requirements
|
||||||
|
|
||||||
- Rust **1.98.1**, pinned in [rust-toolchain.toml](rust-toolchain.toml)
|
- Rust toolchain from [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:
|
||||||
@@ -133,14 +119,7 @@ The authoritative target used by both GitHub and Jenkins is:
|
|||||||
make ci-domains
|
make ci-domains
|
||||||
```
|
```
|
||||||
|
|
||||||
`make test-unit` selects library and binary unit-test harnesses with
|
The five debugger socket tests bind localhost sockets and are marked ignored in Rust test metadata; both `make test` and `make ci-domains` select only `runner::tests` through `test-debugger-socket`. Physical audio and other manual probes remain opt-in. See [quality-gate prerequisites and commands](docs/vm-arch/COVERAGE_DOMAINS.md#commands-and-ci).
|
||||||
`--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
|
||||||
|
|
||||||
@@ -166,6 +145,7 @@ This produces:
|
|||||||
- `target/llvm-cov/report.json`
|
- `target/llvm-cov/report.json`
|
||||||
- `target/llvm-cov/summary.json`
|
- `target/llvm-cov/summary.json`
|
||||||
- `target/llvm-cov/cobertura.xml`
|
- `target/llvm-cov/cobertura.xml`
|
||||||
|
- `target/quality-gate/metadata.json` and per-step logs
|
||||||
|
|
||||||
Domain-oriented evidence helpers:
|
Domain-oriented evidence helpers:
|
||||||
|
|
||||||
@@ -177,7 +157,7 @@ make coverage-domain-evidence DOMAIN=host/headless
|
|||||||
```
|
```
|
||||||
|
|
||||||
`make ci-domains` runs formatting, strict workspace/all-target/all-feature Clippy,
|
`make ci-domains` runs formatting, strict workspace/all-target/all-feature Clippy,
|
||||||
library/binary unit tests, fresh unit-only coverage and every domain
|
all-target tests, the five debugger socket tests, fresh coverage and every domain
|
||||||
ownership/evidence gate. Both CI providers archive available evidence on failure.
|
ownership/evidence gate. Both CI providers archive available evidence on failure.
|
||||||
A failing run never lowers a configured floor; local and CI checks use the same
|
A failing run never lowers a configured floor; local and CI checks use the same
|
||||||
repository-owned commands. Reports identify their revision, source/configuration
|
repository-owned commands. Reports identify their revision, source/configuration
|
||||||
@@ -194,7 +174,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 AI Engineering;
|
- the machine contract is being clarified through the specs and discussion workflow;
|
||||||
- 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" | "ARRAY_COPY" => {
|
"STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" => {
|
||||||
if ops.is_empty() {
|
if ops.is_empty() {
|
||||||
return Err(AsmError::MissingOperand(line.into()));
|
return Err(AsmError::MissingOperand(line.into()));
|
||||||
}
|
}
|
||||||
@@ -354,32 +354,23 @@ 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" | "REF_IDENTITY_HASH" => {
|
"DYN_PACK" | "DYN_UNPACK" | "DYN_CAN_UNPACK" => {
|
||||||
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,14 +65,12 @@ 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)
|
||||||
}
|
}
|
||||||
@@ -81,11 +79,6 @@ 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 v0 resource limits and structured validation failures.
|
//! Shared PBX v1 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,10 +192,6 @@ 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,
|
||||||
@@ -205,8 +201,6 @@ 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 {
|
||||||
@@ -273,8 +267,6 @@ 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),
|
||||||
@@ -282,7 +274,6 @@ 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)),
|
||||||
}
|
}
|
||||||
@@ -353,8 +344,6 @@ 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,
|
||||||
@@ -362,7 +351,6 @@ impl OpCode {
|
|||||||
OpCode::ArrayLen => 3,
|
OpCode::ArrayLen => 3,
|
||||||
OpCode::ArrayGet => 3,
|
OpCode::ArrayGet => 3,
|
||||||
OpCode::ArraySet => 4,
|
OpCode::ArraySet => 4,
|
||||||
OpCode::ArrayCopy => 4,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -596,26 +596,6 @@ 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,
|
||||||
@@ -686,16 +666,6 @@ 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,19 +52,6 @@ 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 v0 envelope and Registry sections. No legacy fallback.
|
//! Strict PBX v1 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] != [0, 0] {
|
if bytes[4..6] != [1, 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 v0 envelope writer. Non-Registry section bytes must
|
/// Raw section input for a v1 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 v0 sections. The output buffer is charged to temporary load storage.
|
/// Assemble strict v1 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(&[0, 0, 0, 0]);
|
out.extend_from_slice(&[1, 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 v0 tables for the executable loader. This is not an
|
/// Owned, bounded PBX v1 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 v0; executable consumers still need bindings and code verification.
|
//! only v1; 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,29 +133,6 @@ 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,8 +34,6 @@ 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);
|
||||||
@@ -51,8 +49,8 @@ fn all_typed_instructions_match_independent_bytes_and_costs() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
assert!(matches!(
|
assert!(matches!(
|
||||||
decode_next(0, &[0x99, 0]),
|
decode_next(0, &[0x97, 0]),
|
||||||
Err(DecodeError::UnknownOpcode { opcode: 0x99, .. })
|
Err(DecodeError::UnknownOpcode { opcode: 0x97, .. })
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
@@ -70,8 +68,6 @@ 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!(
|
||||||
@@ -98,9 +94,6 @@ 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();
|
||||||
@@ -121,10 +114,6 @@ 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}");
|
||||||
}
|
}
|
||||||
@@ -215,62 +204,3 @@ 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 00 00 00 00 08 00 00 00
|
50 42 58 00 01 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_v0_decoder_accepts_independent_bytes_without_publishing_an_image() {
|
fn owned_v1_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, 1, LoadCode::UnsupportedFormat, LoadReason::Version),
|
(4, 0, 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),
|
||||||
@@ -1,256 +0,0 @@
|
|||||||
//! Repeatable CPU/memory observations, not a handheld or physical-device guarantee.
|
|
||||||
use prometeu_drivers::{
|
|
||||||
Audio, MemoryBanks, SoundBankPoolInstaller,
|
|
||||||
bank_format::{decode_audio_bank, encode_ima_wav4},
|
|
||||||
engine::{AudioMixer, Packet},
|
|
||||||
};
|
|
||||||
use prometeu_hal::{
|
|
||||||
AudioBridge, LoopMode,
|
|
||||||
audio_bridge::AudioControl,
|
|
||||||
music_bank::{Instrument, MusicBank, MusicEvent},
|
|
||||||
sample::Sample,
|
|
||||||
sound_bank::SoundBank,
|
|
||||||
};
|
|
||||||
use serde_json::{Value, json};
|
|
||||||
use std::{
|
|
||||||
alloc::{GlobalAlloc, Layout, System},
|
|
||||||
sync::{
|
|
||||||
Arc,
|
|
||||||
atomic::{AtomicUsize, Ordering},
|
|
||||||
},
|
|
||||||
time::Instant,
|
|
||||||
};
|
|
||||||
struct Counter;
|
|
||||||
static LIVE: AtomicUsize = AtomicUsize::new(0);
|
|
||||||
static PEAK: AtomicUsize = AtomicUsize::new(0);
|
|
||||||
unsafe impl GlobalAlloc for Counter {
|
|
||||||
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
|
|
||||||
let p = unsafe { System.alloc(l) };
|
|
||||||
if !p.is_null() {
|
|
||||||
let n = LIVE.fetch_add(l.size(), Ordering::Relaxed) + l.size();
|
|
||||||
PEAK.fetch_max(n, Ordering::Relaxed);
|
|
||||||
}
|
|
||||||
p
|
|
||||||
}
|
|
||||||
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
|
|
||||||
LIVE.fetch_sub(l.size(), Ordering::Relaxed);
|
|
||||||
unsafe { System.dealloc(p, l) }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[global_allocator]
|
|
||||||
static ALLOCATOR: Counter = Counter;
|
|
||||||
fn stats(values: &mut [u64]) -> Value {
|
|
||||||
values.sort_unstable();
|
|
||||||
let n = values.len();
|
|
||||||
json!({"p50_ns":values[n/2],"p95_ns":values[n*95/100],"p99_ns":values[n*99/100],"max_ns":values[n-1]})
|
|
||||||
}
|
|
||||||
fn music(channels: u8) -> Arc<MusicBank> {
|
|
||||||
let pcm = (0..4096)
|
|
||||||
.flat_map(|i| {
|
|
||||||
std::iter::repeat_n(((i as f64 * 0.05).sin() * 800.0) as i16, channels as usize)
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
let sample =
|
|
||||||
Arc::new(Sample::new(48000, pcm).with_channels(channels).unwrap().with_loop(0, 4096));
|
|
||||||
let events = (0..12)
|
|
||||||
.map(|id| MusicEvent { kind: 1, a: id, c: 60 + id as i32, d: 180, ..Default::default() })
|
|
||||||
.collect();
|
|
||||||
Arc::new(
|
|
||||||
MusicBank::compile(
|
|
||||||
"measure".into(),
|
|
||||||
vec![sample],
|
|
||||||
vec![Instrument {
|
|
||||||
looping: true,
|
|
||||||
attack_us: 1000,
|
|
||||||
decay_us: 10_000,
|
|
||||||
sustain: 50000,
|
|
||||||
release_us: 10_000,
|
|
||||||
send: 20000,
|
|
||||||
vibrato_cents: 10,
|
|
||||||
vibrato_millihz: 5000,
|
|
||||||
tremolo_depth: 1000,
|
|
||||||
tremolo_millihz: 3000,
|
|
||||||
..Default::default()
|
|
||||||
}],
|
|
||||||
events,
|
|
||||||
960,
|
|
||||||
500000,
|
|
||||||
3840,
|
|
||||||
None,
|
|
||||||
1,
|
|
||||||
)
|
|
||||||
.unwrap(),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
fn scenario(channels: u8, dsp: bool, replacement: bool) -> Value {
|
|
||||||
let banks = Arc::new(MemoryBanks::new());
|
|
||||||
let mut audio = Audio::new(banks.clone());
|
|
||||||
banks.install_music_bank(0, music(channels));
|
|
||||||
banks.install_music_bank(1, music(channels));
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.music_play(1, 1, true);
|
|
||||||
let sample = Arc::new(
|
|
||||||
Sample::new(48000, vec![500; 4096 * channels as usize])
|
|
||||||
.with_channels(channels)
|
|
||||||
.unwrap()
|
|
||||||
.with_loop(0, 4096),
|
|
||||||
);
|
|
||||||
for voice in 0..8 {
|
|
||||||
audio.play_sample(sample.clone(), voice, 255, 128, 1.0, 0, LoopMode::On);
|
|
||||||
audio.control(AudioControl::SfxSend { voice, gain: 100 });
|
|
||||||
}
|
|
||||||
if dsp {
|
|
||||||
for group in 0..3 {
|
|
||||||
audio.control(AudioControl::Effect {
|
|
||||||
group,
|
|
||||||
cutoff_hz: 6000,
|
|
||||||
delay_frames: 4800,
|
|
||||||
feedback: 0.5,
|
|
||||||
wet: 0.3,
|
|
||||||
dry: 0.7,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
}
|
|
||||||
audio.finish_frame();
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
let mut packet = Packet::new();
|
|
||||||
mixer.apply_delivery_into(audio.transport().try_take().unwrap(), &mut packet);
|
|
||||||
packet.recycle(&audio.transport());
|
|
||||||
let mut pcm = [0.0; 512];
|
|
||||||
let mut timings = Vec::with_capacity(1000);
|
|
||||||
let mut overruns = 0;
|
|
||||||
let mut max_retired = 0;
|
|
||||||
let baseline = LIVE.load(Ordering::Relaxed);
|
|
||||||
PEAK.store(baseline, Ordering::Relaxed);
|
|
||||||
for iteration in 0..1000 {
|
|
||||||
if replacement && iteration % 10 == 0 {
|
|
||||||
banks.install_music_bank(0, music(channels));
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.control(AudioControl::MusicFade {
|
|
||||||
group: 1,
|
|
||||||
gain: 180,
|
|
||||||
frames: 2400,
|
|
||||||
smooth: true,
|
|
||||||
});
|
|
||||||
audio.finish_frame();
|
|
||||||
}
|
|
||||||
let start = Instant::now();
|
|
||||||
mixer.retire_inactive(&mut packet);
|
|
||||||
if let Some(delivery) = audio.transport().try_take() {
|
|
||||||
mixer.apply_delivery_into(delivery, &mut packet);
|
|
||||||
}
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
mixer.retire_inactive(&mut packet);
|
|
||||||
let elapsed = start.elapsed().as_nanos() as u64;
|
|
||||||
if elapsed > 5_333_333 {
|
|
||||||
overruns += 1;
|
|
||||||
}
|
|
||||||
timings.push(elapsed);
|
|
||||||
max_retired = max_retired.max(packet.retained_pcm_bytes());
|
|
||||||
packet.recycle(&audio.transport());
|
|
||||||
std::hint::black_box(&pcm);
|
|
||||||
}
|
|
||||||
json!({"channels_per_voice":channels,"dsp":dsp,"replacement_every_10_buffers":replacement,"buffers":1000,"frames_per_buffer":256,"nominal_buffer_ns":5_333_333,"observed_budget_overruns":overruns,"timing":stats(&mut timings),"maximum_active_voices":mixer.diagnostics.maximum_voices,"engine_prepared_bytes":mixer.prepared_bytes(),"maximum_retired_pcm_bytes":max_retired,"baseline_allocated_bytes":baseline,"peak_allocated_bytes":PEAK.load(Ordering::Relaxed)})
|
|
||||||
}
|
|
||||||
fn codec_and_memory() -> Value {
|
|
||||||
let pcm: Vec<i16> = (0..480_000)
|
|
||||||
.flat_map(|i| {
|
|
||||||
[((i as f64 * 0.04).sin() * 12000.0) as i16, ((i as f64 * 0.06).cos() * 9000.0) as i16]
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
let start = Instant::now();
|
|
||||||
let compressed = encode_ima_wav4(&pcm, 2, 512).unwrap();
|
|
||||||
let encode_ns = start.elapsed().as_nanos();
|
|
||||||
let mut bytes = vec![0u8; 88];
|
|
||||||
bytes[..4].copy_from_slice(b"SBNK");
|
|
||||||
bytes[4] = 1;
|
|
||||||
bytes[48] = 1;
|
|
||||||
bytes[49] = 2;
|
|
||||||
bytes[80] = 255;
|
|
||||||
bytes[81] = 128;
|
|
||||||
for (at, n) in [
|
|
||||||
(8, 1u32),
|
|
||||||
(20, 960),
|
|
||||||
(24, 500000),
|
|
||||||
(32, u32::MAX),
|
|
||||||
(52, 48000),
|
|
||||||
(56, 480000),
|
|
||||||
(68, 88),
|
|
||||||
(72, compressed.len() as u32),
|
|
||||||
(84, 65536),
|
|
||||||
] {
|
|
||||||
bytes[at..at + 4].copy_from_slice(&n.to_le_bytes());
|
|
||||||
}
|
|
||||||
bytes[76..78].copy_from_slice(&512u16.to_le_bytes());
|
|
||||||
bytes[78..80].copy_from_slice(&505u16.to_le_bytes());
|
|
||||||
bytes.extend(&compressed);
|
|
||||||
let mut decode = Vec::with_capacity(20);
|
|
||||||
let baseline = LIVE.load(Ordering::Relaxed);
|
|
||||||
PEAK.store(baseline, Ordering::Relaxed);
|
|
||||||
for _ in 0..20 {
|
|
||||||
let start = Instant::now();
|
|
||||||
let bank = decode_audio_bank(&bytes, false).unwrap();
|
|
||||||
decode.push(start.elapsed().as_nanos() as u64);
|
|
||||||
std::hint::black_box(bank);
|
|
||||||
}
|
|
||||||
let decode_peak = PEAK.load(Ordering::Relaxed);
|
|
||||||
let banks = MemoryBanks::new();
|
|
||||||
for slot in 0..16 {
|
|
||||||
banks.install_sound_bank(
|
|
||||||
slot,
|
|
||||||
Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48000, vec![0; 1_048_576]))])),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
let large_music = || {
|
|
||||||
let sample = Arc::new(Sample::new(48000, vec![0; 1_048_576]).with_loop(0, 1_048_576));
|
|
||||||
Arc::new(
|
|
||||||
MusicBank::compile(
|
|
||||||
"large".into(),
|
|
||||||
vec![sample],
|
|
||||||
vec![Instrument { looping: true, ..Default::default() }],
|
|
||||||
vec![MusicEvent { kind: 1, a: 1, c: 60, d: 255, ..Default::default() }],
|
|
||||||
960,
|
|
||||||
500000,
|
|
||||||
3840,
|
|
||||||
None,
|
|
||||||
1,
|
|
||||||
)
|
|
||||||
.unwrap(),
|
|
||||||
)
|
|
||||||
};
|
|
||||||
for slot in 0..16 {
|
|
||||||
banks.install_music_bank(slot, large_music());
|
|
||||||
}
|
|
||||||
let snapshot = banks.audio_memory();
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
let mut packet = Packet::new();
|
|
||||||
use prometeu_drivers::SoundBankPoolAccess;
|
|
||||||
mixer.apply_delivery_into(
|
|
||||||
prometeu_drivers::AudioDelivery {
|
|
||||||
epoch: 0,
|
|
||||||
paused: false,
|
|
||||||
frame: Some(vec![prometeu_drivers::AudioCommand::MusicPlay {
|
|
||||||
group: 0,
|
|
||||||
bank: banks.music_bank_slot(0).unwrap(),
|
|
||||||
looping: true,
|
|
||||||
}]),
|
|
||||||
lifecycle: None,
|
|
||||||
},
|
|
||||||
&mut packet,
|
|
||||||
);
|
|
||||||
packet.recycle(&prometeu_drivers::AudioTransport::default());
|
|
||||||
mixer.mix(&mut [0.0; 2]);
|
|
||||||
let before = LIVE.load(Ordering::Relaxed);
|
|
||||||
PEAK.store(before, Ordering::Relaxed);
|
|
||||||
banks.install_music_bank(0, large_music());
|
|
||||||
mixer.retire_inactive(&mut packet);
|
|
||||||
let retired = packet.retained_pcm_bytes();
|
|
||||||
let replacement_peak = PEAK.load(Ordering::Relaxed);
|
|
||||||
packet.recycle(&prometeu_drivers::AudioTransport::default());
|
|
||||||
let after = LIVE.load(Ordering::Relaxed);
|
|
||||||
|
|
||||||
json!({"source_frames":480000,"channels":2,"pcm_bytes":pcm.len()*2,"cartridge_sample_bytes":compressed.len(),"compression_ratio":compressed.len()as f64/(pcm.len()*2)as f64,"encode_ns":encode_ns,"decode_timing":stats(&mut decode),"decode_baseline_allocated_bytes":baseline,"decode_peak_allocated_bytes":decode_peak,"large_bank_count":snapshot.banks.len(),"large_banks_unique_pcm_bytes":snapshot.unique_pcm_bytes,"replacement_baseline_allocated_bytes":before,"replacement_peak_allocated_bytes":replacement_peak,"replacement_after_reclamation_bytes":after,"retained_replaced_pcm_bytes":retired,"resident_accounted_metadata_bytes":snapshot.metadata_bytes,"resident_total_accounted_bytes":snapshot.total_accounted_bytes})
|
|
||||||
}
|
|
||||||
fn main() {
|
|
||||||
println!("{}",serde_json::to_string_pretty(&json!({"arch":std::env::consts::ARCH,"os":std::env::consts::OS,"observations":[scenario(1,false,false),scenario(2,false,false),scenario(2,true,false),scenario(2,true,true)],"codecs_and_memory":codec_and_memory()})).unwrap());
|
|
||||||
}
|
|
||||||
@@ -1,185 +0,0 @@
|
|||||||
//! 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,7 +1,6 @@
|
|||||||
#![allow(clippy::collapsible_if)]
|
#![allow(clippy::collapsible_if)]
|
||||||
mod decode;
|
mod decode;
|
||||||
mod resumable;
|
mod resumable;
|
||||||
use crate::audio::bank_format::{DecodedAudioBank, decode_audio_bank};
|
|
||||||
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
|
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
|
||||||
use prometeu_hal::AssetBridge;
|
use prometeu_hal::AssetBridge;
|
||||||
use prometeu_hal::asset::{
|
use prometeu_hal::asset::{
|
||||||
@@ -15,7 +14,7 @@ use prometeu_hal::cartridge::AssetsPayloadSource;
|
|||||||
use prometeu_hal::color::Color;
|
use prometeu_hal::color::Color;
|
||||||
use prometeu_hal::glyph::Glyph;
|
use prometeu_hal::glyph::Glyph;
|
||||||
use prometeu_hal::glyph_bank::{GlyphBank, TileSize};
|
use prometeu_hal::glyph_bank::{GlyphBank, TileSize};
|
||||||
use prometeu_hal::music_bank::MusicBank;
|
use prometeu_hal::sample::Sample;
|
||||||
use prometeu_hal::scene_bank::SceneBank;
|
use prometeu_hal::scene_bank::SceneBank;
|
||||||
use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer};
|
use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer};
|
||||||
use prometeu_hal::sound_bank::SoundBank;
|
use prometeu_hal::sound_bank::SoundBank;
|
||||||
@@ -62,7 +61,6 @@ pub struct AssetPipelineTelemetry {
|
|||||||
pub active_progress: u16,
|
pub active_progress: u16,
|
||||||
pub glyph_latency: AssetLatencyPercentiles,
|
pub glyph_latency: AssetLatencyPercentiles,
|
||||||
pub sound_latency: AssetLatencyPercentiles,
|
pub sound_latency: AssetLatencyPercentiles,
|
||||||
pub music_latency: AssetLatencyPercentiles,
|
|
||||||
pub scene_latency: AssetLatencyPercentiles,
|
pub scene_latency: AssetLatencyPercentiles,
|
||||||
pub last_asset_id: Option<AssetId>,
|
pub last_asset_id: Option<AssetId>,
|
||||||
pub last_asset_latency: AssetLatencyPercentiles,
|
pub last_asset_latency: AssetLatencyPercentiles,
|
||||||
@@ -132,7 +130,6 @@ impl AssetPipelineTelemetryState {
|
|||||||
);
|
);
|
||||||
self.snapshot.glyph_latency = percentile_snapshot(self.bank_samples.get(&BankType::GLYPH));
|
self.snapshot.glyph_latency = percentile_snapshot(self.bank_samples.get(&BankType::GLYPH));
|
||||||
self.snapshot.sound_latency = percentile_snapshot(self.bank_samples.get(&BankType::SOUNDS));
|
self.snapshot.sound_latency = percentile_snapshot(self.bank_samples.get(&BankType::SOUNDS));
|
||||||
self.snapshot.music_latency = percentile_snapshot(self.bank_samples.get(&BankType::MUSIC));
|
|
||||||
self.snapshot.scene_latency = percentile_snapshot(self.bank_samples.get(&BankType::SCENE));
|
self.snapshot.scene_latency = percentile_snapshot(self.bank_samples.get(&BankType::SCENE));
|
||||||
self.snapshot.last_asset_id = Some(asset_id);
|
self.snapshot.last_asset_id = Some(asset_id);
|
||||||
self.snapshot.last_asset_latency = percentile_snapshot(self.asset_samples.get(&asset_id));
|
self.snapshot.last_asset_latency = percentile_snapshot(self.asset_samples.get(&asset_id));
|
||||||
@@ -332,14 +329,12 @@ pub struct AssetManager {
|
|||||||
gfx_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
gfx_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
||||||
glyph_slot_index: GlyphAssetSlotIndex,
|
glyph_slot_index: GlyphAssetSlotIndex,
|
||||||
sound_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
sound_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
||||||
music_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
|
||||||
scene_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
scene_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
|
||||||
|
|
||||||
/// Residency policy for GFX glyph banks.
|
/// Residency policy for GFX glyph banks.
|
||||||
gfx_policy: BankPolicy<GlyphBank>,
|
gfx_policy: BankPolicy<GlyphBank>,
|
||||||
/// Residency policy for sound banks.
|
/// Residency policy for sound banks.
|
||||||
sound_policy: BankPolicy<SoundBank>,
|
sound_policy: BankPolicy<SoundBank>,
|
||||||
music_policy: BankPolicy<MusicBank>,
|
|
||||||
/// Residency policy for scene banks.
|
/// Residency policy for scene banks.
|
||||||
scene_policy: BankPolicy<SceneBank>,
|
scene_policy: BankPolicy<SceneBank>,
|
||||||
|
|
||||||
@@ -375,7 +370,6 @@ struct AssetLoadJobResources<'a> {
|
|||||||
pipeline_telemetry: &'a Arc<Mutex<AssetPipelineTelemetryState>>,
|
pipeline_telemetry: &'a Arc<Mutex<AssetPipelineTelemetryState>>,
|
||||||
gfx_policy: &'a BankPolicy<GlyphBank>,
|
gfx_policy: &'a BankPolicy<GlyphBank>,
|
||||||
sound_policy: &'a BankPolicy<SoundBank>,
|
sound_policy: &'a BankPolicy<SoundBank>,
|
||||||
music_policy: &'a BankPolicy<MusicBank>,
|
|
||||||
scene_policy: &'a BankPolicy<SceneBank>,
|
scene_policy: &'a BankPolicy<SceneBank>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -485,7 +479,6 @@ struct AssetLoadWorker {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl AssetLoadWorker {
|
impl AssetLoadWorker {
|
||||||
#[allow(clippy::too_many_arguments)]
|
|
||||||
fn new(
|
fn new(
|
||||||
handles: Arc<RwLock<HandleTable>>,
|
handles: Arc<RwLock<HandleTable>>,
|
||||||
target_generations: Arc<RwLock<TargetGenerationTable>>,
|
target_generations: Arc<RwLock<TargetGenerationTable>>,
|
||||||
@@ -493,7 +486,6 @@ impl AssetLoadWorker {
|
|||||||
pipeline_telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
|
pipeline_telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
|
||||||
gfx_policy: BankPolicy<GlyphBank>,
|
gfx_policy: BankPolicy<GlyphBank>,
|
||||||
sound_policy: BankPolicy<SoundBank>,
|
sound_policy: BankPolicy<SoundBank>,
|
||||||
music_policy: BankPolicy<MusicBank>,
|
|
||||||
scene_policy: BankPolicy<SceneBank>,
|
scene_policy: BankPolicy<SceneBank>,
|
||||||
) -> Self {
|
) -> Self {
|
||||||
let queue = Arc::new(AssetLoadQueue::default());
|
let queue = Arc::new(AssetLoadQueue::default());
|
||||||
@@ -506,7 +498,6 @@ impl AssetLoadWorker {
|
|||||||
pipeline_telemetry: &pipeline_telemetry,
|
pipeline_telemetry: &pipeline_telemetry,
|
||||||
gfx_policy: &gfx_policy,
|
gfx_policy: &gfx_policy,
|
||||||
sound_policy: &sound_policy,
|
sound_policy: &sound_policy,
|
||||||
music_policy: &music_policy,
|
|
||||||
scene_policy: &scene_policy,
|
scene_policy: &scene_policy,
|
||||||
};
|
};
|
||||||
while let Some(job) = worker_queue.next_job() {
|
while let Some(job) = worker_queue.next_job() {
|
||||||
@@ -563,9 +554,6 @@ enum AssetOpMode {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl AssetBridge for AssetManager {
|
impl AssetBridge for AssetManager {
|
||||||
fn unload_audio(&self, music: bool, slot: usize) -> AssetOpStatus {
|
|
||||||
self.unload_audio(music, slot)
|
|
||||||
}
|
|
||||||
fn bind_background_work(
|
fn bind_background_work(
|
||||||
&mut self,
|
&mut self,
|
||||||
lane: Arc<dyn prometeu_hal::background_work::BackgroundWork>,
|
lane: Arc<dyn prometeu_hal::background_work::BackgroundWork>,
|
||||||
@@ -659,9 +647,7 @@ impl AssetManager {
|
|||||||
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
|
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
|
||||||
match (entry.bank_type, entry.codec) {
|
match (entry.bank_type, entry.codec) {
|
||||||
(BankType::GLYPH, AssetCodec::None) => Ok(AssetOpMode::StageInMemory),
|
(BankType::GLYPH, AssetCodec::None) => Ok(AssetOpMode::StageInMemory),
|
||||||
(BankType::SOUNDS, AssetCodec::None) | (BankType::MUSIC, AssetCodec::None) => {
|
(BankType::SOUNDS, AssetCodec::None) => Ok(AssetOpMode::DirectFromSlice),
|
||||||
Ok(AssetOpMode::DirectFromSlice)
|
|
||||||
}
|
|
||||||
(BankType::SCENE, AssetCodec::None) => Ok(AssetOpMode::DirectFromSlice),
|
(BankType::SCENE, AssetCodec::None) => Ok(AssetOpMode::DirectFromSlice),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -684,7 +670,6 @@ impl AssetManager {
|
|||||||
let pipeline_telemetry = Arc::new(Mutex::new(AssetPipelineTelemetryState::default()));
|
let pipeline_telemetry = Arc::new(Mutex::new(AssetPipelineTelemetryState::default()));
|
||||||
let gfx_policy = BankPolicy::new();
|
let gfx_policy = BankPolicy::new();
|
||||||
let sound_policy = BankPolicy::new();
|
let sound_policy = BankPolicy::new();
|
||||||
let music_policy = BankPolicy::new();
|
|
||||||
let scene_policy = BankPolicy::new();
|
let scene_policy = BankPolicy::new();
|
||||||
let load_worker = AssetLoadWorker::new(
|
let load_worker = AssetLoadWorker::new(
|
||||||
Arc::clone(&handles),
|
Arc::clone(&handles),
|
||||||
@@ -693,7 +678,6 @@ impl AssetManager {
|
|||||||
Arc::clone(&pipeline_telemetry),
|
Arc::clone(&pipeline_telemetry),
|
||||||
gfx_policy.clone(),
|
gfx_policy.clone(),
|
||||||
sound_policy.clone(),
|
sound_policy.clone(),
|
||||||
music_policy.clone(),
|
|
||||||
scene_policy.clone(),
|
scene_policy.clone(),
|
||||||
);
|
);
|
||||||
|
|
||||||
@@ -705,11 +689,9 @@ impl AssetManager {
|
|||||||
gfx_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
gfx_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
glyph_slot_index: GlyphAssetSlotIndex::new(),
|
glyph_slot_index: GlyphAssetSlotIndex::new(),
|
||||||
sound_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
sound_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
music_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
|
||||||
scene_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
scene_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
gfx_policy,
|
gfx_policy,
|
||||||
sound_policy,
|
sound_policy,
|
||||||
music_policy,
|
|
||||||
scene_policy,
|
scene_policy,
|
||||||
handles,
|
handles,
|
||||||
target_handles: Arc::new(RwLock::new(HashMap::new())),
|
target_handles: Arc::new(RwLock::new(HashMap::new())),
|
||||||
@@ -794,23 +776,6 @@ impl AssetManager {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
if let Ok(bank) =
|
|
||||||
Self::perform_load_music_bank(&entry, self.assets_data.clone())
|
|
||||||
{
|
|
||||||
let bank_arc = Arc::new(bank);
|
|
||||||
self.music_policy.put_resident(
|
|
||||||
entry.asset_id,
|
|
||||||
Arc::clone(&bank_arc),
|
|
||||||
entry.decoded_size as usize,
|
|
||||||
);
|
|
||||||
self.sound_installer.install_music_bank(slot_index, bank_arc);
|
|
||||||
let mut slots = self.music_slots.write().unwrap();
|
|
||||||
if slot_index < slots.len() {
|
|
||||||
slots[slot_index] = Some(entry.asset_id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
if let Ok(bank) =
|
if let Ok(bank) =
|
||||||
Self::perform_load_scene_bank(&entry, self.assets_data.clone())
|
Self::perform_load_scene_bank(&entry, self.assets_data.clone())
|
||||||
@@ -875,7 +840,6 @@ impl AssetManager {
|
|||||||
fn clear_staging_for_handle(&self, handle_id: HandleId) {
|
fn clear_staging_for_handle(&self, handle_id: HandleId) {
|
||||||
self.gfx_policy.take_staging(handle_id);
|
self.gfx_policy.take_staging(handle_id);
|
||||||
self.sound_policy.take_staging(handle_id);
|
self.sound_policy.take_staging(handle_id);
|
||||||
self.music_policy.take_staging(handle_id);
|
|
||||||
self.scene_policy.take_staging(handle_id);
|
self.scene_policy.take_staging(handle_id);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -891,7 +855,6 @@ impl AssetManager {
|
|||||||
match slot.asset_type {
|
match slot.asset_type {
|
||||||
BankType::GLYPH => self.gfx_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
BankType::GLYPH => self.gfx_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
||||||
BankType::SOUNDS => self.sound_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
BankType::SOUNDS => self.sound_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
||||||
BankType::MUSIC => self.music_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
|
||||||
BankType::SCENE => self.scene_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
BankType::SCENE => self.scene_slots.read().unwrap().get(slot.index).and_then(|s| *s),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -911,7 +874,6 @@ impl AssetManager {
|
|||||||
let slot = match entry.bank_type {
|
let slot = match entry.bank_type {
|
||||||
BankType::GLYPH => SlotRef::gfx(slot_index),
|
BankType::GLYPH => SlotRef::gfx(slot_index),
|
||||||
BankType::SOUNDS => SlotRef::audio(slot_index),
|
BankType::SOUNDS => SlotRef::audio(slot_index),
|
||||||
BankType::MUSIC => SlotRef::music(slot_index),
|
|
||||||
BankType::SCENE => SlotRef::scene(slot_index),
|
BankType::SCENE => SlotRef::scene(slot_index),
|
||||||
};
|
};
|
||||||
|
|
||||||
@@ -937,14 +899,6 @@ impl AssetManager {
|
|||||||
false
|
false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
if let Some(bank) = self.music_policy.get_resident(asset_id) {
|
|
||||||
self.music_policy.stage(handle_id, bank, entry.decoded_size as usize);
|
|
||||||
true
|
|
||||||
} else {
|
|
||||||
false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
if let Some(bank) = self.scene_policy.get_resident(asset_id) {
|
if let Some(bank) = self.scene_policy.get_resident(asset_id) {
|
||||||
self.scene_policy.stage(handle_id, bank, entry.decoded_size as usize);
|
self.scene_policy.stage(handle_id, bank, entry.decoded_size as usize);
|
||||||
@@ -1127,57 +1081,6 @@ impl AssetManager {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
let result =
|
|
||||||
Self::perform_load_music_bank(&job.entry, Arc::clone(resources.assets_data));
|
|
||||||
match result {
|
|
||||||
Ok(musicbank) => {
|
|
||||||
if !Self::is_current_target_generation(
|
|
||||||
resources.target_generations,
|
|
||||||
job.slot,
|
|
||||||
job.request_generation,
|
|
||||||
) {
|
|
||||||
resources.pipeline_telemetry.lock().unwrap().record_stale_discard();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let bank_arc = Arc::new(musicbank);
|
|
||||||
let resident_arc = resources.music_policy.put_resident(
|
|
||||||
job.asset_id,
|
|
||||||
bank_arc,
|
|
||||||
job.entry.decoded_size as usize,
|
|
||||||
);
|
|
||||||
if !Self::is_current_target_generation(
|
|
||||||
resources.target_generations,
|
|
||||||
job.slot,
|
|
||||||
job.request_generation,
|
|
||||||
) {
|
|
||||||
resources.pipeline_telemetry.lock().unwrap().record_stale_discard();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
resources.music_policy.stage(
|
|
||||||
job.handle_id,
|
|
||||||
resident_arc,
|
|
||||||
job.entry.decoded_size as usize,
|
|
||||||
);
|
|
||||||
Self::complete_load_job(resources.handles, &job, LoadStatus::READY);
|
|
||||||
Self::record_load_job_finished(
|
|
||||||
resources.pipeline_telemetry,
|
|
||||||
&job,
|
|
||||||
started_at,
|
|
||||||
LoadStatus::READY,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
Err(_) => {
|
|
||||||
Self::complete_load_job(resources.handles, &job, LoadStatus::ERROR);
|
|
||||||
Self::record_load_job_finished(
|
|
||||||
resources.pipeline_telemetry,
|
|
||||||
&job,
|
|
||||||
started_at,
|
|
||||||
LoadStatus::ERROR,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
let result =
|
let result =
|
||||||
Self::perform_load_scene_bank(&job.entry, Arc::clone(resources.assets_data));
|
Self::perform_load_scene_bank(&job.entry, Arc::clone(resources.assets_data));
|
||||||
@@ -1365,32 +1268,6 @@ impl AssetManager {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn perform_load_music_bank(
|
|
||||||
entry: &AssetEntry,
|
|
||||||
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
|
||||||
) -> Result<MusicBank, String> {
|
|
||||||
let op_mode = Self::op_mode_for(entry)?;
|
|
||||||
let slice = {
|
|
||||||
let assets_data = assets_data.read().unwrap();
|
|
||||||
assets_data
|
|
||||||
.open_slice(entry.offset, entry.size)
|
|
||||||
.map_err(|_| "Asset offset/size out of bounds".to_string())?
|
|
||||||
};
|
|
||||||
|
|
||||||
match op_mode {
|
|
||||||
AssetOpMode::DirectFromSlice => {
|
|
||||||
let mut reader =
|
|
||||||
slice.open_reader().map_err(|_| "Asset payload read failed".to_string())?;
|
|
||||||
Self::decode_music_bank_from_reader(entry, &mut reader)
|
|
||||||
}
|
|
||||||
AssetOpMode::StageInMemory => {
|
|
||||||
let buffer =
|
|
||||||
slice.read_all().map_err(|_| "Asset payload read failed".to_string())?;
|
|
||||||
Self::decode_music_bank_from_buffer(entry, &buffer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn perform_load_scene_bank(
|
fn perform_load_scene_bank(
|
||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
||||||
@@ -1457,32 +1334,13 @@ impl AssetManager {
|
|||||||
entry: &AssetEntry,
|
entry: &AssetEntry,
|
||||||
buffer: &[u8],
|
buffer: &[u8],
|
||||||
) -> Result<SoundBank, String> {
|
) -> Result<SoundBank, String> {
|
||||||
|
let sample_rate = decode::sound_rate(entry)?;
|
||||||
decode::payload_size(entry, buffer.len())?;
|
decode::payload_size(entry, buffer.len())?;
|
||||||
let bank = decode_audio_bank(buffer, false)?;
|
let mut data = Vec::with_capacity(buffer.len() / 2);
|
||||||
if bank.decoded_size() as u64 != entry.decoded_size {
|
decode::append_pcm(&mut data, buffer);
|
||||||
return Err("audio decoded_size mismatch".into());
|
|
||||||
}
|
|
||||||
if let DecodedAudioBank::Sound(bank) = bank {
|
|
||||||
Ok(bank)
|
|
||||||
} else {
|
|
||||||
Err("audio bank type mismatch".into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn decode_music_bank_from_buffer(
|
let sample = Arc::new(Sample::new(sample_rate, data));
|
||||||
entry: &AssetEntry,
|
Ok(SoundBank::new(vec![sample]))
|
||||||
buffer: &[u8],
|
|
||||||
) -> Result<MusicBank, String> {
|
|
||||||
decode::payload_size(entry, buffer.len())?;
|
|
||||||
let bank = decode_audio_bank(buffer, true)?;
|
|
||||||
if bank.decoded_size() as u64 != entry.decoded_size {
|
|
||||||
return Err("audio decoded_size mismatch".into());
|
|
||||||
}
|
|
||||||
if let DecodedAudioBank::Music(bank) = bank {
|
|
||||||
Ok(bank)
|
|
||||||
} else {
|
|
||||||
Err("audio bank type mismatch".into())
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn decode_sound_bank_from_reader(
|
fn decode_sound_bank_from_reader(
|
||||||
@@ -1494,15 +1352,6 @@ impl AssetManager {
|
|||||||
Self::decode_sound_bank_from_buffer(entry, &raw)
|
Self::decode_sound_bank_from_buffer(entry, &raw)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn decode_music_bank_from_reader(
|
|
||||||
entry: &AssetEntry,
|
|
||||||
reader: &mut impl Read,
|
|
||||||
) -> Result<MusicBank, String> {
|
|
||||||
let mut raw = Vec::new();
|
|
||||||
reader.read_to_end(&mut raw).map_err(|_| "Asset payload read failed".to_string())?;
|
|
||||||
Self::decode_music_bank_from_buffer(entry, &raw)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn status(&self, handle: HandleId) -> LoadStatus {
|
pub fn status(&self, handle: HandleId) -> LoadStatus {
|
||||||
if let Some(status) = self.handles.read().unwrap().get(&handle).map(|h| h.status) {
|
if let Some(status) = self.handles.read().unwrap().get(&handle).map(|h| h.status) {
|
||||||
return status;
|
return status;
|
||||||
@@ -1631,7 +1480,6 @@ impl AssetManager {
|
|||||||
let slot_ref = match bank_type {
|
let slot_ref = match bank_type {
|
||||||
BankType::GLYPH => SlotRef::gfx(slot),
|
BankType::GLYPH => SlotRef::gfx(slot),
|
||||||
BankType::SOUNDS => SlotRef::audio(slot),
|
BankType::SOUNDS => SlotRef::audio(slot),
|
||||||
BankType::MUSIC => SlotRef::music(slot),
|
|
||||||
BankType::SCENE => SlotRef::scene(slot),
|
BankType::SCENE => SlotRef::scene(slot),
|
||||||
};
|
};
|
||||||
let handle = self.handle_for_slot(slot_ref);
|
let handle = self.handle_for_slot(slot_ref);
|
||||||
@@ -1747,16 +1595,6 @@ impl AssetManager {
|
|||||||
h.status = LoadStatus::COMMITTED;
|
h.status = LoadStatus::COMMITTED;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
if let Some((bank, _)) = self.music_policy.take_staging(handle_id) {
|
|
||||||
self.sound_installer.install_music_bank(h.slot.index, bank);
|
|
||||||
let mut slots = self.music_slots.write().unwrap();
|
|
||||||
if h.slot.index < slots.len() {
|
|
||||||
slots[h.slot.index] = Some(h._asset_id);
|
|
||||||
}
|
|
||||||
h.status = LoadStatus::COMMITTED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
if let Some((bank, _)) = self.scene_policy.take_staging(handle_id) {
|
if let Some((bank, _)) = self.scene_policy.take_staging(handle_id) {
|
||||||
self.scene_installer.install_scene_bank(h.slot.index, bank);
|
self.scene_installer.install_scene_bank(h.slot.index, bank);
|
||||||
@@ -1771,57 +1609,12 @@ impl AssetManager {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
self.reap_audio_cache();
|
|
||||||
}
|
|
||||||
|
|
||||||
fn reap_audio_cache(&self) {
|
|
||||||
fn reap<T>(policy: &BankPolicy<T>, slots: &[Option<AssetId>; 16]) {
|
|
||||||
let mut resident = policy.resident.write().unwrap();
|
|
||||||
resident.retain(|id, entry| {
|
|
||||||
let keep = slots.contains(&Some(*id)) || Arc::strong_count(&entry.value) > 1;
|
|
||||||
if !keep {
|
|
||||||
policy.used_bytes.fetch_sub(entry.bytes, Ordering::Relaxed);
|
|
||||||
}
|
|
||||||
keep
|
|
||||||
});
|
|
||||||
}
|
|
||||||
reap(&self.sound_policy, &self.sound_slots.read().unwrap());
|
|
||||||
reap(&self.music_policy, &self.music_slots.read().unwrap());
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn unload_audio(&self, music: bool, slot: usize) -> AssetOpStatus {
|
|
||||||
if slot >= 16 {
|
|
||||||
return AssetOpStatus::InvalidState;
|
|
||||||
}
|
|
||||||
let target = if music { SlotRef::music(slot) } else { SlotRef::audio(slot) };
|
|
||||||
self.bump_target_generation(target);
|
|
||||||
if let Some(handle) = self.target_handles.read().unwrap().get(&target).copied() {
|
|
||||||
self.clear_staging_for_handle(handle);
|
|
||||||
if let Some(h) = self.handles.write().unwrap().get_mut(&handle) {
|
|
||||||
h.status = LoadStatus::CANCELED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let slots = if music { &self.music_slots } else { &self.sound_slots };
|
|
||||||
let mut ids = slots.write().unwrap();
|
|
||||||
let previous = ids[slot].take();
|
|
||||||
self.sound_installer.unload_audio_bank(music, slot);
|
|
||||||
if let Some(id) = previous.filter(|id| !ids.contains(&Some(*id))) {
|
|
||||||
if music {
|
|
||||||
if let Some(old) = self.music_policy.resident.write().unwrap().remove(&id) {
|
|
||||||
self.music_policy.used_bytes.fetch_sub(old.bytes, Ordering::Relaxed);
|
|
||||||
}
|
|
||||||
} else if let Some(old) = self.sound_policy.resident.write().unwrap().remove(&id) {
|
|
||||||
self.sound_policy.used_bytes.fetch_sub(old.bytes, Ordering::Relaxed);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AssetOpStatus::Ok
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn bank_telemetry(&self) -> Vec<BankTelemetry> {
|
pub fn bank_telemetry(&self) -> Vec<BankTelemetry> {
|
||||||
vec![
|
vec![
|
||||||
self.bank_telemetry_for(BankType::GLYPH),
|
self.bank_telemetry_for(BankType::GLYPH),
|
||||||
self.bank_telemetry_for(BankType::SOUNDS),
|
self.bank_telemetry_for(BankType::SOUNDS),
|
||||||
self.bank_telemetry_for(BankType::MUSIC),
|
|
||||||
self.bank_telemetry_for(BankType::SCENE),
|
self.bank_telemetry_for(BankType::SCENE),
|
||||||
]
|
]
|
||||||
}
|
}
|
||||||
@@ -1834,9 +1627,6 @@ impl AssetManager {
|
|||||||
BankType::SOUNDS => {
|
BankType::SOUNDS => {
|
||||||
self.sound_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
|
self.sound_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
self.music_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
self.scene_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
|
self.scene_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
|
||||||
}
|
}
|
||||||
@@ -1889,27 +1679,6 @@ impl AssetManager {
|
|||||||
|
|
||||||
SlotStats { asset_id, asset_name, generation: 0, resident_bytes: bytes }
|
SlotStats { asset_id, asset_name, generation: 0, resident_bytes: bytes }
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
let slots = self.music_slots.read().unwrap();
|
|
||||||
let asset_id = slots.get(slot.index).and_then(|s| *s);
|
|
||||||
|
|
||||||
let (bytes, asset_name) = if let Some(id) = &asset_id {
|
|
||||||
let bytes = self
|
|
||||||
.music_policy
|
|
||||||
.resident
|
|
||||||
.read()
|
|
||||||
.unwrap()
|
|
||||||
.get(id)
|
|
||||||
.map(|entry| entry.bytes)
|
|
||||||
.unwrap_or(0);
|
|
||||||
let name = self.assets.read().unwrap().get(id).map(|e| e.asset_name.clone());
|
|
||||||
(bytes, name)
|
|
||||||
} else {
|
|
||||||
(0, None)
|
|
||||||
};
|
|
||||||
|
|
||||||
SlotStats { asset_id, asset_name, generation: 0, resident_bytes: bytes }
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
let slots = self.scene_slots.read().unwrap();
|
let slots = self.scene_slots.read().unwrap();
|
||||||
let asset_id = slots.get(slot.index).and_then(|s| *s);
|
let asset_id = slots.get(slot.index).and_then(|s| *s);
|
||||||
@@ -1942,7 +1711,6 @@ impl AssetManager {
|
|||||||
}
|
}
|
||||||
self.gfx_policy.clear();
|
self.gfx_policy.clear();
|
||||||
self.sound_policy.clear();
|
self.sound_policy.clear();
|
||||||
self.music_policy.clear();
|
|
||||||
self.scene_policy.clear();
|
self.scene_policy.clear();
|
||||||
self.handles.write().unwrap().clear();
|
self.handles.write().unwrap().clear();
|
||||||
self.target_handles.write().unwrap().clear();
|
self.target_handles.write().unwrap().clear();
|
||||||
@@ -1953,11 +1721,9 @@ impl AssetManager {
|
|||||||
self.gfx_slots.write().unwrap().fill(None);
|
self.gfx_slots.write().unwrap().fill(None);
|
||||||
self.glyph_slot_index.clear();
|
self.glyph_slot_index.clear();
|
||||||
self.sound_slots.write().unwrap().fill(None);
|
self.sound_slots.write().unwrap().fill(None);
|
||||||
self.music_slots.write().unwrap().fill(None);
|
|
||||||
self.scene_slots.write().unwrap().fill(None);
|
self.scene_slots.write().unwrap().fill(None);
|
||||||
self.gfx_installer.clear_glyph_banks();
|
self.gfx_installer.clear_glyph_banks();
|
||||||
self.sound_installer.clear_sound_banks();
|
self.sound_installer.clear_sound_banks();
|
||||||
self.sound_installer.clear_music_banks();
|
|
||||||
self.scene_installer.clear_scene_banks();
|
self.scene_installer.clear_scene_banks();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -2746,7 +2512,7 @@ mod tests {
|
|||||||
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
|
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
|
||||||
|
|
||||||
// 100 samples of 16-bit PCM (zeros)
|
// 100 samples of 16-bit PCM (zeros)
|
||||||
let data = crate::bank_format::test_pcm_bank(&[0u8; 200], 44100);
|
let data = vec![0u8; 200];
|
||||||
|
|
||||||
let asset_entry = AssetEntry {
|
let asset_entry = AssetEntry {
|
||||||
asset_id: 1,
|
asset_id: 1,
|
||||||
@@ -2792,7 +2558,7 @@ mod tests {
|
|||||||
let sound_installer = Arc::clone(&banks) as Arc<dyn SoundBankPoolInstaller>;
|
let sound_installer = Arc::clone(&banks) as Arc<dyn SoundBankPoolInstaller>;
|
||||||
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
|
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
|
||||||
|
|
||||||
let data = crate::bank_format::test_pcm_bank(&[0u8; 200], 44100);
|
let data = vec![0u8; 200];
|
||||||
|
|
||||||
let asset_entry = AssetEntry {
|
let asset_entry = AssetEntry {
|
||||||
asset_id: 2,
|
asset_id: 2,
|
||||||
|
|||||||
@@ -69,6 +69,13 @@ pub(super) fn write_palettes(
|
|||||||
palettes[at / 16][at % 16] = Color::rgba(rgba[0], rgba[1], rgba[2], rgba[3]);
|
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> {
|
pub(super) fn payload_size(entry: &AssetEntry, actual: usize) -> Result<(), String> {
|
||||||
if actual as u64 != entry.size {
|
if actual as u64 != entry.size {
|
||||||
return Err("Invalid asset payload size".into());
|
return Err("Invalid asset payload size".into());
|
||||||
|
|||||||
@@ -32,33 +32,47 @@ fn pcm_entry(size: u64) -> AssetEntry {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn pcm_chunk_edges_validate_all_declared_frames_and_reject_odd_tails() {
|
fn pcm_chunk_edges_and_odd_tails_have_explicit_baseline_outputs() {
|
||||||
for len in [0, 1, 2, 3, 4095, 4096, 4097, 8191, 8192, 8193] {
|
for len in [0, 1, 2, 3, 4095, 4096, 4097, 8191, 8192, 8193] {
|
||||||
let raw: Vec<u8> = (0..len).map(|i| if i % 2 == 0 { 0x34 } else { 0x12 }).collect();
|
let bytes: Vec<u8> = (0..len).map(|i| if i % 2 == 0 { 0x34 } else { 0x12 }).collect();
|
||||||
let bytes = crate::bank_format::test_pcm_bank(&raw, 44100);
|
let entry = pcm_entry(len as u64);
|
||||||
let expected = if len % 2 == 0 {
|
let expected = json!([[vec![0x1234_i16; len / 2], 44100, null, null]]);
|
||||||
Some(json!([[vec![0x1234_i16; len / 2], 44100, null, null]]))
|
let buffer = AssetManager::decode_sound_bank_from_buffer(&entry, &bytes).unwrap();
|
||||||
} else {
|
let reader = AssetManager::decode_sound_bank_from_reader(&entry, &mut &bytes[..]).unwrap();
|
||||||
None
|
let source = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(bytes)));
|
||||||
};
|
let production = AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap();
|
||||||
check_case("pcm-chunk", &pcm_entry(bytes.len() as u64), bytes, expected);
|
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]
|
#[test]
|
||||||
fn physically_truncated_pcm_file_is_rejected_by_all_modes() {
|
fn physically_truncated_pcm_file_is_rejected_by_both_modes() {
|
||||||
let bytes = crate::bank_format::test_pcm_bank(&[0x34, 0x12], 44100);
|
// Two actual bytes, three declared bytes: the missing byte is an odd tail.
|
||||||
let entry = pcm_entry(bytes.len() as u64);
|
// The approved rule rejects missing declared bytes, including an odd tail.
|
||||||
let fixture = FileFixture::new("truncated-pcm", &bytes[..bytes.len() - 1]);
|
let fixture = FileFixture::new("truncated-pcm", &[0x34, 0x12]);
|
||||||
let source = fixture.source(bytes.len() as u64);
|
let entry = pcm_entry(3);
|
||||||
|
let source = fixture.source(3);
|
||||||
assert!(AssetManager::perform_load_sound_bank(&entry, source.clone()).is_err());
|
assert!(AssetManager::perform_load_sound_bank(&entry, source.clone()).is_err());
|
||||||
assert!(resumable::conformance_result(&entry, &source).is_err());
|
assert!(resumable::conformance_result(&entry, &source).is_err());
|
||||||
std::fs::write(&fixture.0, &bytes).unwrap();
|
// 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]]);
|
let expected = json!([[[0x1234], 44100, null, null]]);
|
||||||
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
sound_snapshot(&AssetManager::perform_load_sound_bank(&entry, source).unwrap()),
|
sound_snapshot(&AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap()),
|
||||||
expected
|
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]
|
#[test]
|
||||||
@@ -115,8 +129,6 @@ fn check_case(name: &str, entry: &AssetEntry, bytes: Vec<u8>, expected: Option<V
|
|||||||
AssetManager::perform_load_sound_bank(entry, source.clone())
|
AssetManager::perform_load_sound_bank(entry, source.clone())
|
||||||
.map(|b| sound_snapshot(&b))
|
.map(|b| sound_snapshot(&b))
|
||||||
}
|
}
|
||||||
BankType::MUSIC => AssetManager::perform_load_music_bank(entry, source.clone())
|
|
||||||
.map(|b| music_snapshot(&b)),
|
|
||||||
BankType::SCENE => AssetManager::perform_load_scene_bank(entry, source.clone())
|
BankType::SCENE => AssetManager::perform_load_scene_bank(entry, source.clone())
|
||||||
.map(|b| scene_snapshot(&b)),
|
.map(|b| scene_snapshot(&b)),
|
||||||
};
|
};
|
||||||
@@ -141,8 +153,6 @@ fn check_case(name: &str, entry: &AssetEntry, bytes: Vec<u8>, expected: Option<V
|
|||||||
AssetManager::decode_sound_bank_from_reader(entry, &mut reader)
|
AssetManager::decode_sound_bank_from_reader(entry, &mut reader)
|
||||||
.map(|b| sound_snapshot(&b))
|
.map(|b| sound_snapshot(&b))
|
||||||
}
|
}
|
||||||
(BankType::MUSIC, _) => AssetManager::decode_music_bank_from_buffer(entry, &bytes)
|
|
||||||
.map(|b| music_snapshot(&b)),
|
|
||||||
(BankType::SCENE, 0) => AssetManager::decode_scene_bank_from_buffer(entry, &bytes)
|
(BankType::SCENE, 0) => AssetManager::decode_scene_bank_from_buffer(entry, &bytes)
|
||||||
.map(|b| scene_snapshot(&b)),
|
.map(|b| scene_snapshot(&b)),
|
||||||
(BankType::SCENE, _) => {
|
(BankType::SCENE, _) => {
|
||||||
@@ -309,29 +319,35 @@ fn scene_tile_chunk_edges_flags_and_reserved_bytes() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn pcm_descriptor_and_source_range_corpus() {
|
fn pcm_metadata_and_source_range_corpus() {
|
||||||
let bytes = crate::bank_format::test_pcm_bank(&[0x34, 0x12], 44100);
|
for metadata in [
|
||||||
let entry = pcm_entry(bytes.len() as u64);
|
json!(null),
|
||||||
// Audio metadata lives in the versioned payload, so it can vary per sample.
|
json!({}),
|
||||||
for (offset, value) in
|
json!({"sample_rate":-1,"channels":1}),
|
||||||
[(48, 99u32), (49, 0), (52, 0), (56, 2), (60, 1), (68, 0), (72, 3), (84, 0)]
|
json!({"sample_rate":44100,"channels":"bad"}),
|
||||||
{
|
] {
|
||||||
let mut invalid = bytes.clone();
|
let mut e = pcm_entry(2);
|
||||||
if offset == 48 || offset == 49 {
|
e.metadata = metadata;
|
||||||
invalid[offset] = value as u8;
|
check_case("pcm-metadata", &e, vec![0x34, 0x12], None);
|
||||||
} else {
|
|
||||||
invalid[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
|
|
||||||
}
|
|
||||||
check_case("descriptor", &entry, invalid, 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] {
|
for offset in [1, u64::MAX] {
|
||||||
let mut invalid = entry.clone();
|
let mut e = pcm_entry(2);
|
||||||
invalid.offset = offset;
|
e.offset = offset;
|
||||||
check_case("source-range", &invalid, bytes.clone(), None);
|
check_case("source-range", &e, vec![0x34, 0x12], None);
|
||||||
}
|
}
|
||||||
let mut invalid = entry;
|
let mut e = pcm_entry(2);
|
||||||
invalid.decoded_size += 1;
|
e.size = u64::MAX;
|
||||||
check_case("decoded-size", &invalid, bytes, None);
|
check_case("source-size-overflow", &e, vec![0x34, 0x12], None);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(in crate::asset) fn glyph_snapshot(bank: &GlyphBank) -> Value {
|
pub(in crate::asset) fn glyph_snapshot(bank: &GlyphBank) -> Value {
|
||||||
@@ -414,48 +430,3 @@ fn physically_truncated_glyph_palette_is_rejected_by_both_modes() {
|
|||||||
);
|
);
|
||||||
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(in crate::asset) fn music_snapshot(bank: &prometeu_hal::music_bank::MusicBank) -> Value {
|
|
||||||
json!({"name": bank.name, "events": bank.events.len(), "pcm": bank.metrics.pcm_bytes})
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn mixed_audio_fixtures_conform_across_all_asset_decode_modes() {
|
|
||||||
for (music, bytes) in [
|
|
||||||
(
|
|
||||||
false,
|
|
||||||
&include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-sound.sbnk"
|
|
||||||
))[..],
|
|
||||||
),
|
|
||||||
(
|
|
||||||
true,
|
|
||||||
&include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-music.mbnk"
|
|
||||||
))[..],
|
|
||||||
),
|
|
||||||
] {
|
|
||||||
let decoded = crate::bank_format::decode_audio_bank(bytes, music).unwrap();
|
|
||||||
let size = decoded.decoded_size();
|
|
||||||
let expected = match decoded {
|
|
||||||
DecodedAudioBank::Sound(b) => sound_snapshot(&b),
|
|
||||||
DecodedAudioBank::Music(b) => music_snapshot(&b),
|
|
||||||
};
|
|
||||||
let entry = AssetEntry {
|
|
||||||
asset_id: 7,
|
|
||||||
asset_name: "mixed".into(),
|
|
||||||
bank_type: if music { BankType::MUSIC } else { BankType::SOUNDS },
|
|
||||||
offset: 0,
|
|
||||||
size: bytes.len() as u64,
|
|
||||||
decoded_size: size as u64,
|
|
||||||
codec: AssetCodec::None,
|
|
||||||
metadata: json!({"version":1}),
|
|
||||||
};
|
|
||||||
check_case("mixed-audio", &entry, bytes.to_vec(), Some(expected));
|
|
||||||
let mut invalid = bytes.to_vec();
|
|
||||||
invalid[0] = 0;
|
|
||||||
check_case("mixed-bad-magic", &entry, invalid, None);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -11,7 +11,6 @@ pub(super) struct Resources {
|
|||||||
telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
|
telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
|
||||||
gfx: BankPolicy<GlyphBank>,
|
gfx: BankPolicy<GlyphBank>,
|
||||||
sound: BankPolicy<SoundBank>,
|
sound: BankPolicy<SoundBank>,
|
||||||
music: BankPolicy<MusicBank>,
|
|
||||||
scene: BankPolicy<SceneBank>,
|
scene: BankPolicy<SceneBank>,
|
||||||
}
|
}
|
||||||
impl Resources {
|
impl Resources {
|
||||||
@@ -23,7 +22,6 @@ impl Resources {
|
|||||||
telemetry: m.pipeline_telemetry.clone(),
|
telemetry: m.pipeline_telemetry.clone(),
|
||||||
gfx: m.gfx_policy.clone(),
|
gfx: m.gfx_policy.clone(),
|
||||||
sound: m.sound_policy.clone(),
|
sound: m.sound_policy.clone(),
|
||||||
music: m.music_policy.clone(),
|
|
||||||
scene: m.scene_policy.clone(),
|
scene: m.scene_policy.clone(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -144,18 +142,6 @@ pub(super) fn schedule(
|
|||||||
job.entry.decoded_size as usize,
|
job.entry.decoded_size as usize,
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
Decoded::Music(bank) => {
|
|
||||||
let resident = resources.music.put_resident(
|
|
||||||
job.asset_id,
|
|
||||||
Arc::new(bank),
|
|
||||||
job.entry.decoded_size as usize,
|
|
||||||
);
|
|
||||||
resources.music.stage(
|
|
||||||
job.handle_id,
|
|
||||||
resident,
|
|
||||||
job.entry.decoded_size as usize,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
Decoded::Scene(bank) => {
|
Decoded::Scene(bank) => {
|
||||||
let resident = resources.scene.put_resident(
|
let resident = resources.scene.put_resident(
|
||||||
job.asset_id,
|
job.asset_id,
|
||||||
@@ -202,7 +188,6 @@ pub(super) fn schedule(
|
|||||||
enum Decoded {
|
enum Decoded {
|
||||||
Glyph(GlyphBank),
|
Glyph(GlyphBank),
|
||||||
Sound(SoundBank),
|
Sound(SoundBank),
|
||||||
Music(MusicBank),
|
|
||||||
Scene(SceneBank),
|
Scene(SceneBank),
|
||||||
}
|
}
|
||||||
enum State {
|
enum State {
|
||||||
@@ -214,11 +199,10 @@ enum State {
|
|||||||
palette_position: usize,
|
palette_position: usize,
|
||||||
},
|
},
|
||||||
Sound {
|
Sound {
|
||||||
raw: Vec<u8>,
|
sample_rate: u32,
|
||||||
|
data: Vec<i16>,
|
||||||
remaining: usize,
|
remaining: usize,
|
||||||
music: bool,
|
|
||||||
},
|
},
|
||||||
Audio(Box<crate::bank_format::AudioBankMaterializer<'static>>),
|
|
||||||
Scene {
|
Scene {
|
||||||
layers: [SceneLayer; SCENE_LAYER_COUNT_V1],
|
layers: [SceneLayer; SCENE_LAYER_COUNT_V1],
|
||||||
layer: usize,
|
layer: usize,
|
||||||
@@ -261,16 +245,12 @@ impl Decoder {
|
|||||||
palette_position: 0,
|
palette_position: 0,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::SOUNDS | BankType::MUSIC => {
|
BankType::SOUNDS => {
|
||||||
let mut raw = Vec::new();
|
let sample_rate = decode::sound_rate(entry)?;
|
||||||
raw.try_reserve_exact(
|
|
||||||
usize::try_from(entry.size).map_err(|_| "audio size overflow")?,
|
|
||||||
)
|
|
||||||
.map_err(|_| "audio allocation failed")?;
|
|
||||||
State::Sound {
|
State::Sound {
|
||||||
raw,
|
sample_rate,
|
||||||
|
data: Vec::with_capacity(entry.size as usize / 2),
|
||||||
remaining: entry.size as usize,
|
remaining: entry.size as usize,
|
||||||
music: entry.bank_type == BankType::MUSIC,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
@@ -314,34 +294,18 @@ impl Decoder {
|
|||||||
};
|
};
|
||||||
Ok(Some(Decoded::Glyph(bank)))
|
Ok(Some(Decoded::Glyph(bank)))
|
||||||
}
|
}
|
||||||
State::Sound { raw, remaining, music } => {
|
State::Sound { sample_rate, data, remaining } => {
|
||||||
if *remaining > 0 {
|
if *remaining > 0 {
|
||||||
let n = (*remaining).min(4096);
|
let n = (*remaining).min(bytes.len());
|
||||||
let mut buffer = [0; 4096];
|
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
|
||||||
self.reader.read_exact(&mut buffer[..n]).map_err(|e| e.to_string())?;
|
decode::append_pcm(data, &bytes[..n]);
|
||||||
raw.extend_from_slice(&buffer[..n]);
|
|
||||||
*remaining -= n;
|
*remaining -= n;
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
let decoder = crate::bank_format::AudioBankMaterializer::new(
|
let rate = *sample_rate;
|
||||||
std::borrow::Cow::Owned(std::mem::take(raw)),
|
let data = std::mem::take(data);
|
||||||
*music,
|
|
||||||
)?;
|
|
||||||
self.state = State::Audio(Box::new(decoder));
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
State::Audio(decoder) => {
|
|
||||||
let Some(bank) = decoder.step()? else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
if bank.decoded_size() as u64 != self.entry.decoded_size {
|
|
||||||
return Err("audio decoded_size mismatch".into());
|
|
||||||
}
|
|
||||||
self.state = State::Done;
|
self.state = State::Done;
|
||||||
Ok(Some(match bank {
|
Ok(Some(Decoded::Sound(SoundBank::new(vec![Arc::new(Sample::new(rate, data))]))))
|
||||||
DecodedAudioBank::Sound(b) => Decoded::Sound(b),
|
|
||||||
DecodedAudioBank::Music(b) => Decoded::Music(b),
|
|
||||||
}))
|
|
||||||
}
|
}
|
||||||
State::Scene { layers, layer, tiles_left, header, decoded } => {
|
State::Scene { layers, layer, tiles_left, header, decoded } => {
|
||||||
if !*header {
|
if !*header {
|
||||||
@@ -408,7 +372,6 @@ pub(super) fn conformance_result(
|
|||||||
Decoded::Glyph(bank) => super::decode::tests::glyph_snapshot(&bank),
|
Decoded::Glyph(bank) => super::decode::tests::glyph_snapshot(&bank),
|
||||||
Decoded::Sound(bank) => super::decode::tests::sound_snapshot(&bank),
|
Decoded::Sound(bank) => super::decode::tests::sound_snapshot(&bank),
|
||||||
Decoded::Scene(bank) => super::decode::tests::scene_snapshot(&bank),
|
Decoded::Scene(bank) => super::decode::tests::scene_snapshot(&bank),
|
||||||
Decoded::Music(bank) => super::decode::tests::music_snapshot(&bank),
|
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -485,12 +448,9 @@ mod tests {
|
|||||||
panic!("decoder did not finish")
|
panic!("decoder did not finish")
|
||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
fn resumable_audio_bank_and_scene_use_canonical_formats() {
|
fn resumable_sound_and_scene_preserve_existing_formats() {
|
||||||
let pcm: Vec<i16> = (0..5000).map(|n| n as i16 - 2500).collect();
|
let pcm: Vec<i16> = (0..5000).map(|n| n as i16 - 2500).collect();
|
||||||
let bytes = crate::bank_format::test_pcm_bank(
|
let bytes: Vec<u8> = pcm.iter().flat_map(|n| n.to_le_bytes()).collect();
|
||||||
&pcm.iter().flat_map(|n| n.to_le_bytes()).collect::<Vec<_>>(),
|
|
||||||
44100,
|
|
||||||
);
|
|
||||||
let entry = AssetEntry {
|
let entry = AssetEntry {
|
||||||
asset_id: 1,
|
asset_id: 1,
|
||||||
asset_name: "pcm".into(),
|
asset_name: "pcm".into(),
|
||||||
@@ -525,7 +485,7 @@ mod tests {
|
|||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
fn shared_preload_waits_for_worker_and_frame_publication() {
|
fn shared_preload_waits_for_worker_and_frame_publication() {
|
||||||
let bytes = crate::bank_format::test_pcm_bank(&[0; 8192], 44100);
|
let bytes = vec![0; 8192];
|
||||||
let entry = AssetEntry {
|
let entry = AssetEntry {
|
||||||
asset_id: 1,
|
asset_id: 1,
|
||||||
asset_name: "pcm".into(),
|
asset_name: "pcm".into(),
|
||||||
@@ -561,7 +521,7 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn canceled_and_superseded_partial_decoders_never_publish() {
|
fn canceled_and_superseded_partial_decoders_never_publish() {
|
||||||
use crate::memory_banks::SoundBankPoolAccess;
|
use crate::memory_banks::SoundBankPoolAccess;
|
||||||
let bytes = crate::bank_format::test_pcm_bank(&[0x12; 16384], 44100);
|
let bytes = vec![0x12; 16384];
|
||||||
let entry = AssetEntry {
|
let entry = AssetEntry {
|
||||||
asset_id: 1,
|
asset_id: 1,
|
||||||
asset_name: "pcm".into(),
|
asset_name: "pcm".into(),
|
||||||
|
|||||||
@@ -1,14 +1,8 @@
|
|||||||
use prometeu_hal::music_bank::MusicBank;
|
use prometeu_hal::{AudioBridge, AudioOpStatus};
|
||||||
use prometeu_hal::{AudioBridge, AudioOpStatus, audio_bridge::AudioControl};
|
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::sync::atomic::AtomicBool;
|
|
||||||
pub mod bank_format;
|
|
||||||
|
|
||||||
/// Maximum number of simultaneous audio voices supported by the hardware.
|
/// Maximum number of simultaneous audio voices supported by the hardware.
|
||||||
pub const MAX_CHANNELS: usize = 32;
|
pub const MAX_CHANNELS: usize = 16;
|
||||||
pub const SFX_CHANNELS: usize = 8;
|
|
||||||
pub const SFX_START: usize = 24;
|
|
||||||
pub mod engine;
|
|
||||||
/// Standard sample rate for the final audio output.
|
/// Standard sample rate for the final audio output.
|
||||||
pub const OUTPUT_SAMPLE_RATE: u32 = 48000;
|
pub const OUTPUT_SAMPLE_RATE: u32 = 48000;
|
||||||
|
|
||||||
@@ -25,14 +19,13 @@ pub struct Channel {
|
|||||||
pub sample: Option<Arc<Sample>>,
|
pub sample: Option<Arc<Sample>>,
|
||||||
/// Whether this channel is currently active.
|
/// Whether this channel is currently active.
|
||||||
pub active: bool,
|
pub active: bool,
|
||||||
pub alive: Option<Arc<AtomicBool>>,
|
|
||||||
/// Current playback position within the sample (fractional for pitch shifting).
|
/// Current playback position within the sample (fractional for pitch shifting).
|
||||||
pub pos: f64,
|
pub pos: f64,
|
||||||
/// Playback speed multiplier (1.0 = original speed).
|
/// Playback speed multiplier (1.0 = original speed).
|
||||||
pub pitch: f64,
|
pub pitch: f64,
|
||||||
/// Voice volume (0-255).
|
/// Voice volume (0-255).
|
||||||
pub volume: u8,
|
pub volume: u8,
|
||||||
/// Stereo panning (0=Full Left, 128=Center, 255=Full Right).
|
/// Stereo panning (0=Full Left, 127=Center, 255=Full Right).
|
||||||
pub pan: u8,
|
pub pan: u8,
|
||||||
/// Loop configuration for this voice.
|
/// Loop configuration for this voice.
|
||||||
pub loop_mode: LoopMode,
|
pub loop_mode: LoopMode,
|
||||||
@@ -45,11 +38,10 @@ impl Default for Channel {
|
|||||||
Self {
|
Self {
|
||||||
sample: None,
|
sample: None,
|
||||||
active: false,
|
active: false,
|
||||||
alive: None,
|
|
||||||
pos: 0.0,
|
pos: 0.0,
|
||||||
pitch: 1.0,
|
pitch: 1.0,
|
||||||
volume: 255,
|
volume: 255,
|
||||||
pan: 128,
|
pan: 127,
|
||||||
loop_mode: LoopMode::Off,
|
loop_mode: LoopMode::Off,
|
||||||
priority: 0,
|
priority: 0,
|
||||||
}
|
}
|
||||||
@@ -61,16 +53,9 @@ impl Default for Channel {
|
|||||||
/// Because the Core logic runs at 60Hz and Audio is generated at 48kHz,
|
/// Because the Core logic runs at 60Hz and Audio is generated at 48kHz,
|
||||||
/// we use an asynchronous command queue to synchronize them.
|
/// we use an asynchronous command queue to synchronize them.
|
||||||
pub enum AudioCommand {
|
pub enum AudioCommand {
|
||||||
MusicPlay {
|
|
||||||
group: usize,
|
|
||||||
bank: Arc<MusicBank>,
|
|
||||||
looping: bool,
|
|
||||||
},
|
|
||||||
Control(AudioControl),
|
|
||||||
/// Start playing a sample on a specific voice.
|
/// Start playing a sample on a specific voice.
|
||||||
Play {
|
Play {
|
||||||
sample: Arc<Sample>,
|
sample: Arc<Sample>,
|
||||||
alive: Option<Arc<AtomicBool>>,
|
|
||||||
voice_id: usize,
|
voice_id: usize,
|
||||||
volume: u8,
|
volume: u8,
|
||||||
pan: u8,
|
pan: u8,
|
||||||
@@ -79,24 +64,13 @@ pub enum AudioCommand {
|
|||||||
loop_mode: LoopMode,
|
loop_mode: LoopMode,
|
||||||
},
|
},
|
||||||
/// Stop playback on a voice when this command is applied.
|
/// Stop playback on a voice when this command is applied.
|
||||||
Stop {
|
Stop { voice_id: usize },
|
||||||
voice_id: usize,
|
|
||||||
},
|
|
||||||
/// Update volume of an ongoing playback.
|
/// Update volume of an ongoing playback.
|
||||||
SetVolume {
|
SetVolume { voice_id: usize, volume: u8 },
|
||||||
voice_id: usize,
|
|
||||||
volume: u8,
|
|
||||||
},
|
|
||||||
/// Update panning of an ongoing playback.
|
/// Update panning of an ongoing playback.
|
||||||
SetPan {
|
SetPan { voice_id: usize, pan: u8 },
|
||||||
voice_id: usize,
|
|
||||||
pan: u8,
|
|
||||||
},
|
|
||||||
/// Update pitch of an ongoing playback.
|
/// Update pitch of an ongoing playback.
|
||||||
SetPitch {
|
SetPitch { voice_id: usize, pitch: f64 },
|
||||||
voice_id: usize,
|
|
||||||
pitch: f64,
|
|
||||||
},
|
|
||||||
}
|
}
|
||||||
|
|
||||||
mod transport;
|
mod transport;
|
||||||
@@ -135,7 +109,7 @@ impl Audio {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn enqueue(&mut self, voice: usize, command: AudioCommand) -> AudioOpStatus {
|
fn enqueue(&mut self, voice: usize, command: AudioCommand) -> AudioOpStatus {
|
||||||
if voice >= SFX_CHANNELS {
|
if voice >= MAX_CHANNELS {
|
||||||
return AudioOpStatus::VoiceInvalid;
|
return AudioOpStatus::VoiceInvalid;
|
||||||
}
|
}
|
||||||
let admitted = if self.in_lifecycle {
|
let admitted = if self.in_lifecycle {
|
||||||
@@ -168,7 +142,7 @@ impl AudioBridge for Audio {
|
|||||||
priority: u8,
|
priority: u8,
|
||||||
loop_mode: LoopMode,
|
loop_mode: LoopMode,
|
||||||
) -> AudioOpStatus {
|
) -> AudioOpStatus {
|
||||||
if voice_id >= SFX_CHANNELS {
|
if voice_id >= MAX_CHANNELS {
|
||||||
return AudioOpStatus::VoiceInvalid;
|
return AudioOpStatus::VoiceInvalid;
|
||||||
}
|
}
|
||||||
if !pitch.is_finite() || pitch <= 0.0 {
|
if !pitch.is_finite() || pitch <= 0.0 {
|
||||||
@@ -180,19 +154,7 @@ impl AudioBridge for Audio {
|
|||||||
let Some(sample) = bank.samples.get(sample_id as usize).cloned() else {
|
let Some(sample) = bank.samples.get(sample_id as usize).cloned() else {
|
||||||
return AudioOpStatus::SampleNotFound;
|
return AudioOpStatus::SampleNotFound;
|
||||||
};
|
};
|
||||||
self.enqueue(
|
self.play_sample(sample, voice_id, volume, pan, pitch, priority, loop_mode)
|
||||||
voice_id,
|
|
||||||
AudioCommand::Play {
|
|
||||||
sample,
|
|
||||||
alive: Some(bank.alive.clone()),
|
|
||||||
voice_id,
|
|
||||||
volume,
|
|
||||||
pan,
|
|
||||||
pitch,
|
|
||||||
priority,
|
|
||||||
loop_mode,
|
|
||||||
},
|
|
||||||
)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn play_sample(
|
fn play_sample(
|
||||||
@@ -205,7 +167,7 @@ impl AudioBridge for Audio {
|
|||||||
priority: u8,
|
priority: u8,
|
||||||
loop_mode: LoopMode,
|
loop_mode: LoopMode,
|
||||||
) -> AudioOpStatus {
|
) -> AudioOpStatus {
|
||||||
if voice_id >= SFX_CHANNELS {
|
if voice_id >= MAX_CHANNELS {
|
||||||
return AudioOpStatus::VoiceInvalid;
|
return AudioOpStatus::VoiceInvalid;
|
||||||
}
|
}
|
||||||
if !pitch.is_finite() || pitch <= 0.0 {
|
if !pitch.is_finite() || pitch <= 0.0 {
|
||||||
@@ -213,57 +175,10 @@ impl AudioBridge for Audio {
|
|||||||
}
|
}
|
||||||
self.enqueue(
|
self.enqueue(
|
||||||
voice_id,
|
voice_id,
|
||||||
AudioCommand::Play {
|
AudioCommand::Play { sample, voice_id, volume, pan, pitch, priority, loop_mode },
|
||||||
sample,
|
|
||||||
alive: None,
|
|
||||||
voice_id,
|
|
||||||
volume,
|
|
||||||
pan,
|
|
||||||
pitch,
|
|
||||||
priority,
|
|
||||||
loop_mode,
|
|
||||||
},
|
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn music_play(&mut self, group: usize, bank: usize, looping: bool) -> AudioOpStatus {
|
|
||||||
if group > 1 {
|
|
||||||
return AudioOpStatus::ArgRangeInvalid;
|
|
||||||
}
|
|
||||||
let Some(bank) = self.sound_banks.music_bank_slot(bank) else {
|
|
||||||
return AudioOpStatus::BankInvalid;
|
|
||||||
};
|
|
||||||
self.enqueue(0, AudioCommand::MusicPlay { group, bank, looping })
|
|
||||||
}
|
|
||||||
fn control(&mut self, control: AudioControl) -> AudioOpStatus {
|
|
||||||
let valid = match control {
|
|
||||||
AudioControl::MusicStop { group }
|
|
||||||
| AudioControl::MusicPause { group, .. }
|
|
||||||
| AudioControl::MusicVolume { group, .. }
|
|
||||||
| AudioControl::MusicFade { group, .. } => group < 2,
|
|
||||||
AudioControl::Crossfade { source, target, .. } => {
|
|
||||||
source < 2 && target < 2 && source != target
|
|
||||||
}
|
|
||||||
AudioControl::BusVolume { bus, .. } => bus < 3,
|
|
||||||
AudioControl::GroupVolume { group, .. } => group < 3,
|
|
||||||
AudioControl::SfxSend { voice, .. } => voice < SFX_CHANNELS,
|
|
||||||
AudioControl::Effect { group, cutoff_hz, delay_frames, feedback, wet, dry } => {
|
|
||||||
group < 3
|
|
||||||
&& cutoff_hz <= OUTPUT_SAMPLE_RATE / 2
|
|
||||||
&& delay_frames <= 96_000
|
|
||||||
&& feedback.is_finite()
|
|
||||||
&& feedback.abs() < 1.0
|
|
||||||
&& wet.is_finite()
|
|
||||||
&& dry.is_finite()
|
|
||||||
&& (0.0..=1.0).contains(&wet)
|
|
||||||
&& (0.0..=1.0).contains(&dry)
|
|
||||||
}
|
|
||||||
};
|
|
||||||
if !valid {
|
|
||||||
return AudioOpStatus::ArgRangeInvalid;
|
|
||||||
}
|
|
||||||
self.enqueue(0, AudioCommand::Control(control))
|
|
||||||
}
|
|
||||||
fn stop(&mut self, voice_id: usize) -> AudioOpStatus {
|
fn stop(&mut self, voice_id: usize) -> AudioOpStatus {
|
||||||
self.enqueue(voice_id, AudioCommand::Stop { voice_id })
|
self.enqueue(voice_id, AudioCommand::Stop { voice_id })
|
||||||
}
|
}
|
||||||
@@ -274,7 +189,7 @@ impl AudioBridge for Audio {
|
|||||||
self.enqueue(voice_id, AudioCommand::SetPan { voice_id, pan })
|
self.enqueue(voice_id, AudioCommand::SetPan { voice_id, pan })
|
||||||
}
|
}
|
||||||
fn set_pitch(&mut self, voice_id: usize, pitch: f64) -> AudioOpStatus {
|
fn set_pitch(&mut self, voice_id: usize, pitch: f64) -> AudioOpStatus {
|
||||||
if voice_id >= SFX_CHANNELS {
|
if voice_id >= MAX_CHANNELS {
|
||||||
return AudioOpStatus::VoiceInvalid;
|
return AudioOpStatus::VoiceInvalid;
|
||||||
}
|
}
|
||||||
if !pitch.is_finite() || pitch <= 0.0 {
|
if !pitch.is_finite() || pitch <= 0.0 {
|
||||||
@@ -396,7 +311,7 @@ mod control_tests {
|
|||||||
for _ in 0..MAX_COMMANDS_PER_FRAME - 1 {
|
for _ in 0..MAX_COMMANDS_PER_FRAME - 1 {
|
||||||
assert_eq!(audio.stop(0), AudioOpStatus::Ok);
|
assert_eq!(audio.stop(0), AudioOpStatus::Ok);
|
||||||
}
|
}
|
||||||
assert_eq!(audio.set_volume(7, 0), AudioOpStatus::Ok);
|
assert_eq!(audio.set_volume(15, 0), AudioOpStatus::Ok);
|
||||||
assert_eq!(audio.set_pan(0, 255), AudioOpStatus::CommandLimit);
|
assert_eq!(audio.set_pan(0, 255), AudioOpStatus::CommandLimit);
|
||||||
assert_eq!(audio.set_pitch(16, f64::NAN), AudioOpStatus::VoiceInvalid);
|
assert_eq!(audio.set_pitch(16, f64::NAN), AudioOpStatus::VoiceInvalid);
|
||||||
assert_eq!(audio.set_pitch(0, f64::NAN), AudioOpStatus::ArgRangeInvalid);
|
assert_eq!(audio.set_pitch(0, f64::NAN), AudioOpStatus::ArgRangeInvalid);
|
||||||
|
|||||||
@@ -1,592 +0,0 @@
|
|||||||
//! SBNK/MBNK v1. IMA WAVE4 algorithm implemented here from the published Intel
|
|
||||||
//! format, not copied from a third-party decoder. Project MIT license applies.
|
|
||||||
use prometeu_hal::{
|
|
||||||
music_bank::{Instrument, MusicBank, MusicCompiler, MusicEvent},
|
|
||||||
sample::Sample,
|
|
||||||
sound_bank::{AudioBankMetrics, SoundBank},
|
|
||||||
};
|
|
||||||
use std::sync::Arc;
|
|
||||||
|
|
||||||
pub const HEADER_BYTES: usize = 48;
|
|
||||||
pub const SAMPLE_BYTES: usize = 40;
|
|
||||||
pub const INSTRUMENT_BYTES: usize = 64;
|
|
||||||
pub const EVENT_BYTES: usize = 32;
|
|
||||||
|
|
||||||
pub enum DecodedAudioBank {
|
|
||||||
Sound(SoundBank),
|
|
||||||
Music(MusicBank),
|
|
||||||
}
|
|
||||||
impl DecodedAudioBank {
|
|
||||||
pub fn decoded_size(&self) -> usize {
|
|
||||||
match self {
|
|
||||||
Self::Sound(b) => b.metrics.canonical_decoded_bytes,
|
|
||||||
Self::Music(b) => b.metrics.canonical_decoded_bytes,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn bytes(data: &[u8], offset: usize, len: usize) -> Result<&[u8], String> {
|
|
||||||
data.get(offset..offset.checked_add(len).ok_or("audio offset overflow")?)
|
|
||||||
.ok_or_else(|| "truncated audio bank".into())
|
|
||||||
}
|
|
||||||
fn u16le(b: &[u8], o: usize) -> Result<u16, String> {
|
|
||||||
Ok(u16::from_le_bytes(bytes(b, o, 2)?.try_into().unwrap()))
|
|
||||||
}
|
|
||||||
fn u32le(b: &[u8], o: usize) -> Result<u32, String> {
|
|
||||||
Ok(u32::from_le_bytes(bytes(b, o, 4)?.try_into().unwrap()))
|
|
||||||
}
|
|
||||||
fn zero(b: &[u8]) -> Result<(), String> {
|
|
||||||
if b.iter().any(|&x| x != 0) { Err("nonzero audio reserved bytes".into()) } else { Ok(()) }
|
|
||||||
}
|
|
||||||
fn vector<T>(n: usize) -> Result<Vec<T>, String> {
|
|
||||||
let mut v = Vec::new();
|
|
||||||
v.try_reserve_exact(n).map_err(|_| "audio allocation failed")?;
|
|
||||||
Ok(v)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// One bank owns its serialized bytes while materializing. IO and CPU preparation
|
|
||||||
/// yield separately; no partially decoded bank escapes this object.
|
|
||||||
pub struct AudioBankMaterializer<'a> {
|
|
||||||
data: std::borrow::Cow<'a, [u8]>,
|
|
||||||
music: bool,
|
|
||||||
ns: usize,
|
|
||||||
ni: usize,
|
|
||||||
ne: usize,
|
|
||||||
ppq: u32,
|
|
||||||
tempo: u32,
|
|
||||||
duration: u32,
|
|
||||||
loop_tick: Option<u32>,
|
|
||||||
tracks: usize,
|
|
||||||
name: String,
|
|
||||||
samples_at: usize,
|
|
||||||
metadata: usize,
|
|
||||||
payload_end: usize,
|
|
||||||
samples: Vec<Arc<Sample>>,
|
|
||||||
instruments: Vec<Instrument>,
|
|
||||||
events: Vec<MusicEvent>,
|
|
||||||
current: Option<SampleMaterializer>,
|
|
||||||
compiler: Option<MusicCompiler>,
|
|
||||||
pcm_bytes: usize,
|
|
||||||
started: std::time::Instant,
|
|
||||||
}
|
|
||||||
struct SampleMaterializer {
|
|
||||||
sample: Sample,
|
|
||||||
codec: u8,
|
|
||||||
frames: usize,
|
|
||||||
offset: usize,
|
|
||||||
size: usize,
|
|
||||||
align: usize,
|
|
||||||
spb: usize,
|
|
||||||
consumed: usize,
|
|
||||||
}
|
|
||||||
impl<'a> AudioBankMaterializer<'a> {
|
|
||||||
pub fn new(data: std::borrow::Cow<'a, [u8]>, music: bool) -> Result<Self, String> {
|
|
||||||
let started = std::time::Instant::now();
|
|
||||||
bytes(&data, 0, HEADER_BYTES)?;
|
|
||||||
if &data[..4] != if music { b"MBNK" } else { b"SBNK" }
|
|
||||||
|| u16le(&data, 4)? != 1
|
|
||||||
|| u16le(&data, 6)? != 0
|
|
||||||
{
|
|
||||||
return Err("unsupported audio bank magic/version/flags".into());
|
|
||||||
}
|
|
||||||
let ns = u32le(&data, 8)? as usize;
|
|
||||||
let ni = u32le(&data, 12)? as usize;
|
|
||||||
let ne = u32le(&data, 16)? as usize;
|
|
||||||
let ppq = u32le(&data, 20)?;
|
|
||||||
let tempo = u32le(&data, 24)?;
|
|
||||||
let duration = u32le(&data, 28)?;
|
|
||||||
let lp = u32le(&data, 32)?;
|
|
||||||
let tracks = u32le(&data, 36)? as usize;
|
|
||||||
let name_len = u32le(&data, 40)? as usize;
|
|
||||||
zero(bytes(&data, 44, 4)?)?;
|
|
||||||
if ns > 65536
|
|
||||||
|| ppq != 960
|
|
||||||
|| tempo == 0
|
|
||||||
|| (!music
|
|
||||||
&& (ns == 0
|
|
||||||
|| ni != 0
|
|
||||||
|| ne != 0
|
|
||||||
|| duration != 0
|
|
||||||
|| tracks != 0
|
|
||||||
|| lp != u32::MAX))
|
|
||||||
{
|
|
||||||
return Err("invalid audio bank counts/clock".into());
|
|
||||||
}
|
|
||||||
if music
|
|
||||||
&& (duration == 0 || !(1..=256).contains(&tracks) || (lp != u32::MAX && lp >= duration))
|
|
||||||
{
|
|
||||||
return Err("invalid music clock/tracks/loop".into());
|
|
||||||
}
|
|
||||||
let mut offset = HEADER_BYTES.checked_add(name_len).ok_or("audio name overflow")?;
|
|
||||||
let samples_at = offset;
|
|
||||||
for (n, size) in [(ns, SAMPLE_BYTES), (ni, INSTRUMENT_BYTES), (ne, EVENT_BYTES)] {
|
|
||||||
offset = offset
|
|
||||||
.checked_add(n.checked_mul(size).ok_or("audio table overflow")?)
|
|
||||||
.ok_or("audio table overflow")?;
|
|
||||||
}
|
|
||||||
bytes(&data, 0, offset)?;
|
|
||||||
let text = std::str::from_utf8(bytes(&data, HEADER_BYTES, name_len)?)
|
|
||||||
.map_err(|_| "audio name UTF-8")?;
|
|
||||||
let mut name = String::new();
|
|
||||||
name.try_reserve_exact(text.len()).map_err(|_| "audio allocation failed")?;
|
|
||||||
name.push_str(text);
|
|
||||||
Ok(Self {
|
|
||||||
data,
|
|
||||||
music,
|
|
||||||
ns,
|
|
||||||
ni,
|
|
||||||
ne,
|
|
||||||
ppq,
|
|
||||||
tempo,
|
|
||||||
duration,
|
|
||||||
loop_tick: (lp != u32::MAX).then_some(lp),
|
|
||||||
tracks,
|
|
||||||
name,
|
|
||||||
samples_at,
|
|
||||||
metadata: offset,
|
|
||||||
payload_end: offset,
|
|
||||||
samples: vector(ns)?,
|
|
||||||
instruments: vector(ni)?,
|
|
||||||
events: vector(ne)?,
|
|
||||||
current: None,
|
|
||||||
compiler: None,
|
|
||||||
pcm_bytes: 0,
|
|
||||||
started,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
fn start_sample(&mut self) -> Result<(), String> {
|
|
||||||
let d =
|
|
||||||
bytes(&self.data, self.samples_at + self.samples.len() * SAMPLE_BYTES, SAMPLE_BYTES)?;
|
|
||||||
let codec = d[0];
|
|
||||||
let channels = d[1];
|
|
||||||
let flags = u16le(d, 2)?;
|
|
||||||
let rate = u32le(d, 4)?;
|
|
||||||
let frames = u32le(d, 8)? as usize;
|
|
||||||
let start = u32le(d, 12)?;
|
|
||||||
let end = u32le(d, 16)?;
|
|
||||||
let offset = u32le(d, 20)? as usize;
|
|
||||||
let size = u32le(d, 24)? as usize;
|
|
||||||
let align = u16le(d, 28)? as usize;
|
|
||||||
let spb = u16le(d, 30)? as usize;
|
|
||||||
let pitch = u32le(d, 36)?;
|
|
||||||
zero(bytes(d, 34, 2)?)?;
|
|
||||||
if !(1..=2).contains(&channels)
|
|
||||||
|| rate == 0
|
|
||||||
|| pitch == 0
|
|
||||||
|| flags & !1 != 0
|
|
||||||
|| offset != self.payload_end
|
|
||||||
|| (flags == 0 && (start != 0 || end != 0))
|
|
||||||
|| (flags == 1 && (start >= end || end as usize > frames))
|
|
||||||
{
|
|
||||||
return Err("invalid audio sample descriptor/loop".into());
|
|
||||||
}
|
|
||||||
let scalar = frames.checked_mul(channels as usize).ok_or("PCM frame overflow")?;
|
|
||||||
let resident = scalar.checked_mul(2).ok_or("PCM byte overflow")?;
|
|
||||||
bytes(&self.data, offset, size)?;
|
|
||||||
match codec {
|
|
||||||
0 => {
|
|
||||||
if size != resident || align != 0 || spb != 0 {
|
|
||||||
return Err("PCM payload/frame count mismatch".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
1 => {
|
|
||||||
let c = channels as usize;
|
|
||||||
if align < 8 * c
|
|
||||||
|| !align.is_multiple_of(4 * c)
|
|
||||||
|| spb != 1 + (align - 4 * c) * 2 / c
|
|
||||||
|| !size.is_multiple_of(align)
|
|
||||||
|| size / align != frames.div_ceil(spb)
|
|
||||||
{
|
|
||||||
return Err("IMA block layout/frame count".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => return Err("unsupported sample codec".into()),
|
|
||||||
}
|
|
||||||
let mut sample = Sample::new(rate, vector(scalar)?).with_channels(channels)?;
|
|
||||||
if flags == 1 {
|
|
||||||
sample = sample.with_loop(start, end);
|
|
||||||
}
|
|
||||||
sample.default_volume = d[32];
|
|
||||||
sample.default_pan = d[33];
|
|
||||||
sample.default_pitch = pitch as f64 / 65536.0;
|
|
||||||
self.pcm_bytes =
|
|
||||||
self.pcm_bytes.checked_add(resident).ok_or("resident audio size overflow")?;
|
|
||||||
self.current = Some(SampleMaterializer {
|
|
||||||
sample,
|
|
||||||
codec,
|
|
||||||
frames,
|
|
||||||
offset,
|
|
||||||
size,
|
|
||||||
align,
|
|
||||||
spb,
|
|
||||||
consumed: 0,
|
|
||||||
});
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
/// Decode at most 4096 PCM bytes or one independently bounded IMA block;
|
|
||||||
/// parse at most 64 metadata records; compile at most 64 music records.
|
|
||||||
pub fn step(&mut self) -> Result<Option<DecodedAudioBank>, String> {
|
|
||||||
if let Some(compiler) = &mut self.compiler {
|
|
||||||
return match compiler.step()? {
|
|
||||||
Some(mut bank) => {
|
|
||||||
bank.metrics = self.metrics()?;
|
|
||||||
Ok(Some(DecodedAudioBank::Music(bank)))
|
|
||||||
}
|
|
||||||
None => Ok(None),
|
|
||||||
};
|
|
||||||
}
|
|
||||||
if self.samples.len() < self.ns {
|
|
||||||
if self.current.is_none() {
|
|
||||||
self.start_sample()?;
|
|
||||||
}
|
|
||||||
let current = self.current.as_mut().unwrap();
|
|
||||||
if current.consumed < current.size {
|
|
||||||
if current.codec == 0 {
|
|
||||||
let count = (current.size - current.consumed).min(4096);
|
|
||||||
let part = bytes(&self.data, current.offset + current.consumed, count)?;
|
|
||||||
current
|
|
||||||
.sample
|
|
||||||
.data
|
|
||||||
.extend(part.as_chunks::<2>().0.iter().map(|p| i16::from_le_bytes(*p)));
|
|
||||||
current.consumed += count;
|
|
||||||
} else {
|
|
||||||
let frames = (current.frames - current.sample.frames_len()).min(current.spb);
|
|
||||||
let pcm = decode_ima_wav4(
|
|
||||||
bytes(&self.data, current.offset + current.consumed, current.align)?,
|
|
||||||
current.sample.channels,
|
|
||||||
frames,
|
|
||||||
current.align,
|
|
||||||
current.spb,
|
|
||||||
)?;
|
|
||||||
current.sample.data.extend(pcm);
|
|
||||||
current.consumed += current.align;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if current.consumed == current.size {
|
|
||||||
self.payload_end = current.offset + current.size;
|
|
||||||
let current = self.current.take().unwrap();
|
|
||||||
self.samples.push(Arc::new(current.sample));
|
|
||||||
}
|
|
||||||
return Ok(None);
|
|
||||||
}
|
|
||||||
if self.payload_end != self.data.len() {
|
|
||||||
return Err("audio trailing/unreferenced payload".into());
|
|
||||||
}
|
|
||||||
if !self.music {
|
|
||||||
let mut bank = SoundBank::new(std::mem::take(&mut self.samples));
|
|
||||||
bank.name = std::mem::take(&mut self.name);
|
|
||||||
bank.metrics = self.metrics()?;
|
|
||||||
return Ok(Some(DecodedAudioBank::Sound(bank)));
|
|
||||||
}
|
|
||||||
let inst_at = self.samples_at + self.ns * SAMPLE_BYTES;
|
|
||||||
if self.instruments.len() < self.ni {
|
|
||||||
for _ in 0..64 {
|
|
||||||
if self.instruments.len() == self.ni {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
let d = bytes(
|
|
||||||
&self.data,
|
|
||||||
inst_at + self.instruments.len() * INSTRUMENT_BYTES,
|
|
||||||
INSTRUMENT_BYTES,
|
|
||||||
)?;
|
|
||||||
if d[7] & !1 != 0 {
|
|
||||||
return Err("instrument flags".into());
|
|
||||||
}
|
|
||||||
zero(bytes(d, 22, 2)?)?;
|
|
||||||
zero(bytes(d, 43, 21)?)?;
|
|
||||||
self.instruments.push(Instrument {
|
|
||||||
id: u16le(d, 0)?,
|
|
||||||
sample: u16le(d, 2)?,
|
|
||||||
low: d[4],
|
|
||||||
high: d[5],
|
|
||||||
root: d[6],
|
|
||||||
looping: d[7] & 1 != 0,
|
|
||||||
tuning_cents: u16le(d, 8)? as i16,
|
|
||||||
pan: d[10],
|
|
||||||
gain: d[11],
|
|
||||||
attack_us: u32le(d, 12)?,
|
|
||||||
decay_us: u32le(d, 16)?,
|
|
||||||
sustain: u16le(d, 20)?,
|
|
||||||
release_us: u32le(d, 24)?,
|
|
||||||
vibrato_millihz: u32le(d, 28)?,
|
|
||||||
vibrato_cents: u16le(d, 32)?,
|
|
||||||
tremolo_depth: u16le(d, 34)?,
|
|
||||||
tremolo_millihz: u32le(d, 36)?,
|
|
||||||
send: u16le(d, 40)?,
|
|
||||||
curve: d[42],
|
|
||||||
});
|
|
||||||
}
|
|
||||||
return Ok(None);
|
|
||||||
}
|
|
||||||
if self.events.len() < self.ne {
|
|
||||||
let at = inst_at + self.ni * INSTRUMENT_BYTES;
|
|
||||||
for _ in 0..64 {
|
|
||||||
if self.events.len() == self.ne {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
let d = bytes(&self.data, at + self.events.len() * EVENT_BYTES, EVENT_BYTES)?;
|
|
||||||
self.events.push(MusicEvent {
|
|
||||||
tick: u32le(d, 0)?,
|
|
||||||
kind: d[4],
|
|
||||||
track: d[5],
|
|
||||||
flags: u16le(d, 6)?,
|
|
||||||
a: u32le(d, 8)?,
|
|
||||||
b: u32le(d, 12)?,
|
|
||||||
c: u32le(d, 16)? as i32,
|
|
||||||
d: u32le(d, 20)? as i32,
|
|
||||||
duration_frames: u32le(d, 24)?,
|
|
||||||
curve: u32le(d, 28)?,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
return Ok(None);
|
|
||||||
}
|
|
||||||
self.compiler = Some(MusicCompiler::new(
|
|
||||||
std::mem::take(&mut self.name),
|
|
||||||
std::mem::take(&mut self.samples),
|
|
||||||
std::mem::take(&mut self.instruments),
|
|
||||||
std::mem::take(&mut self.events),
|
|
||||||
self.ppq,
|
|
||||||
self.tempo,
|
|
||||||
self.duration,
|
|
||||||
self.loop_tick,
|
|
||||||
self.tracks,
|
|
||||||
)?);
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
fn metrics(&self) -> Result<AudioBankMetrics, String> {
|
|
||||||
Ok(AudioBankMetrics {
|
|
||||||
cartridge_bytes: self.data.len(),
|
|
||||||
pcm_bytes: self.pcm_bytes,
|
|
||||||
canonical_decoded_bytes: self
|
|
||||||
.metadata
|
|
||||||
.checked_add(self.pcm_bytes)
|
|
||||||
.ok_or("decoded audio size overflow")?,
|
|
||||||
materialization_ns: self.started.elapsed().as_nanos().min(u64::MAX as u128) as u64,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn decode_audio_bank(data: &[u8], music: bool) -> Result<DecodedAudioBank, String> {
|
|
||||||
let mut decoder = AudioBankMaterializer::new(std::borrow::Cow::Borrowed(data), music)?;
|
|
||||||
loop {
|
|
||||||
if let Some(bank) = decoder.step()? {
|
|
||||||
return Ok(bank);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const STEP: [i32; 89] = [
|
|
||||||
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66,
|
|
||||||
73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449,
|
|
||||||
494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272,
|
|
||||||
2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,
|
|
||||||
10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
|
|
||||||
];
|
|
||||||
const INDEX: [i32; 8] = [-1, -1, -1, -1, 2, 4, 6, 8];
|
|
||||||
fn ima_code(code: u8, predictor: &mut i32, index: &mut usize) -> i16 {
|
|
||||||
let step = STEP[*index];
|
|
||||||
let mut diff = step >> 3;
|
|
||||||
if code & 1 != 0 {
|
|
||||||
diff += step >> 2;
|
|
||||||
}
|
|
||||||
if code & 2 != 0 {
|
|
||||||
diff += step >> 1;
|
|
||||||
}
|
|
||||||
if code & 4 != 0 {
|
|
||||||
diff += step;
|
|
||||||
}
|
|
||||||
*predictor = (*predictor + if code & 8 != 0 { -diff } else { diff }).clamp(-32768, 32767);
|
|
||||||
*index = (*index as i32 + INDEX[(code & 7) as usize]).clamp(0, 88) as usize;
|
|
||||||
*predictor as i16
|
|
||||||
}
|
|
||||||
pub fn decode_ima_wav4(
|
|
||||||
data: &[u8],
|
|
||||||
channels: u8,
|
|
||||||
frames: usize,
|
|
||||||
align: usize,
|
|
||||||
spb: usize,
|
|
||||||
) -> Result<Vec<i16>, String> {
|
|
||||||
let c = channels as usize;
|
|
||||||
if !(1..=2).contains(&channels)
|
|
||||||
|| align > u16::MAX as usize
|
|
||||||
|| align < 8 * c
|
|
||||||
|| !align.is_multiple_of(4 * c)
|
|
||||||
|| spb != 1 + (align - 4 * c) * 2 / c
|
|
||||||
|| !data.len().is_multiple_of(align)
|
|
||||||
|| data.len() / align != frames.div_ceil(spb)
|
|
||||||
{
|
|
||||||
return Err("invalid IMA WAVE4 block/frame layout".into());
|
|
||||||
}
|
|
||||||
let mut out = vector(frames.checked_mul(c).ok_or("IMA frame overflow")?)?;
|
|
||||||
for (block_index, block) in data.chunks_exact(align).enumerate() {
|
|
||||||
let mut pred = [0i32; 2];
|
|
||||||
let mut index = [0usize; 2];
|
|
||||||
for ch in 0..c {
|
|
||||||
pred[ch] = i16::from_le_bytes([block[ch * 4], block[ch * 4 + 1]]) as i32;
|
|
||||||
index[ch] = block[ch * 4 + 2] as usize;
|
|
||||||
if index[ch] > 88 || block[ch * 4 + 3] != 0 {
|
|
||||||
return Err("IMA predictor index/reserved".into());
|
|
||||||
}
|
|
||||||
out.push(pred[ch] as i16);
|
|
||||||
}
|
|
||||||
let remaining = (frames - block_index * spb).min(spb);
|
|
||||||
for group in 0..(spb - 1) / 8 {
|
|
||||||
let mut decoded = [[0i16; 8]; 2];
|
|
||||||
for ch in 0..c {
|
|
||||||
for n in 0..8 {
|
|
||||||
let b = block[4 * c + group * 4 * c + ch * 4 + n / 2];
|
|
||||||
let code = (b >> ((n % 2) * 4)) & 15;
|
|
||||||
if 1 + group * 8 + n >= remaining && code != 0 {
|
|
||||||
return Err("nonzero IMA padding".into());
|
|
||||||
}
|
|
||||||
decoded[ch][n] = ima_code(code, &mut pred[ch], &mut index[ch]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for n in 0..8 {
|
|
||||||
if 1 + group * 8 + n < remaining {
|
|
||||||
for channel in decoded.iter().take(c) {
|
|
||||||
out.push(channel[n]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(out)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Deterministic storage encoder used by conformance tools/fixtures (never RT).
|
|
||||||
pub fn encode_ima_wav4(pcm: &[i16], channels: u8, align: usize) -> Result<Vec<u8>, String> {
|
|
||||||
let c = channels as usize;
|
|
||||||
if !(1..=2).contains(&channels)
|
|
||||||
|| !pcm.len().is_multiple_of(c)
|
|
||||||
|| align > u16::MAX as usize
|
|
||||||
|| align < 8 * c
|
|
||||||
|| !align.is_multiple_of(4 * c)
|
|
||||||
{
|
|
||||||
return Err("IMA encoder shape".into());
|
|
||||||
}
|
|
||||||
let spb = 1 + (align - 4 * c) * 2 / c;
|
|
||||||
if spb > u16::MAX as usize {
|
|
||||||
return Err("IMA block exceeds descriptor range".into());
|
|
||||||
}
|
|
||||||
let frames = pcm.len() / c;
|
|
||||||
let nblocks = frames.div_ceil(spb);
|
|
||||||
let mut out = vector(nblocks.checked_mul(align).ok_or("IMA encoded size overflow")?)?;
|
|
||||||
for block in 0..nblocks {
|
|
||||||
let first = block * spb;
|
|
||||||
let count = (frames - first).min(spb);
|
|
||||||
let mut pred = [0i32; 2];
|
|
||||||
let mut index = [0usize; 2];
|
|
||||||
for ch in 0..c {
|
|
||||||
pred[ch] = pcm[first * c + ch] as i32;
|
|
||||||
let n = (count - 1).min(32);
|
|
||||||
let sum: i32 = (1..=n)
|
|
||||||
.map(|i| {
|
|
||||||
(pcm[(first + i) * c + ch] as i32 - pcm[(first + i - 1) * c + ch] as i32).abs()
|
|
||||||
})
|
|
||||||
.sum();
|
|
||||||
let mean = if n == 0 { 0 } else { sum / n as i32 };
|
|
||||||
index[ch] = STEP.iter().position(|&s| s >= mean).unwrap_or(88);
|
|
||||||
out.extend_from_slice(&(pred[ch] as i16).to_le_bytes());
|
|
||||||
out.push(index[ch] as u8);
|
|
||||||
out.push(0);
|
|
||||||
}
|
|
||||||
for group in 0..(spb - 1) / 8 {
|
|
||||||
for ch in 0..c {
|
|
||||||
for byte in 0..4 {
|
|
||||||
let mut packed = 0;
|
|
||||||
for nibble in 0..2 {
|
|
||||||
let f = 1 + group * 8 + byte * 2 + nibble;
|
|
||||||
let code = if f >= count {
|
|
||||||
0
|
|
||||||
} else {
|
|
||||||
let diff = pcm[(first + f) * c + ch] as i32 - pred[ch];
|
|
||||||
let mut magnitude = diff.abs();
|
|
||||||
let step = STEP[index[ch]];
|
|
||||||
let mut code = if diff < 0 { 8 } else { 0 };
|
|
||||||
if magnitude >= step {
|
|
||||||
code |= 4;
|
|
||||||
magnitude -= step;
|
|
||||||
}
|
|
||||||
if magnitude >= step >> 1 {
|
|
||||||
code |= 2;
|
|
||||||
magnitude -= step >> 1;
|
|
||||||
}
|
|
||||||
if magnitude >= step >> 2 {
|
|
||||||
code |= 1;
|
|
||||||
}
|
|
||||||
code
|
|
||||||
};
|
|
||||||
ima_code(code, &mut pred[ch], &mut index[ch]);
|
|
||||||
packed |= code << (nibble * 4);
|
|
||||||
}
|
|
||||||
out.push(packed);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(out)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
#[test]
|
|
||||||
fn ima_known_nibbles_and_stereo_headers() {
|
|
||||||
let block = [0, 0, 0, 0, 0x11, 0, 0, 0];
|
|
||||||
assert_eq!(decode_ima_wav4(&block, 1, 3, 8, 9).unwrap(), [0, 1, 2]);
|
|
||||||
let mut stereo = vec![0, 0, 0, 0, 100, 0, 0, 0];
|
|
||||||
stereo.extend([0u8; 8]);
|
|
||||||
let decoded = decode_ima_wav4(&stereo, 2, 9, 16, 9).unwrap();
|
|
||||||
assert_eq!(&decoded[..6], [0, 100, 0, 100, 0, 100]);
|
|
||||||
stereo[2] = 89;
|
|
||||||
assert!(decode_ima_wav4(&stereo, 2, 9, 16, 9).is_err());
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn ima_partial_block_padding_round_trip_is_deterministic() {
|
|
||||||
let pcm: Vec<i16> = (0..1111)
|
|
||||||
.flat_map(|i| {
|
|
||||||
[
|
|
||||||
((i as f64 * 0.03).sin() * 12000.0) as i16,
|
|
||||||
((i as f64 * 0.02).cos() * 9000.0) as i16,
|
|
||||||
]
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
let encoded = encode_ima_wav4(&pcm, 2, 512).unwrap();
|
|
||||||
assert_eq!(encoded, encode_ima_wav4(&pcm, 2, 512).unwrap());
|
|
||||||
let decoded = decode_ima_wav4(&encoded, 2, 1111, 512, 505).unwrap();
|
|
||||||
assert_eq!(decoded.len(), pcm.len());
|
|
||||||
assert_eq!(decoded[1010], pcm[1010]);
|
|
||||||
assert!(decode_ima_wav4(&encoded[..encoded.len() - 1], 2, 1111, 512, 505).is_err());
|
|
||||||
let error: f64 =
|
|
||||||
pcm.iter().zip(decoded).map(|(&a, b)| (a as f64 - b as f64).powi(2)).sum::<f64>()
|
|
||||||
/ pcm.len() as f64;
|
|
||||||
assert!(error.sqrt() < 400.0, "RMS error {error}");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
pub(crate) fn test_pcm_bank(raw: &[u8], rate: u32) -> Vec<u8> {
|
|
||||||
let mut bytes = vec![0u8; 88];
|
|
||||||
bytes[..4].copy_from_slice(b"SBNK");
|
|
||||||
bytes[4] = 1;
|
|
||||||
for (at, value) in [
|
|
||||||
(8, 1),
|
|
||||||
(20, 960),
|
|
||||||
(24, 500000),
|
|
||||||
(32, u32::MAX),
|
|
||||||
(52, rate),
|
|
||||||
(56, (raw.len() / 2) as u32),
|
|
||||||
(68, 88),
|
|
||||||
(72, raw.len() as u32),
|
|
||||||
(84, 65536),
|
|
||||||
] {
|
|
||||||
bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
|
|
||||||
}
|
|
||||||
bytes[49] = 1;
|
|
||||||
bytes[80] = 255;
|
|
||||||
bytes[81] = 128;
|
|
||||||
bytes.extend_from_slice(raw);
|
|
||||||
bytes
|
|
||||||
}
|
|
||||||
#[cfg(test)]
|
|
||||||
#[path = "bank_tests.rs"]
|
|
||||||
mod bank_tests;
|
|
||||||
@@ -1,182 +0,0 @@
|
|||||||
use super::*;
|
|
||||||
use crate::{AssetManager, MemoryBanks, SoundBankPoolAccess};
|
|
||||||
use prometeu_hal::{
|
|
||||||
asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus, SlotRef},
|
|
||||||
cartridge::AssetsPayloadSource,
|
|
||||||
};
|
|
||||||
use std::time::{Duration, Instant};
|
|
||||||
fn fixtures() -> Vec<(&'static [u8], bool)> {
|
|
||||||
vec![
|
|
||||||
(
|
|
||||||
include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/pcm-only.sbnk"
|
|
||||||
)),
|
|
||||||
false,
|
|
||||||
),
|
|
||||||
(
|
|
||||||
include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/ima-only.sbnk"
|
|
||||||
)),
|
|
||||||
false,
|
|
||||||
),
|
|
||||||
(
|
|
||||||
include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-sound.sbnk"
|
|
||||||
)),
|
|
||||||
false,
|
|
||||||
),
|
|
||||||
(
|
|
||||||
include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-music.mbnk"
|
|
||||||
)),
|
|
||||||
true,
|
|
||||||
),
|
|
||||||
]
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn packer_binary_fixtures_materialize_mixed_stereo_banks_and_separate_encoded_from_pcm_sizes() {
|
|
||||||
for (index, (bytes, music)) in fixtures().into_iter().enumerate() {
|
|
||||||
let decoded = decode_audio_bank(bytes, music).unwrap();
|
|
||||||
let (samples, metrics) = match &decoded {
|
|
||||||
DecodedAudioBank::Sound(b) => (&b.samples, b.metrics),
|
|
||||||
DecodedAudioBank::Music(b) => {
|
|
||||||
assert_eq!(b.events.len(), 4);
|
|
||||||
assert_eq!(b.instruments.len(), 2);
|
|
||||||
assert_eq!(b.tracks, 2);
|
|
||||||
(&b.samples, b.metrics)
|
|
||||||
}
|
|
||||||
};
|
|
||||||
assert_eq!(metrics.cartridge_bytes, bytes.len());
|
|
||||||
assert_eq!(metrics.pcm_bytes, if index < 2 { 2000 } else { 6000 });
|
|
||||||
assert_eq!(samples[0].frames_len(), 1000);
|
|
||||||
assert_eq!(samples[0].loop_end, Some(1000));
|
|
||||||
if index >= 2 {
|
|
||||||
assert_eq!(samples[1].channels, 2);
|
|
||||||
assert_eq!(samples[1].frames_len(), 1000);
|
|
||||||
}
|
|
||||||
if index != 0 {
|
|
||||||
assert!(decoded.decoded_size() > bytes.len());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn complete_validation_rejects_truncation_unknown_codec_bad_loops_and_reserved_bytes() {
|
|
||||||
for (bytes, music) in fixtures() {
|
|
||||||
for cut in [0, 4, 47, 48, bytes.len() - 1] {
|
|
||||||
assert!(decode_audio_bank(&bytes[..cut], music).is_err());
|
|
||||||
}
|
|
||||||
let name = u32le(bytes, 40).unwrap() as usize;
|
|
||||||
let sample = 48 + name;
|
|
||||||
for (at, value) in
|
|
||||||
[(4, 2), (44, 1), (sample, 99), (sample + 1, 3), (sample + 2, 2), (sample + 34, 1)]
|
|
||||||
{
|
|
||||||
let mut bad = bytes.to_vec();
|
|
||||||
bad[at] = value;
|
|
||||||
assert!(decode_audio_bank(&bad, music).is_err(), "{at}");
|
|
||||||
}
|
|
||||||
let mut bad = bytes.to_vec();
|
|
||||||
bad[sample + 12..sample + 16].copy_from_slice(&1001u32.to_le_bytes());
|
|
||||||
assert!(decode_audio_bank(&bad, music).is_err());
|
|
||||||
let mut bad = bytes.to_vec();
|
|
||||||
bad.push(0);
|
|
||||||
assert!(decode_audio_bank(&bad, music).is_err());
|
|
||||||
// Mutating every byte must produce either a validated bank or a clean error.
|
|
||||||
for i in 0..bytes.len() {
|
|
||||||
let mut changed = bytes.to_vec();
|
|
||||||
changed[i] ^= 0xff;
|
|
||||||
let _ = decode_audio_bank(&changed, music);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn entry(id: i32, offset: usize, bytes: &[u8], music: bool) -> AssetEntry {
|
|
||||||
AssetEntry {
|
|
||||||
asset_id: id,
|
|
||||||
asset_name: format!("bank{id}"),
|
|
||||||
bank_type: if music { BankType::MUSIC } else { BankType::SOUNDS },
|
|
||||||
offset: offset as u64,
|
|
||||||
size: bytes.len() as u64,
|
|
||||||
decoded_size: decode_audio_bank(bytes, music).unwrap().decoded_size() as u64,
|
|
||||||
codec: AssetCodec::None,
|
|
||||||
metadata: serde_json::json!({"version":1}),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn ready(manager: &AssetManager, handle: u32) {
|
|
||||||
let end = Instant::now() + Duration::from_secs(3);
|
|
||||||
while matches!(
|
|
||||||
manager.status(handle),
|
|
||||||
LoadStatus::QUEUED | LoadStatus::LOADING | LoadStatus::PENDING | LoadStatus::ACTIVE
|
|
||||||
) {
|
|
||||||
assert!(Instant::now() < end);
|
|
||||||
std::thread::yield_now();
|
|
||||||
}
|
|
||||||
assert_eq!(manager.status(handle), LoadStatus::READY);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn audio_loading_commit_replacement_and_unload_are_atomic_and_type_isolated() {
|
|
||||||
let fixtures = fixtures();
|
|
||||||
let sound = fixtures[2].0;
|
|
||||||
let music = fixtures[3].0;
|
|
||||||
let mut payload = sound.to_vec();
|
|
||||||
payload.extend_from_slice(music);
|
|
||||||
let bad_at = payload.len();
|
|
||||||
let mut corrupt = sound.to_vec();
|
|
||||||
corrupt[0] = 0;
|
|
||||||
payload.extend(&corrupt);
|
|
||||||
let mut bad = entry(3, bad_at, sound, false);
|
|
||||||
bad.decoded_size += 1;
|
|
||||||
let banks = Arc::new(MemoryBanks::new());
|
|
||||||
let manager = AssetManager::new(
|
|
||||||
vec![entry(1, 0, sound, false), entry(2, sound.len(), music, true), bad],
|
|
||||||
AssetsPayloadSource::from_bytes(payload),
|
|
||||||
banks.clone(),
|
|
||||||
banks.clone(),
|
|
||||||
banks.clone(),
|
|
||||||
);
|
|
||||||
let s = manager.load(1, 0).unwrap();
|
|
||||||
ready(&manager, s);
|
|
||||||
assert!(banks.sound_bank_slot(0).is_none());
|
|
||||||
assert_eq!(manager.commit(s), AssetOpStatus::Ok);
|
|
||||||
manager.apply_commits();
|
|
||||||
let old = banks.sound_bank_slot(0).unwrap();
|
|
||||||
let m = manager.load(2, 0).unwrap();
|
|
||||||
ready(&manager, m);
|
|
||||||
manager.commit(m);
|
|
||||||
manager.apply_commits();
|
|
||||||
assert!(old.alive.load(std::sync::atomic::Ordering::Acquire));
|
|
||||||
assert!(banks.music_bank_slot(0).is_some());
|
|
||||||
let failing = manager.load(3, 0).unwrap();
|
|
||||||
let end = Instant::now() + Duration::from_secs(3);
|
|
||||||
while manager.status(failing) != LoadStatus::ERROR {
|
|
||||||
assert!(Instant::now() < end);
|
|
||||||
std::thread::yield_now();
|
|
||||||
}
|
|
||||||
manager.apply_commits();
|
|
||||||
assert!(Arc::ptr_eq(&old, &banks.sound_bank_slot(0).unwrap()));
|
|
||||||
let replacement = manager.load(1, 0).unwrap();
|
|
||||||
ready(&manager, replacement);
|
|
||||||
assert!(old.alive.load(std::sync::atomic::Ordering::Acquire));
|
|
||||||
manager.commit(replacement);
|
|
||||||
manager.apply_commits();
|
|
||||||
assert!(!old.alive.load(std::sync::atomic::Ordering::Acquire));
|
|
||||||
assert_eq!(manager.unload_audio(true, 0), AssetOpStatus::Ok);
|
|
||||||
assert!(banks.music_bank_slot(0).is_none());
|
|
||||||
assert!(banks.sound_bank_slot(0).is_some());
|
|
||||||
assert_eq!(manager.slot_info(SlotRef::music(0)).asset_id, None);
|
|
||||||
assert_eq!(manager.unload_audio(false, 0), AssetOpStatus::Ok);
|
|
||||||
assert!(banks.sound_bank_slot(0).is_none());
|
|
||||||
assert_eq!(manager.unload_audio(false, 16), AssetOpStatus::InvalidState);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn codec_tooling_rejects_overflowing_block_parameters_without_panicking() {
|
|
||||||
for align in [0, 4, usize::MAX - 3, usize::MAX] {
|
|
||||||
assert!(encode_ima_wav4(&[1, 2], 1, align).is_err());
|
|
||||||
assert!(decode_ima_wav4(&[0; 8], 1, 9, align, 9).is_err());
|
|
||||||
}
|
|
||||||
assert!(encode_ima_wav4(&[1], 1, 65532).is_err());
|
|
||||||
assert!(decode_ima_wav4(&[0; 8], 1, usize::MAX, 8, 9).is_err());
|
|
||||||
assert!(encode_ima_wav4(&[1], 0, 256).is_err());
|
|
||||||
}
|
|
||||||
@@ -1,924 +0,0 @@
|
|||||||
//! Host-independent bounded PCM engine. Construct resources off the render lane.
|
|
||||||
use super::{
|
|
||||||
AudioCommand, AudioDelivery, AudioTransport, Channel, LoopMode, MAX_CHANNELS,
|
|
||||||
MAX_COMMANDS_PER_FRAME, SFX_CHANNELS, SFX_START,
|
|
||||||
};
|
|
||||||
use prometeu_hal::{
|
|
||||||
audio_bridge::AudioControl,
|
|
||||||
music_bank::{Instrument, MAX_MUSIC_TRACKS, MusicBank, MusicEvent},
|
|
||||||
sample::Sample,
|
|
||||||
};
|
|
||||||
use std::{
|
|
||||||
sync::{
|
|
||||||
Arc,
|
|
||||||
atomic::{AtomicBool, Ordering},
|
|
||||||
},
|
|
||||||
time::{Duration, Instant},
|
|
||||||
};
|
|
||||||
|
|
||||||
pub const RETIRED_CAPACITY: usize = 2 * (3 * MAX_COMMANDS_PER_FRAME + MAX_CHANNELS + 2);
|
|
||||||
/// Owning resources leave the real-time lane in a preallocated packet.
|
|
||||||
#[allow(dead_code)]
|
|
||||||
enum Retired {
|
|
||||||
Sample(Arc<Sample>),
|
|
||||||
Bank(Arc<MusicBank>),
|
|
||||||
Token(Arc<AtomicBool>),
|
|
||||||
}
|
|
||||||
pub struct Packet {
|
|
||||||
retired: Vec<Retired>,
|
|
||||||
pub batches: [Option<Vec<AudioCommand>>; 2],
|
|
||||||
}
|
|
||||||
impl Default for Packet {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::new()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl Packet {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self { retired: Vec::with_capacity(RETIRED_CAPACITY), batches: [None, None] }
|
|
||||||
}
|
|
||||||
fn push(&mut self, owner: Retired) {
|
|
||||||
assert!(self.retired.len() < RETIRED_CAPACITY, "audio retirement bound");
|
|
||||||
self.retired.push(owner);
|
|
||||||
}
|
|
||||||
fn voice(&mut self, voice: &mut Channel) {
|
|
||||||
if let Some(s) = voice.sample.take() {
|
|
||||||
self.push(Retired::Sample(s));
|
|
||||||
}
|
|
||||||
if let Some(t) = voice.alive.take() {
|
|
||||||
self.push(Retired::Token(t));
|
|
||||||
}
|
|
||||||
voice.active = false;
|
|
||||||
}
|
|
||||||
pub fn recycle(&mut self, transport: &AudioTransport) {
|
|
||||||
self.retired.clear();
|
|
||||||
for batch in &mut self.batches {
|
|
||||||
if let Some(batch) = batch.take() {
|
|
||||||
transport.recycle_commands(batch);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// Service thread only: count distinct retired PCM payloads, excluding Arc overhead.
|
|
||||||
pub fn retained_pcm_bytes(&self) -> usize {
|
|
||||||
let mut seen = std::collections::HashSet::new();
|
|
||||||
let mut bytes = 0;
|
|
||||||
let mut add = |sample: &Arc<Sample>| {
|
|
||||||
if seen.insert(Arc::as_ptr(sample)) {
|
|
||||||
bytes += sample.data.capacity() * 2;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
for owner in &self.retired {
|
|
||||||
match owner {
|
|
||||||
Retired::Sample(sample) => add(sample),
|
|
||||||
Retired::Bank(bank) => {
|
|
||||||
for sample in bank.samples.iter() {
|
|
||||||
add(sample);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Retired::Token(_) => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for batch in self.batches.iter().flatten() {
|
|
||||||
for command in batch {
|
|
||||||
match command {
|
|
||||||
AudioCommand::Play { sample, .. } => add(sample),
|
|
||||||
AudioCommand::MusicPlay { bank, .. } => {
|
|
||||||
for sample in bank.samples.iter() {
|
|
||||||
add(sample);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
bytes
|
|
||||||
}
|
|
||||||
pub fn is_empty(&self) -> bool {
|
|
||||||
self.retired.is_empty() && self.batches.iter().all(Option::is_none)
|
|
||||||
}
|
|
||||||
pub fn capacity(&self) -> usize {
|
|
||||||
self.retired.capacity()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy)]
|
|
||||||
struct Ramp {
|
|
||||||
from: f64,
|
|
||||||
to: f64,
|
|
||||||
start: u64,
|
|
||||||
duration: u32,
|
|
||||||
smooth: bool,
|
|
||||||
}
|
|
||||||
impl Ramp {
|
|
||||||
fn constant(value: f64) -> Self {
|
|
||||||
Self { from: value, to: value, start: 0, duration: 0, smooth: false }
|
|
||||||
}
|
|
||||||
fn at(self, now: u64) -> f64 {
|
|
||||||
if self.duration == 0 {
|
|
||||||
return self.to;
|
|
||||||
}
|
|
||||||
let elapsed = now.saturating_sub(self.start);
|
|
||||||
if elapsed >= self.duration as u64 {
|
|
||||||
return self.to;
|
|
||||||
}
|
|
||||||
let x = elapsed as f64 / self.duration as f64;
|
|
||||||
let x = if self.smooth { x * x * (3.0 - 2.0 * x) } else { x };
|
|
||||||
self.from + (self.to - self.from) * x
|
|
||||||
}
|
|
||||||
fn set(&mut self, value: f64, now: u64, duration: u32, smooth: bool) {
|
|
||||||
*self = Self { from: self.at(now), to: value, start: now, duration, smooth };
|
|
||||||
}
|
|
||||||
fn done(self, now: u64) -> bool {
|
|
||||||
now.saturating_sub(self.start) >= self.duration as u64
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone, Copy)]
|
|
||||||
struct SendRamp {
|
|
||||||
base: Ramp,
|
|
||||||
scale: Ramp,
|
|
||||||
}
|
|
||||||
impl Default for SendRamp {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self { base: Ramp::constant(0.0), scale: Ramp::constant(1.0) }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl SendRamp {
|
|
||||||
fn at(self, now: u64, instrument_default: f64) -> f64 {
|
|
||||||
self.base.at(now) + self.scale.at(now) * instrument_default
|
|
||||||
}
|
|
||||||
fn set(&mut self, to: f64, now: u64, frames: u32, smooth: bool) {
|
|
||||||
self.base.set(to, now, frames, smooth);
|
|
||||||
self.scale.set(0.0, now, frames, smooth);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone, Copy)]
|
|
||||||
struct Track {
|
|
||||||
gain: Ramp,
|
|
||||||
pan: Ramp,
|
|
||||||
pitch: Ramp,
|
|
||||||
send: SendRamp,
|
|
||||||
vibrato: Option<(u32, f64)>,
|
|
||||||
tremolo: Option<(u32, f64)>,
|
|
||||||
}
|
|
||||||
impl Default for Track {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
gain: Ramp::constant(1.0),
|
|
||||||
pan: Ramp::constant(128.0),
|
|
||||||
pitch: Ramp::constant(0.0),
|
|
||||||
send: SendRamp::default(),
|
|
||||||
vibrato: None,
|
|
||||||
tremolo: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct MusicGroup {
|
|
||||||
bank: Option<Arc<MusicBank>>,
|
|
||||||
active: bool,
|
|
||||||
paused: bool,
|
|
||||||
looping: bool,
|
|
||||||
time: u128,
|
|
||||||
cursor: usize,
|
|
||||||
frame: u64,
|
|
||||||
iteration: u64,
|
|
||||||
tracks: [Track; MAX_MUSIC_TRACKS],
|
|
||||||
gain: Ramp,
|
|
||||||
stop_after_fade: bool,
|
|
||||||
}
|
|
||||||
impl Default for MusicGroup {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
bank: None,
|
|
||||||
active: false,
|
|
||||||
paused: false,
|
|
||||||
looping: false,
|
|
||||||
time: 0,
|
|
||||||
cursor: 0,
|
|
||||||
frame: 0,
|
|
||||||
iteration: 0,
|
|
||||||
tracks: [Track::default(); MAX_MUSIC_TRACKS],
|
|
||||||
gain: Ramp::constant(1.0),
|
|
||||||
stop_after_fade: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone, Copy)]
|
|
||||||
struct VoiceState {
|
|
||||||
inst: Instrument,
|
|
||||||
track: usize,
|
|
||||||
note_id: u32,
|
|
||||||
iteration: u64,
|
|
||||||
born: u64,
|
|
||||||
age: u64,
|
|
||||||
release_age: Option<u64>,
|
|
||||||
release_level: f64,
|
|
||||||
release_order: Option<u64>,
|
|
||||||
level: f64,
|
|
||||||
cached_cents: f64,
|
|
||||||
pitch_factor: f64,
|
|
||||||
glide: Ramp,
|
|
||||||
send: f64,
|
|
||||||
zone: usize,
|
|
||||||
}
|
|
||||||
impl Default for VoiceState {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
inst: Instrument::default(),
|
|
||||||
track: 0,
|
|
||||||
note_id: 0,
|
|
||||||
iteration: 0,
|
|
||||||
born: 0,
|
|
||||||
age: 0,
|
|
||||||
release_age: None,
|
|
||||||
release_level: 0.0,
|
|
||||||
release_order: None,
|
|
||||||
level: 1.0,
|
|
||||||
cached_cents: f64::INFINITY,
|
|
||||||
pitch_factor: 1.0,
|
|
||||||
glide: Ramp::constant(0.0),
|
|
||||||
send: 0.0,
|
|
||||||
zone: 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct Effect {
|
|
||||||
delay: Vec<[f32; 2]>,
|
|
||||||
write: usize,
|
|
||||||
history: usize,
|
|
||||||
frames: usize,
|
|
||||||
feedback: f32,
|
|
||||||
wet: f32,
|
|
||||||
dry: f32,
|
|
||||||
coefficient: f32,
|
|
||||||
filter: [f32; 2],
|
|
||||||
}
|
|
||||||
impl Effect {
|
|
||||||
fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
delay: vec![[0.0; 2]; 96_000],
|
|
||||||
write: 0,
|
|
||||||
history: 0,
|
|
||||||
frames: 0,
|
|
||||||
feedback: 0.0,
|
|
||||||
wet: 0.0,
|
|
||||||
dry: 1.0,
|
|
||||||
coefficient: 1.0,
|
|
||||||
filter: [0.0; 2],
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn reset(&mut self) {
|
|
||||||
self.write = 0;
|
|
||||||
self.history = 0;
|
|
||||||
self.filter = [0.0; 2];
|
|
||||||
}
|
|
||||||
fn process(&mut self, input: [f32; 2], send: [f32; 2]) -> [f32; 2] {
|
|
||||||
if self.frames == 0 && self.coefficient == 1.0 {
|
|
||||||
self.filter = input;
|
|
||||||
return [input[0] * self.dry, input[1] * self.dry];
|
|
||||||
}
|
|
||||||
let mut out = [0.0; 2];
|
|
||||||
for c in 0..2 {
|
|
||||||
self.filter[c] += self.coefficient * (input[c] - self.filter[c]);
|
|
||||||
// Flush subnormals without denormal-sensitive host settings.
|
|
||||||
if self.filter[c].abs() < 1e-20 {
|
|
||||||
self.filter[c] = 0.0;
|
|
||||||
}
|
|
||||||
let echo = if self.frames != 0 && self.history >= self.frames {
|
|
||||||
self.delay[(self.write + 96_000 - self.frames) % 96_000][c]
|
|
||||||
} else {
|
|
||||||
0.0
|
|
||||||
};
|
|
||||||
out[c] = self.filter[c] * self.dry + echo * self.wet;
|
|
||||||
self.delay[self.write][c] = send[c] + echo * self.feedback;
|
|
||||||
if self.delay[self.write][c].abs() < 1e-20 {
|
|
||||||
self.delay[self.write][c] = 0.0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
self.write = (self.write + 1) % 96_000;
|
|
||||||
self.history = (self.history + 1).min(96_000);
|
|
||||||
out
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Debug, Clone, Copy, Default)]
|
|
||||||
pub struct AudioDiagnostics {
|
|
||||||
pub frames: u64,
|
|
||||||
pub active_voices: usize,
|
|
||||||
pub maximum_voices: usize,
|
|
||||||
pub last_render_us: u64,
|
|
||||||
pub maximum_render_us: u64,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct AudioMixer {
|
|
||||||
pub voices: [Channel; MAX_CHANNELS],
|
|
||||||
states: [VoiceState; MAX_CHANNELS],
|
|
||||||
groups: [MusicGroup; 2],
|
|
||||||
effects: [Effect; 3],
|
|
||||||
bus: [f32; 3],
|
|
||||||
sfx_gain: f32,
|
|
||||||
exponential: [f64; 1025],
|
|
||||||
sine: [f64; 4097],
|
|
||||||
pub last_processing_time: Duration,
|
|
||||||
paused: bool,
|
|
||||||
epoch: u64,
|
|
||||||
pub diagnostics: AudioDiagnostics,
|
|
||||||
note_serial: u64,
|
|
||||||
}
|
|
||||||
impl Default for AudioMixer {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::new()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl AudioMixer {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
voices: std::array::from_fn(|_| Channel::default()),
|
|
||||||
states: [VoiceState::default(); MAX_CHANNELS],
|
|
||||||
groups: std::array::from_fn(|_| MusicGroup::default()),
|
|
||||||
effects: std::array::from_fn(|_| Effect::new()),
|
|
||||||
bus: [1.0; 3],
|
|
||||||
sfx_gain: 1.0,
|
|
||||||
exponential: std::array::from_fn(|i| {
|
|
||||||
((-6.0 * i as f64 / 1024.0).exp() - (-6.0f64).exp()) / (1.0 - (-6.0f64).exp())
|
|
||||||
}),
|
|
||||||
sine: std::array::from_fn(|i| (std::f64::consts::TAU * i as f64 / 4096.0).sin()),
|
|
||||||
last_processing_time: Duration::ZERO,
|
|
||||||
paused: false,
|
|
||||||
epoch: 0,
|
|
||||||
diagnostics: AudioDiagnostics::default(),
|
|
||||||
note_serial: 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn prepared_bytes(&self) -> usize {
|
|
||||||
std::mem::size_of::<Self>()
|
|
||||||
+ self
|
|
||||||
.effects
|
|
||||||
.iter()
|
|
||||||
.map(|e| e.delay.capacity() * std::mem::size_of::<[f32; 2]>())
|
|
||||||
.sum::<usize>()
|
|
||||||
}
|
|
||||||
fn stop_group(&mut self, group: usize, packet: &mut Packet) {
|
|
||||||
for v in &mut self.voices[group * 12..group * 12 + 12] {
|
|
||||||
packet.voice(v);
|
|
||||||
}
|
|
||||||
if let Some(bank) = self.groups[group].bank.take() {
|
|
||||||
packet.push(Retired::Bank(bank));
|
|
||||||
}
|
|
||||||
let gain = self.groups[group].gain.at(self.groups[group].frame);
|
|
||||||
self.groups[group] = MusicGroup::default();
|
|
||||||
self.groups[group].gain = Ramp::constant(gain);
|
|
||||||
self.effects[group].reset();
|
|
||||||
}
|
|
||||||
pub fn retire_inactive(&mut self, packet: &mut Packet) {
|
|
||||||
for g in 0..2 {
|
|
||||||
if self.groups[g].bank.as_ref().is_some_and(|b| !b.alive.load(Ordering::Acquire))
|
|
||||||
|| (self.groups[g].stop_after_fade && !self.groups[g].active)
|
|
||||||
{
|
|
||||||
self.stop_group(g, packet);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for v in &mut self.voices {
|
|
||||||
if !v.active || v.alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire)) {
|
|
||||||
packet.voice(v);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn apply_delivery_into(&mut self, delivery: AudioDelivery, packet: &mut Packet) {
|
|
||||||
if delivery.epoch < self.epoch {
|
|
||||||
packet.batches = [delivery.frame, delivery.lifecycle];
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if delivery.epoch != self.epoch {
|
|
||||||
for group in 0..2 {
|
|
||||||
self.stop_group(group, packet);
|
|
||||||
}
|
|
||||||
for voice in &mut self.voices {
|
|
||||||
packet.voice(voice);
|
|
||||||
*voice = Channel::default();
|
|
||||||
}
|
|
||||||
for group in &mut self.groups {
|
|
||||||
group.gain = Ramp::constant(1.0);
|
|
||||||
}
|
|
||||||
for effect in &mut self.effects {
|
|
||||||
effect.reset();
|
|
||||||
effect.frames = 0;
|
|
||||||
effect.feedback = 0.0;
|
|
||||||
effect.wet = 0.0;
|
|
||||||
effect.dry = 1.0;
|
|
||||||
effect.coefficient = 1.0;
|
|
||||||
}
|
|
||||||
self.bus = [1.0; 3];
|
|
||||||
self.sfx_gain = 1.0;
|
|
||||||
self.epoch = delivery.epoch;
|
|
||||||
}
|
|
||||||
packet.batches = [delivery.frame, delivery.lifecycle];
|
|
||||||
for index in 0..2 {
|
|
||||||
if let Some(mut batch) = packet.batches[index].take() {
|
|
||||||
for command in &mut batch {
|
|
||||||
let command =
|
|
||||||
std::mem::replace(command, AudioCommand::Stop { voice_id: SFX_CHANNELS });
|
|
||||||
self.process_command(command, packet);
|
|
||||||
}
|
|
||||||
packet.batches[index] = Some(batch);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
self.paused = delivery.paused;
|
|
||||||
}
|
|
||||||
/// Convenience for non-real-time signal tests/offline owners.
|
|
||||||
pub fn apply_delivery(&mut self, delivery: AudioDelivery) {
|
|
||||||
self.apply_delivery_into(delivery, &mut Packet::new());
|
|
||||||
}
|
|
||||||
pub fn fill_buffer(&mut self, buffer: &mut [f32]) {
|
|
||||||
self.mix(buffer);
|
|
||||||
self.retire_inactive(&mut Packet::new());
|
|
||||||
}
|
|
||||||
fn process_command(&mut self, command: AudioCommand, packet: &mut Packet) {
|
|
||||||
match command {
|
|
||||||
AudioCommand::Play {
|
|
||||||
sample,
|
|
||||||
alive,
|
|
||||||
voice_id,
|
|
||||||
volume,
|
|
||||||
pan,
|
|
||||||
pitch,
|
|
||||||
priority,
|
|
||||||
loop_mode,
|
|
||||||
} => {
|
|
||||||
if voice_id >= SFX_CHANNELS
|
|
||||||
|| alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire))
|
|
||||||
{
|
|
||||||
packet.push(Retired::Sample(sample));
|
|
||||||
if let Some(t) = alive {
|
|
||||||
packet.push(Retired::Token(t));
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let index = SFX_START + voice_id;
|
|
||||||
packet.voice(&mut self.voices[index]);
|
|
||||||
self.voices[index] = Channel {
|
|
||||||
sample: Some(sample),
|
|
||||||
alive,
|
|
||||||
active: true,
|
|
||||||
pos: 0.0,
|
|
||||||
pitch,
|
|
||||||
volume,
|
|
||||||
pan,
|
|
||||||
loop_mode,
|
|
||||||
priority,
|
|
||||||
};
|
|
||||||
self.states[index] = VoiceState::default();
|
|
||||||
}
|
|
||||||
AudioCommand::Stop { voice_id } => {
|
|
||||||
if voice_id < SFX_CHANNELS {
|
|
||||||
packet.voice(&mut self.voices[SFX_START + voice_id]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioCommand::SetVolume { voice_id, volume } => {
|
|
||||||
if voice_id < SFX_CHANNELS {
|
|
||||||
self.voices[SFX_START + voice_id].volume = volume;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioCommand::SetPan { voice_id, pan } => {
|
|
||||||
if voice_id < SFX_CHANNELS {
|
|
||||||
self.voices[SFX_START + voice_id].pan = pan;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioCommand::SetPitch { voice_id, pitch } => {
|
|
||||||
if voice_id < SFX_CHANNELS {
|
|
||||||
self.voices[SFX_START + voice_id].pitch = pitch;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioCommand::MusicPlay { group, bank, looping } => {
|
|
||||||
if group >= 2 || !bank.alive.load(Ordering::Acquire) {
|
|
||||||
packet.push(Retired::Bank(bank));
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
self.stop_group(group, packet);
|
|
||||||
self.groups[group].bank = Some(bank);
|
|
||||||
self.groups[group].active = true;
|
|
||||||
self.groups[group].looping = looping;
|
|
||||||
}
|
|
||||||
AudioCommand::Control(control) => match control {
|
|
||||||
AudioControl::GroupVolume { group, gain } => {
|
|
||||||
if group == 2 {
|
|
||||||
self.sfx_gain = gain as f32 / 255.0;
|
|
||||||
} else {
|
|
||||||
self.groups[group].gain = Ramp::constant(gain as f64 / 255.0);
|
|
||||||
self.groups[group].stop_after_fade = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioControl::MusicStop { group } => self.stop_group(group, packet),
|
|
||||||
AudioControl::MusicPause { group, paused } => self.groups[group].paused = paused,
|
|
||||||
AudioControl::MusicVolume { group, gain } => {
|
|
||||||
self.groups[group].gain = Ramp::constant(gain as f64 / 255.0);
|
|
||||||
self.groups[group].stop_after_fade = false;
|
|
||||||
}
|
|
||||||
AudioControl::MusicFade { group, gain, frames, smooth } => {
|
|
||||||
let g = &mut self.groups[group];
|
|
||||||
g.gain.set(gain as f64 / 255.0, g.frame, frames, smooth);
|
|
||||||
g.stop_after_fade = false;
|
|
||||||
}
|
|
||||||
AudioControl::Crossfade { source, target, frames, smooth } => {
|
|
||||||
if !self.groups[source].active || !self.groups[target].active {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
for (g, value) in [(source, 0.0), (target, 1.0)] {
|
|
||||||
let group = &mut self.groups[g];
|
|
||||||
group.gain.set(value, group.frame, frames, smooth);
|
|
||||||
group.stop_after_fade = g == source;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AudioControl::BusVolume { bus, gain } => self.bus[bus] = gain as f32 / 255.0,
|
|
||||||
AudioControl::SfxSend { voice, gain } => {
|
|
||||||
self.states[SFX_START + voice].send = gain as f64 / 255.0
|
|
||||||
}
|
|
||||||
AudioControl::Effect { group, cutoff_hz, delay_frames, feedback, wet, dry } => {
|
|
||||||
let effect = &mut self.effects[group];
|
|
||||||
effect.coefficient = if cutoff_hz == 0 {
|
|
||||||
1.0
|
|
||||||
} else {
|
|
||||||
(1.0 - (-std::f32::consts::TAU * cutoff_hz as f32 / 48_000.0).exp())
|
|
||||||
.clamp(0.0, 1.0)
|
|
||||||
};
|
|
||||||
if effect.frames != delay_frames as usize {
|
|
||||||
effect.reset();
|
|
||||||
}
|
|
||||||
effect.frames = delay_frames as usize;
|
|
||||||
effect.feedback = feedback;
|
|
||||||
effect.wet = wet;
|
|
||||||
effect.dry = dry;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn begin_note_release(&mut self, index: usize) {
|
|
||||||
let state = &mut self.states[index];
|
|
||||||
if state.release_age.is_none() {
|
|
||||||
let level = envelope(state, &self.exponential);
|
|
||||||
state.release_age = Some(state.age);
|
|
||||||
state.release_order = Some(self.note_serial);
|
|
||||||
self.note_serial = self.note_serial.wrapping_add(1);
|
|
||||||
state.release_level = level;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn event(&mut self, group: usize, event: MusicEvent, zone: usize) {
|
|
||||||
let frame = self.groups[group].frame;
|
|
||||||
let track = event.track as usize;
|
|
||||||
if event.kind == 1 {
|
|
||||||
let bank = self.groups[group].bank.as_ref().unwrap();
|
|
||||||
let inst = bank.instruments[zone];
|
|
||||||
let cents = (event.c - inst.root as i32) as f64 * 100.0 + inst.tuning_cents as f64;
|
|
||||||
let range = group * 12..group * 12 + 12;
|
|
||||||
self.note_serial = self.note_serial.wrapping_add(1);
|
|
||||||
let legato = if event.flags & 1 != 0 {
|
|
||||||
range
|
|
||||||
.clone()
|
|
||||||
.filter(|&i| {
|
|
||||||
self.voices[i].active
|
|
||||||
&& self.states[i].track == track
|
|
||||||
&& self.states[i].release_age.is_none()
|
|
||||||
})
|
|
||||||
.max_by_key(|&i| (self.states[i].born, i))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
};
|
|
||||||
if let Some(index) = legato.filter(|&i| self.states[i].zone == zone) {
|
|
||||||
let state = &mut self.states[index];
|
|
||||||
state.glide.set(cents, frame, event.duration_frames, event.curve == 1);
|
|
||||||
state.note_id = event.a;
|
|
||||||
state.born = self.note_serial;
|
|
||||||
state.iteration = self.groups[group].iteration;
|
|
||||||
self.voices[index].volume = ((inst.gain as u16 * event.d as u16 + 127) / 255) as u8;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let index = legato.unwrap_or_else(|| {
|
|
||||||
range.clone().find(|&i| !self.voices[i].active).unwrap_or_else(|| {
|
|
||||||
range
|
|
||||||
.min_by_key(|&i| {
|
|
||||||
(
|
|
||||||
self.states[i].release_age.is_none(),
|
|
||||||
self.states[i].release_order.unwrap_or(self.states[i].born),
|
|
||||||
i,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.unwrap()
|
|
||||||
})
|
|
||||||
});
|
|
||||||
// Music samples always have an owner in this group's retained bank.
|
|
||||||
self.voices[index] = Channel {
|
|
||||||
sample: Some(bank.samples[inst.sample as usize].clone()),
|
|
||||||
alive: None,
|
|
||||||
active: true,
|
|
||||||
pos: 0.0,
|
|
||||||
pitch: 1.0,
|
|
||||||
volume: ((inst.gain as u16 * event.d as u16 + 127) / 255) as u8,
|
|
||||||
pan: inst.pan,
|
|
||||||
loop_mode: if inst.looping { LoopMode::On } else { LoopMode::Off },
|
|
||||||
priority: 0,
|
|
||||||
};
|
|
||||||
self.states[index] = VoiceState {
|
|
||||||
inst,
|
|
||||||
track,
|
|
||||||
note_id: event.a,
|
|
||||||
iteration: self.groups[group].iteration,
|
|
||||||
born: self.note_serial,
|
|
||||||
glide: Ramp::constant(cents),
|
|
||||||
send: inst.send as f64 / 65535.0,
|
|
||||||
zone,
|
|
||||||
..VoiceState::default()
|
|
||||||
};
|
|
||||||
} else if event.kind == 2 {
|
|
||||||
for index in group * 12..group * 12 + 12 {
|
|
||||||
let state = &self.states[index];
|
|
||||||
if self.voices[index].active
|
|
||||||
&& state.track == track
|
|
||||||
&& state.note_id == event.a
|
|
||||||
&& state.iteration == self.groups[group].iteration
|
|
||||||
{
|
|
||||||
self.begin_note_release(index);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
let t = &mut self.groups[group].tracks[track];
|
|
||||||
let smooth = event.curve == 1;
|
|
||||||
match event.kind {
|
|
||||||
4 => t.gain.set(event.c as f64 / 65535.0, frame, event.duration_frames, smooth),
|
|
||||||
5 => t.pan.set(event.c as f64, frame, event.duration_frames, smooth),
|
|
||||||
6 => t.pitch.set(event.c as f64, frame, event.duration_frames, smooth),
|
|
||||||
7 => t.vibrato = Some((event.a, event.c as f64)),
|
|
||||||
8 => t.tremolo = Some((event.a, event.c as f64 / 65535.0)),
|
|
||||||
9 => t.send.set(event.c as f64 / 65535.0, frame, event.duration_frames, smooth),
|
|
||||||
_ => {} // Tempo/instrument selection were resolved during compilation.
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn sequence(&mut self, group: usize) {
|
|
||||||
if !self.groups[group].active || self.groups[group].paused {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
loop {
|
|
||||||
let g = &self.groups[group];
|
|
||||||
let bank = g.bank.as_ref().unwrap();
|
|
||||||
if let Some(event) = bank.events.get(g.cursor).filter(|e| e.time <= g.time) {
|
|
||||||
let event = *event;
|
|
||||||
self.groups[group].cursor += 1;
|
|
||||||
self.event(group, event.event, event.zone);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if g.time < bank.end_time {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
let loop_start = bank.loop_time.unwrap_or(0);
|
|
||||||
let loop_event = if bank.loop_time.is_some() { bank.loop_event } else { 0 };
|
|
||||||
let loop_length = bank.end_time - loop_start;
|
|
||||||
for index in group * 12..group * 12 + 12 {
|
|
||||||
self.begin_note_release(index);
|
|
||||||
}
|
|
||||||
let g = &mut self.groups[group];
|
|
||||||
if !g.looping {
|
|
||||||
g.active = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
g.time -= loop_length;
|
|
||||||
g.cursor = loop_event;
|
|
||||||
g.iteration = g.iteration.wrapping_add(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn mix(&mut self, buffer: &mut [f32]) {
|
|
||||||
let start = Instant::now();
|
|
||||||
buffer.fill(0.0);
|
|
||||||
if self.paused {
|
|
||||||
self.last_processing_time = start.elapsed();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
for frame in buffer.as_chunks_mut::<2>().0 {
|
|
||||||
// Invalidated resources stay owned until a reclamation packet is available.
|
|
||||||
for g in 0..2 {
|
|
||||||
if self.groups[g].bank.as_ref().is_some_and(|b| !b.alive.load(Ordering::Acquire)) {
|
|
||||||
self.groups[g].active = false;
|
|
||||||
for v in &mut self.voices[g * 12..g * 12 + 12] {
|
|
||||||
v.active = false;
|
|
||||||
}
|
|
||||||
self.effects[g].reset();
|
|
||||||
}
|
|
||||||
self.sequence(g);
|
|
||||||
}
|
|
||||||
let mut dry = [[0.0f32; 2]; 3];
|
|
||||||
let mut send = [[0.0f32; 2]; 3];
|
|
||||||
let mut active = 0;
|
|
||||||
for index in 0..MAX_CHANNELS {
|
|
||||||
let group = if index < 12 {
|
|
||||||
0
|
|
||||||
} else if index < 24 {
|
|
||||||
1
|
|
||||||
} else {
|
|
||||||
2
|
|
||||||
};
|
|
||||||
if group < 2 && self.groups[group].paused {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let voice = &mut self.voices[index];
|
|
||||||
if !voice.active {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if voice.alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire)) {
|
|
||||||
voice.active = false;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let Some(sample) = &voice.sample else {
|
|
||||||
continue;
|
|
||||||
};
|
|
||||||
let len = sample.frames_len();
|
|
||||||
if len == 0 {
|
|
||||||
voice.active = false;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
active += 1;
|
|
||||||
let state = &mut self.states[index];
|
|
||||||
let mut volume = voice.volume as f64 / 255.0;
|
|
||||||
let mut pan = voice.pan as f64;
|
|
||||||
let mut pitch = voice.pitch;
|
|
||||||
let mut amount = state.send;
|
|
||||||
if group < 2 {
|
|
||||||
let g = &self.groups[group];
|
|
||||||
let track = g.tracks[state.track];
|
|
||||||
state.level = envelope(state, &self.exponential);
|
|
||||||
if state.release_age.is_some() && state.level <= 0.0 {
|
|
||||||
voice.active = false;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let vib = track
|
|
||||||
.vibrato
|
|
||||||
.unwrap_or((state.inst.vibrato_millihz, state.inst.vibrato_cents as f64));
|
|
||||||
let trem = track.tremolo.unwrap_or((
|
|
||||||
state.inst.tremolo_millihz,
|
|
||||||
state.inst.tremolo_depth as f64 / 65535.0,
|
|
||||||
));
|
|
||||||
let cents = state.glide.at(g.frame)
|
|
||||||
+ track.pitch.at(g.frame)
|
|
||||||
+ lfo(&self.sine, state.age, vib.0) * vib.1;
|
|
||||||
if cents != state.cached_cents {
|
|
||||||
state.pitch_factor = (cents / 1200.0).exp2();
|
|
||||||
state.cached_cents = cents;
|
|
||||||
}
|
|
||||||
pitch *= state.pitch_factor;
|
|
||||||
volume *= state.level
|
|
||||||
* track.gain.at(g.frame)
|
|
||||||
* (1.0 - trem.1 * (lfo(&self.sine, state.age, trem.0) + 1.0) * 0.5);
|
|
||||||
pan = (pan + track.pan.at(g.frame) - 128.0).clamp(0.0, 255.0);
|
|
||||||
amount = track.send.at(g.frame, state.send);
|
|
||||||
state.age = state.age.wrapping_add(1);
|
|
||||||
}
|
|
||||||
let channels = sample.channels as usize;
|
|
||||||
let (loop_start, end) = match (voice.loop_mode, sample.loop_start, sample.loop_end)
|
|
||||||
{
|
|
||||||
(LoopMode::On, Some(a), Some(b)) if a < b && b as usize <= len => {
|
|
||||||
(a as f64, b as f64)
|
|
||||||
}
|
|
||||||
_ => (0.0, len as f64),
|
|
||||||
};
|
|
||||||
let pos = voice.pos as usize;
|
|
||||||
if pos >= len {
|
|
||||||
voice.active = false;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let next = if voice.loop_mode == LoopMode::On && (pos + 1) as f64 >= end {
|
|
||||||
loop_start as usize
|
|
||||||
} else {
|
|
||||||
pos + 1
|
|
||||||
};
|
|
||||||
let frac = (voice.pos - pos as f64) as f32;
|
|
||||||
let value = |c: usize| {
|
|
||||||
let a = sample.data[pos * channels + c] as f32 / 32768.0;
|
|
||||||
let b =
|
|
||||||
sample.data.get(next * channels + c).copied().unwrap_or(0) as f32 / 32768.0;
|
|
||||||
a + (b - a) * frac
|
|
||||||
};
|
|
||||||
if volume != 0.0 {
|
|
||||||
let normalized_pan =
|
|
||||||
if pan <= 128.0 { pan / 256.0 } else { 0.5 + (pan - 128.0) / 254.0 };
|
|
||||||
let gains = if channels == 1 {
|
|
||||||
[(1.0 - normalized_pan).sqrt(), normalized_pan.sqrt()]
|
|
||||||
} else {
|
|
||||||
[
|
|
||||||
if pan <= 128.0 { 1.0 } else { (255.0 - pan) / 127.0 },
|
|
||||||
if pan >= 128.0 { 1.0 } else { pan / 128.0 },
|
|
||||||
]
|
|
||||||
};
|
|
||||||
for c in 0..2 {
|
|
||||||
let v =
|
|
||||||
value(if channels == 1 { 0 } else { c }) * (volume * gains[c]) as f32;
|
|
||||||
dry[group][c] += v;
|
|
||||||
send[group][c] += v * amount as f32;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let ratio = sample.sample_rate as f64 / 48_000.0;
|
|
||||||
if ratio > 0.0 {
|
|
||||||
if pitch >= (end - voice.pos) / ratio {
|
|
||||||
if voice.loop_mode == LoopMode::Off {
|
|
||||||
voice.active = false;
|
|
||||||
} else {
|
|
||||||
let length = end - loop_start;
|
|
||||||
let step = (pitch % (length / ratio)) * ratio;
|
|
||||||
voice.pos =
|
|
||||||
loop_start + (voice.pos - loop_start + step).rem_euclid(length);
|
|
||||||
if voice.pos >= end {
|
|
||||||
voice.pos = loop_start;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
voice.pos += pitch * ratio;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
self.diagnostics.active_voices = active;
|
|
||||||
self.diagnostics.maximum_voices = self.diagnostics.maximum_voices.max(active);
|
|
||||||
for group in 0..3 {
|
|
||||||
if group < 2 && self.groups[group].paused {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let gain = if group < 2 {
|
|
||||||
self.groups[group].gain.at(self.groups[group].frame) as f32 * self.bus[0]
|
|
||||||
} else {
|
|
||||||
self.bus[1] * self.sfx_gain
|
|
||||||
};
|
|
||||||
let values = self.effects[group].process(dry[group], send[group]);
|
|
||||||
for c in 0..2 {
|
|
||||||
frame[c] += values[c] * gain;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for value in frame {
|
|
||||||
*value = (*value * self.bus[2]).clamp(-1.0, 1.0);
|
|
||||||
}
|
|
||||||
for group in &mut self.groups {
|
|
||||||
if !group.paused
|
|
||||||
&& let Some(bank) = &group.bank
|
|
||||||
{
|
|
||||||
group.frame = group.frame.wrapping_add(1);
|
|
||||||
if group.active {
|
|
||||||
group.time += bank.denominator;
|
|
||||||
}
|
|
||||||
if group.stop_after_fade && group.gain.done(group.frame) {
|
|
||||||
group.active = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// Crossfade completion silences/relinquishes notes; bank reclamation is deferred.
|
|
||||||
for g in 0..2 {
|
|
||||||
if self.groups[g].stop_after_fade && !self.groups[g].active {
|
|
||||||
for voice in &mut self.voices[g * 12..g * 12 + 12] {
|
|
||||||
voice.active = false;
|
|
||||||
}
|
|
||||||
self.effects[g].reset();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
self.diagnostics.frames += 1;
|
|
||||||
}
|
|
||||||
self.last_processing_time = start.elapsed();
|
|
||||||
self.diagnostics.last_render_us = self.last_processing_time.as_micros() as u64;
|
|
||||||
self.diagnostics.maximum_render_us =
|
|
||||||
self.diagnostics.maximum_render_us.max(self.diagnostics.last_render_us);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn lfo(table: &[f64; 4097], age: u64, millihz: u32) -> f64 {
|
|
||||||
let phase = ((age % 48_000_000) * millihz as u64 % 48_000_000) as f64 / 48_000_000.0 * 4096.0;
|
|
||||||
let index = phase as usize;
|
|
||||||
table[index] + (table[index + 1] - table[index]) * (phase - index as f64)
|
|
||||||
}
|
|
||||||
fn micros_frames(value: u32) -> u64 {
|
|
||||||
(value as u64 * 48_000).div_ceil(1_000_000)
|
|
||||||
}
|
|
||||||
fn envelope(state: &VoiceState, table: &[f64; 1025]) -> f64 {
|
|
||||||
let curve = |x: f64| {
|
|
||||||
if state.inst.curve == 0 {
|
|
||||||
1.0 - x
|
|
||||||
} else {
|
|
||||||
let p = x.clamp(0.0, 1.0) * 1024.0;
|
|
||||||
let i = (p as usize).min(1023);
|
|
||||||
table[i] + (table[i + 1] - table[i]) * (p - i as f64)
|
|
||||||
}
|
|
||||||
};
|
|
||||||
if let Some(start) = state.release_age {
|
|
||||||
let duration = micros_frames(state.inst.release_us);
|
|
||||||
let elapsed = state.age - start;
|
|
||||||
return if duration == 0 || elapsed >= duration {
|
|
||||||
0.0
|
|
||||||
} else {
|
|
||||||
state.release_level * curve(elapsed as f64 / duration as f64)
|
|
||||||
};
|
|
||||||
}
|
|
||||||
let attack = micros_frames(state.inst.attack_us);
|
|
||||||
let decay = micros_frames(state.inst.decay_us);
|
|
||||||
if state.age < attack {
|
|
||||||
return state.age as f64 / attack as f64;
|
|
||||||
}
|
|
||||||
let sustain = state.inst.sustain as f64 / 65535.0;
|
|
||||||
if state.age - attack < decay {
|
|
||||||
sustain + (1.0 - sustain) * curve((state.age - attack) as f64 / decay as f64)
|
|
||||||
} else {
|
|
||||||
sustain
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
#[path = "engine_tests.rs"]
|
|
||||||
mod tests;
|
|
||||||
@@ -1,508 +0,0 @@
|
|||||||
use super::*;
|
|
||||||
use crate::{Audio, MemoryBanks, SoundBankPoolAccess, SoundBankPoolInstaller};
|
|
||||||
use prometeu_hal::{AudioBridge, AudioOpStatus, music_bank::AUDIO_PPQ, sound_bank::SoundBank};
|
|
||||||
fn note(tick: u32, id: u32) -> MusicEvent {
|
|
||||||
MusicEvent { tick, kind: 1, a: id, c: 60, d: 255, ..Default::default() }
|
|
||||||
}
|
|
||||||
fn bank(events: Vec<MusicEvent>, inst: Instrument, tempo: u32, duration: u32) -> Arc<MusicBank> {
|
|
||||||
Arc::new(
|
|
||||||
MusicBank::compile(
|
|
||||||
"test".into(),
|
|
||||||
vec![Arc::new(
|
|
||||||
Sample::new(48_000, vec![1024, -2048, 1024, -2048])
|
|
||||||
.with_channels(2)
|
|
||||||
.unwrap()
|
|
||||||
.with_loop(0, 2),
|
|
||||||
)],
|
|
||||||
vec![inst],
|
|
||||||
events,
|
|
||||||
AUDIO_PPQ,
|
|
||||||
tempo,
|
|
||||||
duration,
|
|
||||||
None,
|
|
||||||
1,
|
|
||||||
)
|
|
||||||
.unwrap(),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
fn pair() -> (Arc<MemoryBanks>, Audio, AudioMixer) {
|
|
||||||
let banks = Arc::new(MemoryBanks::new());
|
|
||||||
(banks.clone(), Audio::new(banks), AudioMixer::new())
|
|
||||||
}
|
|
||||||
fn publish(audio: &mut Audio, mixer: &mut AudioMixer) {
|
|
||||||
audio.finish_frame();
|
|
||||||
mixer.apply_delivery(audio.transport().try_take().unwrap());
|
|
||||||
}
|
|
||||||
fn install(banks: &MemoryBanks, slot: usize, events: Vec<MusicEvent>) {
|
|
||||||
banks.install_music_bank(
|
|
||||||
slot,
|
|
||||||
bank(events, Instrument { looping: true, ..Default::default() }, 20_000, 100_000),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn thirty_two_stereo_voices_have_fixed_group_ownership_and_safe_clipping() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, (0..12).map(|n| note(0, n)).collect());
|
|
||||||
assert_eq!(audio.music_play(0, 0, true), AudioOpStatus::Ok);
|
|
||||||
assert_eq!(audio.music_play(1, 0, true), AudioOpStatus::Ok);
|
|
||||||
let sample = Arc::new(Sample::new(48_000, vec![1024, -2048]));
|
|
||||||
// Stereo uses one cursor/slot; no channel consumes a second voice.
|
|
||||||
let sample = Arc::new(
|
|
||||||
Sample::new(48_000, sample.data.clone()).with_channels(2).unwrap().with_loop(0, 1),
|
|
||||||
);
|
|
||||||
for i in 0..8 {
|
|
||||||
assert_eq!(
|
|
||||||
audio.play_sample(sample.clone(), i, 255, 128, 1.0, 0, LoopMode::On),
|
|
||||||
AudioOpStatus::Ok
|
|
||||||
);
|
|
||||||
}
|
|
||||||
assert_eq!(audio.stop(8), AudioOpStatus::VoiceInvalid);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
let mut pcm = [0.0; 2];
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
assert_eq!(mixer.voices.iter().filter(|v| v.active).count(), 32);
|
|
||||||
assert_eq!(mixer.diagnostics.maximum_voices, 32);
|
|
||||||
assert_eq!(pcm, [1.0, -1.0]);
|
|
||||||
audio.control(AudioControl::MusicStop { group: 0 });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
assert!(mixer.voices[..12].iter().all(|v| !v.active));
|
|
||||||
assert!(mixer.voices[12..].iter().all(|v| v.active));
|
|
||||||
for i in 0..8 {
|
|
||||||
audio.stop(i);
|
|
||||||
}
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
assert!(mixer.voices[12..24].iter().all(|v| v.active));
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn audio_time_does_not_wait_for_frame_sync_and_buffer_partition_is_invariant() {
|
|
||||||
let (banks, mut audio, mut a) = pair();
|
|
||||||
install(&banks, 0, vec![note(17, 1)]);
|
|
||||||
audio.music_play(0, 0, false);
|
|
||||||
publish(&mut audio, &mut a);
|
|
||||||
let mut b = AudioMixer::new();
|
|
||||||
let resident = banks.music_bank_slot(0).unwrap();
|
|
||||||
b.process_command(
|
|
||||||
AudioCommand::MusicPlay { group: 0, bank: resident, looping: false },
|
|
||||||
&mut Packet::new(),
|
|
||||||
);
|
|
||||||
let mut whole = vec![0.0; 4000];
|
|
||||||
a.mix(&mut whole);
|
|
||||||
let mut pieces = vec![0.0; 4000];
|
|
||||||
for piece in pieces.chunks_mut(14) {
|
|
||||||
b.mix(piece);
|
|
||||||
}
|
|
||||||
assert_eq!(whole, pieces);
|
|
||||||
assert!(whole[..34].iter().all(|&v| v == 0.0));
|
|
||||||
assert_ne!(whole[34], 0.0);
|
|
||||||
assert_eq!(a.groups[0].frame, 2000);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn fractional_tempo_changes_and_loop_remainder_have_no_cumulative_drift() {
|
|
||||||
let events = vec![MusicEvent { tick: 2, kind: 3, a: 30_001, ..Default::default() }, note(3, 1)];
|
|
||||||
let music = bank(events, Instrument::default(), 20_001, 5);
|
|
||||||
assert_eq!(music.events[1].time, 2 * 20_001u128 * 48_000 + 30_001u128 * 48_000);
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
let end = music.end_time;
|
|
||||||
let den = music.denominator;
|
|
||||||
mixer.process_command(
|
|
||||||
AudioCommand::MusicPlay { group: 0, bank: music, looping: true },
|
|
||||||
&mut Packet::new(),
|
|
||||||
);
|
|
||||||
let n = 100_000;
|
|
||||||
mixer.mix(&mut vec![0.0; n * 2]);
|
|
||||||
// The first event of a loop is evaluated before the rendered frame.
|
|
||||||
assert_eq!(mixer.groups[0].iteration, ((n - 1) as u128 * den / end) as u64);
|
|
||||||
assert_eq!(mixer.groups[0].time, n as u128 * den - mixer.groups[0].iteration as u128 * end);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn music_allocator_uses_free_then_release_then_oldest_and_stale_off_does_not_stop_reuse() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
let mut events: Vec<_> = (0..12).map(|n| note(0, n)).collect();
|
|
||||||
events.push(MusicEvent { tick: 1, kind: 2, a: 3, ..Default::default() });
|
|
||||||
events.push(note(2, 12));
|
|
||||||
events.push(MusicEvent { tick: 3, kind: 2, a: 3, ..Default::default() });
|
|
||||||
events.push(note(4, 13));
|
|
||||||
banks.install_music_bank(
|
|
||||||
0,
|
|
||||||
bank(
|
|
||||||
events,
|
|
||||||
Instrument { looping: true, release_us: 1_000_000, ..Default::default() },
|
|
||||||
20_000,
|
|
||||||
1000,
|
|
||||||
),
|
|
||||||
);
|
|
||||||
audio.music_play(0, 0, false);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 10]);
|
|
||||||
assert_eq!(mixer.states[3].note_id, 12);
|
|
||||||
assert_eq!(mixer.states[0].note_id, 13);
|
|
||||||
assert!(mixer.states[3].release_age.is_none());
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn envelopes_have_exact_endpoints_and_note_off_releases() {
|
|
||||||
let mut state = VoiceState {
|
|
||||||
inst: Instrument {
|
|
||||||
attack_us: 1000,
|
|
||||||
decay_us: 1000,
|
|
||||||
sustain: 32768,
|
|
||||||
release_us: 1000,
|
|
||||||
curve: 0,
|
|
||||||
..Default::default()
|
|
||||||
},
|
|
||||||
..Default::default()
|
|
||||||
};
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
for (age, value) in [(0, 0.0), (24, 0.5), (48, 1.0), (96, 32768.0 / 65535.0)] {
|
|
||||||
state.age = age;
|
|
||||||
assert!((envelope(&state, &mixer.exponential) - value).abs() < 1e-12);
|
|
||||||
}
|
|
||||||
state.release_age = Some(96);
|
|
||||||
state.release_level = 0.5;
|
|
||||||
for (age, value) in [(96, 0.5), (120, 0.25), (144, 0.0)] {
|
|
||||||
state.age = age;
|
|
||||||
assert!((envelope(&state, &mixer.exponential) - value).abs() < 1e-12);
|
|
||||||
}
|
|
||||||
for i in 0..10_000 {
|
|
||||||
let x = i as f64 / 10_000.0;
|
|
||||||
state.inst.curve = 1;
|
|
||||||
state.inst.release_us = 1_000_000;
|
|
||||||
state.release_age = Some(0);
|
|
||||||
state.release_level = 1.0;
|
|
||||||
state.age = (x * 48_000.0) as u64;
|
|
||||||
let x = state.age as f64 / 48_000.0;
|
|
||||||
let expected = ((-6.0 * x).exp() - (-6.0f64).exp()) / (1.0 - (-6.0f64).exp());
|
|
||||||
assert!((envelope(&state, &mixer.exponential) - expected).abs() < 1e-4);
|
|
||||||
}
|
|
||||||
let music = bank(
|
|
||||||
vec![note(0, 1), MusicEvent { tick: 2, kind: 2, a: 1, ..Default::default() }],
|
|
||||||
Instrument { looping: true, release_us: 1000, ..Default::default() },
|
|
||||||
20_000,
|
|
||||||
1000,
|
|
||||||
);
|
|
||||||
mixer.process_command(
|
|
||||||
AudioCommand::MusicPlay { group: 0, bank: music, looping: false },
|
|
||||||
&mut Packet::new(),
|
|
||||||
);
|
|
||||||
mixer.mix(&mut [0.0; 8]);
|
|
||||||
assert!(mixer.voices[0].active);
|
|
||||||
mixer.mix(&mut [0.0; 100]);
|
|
||||||
assert!(!mixer.voices[0].active);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn legato_retains_cursor_and_envelope_only_for_same_zone() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
let mut legato = note(1, 2);
|
|
||||||
legato.flags = 1;
|
|
||||||
legato.c = 72;
|
|
||||||
legato.duration_frames = 10;
|
|
||||||
legato.curve = 1;
|
|
||||||
install(&banks, 0, vec![note(0, 1), legato]);
|
|
||||||
audio.music_play(0, 0, false);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 8]);
|
|
||||||
assert_eq!(mixer.voices[..12].iter().filter(|v| v.active).count(), 1);
|
|
||||||
assert_eq!(mixer.states[0].age, 4);
|
|
||||||
assert!((mixer.states[0].cached_cents - 124.8).abs() < 1e-10);
|
|
||||||
assert_eq!(mixer.states[0].note_id, 2);
|
|
||||||
assert_eq!(mixer.states[0].glide.to, 1200.0);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn pause_freezes_sequence_envelopes_fade_and_effect_timeline() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 6]);
|
|
||||||
audio.control(AudioControl::MusicPause { group: 0, paused: true });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
let before = (mixer.groups[0].time, mixer.states[0].age, mixer.effects[0].write);
|
|
||||||
let mut pcm = [1.0; 200];
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
assert_eq!(pcm, [0.0; 200]);
|
|
||||||
assert_eq!(before, (mixer.groups[0].time, mixer.states[0].age, mixer.effects[0].write));
|
|
||||||
audio.control(AudioControl::MusicPause { group: 0, paused: false });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 2]);
|
|
||||||
assert_eq!(mixer.states[0].age, before.1 + 1);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn crossfade_stops_outgoing_group_and_target_keeps_its_sequence() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.music_play(1, 0, true);
|
|
||||||
audio.control(AudioControl::MusicVolume { group: 1, gain: 0 });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 10]);
|
|
||||||
audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 10, smooth: true });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.fill_buffer(&mut [0.0; 20]);
|
|
||||||
assert!(mixer.groups[0].bank.is_none());
|
|
||||||
assert_eq!(mixer.groups[1].frame, 15);
|
|
||||||
assert_eq!(mixer.groups[1].gain.at(15), 1.0);
|
|
||||||
assert!(mixer.voices[12].active);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn shared_delay_has_selective_sends_and_sfx_tails_survive_unload() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
banks.install_sound_bank(
|
|
||||||
0,
|
|
||||||
Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48_000, vec![16384]))])),
|
|
||||||
);
|
|
||||||
audio.control(AudioControl::Effect {
|
|
||||||
group: 2,
|
|
||||||
cutoff_hz: 0,
|
|
||||||
delay_frames: 2,
|
|
||||||
feedback: 0.5,
|
|
||||||
wet: 1.0,
|
|
||||||
dry: 0.0,
|
|
||||||
});
|
|
||||||
audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::Off);
|
|
||||||
audio.control(AudioControl::SfxSend { voice: 0, gain: 255 });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
let mut first = [0.0; 2];
|
|
||||||
mixer.mix(&mut first);
|
|
||||||
assert_eq!(first, [0.0; 2]);
|
|
||||||
banks.unload_audio_bank(false, 0);
|
|
||||||
let mut tail = [0.0; 8];
|
|
||||||
mixer.fill_buffer(&mut tail);
|
|
||||||
assert_eq!(tail, [0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.25, 0.0]);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn replacing_or_unloading_bank_invalidates_queued_play_and_only_its_resident_instance() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
let source = Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48_000, vec![16384; 4]))]));
|
|
||||||
banks.install_sound_bank(0, source.clone());
|
|
||||||
banks.install_sound_bank(1, source);
|
|
||||||
audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On);
|
|
||||||
audio.play(1, 0, 1, 255, 0, 1.0, 0, LoopMode::On);
|
|
||||||
audio.finish_frame();
|
|
||||||
banks.unload_audio_bank(false, 0);
|
|
||||||
mixer.apply_delivery(audio.transport().try_take().unwrap());
|
|
||||||
assert!(!mixer.voices[24].active);
|
|
||||||
assert!(mixer.voices[25].active);
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.music_play(1, 0, true);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 2]);
|
|
||||||
banks.unload_audio_bank(true, 0);
|
|
||||||
mixer.fill_buffer(&mut [0.0; 2]);
|
|
||||||
assert!(mixer.voices[..24].iter().all(|v| !v.active));
|
|
||||||
assert!(mixer.groups.iter().all(|g| g.bank.is_none()));
|
|
||||||
assert!(mixer.voices[25].active);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn stealing_respects_release_order_and_serialized_onsets_within_one_frame() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, (0..14).map(|n| note(0, n)).collect());
|
|
||||||
audio.music_play(0, 0, false);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 2]);
|
|
||||||
assert_eq!(mixer.states[0].note_id, 12);
|
|
||||||
assert_eq!(mixer.states[1].note_id, 13);
|
|
||||||
let mut events: Vec<_> = (0..12).map(|n| note(0, n)).collect();
|
|
||||||
events.push(MusicEvent { tick: 1, kind: 2, a: 4, ..Default::default() });
|
|
||||||
events.push(MusicEvent { tick: 2, kind: 2, a: 2, ..Default::default() });
|
|
||||||
events.push(note(3, 20));
|
|
||||||
banks.install_music_bank(
|
|
||||||
0,
|
|
||||||
bank(
|
|
||||||
events,
|
|
||||||
Instrument { looping: true, release_us: 1_000_000, ..Default::default() },
|
|
||||||
20000,
|
|
||||||
1000,
|
|
||||||
),
|
|
||||||
);
|
|
||||||
audio.music_play(0, 0, false);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 8]);
|
|
||||||
assert_eq!(mixer.states[4].note_id, 20);
|
|
||||||
assert!(mixer.states[2].release_age.is_some());
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn incompatible_legato_retriggers_the_same_voice_with_no_hidden_polyphony() {
|
|
||||||
let sample = Arc::new(Sample::new(48000, vec![1000; 8]).with_loop(0, 8));
|
|
||||||
let mut legato = note(2, 2);
|
|
||||||
legato.flags = 1;
|
|
||||||
legato.c = 72;
|
|
||||||
let music = MusicBank::compile(
|
|
||||||
"zones".into(),
|
|
||||||
vec![sample.clone(), sample],
|
|
||||||
vec![
|
|
||||||
Instrument { low: 0, high: 63, looping: true, ..Default::default() },
|
|
||||||
Instrument { low: 64, high: 127, sample: 1, looping: true, ..Default::default() },
|
|
||||||
],
|
|
||||||
vec![note(0, 1), legato],
|
|
||||||
960,
|
|
||||||
20000,
|
|
||||||
1000,
|
|
||||||
None,
|
|
||||||
1,
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
mixer.process_command(
|
|
||||||
AudioCommand::MusicPlay { group: 0, bank: Arc::new(music), looping: false },
|
|
||||||
&mut Packet::new(),
|
|
||||||
);
|
|
||||||
mixer.mix(&mut [0.0; 6]);
|
|
||||||
assert_eq!(mixer.voices[..12].iter().filter(|v| v.active).count(), 1);
|
|
||||||
assert_eq!(mixer.states[0].age, 1);
|
|
||||||
assert_eq!(mixer.states[0].zone, 1);
|
|
||||||
assert_eq!(mixer.states[0].note_id, 2);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn parameter_ramps_lfos_and_send_override_use_the_current_audio_value() {
|
|
||||||
let mut send = SendRamp::default();
|
|
||||||
assert_eq!(send.at(0, 0.8), 0.8);
|
|
||||||
send.set(0.0, 0, 100, false);
|
|
||||||
assert_eq!(send.at(50, 0.8), 0.4);
|
|
||||||
send.set(1.0, 50, 100, false);
|
|
||||||
assert_eq!(send.at(50, 0.8), 0.4);
|
|
||||||
assert!((send.at(100, 0.8) - 0.7).abs() < 1e-12);
|
|
||||||
assert_eq!(send.at(150, 0.8), 1.0);
|
|
||||||
let events = vec![
|
|
||||||
note(0, 1),
|
|
||||||
MusicEvent { kind: 4, c: 0, duration_frames: 480, ..Default::default() },
|
|
||||||
MusicEvent { kind: 5, c: 255, duration_frames: 480, ..Default::default() },
|
|
||||||
MusicEvent { kind: 6, c: 1200, duration_frames: 480, ..Default::default() },
|
|
||||||
MusicEvent { kind: 7, a: 100000, c: 1200, ..Default::default() },
|
|
||||||
MusicEvent { kind: 8, a: 100000, c: 65535, ..Default::default() },
|
|
||||||
];
|
|
||||||
let mut mixer = AudioMixer::new();
|
|
||||||
mixer.process_command(
|
|
||||||
AudioCommand::MusicPlay {
|
|
||||||
group: 0,
|
|
||||||
bank: bank(events, Instrument { looping: true, ..Default::default() }, 20000, 1000),
|
|
||||||
looping: false,
|
|
||||||
},
|
|
||||||
&mut Packet::new(),
|
|
||||||
);
|
|
||||||
let mut pcm = [0.0; 962];
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
assert_eq!(&pcm[..2], &[1.0 / 64.0, -1.0 / 32.0]);
|
|
||||||
assert!(pcm[240].abs() < 1e-8 && pcm[241].abs() < 1e-8);
|
|
||||||
assert_eq!(&pcm[960..], &[0.0, 0.0]);
|
|
||||||
assert!(mixer.voices[0].active);
|
|
||||||
assert_eq!(mixer.groups[0].tracks[0].gain.at(240), 0.5);
|
|
||||||
assert_eq!(mixer.groups[0].tracks[0].pan.at(240), 191.5);
|
|
||||||
assert_eq!(mixer.groups[0].tracks[0].pitch.at(240), 600.0);
|
|
||||||
let mut ramp = Ramp::constant(0.0);
|
|
||||||
ramp.set(1.0, 0, 100, true);
|
|
||||||
assert_eq!(ramp.at(0), 0.0);
|
|
||||||
assert_eq!(ramp.at(50), 0.5);
|
|
||||||
assert_eq!(ramp.at(100), 1.0);
|
|
||||||
let endpoint = 1.0 / 65535.0;
|
|
||||||
ramp.set(endpoint, 100, 100, false);
|
|
||||||
assert_eq!(ramp.at(200), endpoint);
|
|
||||||
assert_eq!(ramp.at(1000), endpoint);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn music_sfx_and_master_gains_remain_independent_of_group_gain() {
|
|
||||||
let (_, mut audio, mut mixer) = pair();
|
|
||||||
audio.play_sample(
|
|
||||||
Arc::new(Sample::new(48000, vec![16384; 4])),
|
|
||||||
0,
|
|
||||||
255,
|
|
||||||
0,
|
|
||||||
1.0,
|
|
||||||
0,
|
|
||||||
LoopMode::On,
|
|
||||||
);
|
|
||||||
audio.control(AudioControl::GroupVolume { group: 2, gain: 128 });
|
|
||||||
audio.control(AudioControl::BusVolume { bus: 1, gain: 128 });
|
|
||||||
audio.control(AudioControl::BusVolume { bus: 2, gain: 128 });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
let mut pcm = [0.0; 2];
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
assert!((pcm[0] - 0.5 * (128.0f32 / 255.0).powi(3)).abs() < 1e-7);
|
|
||||||
assert_eq!(pcm[1], 0.0);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn invalidating_one_music_slot_clears_only_its_effect_history() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
install(&banks, 1, vec![note(0, 1)]);
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.music_play(1, 1, true);
|
|
||||||
for group in 0..2 {
|
|
||||||
audio.control(AudioControl::Effect {
|
|
||||||
group,
|
|
||||||
cutoff_hz: 6000,
|
|
||||||
delay_frames: 48,
|
|
||||||
feedback: 0.5,
|
|
||||||
wet: 0.3,
|
|
||||||
dry: 0.7,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 100]);
|
|
||||||
banks.unload_audio_bank(true, 0);
|
|
||||||
mixer.retire_inactive(&mut Packet::new());
|
|
||||||
assert_eq!(mixer.effects[0].history, 0);
|
|
||||||
assert_eq!(mixer.effects[1].history, 50);
|
|
||||||
assert!(mixer.voices[12].active);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn crossfade_with_absent_target_does_not_silence_the_active_source() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 0, smooth: false });
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
mixer.mix(&mut [0.0; 2]);
|
|
||||||
assert!(mixer.groups[0].active);
|
|
||||||
assert_eq!(mixer.groups[0].gain.at(1), 1.0);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn resident_memory_diagnostics_deduplicate_shared_pcm_across_all_slots() {
|
|
||||||
let banks = MemoryBanks::new();
|
|
||||||
let sample = Arc::new(Sample::new(48000, vec![1, 2, 3, 4]));
|
|
||||||
let source = Arc::new(SoundBank::new(vec![sample]));
|
|
||||||
for slot in 0..16 {
|
|
||||||
banks.install_sound_bank(slot, source.clone());
|
|
||||||
banks.install_music_bank(slot, bank(vec![note(0, 1)], Instrument::default(), 20000, 1000));
|
|
||||||
}
|
|
||||||
let snapshot = banks.audio_memory();
|
|
||||||
assert_eq!(snapshot.banks.len(), 32);
|
|
||||||
assert_eq!(snapshot.unique_pcm_bytes, 8 + 16 * 8);
|
|
||||||
assert!(snapshot.metadata_bytes > 0);
|
|
||||||
assert_eq!(
|
|
||||||
snapshot.total_accounted_bytes,
|
|
||||||
snapshot.allocated_pcm_bytes + snapshot.metadata_bytes
|
|
||||||
);
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn group_configuration_survives_play_stop_and_replacement_but_not_session_reset() {
|
|
||||||
let (banks, mut audio, mut mixer) = pair();
|
|
||||||
install(&banks, 0, vec![note(0, 1)]);
|
|
||||||
audio.control(AudioControl::MusicVolume { group: 0, gain: 0 });
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
let mut pcm = [1.0; 2];
|
|
||||||
mixer.mix(&mut pcm);
|
|
||||||
assert_eq!(pcm, [0.0; 2]);
|
|
||||||
assert_eq!(mixer.groups[0].gain.at(0), 0.0);
|
|
||||||
audio.control(AudioControl::Effect {
|
|
||||||
group: 0,
|
|
||||||
cutoff_hz: 1000,
|
|
||||||
delay_frames: 48,
|
|
||||||
feedback: 0.5,
|
|
||||||
wet: 0.5,
|
|
||||||
dry: 0.5,
|
|
||||||
});
|
|
||||||
audio.control(AudioControl::MusicStop { group: 0 });
|
|
||||||
audio.music_play(0, 0, true);
|
|
||||||
publish(&mut audio, &mut mixer);
|
|
||||||
assert_eq!(mixer.groups[0].gain.at(0), 0.0);
|
|
||||||
assert_eq!(mixer.effects[0].frames, 48);
|
|
||||||
audio.reset();
|
|
||||||
mixer.apply_delivery(audio.transport().try_take().unwrap());
|
|
||||||
assert_eq!(mixer.groups[0].gain.at(0), 1.0);
|
|
||||||
assert_eq!(mixer.effects[0].frames, 0);
|
|
||||||
assert_eq!(mixer.effects[0].coefficient, 1.0);
|
|
||||||
assert_eq!(mixer.effects[0].wet, 0.0);
|
|
||||||
assert_eq!(mixer.effects[0].dry, 1.0);
|
|
||||||
}
|
|
||||||
@@ -123,7 +123,6 @@ mod reuse_tests {
|
|||||||
let allocation = batch.as_ptr();
|
let allocation = batch.as_ptr();
|
||||||
batch.push(AudioCommand::Play {
|
batch.push(AudioCommand::Play {
|
||||||
sample,
|
sample,
|
||||||
alive: None,
|
|
||||||
voice_id: 0,
|
voice_id: 0,
|
||||||
volume: 255,
|
volume: 255,
|
||||||
pan: 0,
|
pan: 0,
|
||||||
|
|||||||
@@ -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()), (85, 49));
|
assert_eq!((cache.width(), cache.height()), (65, 38));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|||||||
@@ -43,8 +43,6 @@ 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>,
|
||||||
@@ -323,7 +321,6 @@ 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,
|
||||||
@@ -573,11 +570,6 @@ 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**: 640x360 (16:9 Aspect Ratio).
|
/// - **Resolution**: 480x270 (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 = prometeu_hal::graphics_contract::WIDTH;
|
pub const W: usize = 480;
|
||||||
/// Internal hardware height in pixels.
|
/// Internal hardware height in pixels.
|
||||||
pub const H: usize = prometeu_hal::graphics_contract::HEIGHT;
|
pub const H: usize = 270;
|
||||||
|
|
||||||
/// 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,15 +5,12 @@ 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;
|
||||||
mod wall_clock;
|
mod wall_clock;
|
||||||
|
|
||||||
pub use crate::asset::AssetManager;
|
pub use crate::asset::AssetManager;
|
||||||
pub use crate::audio::bank_format;
|
|
||||||
pub use crate::audio::{
|
pub use crate::audio::{
|
||||||
Audio, AudioCommand, AudioDelivery, AudioTransport, Channel, MAX_CHANNELS,
|
Audio, AudioCommand, AudioDelivery, AudioTransport, Channel, MAX_CHANNELS,
|
||||||
MAX_COMMANDS_PER_FRAME, OUTPUT_SAMPLE_RATE,
|
MAX_COMMANDS_PER_FRAME, OUTPUT_SAMPLE_RATE,
|
||||||
@@ -30,5 +27,3 @@ pub use crate::test_platform::TestPlatform;
|
|||||||
pub use crate::wall_clock::ControlledWallClock;
|
pub use crate::wall_clock::ControlledWallClock;
|
||||||
|
|
||||||
pub mod memcard;
|
pub mod memcard;
|
||||||
|
|
||||||
pub use crate::audio::{SFX_CHANNELS, SFX_START, engine};
|
|
||||||
|
|||||||
@@ -13,8 +13,7 @@ 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::AccessDenied,
|
K::PermissionDenied => Error::ReadOnly,
|
||||||
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,
|
||||||
@@ -22,15 +21,8 @@ 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 })
|
||||||
}
|
}
|
||||||
@@ -55,9 +47,7 @@ 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;
|
||||||
@@ -74,7 +64,6 @@ 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)
|
||||||
})();
|
})();
|
||||||
@@ -82,10 +71,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(|_| Error::Indeterminate)?;
|
cleanup.map_err(io_error)?;
|
||||||
Ok(card)
|
Ok(card)
|
||||||
}
|
}
|
||||||
Err(e) => Err(if published { Error::Indeterminate } else { e }),
|
Err(e) => Err(e),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[cfg(not(unix))]
|
#[cfg(not(unix))]
|
||||||
|
|||||||
@@ -7,7 +7,6 @@
|
|||||||
//! the render read surface.
|
//! the render read surface.
|
||||||
|
|
||||||
use prometeu_hal::glyph_bank::GlyphBank;
|
use prometeu_hal::glyph_bank::GlyphBank;
|
||||||
use prometeu_hal::music_bank::MusicBank;
|
|
||||||
use prometeu_hal::render_resources::RenderResourceAccess as HalRenderResourceAccess;
|
use prometeu_hal::render_resources::RenderResourceAccess as HalRenderResourceAccess;
|
||||||
use prometeu_hal::scene_bank::SceneBank;
|
use prometeu_hal::scene_bank::SceneBank;
|
||||||
use prometeu_hal::sound_bank::SoundBank;
|
use prometeu_hal::sound_bank::SoundBank;
|
||||||
@@ -31,7 +30,6 @@ pub trait GlyphBankPoolInstaller: Send + Sync {
|
|||||||
|
|
||||||
/// Non-generic interface for peripherals to access sound banks.
|
/// Non-generic interface for peripherals to access sound banks.
|
||||||
pub trait SoundBankPoolAccess: Send + Sync {
|
pub trait SoundBankPoolAccess: Send + Sync {
|
||||||
fn music_bank_slot(&self, slot: usize) -> Option<Arc<MusicBank>>;
|
|
||||||
/// Returns a reference to the resident SoundBank in the specified slot, if any.
|
/// Returns a reference to the resident SoundBank in the specified slot, if any.
|
||||||
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>>;
|
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>>;
|
||||||
/// Returns the total number of slots available in this bank.
|
/// Returns the total number of slots available in this bank.
|
||||||
@@ -40,9 +38,6 @@ pub trait SoundBankPoolAccess: Send + Sync {
|
|||||||
|
|
||||||
/// Non-generic interface for the AssetManager to install sound banks.
|
/// Non-generic interface for the AssetManager to install sound banks.
|
||||||
pub trait SoundBankPoolInstaller: Send + Sync {
|
pub trait SoundBankPoolInstaller: Send + Sync {
|
||||||
fn install_music_bank(&self, slot: usize, bank: Arc<MusicBank>);
|
|
||||||
fn clear_music_banks(&self);
|
|
||||||
fn unload_audio_bank(&self, music: bool, slot: usize);
|
|
||||||
/// Atomically swaps the resident SoundBank in the specified slot.
|
/// Atomically swaps the resident SoundBank in the specified slot.
|
||||||
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>);
|
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>);
|
||||||
/// Clears all resident SoundBank slots.
|
/// Clears all resident SoundBank slots.
|
||||||
@@ -73,7 +68,6 @@ pub trait SceneBankPoolInstaller: Send + Sync {
|
|||||||
pub struct MemoryBanks {
|
pub struct MemoryBanks {
|
||||||
glyph_bank_pool: Arc<RwLock<[Option<Arc<GlyphBank>>; 16]>>,
|
glyph_bank_pool: Arc<RwLock<[Option<Arc<GlyphBank>>; 16]>>,
|
||||||
sound_bank_pool: Arc<RwLock<[Option<Arc<SoundBank>>; 16]>>,
|
sound_bank_pool: Arc<RwLock<[Option<Arc<SoundBank>>; 16]>>,
|
||||||
music_bank_pool: Arc<RwLock<[Option<Arc<MusicBank>>; 16]>>,
|
|
||||||
scene_bank_pool: Arc<RwLock<[Option<Arc<SceneBank>>; 16]>>,
|
scene_bank_pool: Arc<RwLock<[Option<Arc<SceneBank>>; 16]>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -89,7 +83,6 @@ impl MemoryBanks {
|
|||||||
Self {
|
Self {
|
||||||
glyph_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
glyph_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
sound_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
sound_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
music_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
|
||||||
scene_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
scene_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -120,9 +113,6 @@ impl GlyphBankPoolInstaller for MemoryBanks {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl SoundBankPoolAccess for MemoryBanks {
|
impl SoundBankPoolAccess for MemoryBanks {
|
||||||
fn music_bank_slot(&self, slot: usize) -> Option<Arc<MusicBank>> {
|
|
||||||
self.music_bank_pool.read().unwrap().get(slot).and_then(Clone::clone)
|
|
||||||
}
|
|
||||||
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>> {
|
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>> {
|
||||||
let pool = self.sound_bank_pool.read().unwrap();
|
let pool = self.sound_bank_pool.read().unwrap();
|
||||||
pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone))
|
pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone))
|
||||||
@@ -134,61 +124,15 @@ impl SoundBankPoolAccess for MemoryBanks {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl SoundBankPoolInstaller for MemoryBanks {
|
impl SoundBankPoolInstaller for MemoryBanks {
|
||||||
fn install_music_bank(&self, slot: usize, bank: Arc<MusicBank>) {
|
|
||||||
if slot >= 16 {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let prepared = Arc::new(bank.resident_copy());
|
|
||||||
let mut pool = self.music_bank_pool.write().unwrap();
|
|
||||||
if let Some(target) = pool.get_mut(slot) {
|
|
||||||
if let Some(old) = target.take() {
|
|
||||||
old.invalidate();
|
|
||||||
}
|
|
||||||
*target = Some(prepared);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn clear_music_banks(&self) {
|
|
||||||
let mut pool = self.music_bank_pool.write().unwrap();
|
|
||||||
for bank in pool.iter_mut() {
|
|
||||||
if let Some(old) = bank.take() {
|
|
||||||
old.invalidate();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn unload_audio_bank(&self, music: bool, slot: usize) {
|
|
||||||
if music {
|
|
||||||
if let Some(bank) =
|
|
||||||
self.music_bank_pool.write().unwrap().get_mut(slot).and_then(Option::take)
|
|
||||||
{
|
|
||||||
bank.invalidate();
|
|
||||||
}
|
|
||||||
} else if let Some(bank) =
|
|
||||||
self.sound_bank_pool.write().unwrap().get_mut(slot).and_then(Option::take)
|
|
||||||
{
|
|
||||||
bank.invalidate();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>) {
|
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>) {
|
||||||
if slot >= 16 {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let prepared = Arc::new(bank.resident_copy());
|
|
||||||
let mut pool = self.sound_bank_pool.write().unwrap();
|
let mut pool = self.sound_bank_pool.write().unwrap();
|
||||||
if slot < 16 {
|
if slot < 16 {
|
||||||
if let Some(old) = pool[slot].take() {
|
pool[slot] = Some(bank);
|
||||||
old.invalidate();
|
|
||||||
}
|
|
||||||
pool[slot] = Some(prepared);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn clear_sound_banks(&self) {
|
fn clear_sound_banks(&self) {
|
||||||
let mut pool = self.sound_bank_pool.write().unwrap();
|
self.sound_bank_pool.write().unwrap().fill(None);
|
||||||
for bank in pool.iter_mut() {
|
|
||||||
if let Some(old) = bank.take() {
|
|
||||||
old.invalidate();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -302,84 +246,3 @@ mod tests {
|
|||||||
assert_eq!(HalRenderResourceAccess::scene_bank_count(&banks), 16);
|
assert_eq!(HalRenderResourceAccess::scene_bank_count(&banks), 16);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Owner-thread diagnostics: canonical bank costs and unique PCM allocation costs
|
|
||||||
/// are separate, so loading the same asset in two slots does not double-count RAM.
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct AudioSlotMemory {
|
|
||||||
pub music: bool,
|
|
||||||
pub slot: usize,
|
|
||||||
pub name: String,
|
|
||||||
pub metrics: prometeu_hal::sound_bank::AudioBankMetrics,
|
|
||||||
}
|
|
||||||
#[derive(Debug, Default)]
|
|
||||||
pub struct AudioMemorySnapshot {
|
|
||||||
pub banks: Vec<AudioSlotMemory>,
|
|
||||||
pub unique_pcm_bytes: usize,
|
|
||||||
pub allocated_pcm_bytes: usize,
|
|
||||||
/// Resident Rust structs/vector/string capacities; excludes allocator/Arc headers and host caches.
|
|
||||||
pub metadata_bytes: usize,
|
|
||||||
pub total_accounted_bytes: usize,
|
|
||||||
}
|
|
||||||
impl MemoryBanks {
|
|
||||||
pub fn audio_memory(&self) -> AudioMemorySnapshot {
|
|
||||||
let mut snapshot = AudioMemorySnapshot::default();
|
|
||||||
let mut seen = std::collections::HashSet::new();
|
|
||||||
let mut metadata = 0usize;
|
|
||||||
let mut vectors = std::collections::HashSet::new();
|
|
||||||
let mut add =
|
|
||||||
|music, slot, name: String, metrics, samples: &[Arc<prometeu_hal::sample::Sample>]| {
|
|
||||||
for sample in samples {
|
|
||||||
if seen.insert(Arc::as_ptr(sample)) {
|
|
||||||
metadata += std::mem::size_of::<prometeu_hal::sample::Sample>();
|
|
||||||
snapshot.unique_pcm_bytes += sample.data.len() * 2;
|
|
||||||
snapshot.allocated_pcm_bytes += sample.data.capacity() * 2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
snapshot.banks.push(AudioSlotMemory { music, slot, name, metrics });
|
|
||||||
};
|
|
||||||
for (slot, bank) in self.sound_bank_pool.read().unwrap().iter().enumerate() {
|
|
||||||
if let Some(b) = bank {
|
|
||||||
add(false, slot, b.name.clone(), b.metrics, &b.samples);
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<SoundBank>()
|
|
||||||
+ b.name.capacity()
|
|
||||||
+ std::mem::size_of::<std::sync::atomic::AtomicBool>();
|
|
||||||
if vectors.insert(Arc::as_ptr(&b.samples) as usize) {
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<
|
|
||||||
Vec<Arc<prometeu_hal::sample::Sample>>,
|
|
||||||
>() + b.samples.capacity()
|
|
||||||
* std::mem::size_of::<Arc<prometeu_hal::sample::Sample>>();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (slot, bank) in self.music_bank_pool.read().unwrap().iter().enumerate() {
|
|
||||||
if let Some(b) = bank {
|
|
||||||
add(true, slot, b.name.clone(), b.metrics, &b.samples);
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<MusicBank>()
|
|
||||||
+ b.name.capacity()
|
|
||||||
+ std::mem::size_of::<std::sync::atomic::AtomicBool>();
|
|
||||||
if vectors.insert(Arc::as_ptr(&b.samples) as usize) {
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<
|
|
||||||
Vec<Arc<prometeu_hal::sample::Sample>>,
|
|
||||||
>() + b.samples.capacity()
|
|
||||||
* std::mem::size_of::<Arc<prometeu_hal::sample::Sample>>();
|
|
||||||
}
|
|
||||||
if vectors.insert(Arc::as_ptr(&b.instruments) as usize) {
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<
|
|
||||||
Vec<prometeu_hal::music_bank::Instrument>,
|
|
||||||
>() + b.instruments.capacity()
|
|
||||||
* std::mem::size_of::<prometeu_hal::music_bank::Instrument>();
|
|
||||||
}
|
|
||||||
if vectors.insert(Arc::as_ptr(&b.events) as usize) {
|
|
||||||
snapshot.metadata_bytes += std::mem::size_of::<
|
|
||||||
Vec<prometeu_hal::music_bank::TimedMusicEvent>,
|
|
||||||
>() + b.events.capacity()
|
|
||||||
* std::mem::size_of::<prometeu_hal::music_bank::TimedMusicEvent>();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
snapshot.metadata_bytes += metadata;
|
|
||||||
snapshot.total_accounted_bytes = snapshot.allocated_pcm_bytes + snapshot.metadata_bytes;
|
|
||||||
snapshot
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -1,109 +0,0 @@
|
|||||||
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,8 +18,6 @@ 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 = prometeu_hal::graphics_contract::WIDTH;
|
const FRAMEBUFFER_WIDTH: usize = 480;
|
||||||
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]
|
||||||
}
|
}
|
||||||
@@ -1024,10 +1024,6 @@ mod tests {
|
|||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
||||||
Some(1)
|
Some(1)
|
||||||
);
|
);
|
||||||
assert_eq!(
|
|
||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::MUSIC, index: 0 }).asset_id,
|
|
||||||
Some(201)
|
|
||||||
);
|
|
||||||
|
|
||||||
firmware.request_home_from_host();
|
firmware.request_home_from_host();
|
||||||
firmware.tick(&InputSignals::default(), &mut platform);
|
firmware.tick(&InputSignals::default(), &mut platform);
|
||||||
@@ -1042,10 +1038,6 @@ mod tests {
|
|||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
||||||
Some(1)
|
Some(1)
|
||||||
);
|
);
|
||||||
assert_eq!(
|
|
||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::MUSIC, index: 0 }).asset_id,
|
|
||||||
Some(201)
|
|
||||||
);
|
|
||||||
|
|
||||||
firmware.tick(&InputSignals::default(), &mut platform);
|
firmware.tick(&InputSignals::default(), &mut platform);
|
||||||
let dummy_click =
|
let dummy_click =
|
||||||
@@ -1059,10 +1051,6 @@ mod tests {
|
|||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
||||||
None
|
None
|
||||||
);
|
);
|
||||||
assert_eq!(
|
|
||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::MUSIC, index: 0 }).asset_id,
|
|
||||||
None
|
|
||||||
);
|
|
||||||
assert!(platform.local_hardware().memory_banks.glyph_bank_slot(0).is_none());
|
assert!(platform.local_hardware().memory_banks.glyph_bank_slot(0).is_none());
|
||||||
assert!(platform.local_hardware().memory_banks.scene_bank_slot(0).is_none());
|
assert!(platform.local_hardware().memory_banks.scene_bank_slot(0).is_none());
|
||||||
|
|
||||||
@@ -1090,7 +1078,6 @@ mod tests {
|
|||||||
);
|
);
|
||||||
|
|
||||||
firmware.tick(&InputSignals::default(), &mut platform);
|
firmware.tick(&InputSignals::default(), &mut platform);
|
||||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
|
||||||
|
|
||||||
match &firmware.state {
|
match &firmware.state {
|
||||||
FirmwareState::GameRunning(step) => assert_eq!(step.task_id, dummy_task),
|
FirmwareState::GameRunning(step) => assert_eq!(step.task_id, dummy_task),
|
||||||
@@ -1107,9 +1094,7 @@ 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 = prometeu_hal::graphics_contract::WIDTH / 2
|
let center = 240 + 135 * 480;
|
||||||
+ (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();
|
||||||
@@ -1141,10 +1126,6 @@ mod tests {
|
|||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
platform.assets().slot_info(SlotRef { asset_type: BankType::SCENE, index: 0 }).asset_id,
|
||||||
Some(1)
|
Some(1)
|
||||||
);
|
);
|
||||||
assert_eq!(
|
|
||||||
platform.assets().slot_info(SlotRef { asset_type: BankType::MUSIC, index: 0 }).asset_id,
|
|
||||||
Some(201)
|
|
||||||
);
|
|
||||||
assert!(platform.local_hardware().memory_banks.glyph_bank_slot(0).is_some());
|
assert!(platform.local_hardware().memory_banks.glyph_bank_slot(0).is_some());
|
||||||
assert!(platform.local_hardware().memory_banks.scene_bank_slot(0).is_some());
|
assert!(platform.local_hardware().memory_banks.scene_bank_slot(0).is_some());
|
||||||
|
|
||||||
@@ -1531,12 +1512,8 @@ 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 = InputSignals {
|
let close_signals =
|
||||||
f_signal: true,
|
InputSignals { f_signal: true, x_pos: 420, y_pos: 24, ..Default::default() };
|
||||||
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,12 +47,7 @@ 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 {
|
Rect { x: 40, y: 20, w: 400, h: 220 },
|
||||||
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,25 +48,6 @@ 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) }
|
||||||
@@ -147,8 +128,13 @@ 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 self.choose_memcard(ctx.os, choice, created_at) {
|
match ctx.os.memcard().choose_for_game(
|
||||||
Ok(()) => {}
|
self.cartridge.app_id,
|
||||||
|
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),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -8,7 +8,6 @@ pub type AssetId = i32;
|
|||||||
pub enum BankType {
|
pub enum BankType {
|
||||||
GLYPH,
|
GLYPH,
|
||||||
SOUNDS,
|
SOUNDS,
|
||||||
MUSIC,
|
|
||||||
SCENE,
|
SCENE,
|
||||||
// TILEMAPS,
|
// TILEMAPS,
|
||||||
// BLOBS,
|
// BLOBS,
|
||||||
@@ -42,8 +41,9 @@ pub struct GlyphBankMetadata {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||||
pub struct AudioBankMetadata {
|
pub struct SoundBankMetadata {
|
||||||
pub version: u16,
|
pub sample_rate: u32,
|
||||||
|
pub channels: u32,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
||||||
@@ -73,16 +73,15 @@ impl AssetEntry {
|
|||||||
.map_err(|e| format!("Invalid GLYPH metadata for asset {}: {}", self.asset_id, e))
|
.map_err(|e| format!("Invalid GLYPH metadata for asset {}: {}", self.asset_id, e))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn metadata_as_audio_bank(&self) -> Result<AudioBankMetadata, String> {
|
pub fn metadata_as_sound_bank(&self) -> Result<SoundBankMetadata, String> {
|
||||||
if !matches!(self.bank_type, BankType::SOUNDS | BankType::MUSIC) {
|
if self.bank_type != BankType::SOUNDS {
|
||||||
return Err("asset is not an audio bank".into());
|
return Err(format!(
|
||||||
|
"Asset {} is not a SOUNDS bank (type: {:?})",
|
||||||
|
self.asset_id, self.bank_type
|
||||||
|
));
|
||||||
}
|
}
|
||||||
let metadata: AudioBankMetadata = serde_json::from_value(self.metadata.clone())
|
serde_json::from_value(self.metadata.clone())
|
||||||
.map_err(|e| format!("Invalid audio metadata: {e}"))?;
|
.map_err(|e| format!("Invalid SOUNDS metadata for asset {}: {}", self.asset_id, e))
|
||||||
if metadata.version != 1 {
|
|
||||||
return Err("unsupported audio metadata version".into());
|
|
||||||
}
|
|
||||||
Ok(metadata)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn metadata_as_scene_bank(&self) -> Result<SceneBankMetadata, String> {
|
pub fn metadata_as_scene_bank(&self) -> Result<SceneBankMetadata, String> {
|
||||||
@@ -190,9 +189,6 @@ pub struct SlotRef {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl SlotRef {
|
impl SlotRef {
|
||||||
pub fn music(index: usize) -> Self {
|
|
||||||
Self { asset_type: BankType::MUSIC, index }
|
|
||||||
}
|
|
||||||
pub fn gfx(index: usize) -> Self {
|
pub fn gfx(index: usize) -> Self {
|
||||||
Self { asset_type: BankType::GLYPH, index }
|
Self { asset_type: BankType::GLYPH, index }
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -6,9 +6,6 @@ use crate::asset::{
|
|||||||
use crate::cartridge::AssetsPayloadSource;
|
use crate::cartridge::AssetsPayloadSource;
|
||||||
|
|
||||||
pub trait AssetBridge {
|
pub trait AssetBridge {
|
||||||
fn unload_audio(&self, _music: bool, _slot: usize) -> AssetOpStatus {
|
|
||||||
AssetOpStatus::InvalidState
|
|
||||||
}
|
|
||||||
/// Bind before cartridge preload/loading. Hosts supporting memcard must use
|
/// Bind before cartridge preload/loading. Hosts supporting memcard must use
|
||||||
/// this same lane for assets; an unsupported bridge refuses the fast profile.
|
/// this same lane for assets; an unsupported bridge refuses the fast profile.
|
||||||
fn bind_background_work(
|
fn bind_background_work(
|
||||||
|
|||||||
@@ -20,20 +20,6 @@ pub enum AudioOpStatus {
|
|||||||
CommandLimit = 7,
|
CommandLimit = 7,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// High-level commands are staged with the ordinary frame/lifecycle batch.
|
|
||||||
#[derive(Debug, Clone, Copy)]
|
|
||||||
pub enum AudioControl {
|
|
||||||
GroupVolume { group: usize, gain: u8 },
|
|
||||||
MusicStop { group: usize },
|
|
||||||
MusicPause { group: usize, paused: bool },
|
|
||||||
MusicVolume { group: usize, gain: u8 },
|
|
||||||
MusicFade { group: usize, gain: u8, frames: u32, smooth: bool },
|
|
||||||
Crossfade { source: usize, target: usize, frames: u32, smooth: bool },
|
|
||||||
BusVolume { bus: usize, gain: u8 },
|
|
||||||
Effect { group: usize, cutoff_hz: u32, delay_frames: u32, feedback: f32, wet: f32, dry: f32 },
|
|
||||||
SfxSend { voice: usize, gain: u8 },
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait AudioBridge {
|
pub trait AudioBridge {
|
||||||
#[allow(clippy::too_many_arguments)]
|
#[allow(clippy::too_many_arguments)]
|
||||||
fn play(
|
fn play(
|
||||||
@@ -58,8 +44,6 @@ pub trait AudioBridge {
|
|||||||
priority: u8,
|
priority: u8,
|
||||||
loop_mode: LoopMode,
|
loop_mode: LoopMode,
|
||||||
) -> AudioOpStatus;
|
) -> AudioOpStatus;
|
||||||
fn music_play(&mut self, group: usize, bank: usize, looping: bool) -> AudioOpStatus;
|
|
||||||
fn control(&mut self, control: AudioControl) -> AudioOpStatus;
|
|
||||||
fn stop(&mut self, voice_id: usize) -> AudioOpStatus;
|
fn stop(&mut self, voice_id: usize) -> AudioOpStatus;
|
||||||
fn set_volume(&mut self, voice_id: usize, volume: u8) -> AudioOpStatus;
|
fn set_volume(&mut self, voice_id: usize, volume: u8) -> AudioOpStatus;
|
||||||
fn set_pan(&mut self, voice_id: usize, pan: u8) -> AudioOpStatus;
|
fn set_pan(&mut self, voice_id: usize, pan: u8) -> AudioOpStatus;
|
||||||
|
|||||||
@@ -1,20 +0,0 @@
|
|||||||
//! 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,13 +12,11 @@ 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;
|
||||||
pub mod log;
|
pub mod log;
|
||||||
pub mod memcard;
|
pub mod memcard;
|
||||||
pub mod music_bank;
|
|
||||||
pub mod native_helpers;
|
pub mod native_helpers;
|
||||||
pub mod native_interface;
|
pub mod native_interface;
|
||||||
pub mod owned_frame;
|
pub mod owned_frame;
|
||||||
|
|||||||
@@ -57,21 +57,6 @@ 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)
|
||||||
}
|
}
|
||||||
@@ -122,35 +107,4 @@ 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,10 +6,6 @@ pub enum MemcardIoError {
|
|||||||
InvalidRange,
|
InvalidRange,
|
||||||
NoSpace,
|
NoSpace,
|
||||||
Unsupported,
|
Unsupported,
|
||||||
Busy,
|
|
||||||
AccessDenied,
|
|
||||||
AlreadyExists,
|
|
||||||
Indeterminate,
|
|
||||||
IoError,
|
IoError,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -1,376 +0,0 @@
|
|||||||
//! Resident, self-contained music data. Construction/compilation is off the audio lane.
|
|
||||||
use crate::{sample::Sample, sound_bank::AudioBankMetrics};
|
|
||||||
use std::sync::{
|
|
||||||
Arc,
|
|
||||||
atomic::{AtomicBool, Ordering},
|
|
||||||
};
|
|
||||||
|
|
||||||
pub const AUDIO_PPQ: u32 = 960;
|
|
||||||
pub const AUDIO_RATE: u32 = 48_000;
|
|
||||||
pub const MAX_MUSIC_TRACKS: usize = 256;
|
|
||||||
pub const MAX_EVENTS_PER_FRAME: usize = 64;
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy)]
|
|
||||||
pub struct Instrument {
|
|
||||||
pub id: u16,
|
|
||||||
pub sample: u16,
|
|
||||||
pub low: u8,
|
|
||||||
pub high: u8,
|
|
||||||
pub root: u8,
|
|
||||||
pub looping: bool,
|
|
||||||
pub tuning_cents: i16,
|
|
||||||
pub pan: u8,
|
|
||||||
pub gain: u8,
|
|
||||||
pub attack_us: u32,
|
|
||||||
pub decay_us: u32,
|
|
||||||
pub sustain: u16,
|
|
||||||
pub release_us: u32,
|
|
||||||
pub vibrato_millihz: u32,
|
|
||||||
pub vibrato_cents: u16,
|
|
||||||
pub tremolo_depth: u16,
|
|
||||||
pub tremolo_millihz: u32,
|
|
||||||
pub send: u16,
|
|
||||||
pub curve: u8,
|
|
||||||
}
|
|
||||||
impl Default for Instrument {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
id: 0,
|
|
||||||
sample: 0,
|
|
||||||
low: 0,
|
|
||||||
high: 127,
|
|
||||||
root: 60,
|
|
||||||
looping: false,
|
|
||||||
tuning_cents: 0,
|
|
||||||
pan: 128,
|
|
||||||
gain: 255,
|
|
||||||
attack_us: 0,
|
|
||||||
decay_us: 0,
|
|
||||||
sustain: u16::MAX,
|
|
||||||
release_us: 0,
|
|
||||||
vibrato_millihz: 0,
|
|
||||||
vibrato_cents: 0,
|
|
||||||
tremolo_depth: 0,
|
|
||||||
tremolo_millihz: 0,
|
|
||||||
send: 0,
|
|
||||||
curve: 1,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, Default)]
|
|
||||||
pub struct MusicEvent {
|
|
||||||
pub tick: u32,
|
|
||||||
pub kind: u8,
|
|
||||||
pub track: u8,
|
|
||||||
pub flags: u16,
|
|
||||||
pub a: u32,
|
|
||||||
pub b: u32,
|
|
||||||
pub c: i32,
|
|
||||||
pub d: i32,
|
|
||||||
pub duration_frames: u32,
|
|
||||||
pub curve: u32,
|
|
||||||
}
|
|
||||||
#[derive(Debug, Clone, Copy)]
|
|
||||||
pub struct TimedMusicEvent {
|
|
||||||
pub time: u128,
|
|
||||||
pub event: MusicEvent,
|
|
||||||
pub zone: usize,
|
|
||||||
}
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct MusicBank {
|
|
||||||
pub name: String,
|
|
||||||
pub samples: Arc<Vec<Arc<Sample>>>,
|
|
||||||
pub instruments: Arc<Vec<Instrument>>,
|
|
||||||
pub events: Arc<Vec<TimedMusicEvent>>,
|
|
||||||
pub denominator: u128,
|
|
||||||
pub end_time: u128,
|
|
||||||
pub loop_time: Option<u128>,
|
|
||||||
pub loop_event: usize,
|
|
||||||
pub tracks: usize,
|
|
||||||
pub alive: Arc<AtomicBool>,
|
|
||||||
pub metrics: AudioBankMetrics,
|
|
||||||
}
|
|
||||||
impl MusicBank {
|
|
||||||
#[allow(clippy::too_many_arguments)]
|
|
||||||
pub fn compile(
|
|
||||||
name: String,
|
|
||||||
samples: Vec<Arc<Sample>>,
|
|
||||||
instruments: Vec<Instrument>,
|
|
||||||
events: Vec<MusicEvent>,
|
|
||||||
ppq: u32,
|
|
||||||
tempo: u32,
|
|
||||||
duration: u32,
|
|
||||||
loop_tick: Option<u32>,
|
|
||||||
tracks: usize,
|
|
||||||
) -> Result<Self, String> {
|
|
||||||
let mut compiler = MusicCompiler::new(
|
|
||||||
name,
|
|
||||||
samples,
|
|
||||||
instruments,
|
|
||||||
events,
|
|
||||||
ppq,
|
|
||||||
tempo,
|
|
||||||
duration,
|
|
||||||
loop_tick,
|
|
||||||
tracks,
|
|
||||||
)?;
|
|
||||||
loop {
|
|
||||||
if let Some(bank) = compiler.step()? {
|
|
||||||
return Ok(bank);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn invalidate(&self) {
|
|
||||||
self.alive.store(false, Ordering::Release);
|
|
||||||
}
|
|
||||||
pub fn resident_copy(&self) -> Self {
|
|
||||||
Self {
|
|
||||||
name: self.name.clone(),
|
|
||||||
samples: self.samples.clone(),
|
|
||||||
instruments: self.instruments.clone(),
|
|
||||||
events: self.events.clone(),
|
|
||||||
denominator: self.denominator,
|
|
||||||
end_time: self.end_time,
|
|
||||||
loop_time: self.loop_time,
|
|
||||||
loop_event: self.loop_event,
|
|
||||||
tracks: self.tracks,
|
|
||||||
alive: Arc::new(AtomicBool::new(true)),
|
|
||||||
metrics: self.metrics,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Cooperative off-lane validation/clock compilation. At most 64 zones/events
|
|
||||||
/// per step; lookup is logarithmic and the loop-seam check is bounded by 65.
|
|
||||||
pub struct MusicCompiler {
|
|
||||||
name: Option<String>,
|
|
||||||
samples: Vec<Arc<Sample>>,
|
|
||||||
instruments: Vec<Instrument>,
|
|
||||||
source: std::vec::IntoIter<MusicEvent>,
|
|
||||||
compiled: Vec<TimedMusicEvent>,
|
|
||||||
zones: std::collections::BTreeMap<(u16, u8), usize>,
|
|
||||||
zone_cursor: usize,
|
|
||||||
ppq: u32,
|
|
||||||
tempo: u32,
|
|
||||||
duration: u32,
|
|
||||||
loop_tick: Option<u32>,
|
|
||||||
tracks: usize,
|
|
||||||
tick: u32,
|
|
||||||
time: u128,
|
|
||||||
loop_time: Option<u128>,
|
|
||||||
selected: [u32; MAX_MUSIC_TRACKS],
|
|
||||||
}
|
|
||||||
impl MusicCompiler {
|
|
||||||
#[allow(clippy::too_many_arguments)]
|
|
||||||
pub fn new(
|
|
||||||
name: String,
|
|
||||||
samples: Vec<Arc<Sample>>,
|
|
||||||
instruments: Vec<Instrument>,
|
|
||||||
events: Vec<MusicEvent>,
|
|
||||||
ppq: u32,
|
|
||||||
tempo: u32,
|
|
||||||
duration: u32,
|
|
||||||
loop_tick: Option<u32>,
|
|
||||||
tracks: usize,
|
|
||||||
) -> Result<Self, String> {
|
|
||||||
if ppq != AUDIO_PPQ
|
|
||||||
|| tempo == 0
|
|
||||||
|| duration == 0
|
|
||||||
|| tracks == 0
|
|
||||||
|| tracks > MAX_MUSIC_TRACKS
|
|
||||||
|| loop_tick.is_some_and(|t| t >= duration)
|
|
||||||
{
|
|
||||||
return Err("invalid music clock/tracks/loop".into());
|
|
||||||
}
|
|
||||||
let mut compiled = Vec::new();
|
|
||||||
compiled.try_reserve_exact(events.len()).map_err(|_| "music allocation failed")?;
|
|
||||||
Ok(Self {
|
|
||||||
name: Some(name),
|
|
||||||
samples,
|
|
||||||
instruments,
|
|
||||||
source: events.into_iter(),
|
|
||||||
compiled,
|
|
||||||
zones: std::collections::BTreeMap::new(),
|
|
||||||
zone_cursor: 0,
|
|
||||||
ppq,
|
|
||||||
tempo,
|
|
||||||
duration,
|
|
||||||
loop_tick,
|
|
||||||
tracks,
|
|
||||||
tick: 0,
|
|
||||||
time: 0,
|
|
||||||
loop_time: None,
|
|
||||||
selected: [u32::MAX; MAX_MUSIC_TRACKS],
|
|
||||||
})
|
|
||||||
}
|
|
||||||
pub fn step(&mut self) -> Result<Option<MusicBank>, String> {
|
|
||||||
let denominator = self.ppq as u128 * 1_000_000;
|
|
||||||
for _ in 0..64 {
|
|
||||||
if self.zone_cursor < self.instruments.len() {
|
|
||||||
let i = self.zone_cursor;
|
|
||||||
let inst = self.instruments[i];
|
|
||||||
if inst.low > inst.high
|
|
||||||
|| inst.high > 127
|
|
||||||
|| inst.root > 127
|
|
||||||
|| inst.curve > 1
|
|
||||||
|| inst.sample as usize >= self.samples.len()
|
|
||||||
|| inst.vibrato_millihz > 100_000
|
|
||||||
|| inst.tremolo_millihz > 100_000
|
|
||||||
|| inst.vibrato_cents > 2400
|
|
||||||
{
|
|
||||||
return Err("invalid instrument zone/modulation".into());
|
|
||||||
}
|
|
||||||
if inst.looping && self.samples[inst.sample as usize].loop_start.is_none() {
|
|
||||||
return Err("instrument requires a sample loop".into());
|
|
||||||
}
|
|
||||||
if self
|
|
||||||
.zones
|
|
||||||
.range((inst.id, 0)..=(inst.id, inst.high))
|
|
||||||
.next_back()
|
|
||||||
.is_some_and(|(_, j)| self.instruments[*j].high >= inst.low)
|
|
||||||
{
|
|
||||||
return Err("overlapping instrument zones".into());
|
|
||||||
}
|
|
||||||
self.zones.insert((inst.id, inst.low), i);
|
|
||||||
self.zone_cursor += 1;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let Some(event) = self.source.next() else {
|
|
||||||
return self.finish(denominator).map(Some);
|
|
||||||
};
|
|
||||||
if event.tick < self.tick
|
|
||||||
|| event.tick > self.duration
|
|
||||||
|| event.track as usize >= self.tracks
|
|
||||||
|| event.curve > 1
|
|
||||||
|| event.flags & !1 != 0
|
|
||||||
|| !(1..=10).contains(&event.kind)
|
|
||||||
{
|
|
||||||
return Err("invalid music event ordering/shape".into());
|
|
||||||
}
|
|
||||||
if let Some(t) = self.loop_tick.filter(|&t| t >= self.tick && t <= event.tick)
|
|
||||||
&& self.loop_time.is_none()
|
|
||||||
{
|
|
||||||
self.loop_time = Some(
|
|
||||||
self.time + (t - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
self.time += (event.tick - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128;
|
|
||||||
self.tick = event.tick;
|
|
||||||
let mut zone = 0;
|
|
||||||
match event.kind {
|
|
||||||
1 => {
|
|
||||||
if !(0..=127).contains(&event.c) || !(0..=255).contains(&event.d) {
|
|
||||||
return Err("invalid note/velocity".into());
|
|
||||||
}
|
|
||||||
let id = if event.b == u32::MAX {
|
|
||||||
self.selected[event.track as usize]
|
|
||||||
} else {
|
|
||||||
event.b
|
|
||||||
};
|
|
||||||
if id > u16::MAX as u32 {
|
|
||||||
return Err("note has no bank-local instrument".into());
|
|
||||||
}
|
|
||||||
zone = *self
|
|
||||||
.zones
|
|
||||||
.range((id as u16, 0)..=(id as u16, event.c as u8))
|
|
||||||
.next_back()
|
|
||||||
.map(|(_, i)| i)
|
|
||||||
.filter(|&&i| self.instruments[i].high as i32 >= event.c)
|
|
||||||
.ok_or("note has no bank-local instrument zone")?;
|
|
||||||
}
|
|
||||||
3 => {
|
|
||||||
if event.a == 0 {
|
|
||||||
return Err("zero tempo".into());
|
|
||||||
}
|
|
||||||
self.tempo = event.a;
|
|
||||||
}
|
|
||||||
4 | 9 => {
|
|
||||||
if !(0..=65535).contains(&event.c) {
|
|
||||||
return Err("invalid gain/send".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
5 => {
|
|
||||||
if !(0..=255).contains(&event.c) {
|
|
||||||
return Err("invalid pan".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
6 => {
|
|
||||||
if !(-9600..=9600).contains(&event.c) {
|
|
||||||
return Err("invalid pitch bend".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
7 | 8 => {
|
|
||||||
if event.a > 100_000
|
|
||||||
|| event.c < 0
|
|
||||||
|| event.c > if event.kind == 7 { 2400 } else { 65535 }
|
|
||||||
{
|
|
||||||
return Err("invalid modulation".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
10 => {
|
|
||||||
if event.a > u16::MAX as u32
|
|
||||||
|| self
|
|
||||||
.zones
|
|
||||||
.range((event.a as u16, 0)..=(event.a as u16, 127))
|
|
||||||
.next()
|
|
||||||
.is_none()
|
|
||||||
{
|
|
||||||
return Err("unknown instrument".into());
|
|
||||||
}
|
|
||||||
self.selected[event.track as usize] = event.a;
|
|
||||||
}
|
|
||||||
_ => {}
|
|
||||||
}
|
|
||||||
if self.compiled.len() >= MAX_EVENTS_PER_FRAME
|
|
||||||
&& self.time - self.compiled[self.compiled.len() - MAX_EVENTS_PER_FRAME].time
|
|
||||||
< denominator
|
|
||||||
{
|
|
||||||
return Err("music event density exceeds real-time bound".into());
|
|
||||||
}
|
|
||||||
self.compiled.push(TimedMusicEvent { time: self.time, event, zone });
|
|
||||||
}
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
fn finish(&mut self, denominator: u128) -> Result<MusicBank, String> {
|
|
||||||
if let Some(t) = self.loop_tick.filter(|&t| t >= self.tick)
|
|
||||||
&& self.loop_time.is_none()
|
|
||||||
{
|
|
||||||
self.loop_time =
|
|
||||||
Some(self.time + (t - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128);
|
|
||||||
}
|
|
||||||
let end_time = self.time
|
|
||||||
+ (self.duration - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128;
|
|
||||||
if end_time < denominator || self.loop_time.is_some_and(|t| end_time - t < denominator) {
|
|
||||||
return Err("music/loop shorter than one output frame".into());
|
|
||||||
}
|
|
||||||
let loop_event =
|
|
||||||
self.loop_time.map_or(0, |t| self.compiled.partition_point(|e| e.time < t));
|
|
||||||
let length = end_time - self.loop_time.unwrap_or(0);
|
|
||||||
let slice = &self.compiled[loop_event..];
|
|
||||||
for i in 0..slice.len().min(MAX_EVENTS_PER_FRAME + 1) {
|
|
||||||
let tail =
|
|
||||||
slice.len().saturating_sub(MAX_EVENTS_PER_FRAME - i.min(MAX_EVENTS_PER_FRAME));
|
|
||||||
if tail < slice.len()
|
|
||||||
&& slice.len() - tail + i + 1 > MAX_EVENTS_PER_FRAME
|
|
||||||
&& slice[i].time + length - slice[tail].time < denominator
|
|
||||||
{
|
|
||||||
return Err("music loop seam event density".into());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let pcm_bytes = self.samples.iter().map(|s| s.data.len() * 2).sum();
|
|
||||||
Ok(MusicBank {
|
|
||||||
name: self.name.take().ok_or("compiler already complete")?,
|
|
||||||
samples: Arc::new(std::mem::take(&mut self.samples)),
|
|
||||||
instruments: Arc::new(std::mem::take(&mut self.instruments)),
|
|
||||||
events: Arc::new(std::mem::take(&mut self.compiled)),
|
|
||||||
denominator,
|
|
||||||
end_time,
|
|
||||||
loop_time: self.loop_time,
|
|
||||||
loop_event,
|
|
||||||
tracks: self.tracks,
|
|
||||||
alive: Arc::new(AtomicBool::new(true)),
|
|
||||||
metrics: AudioBankMetrics { pcm_bytes, ..Default::default() },
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -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) {
|
||||||
(crate::graphics_contract::WIDTH, crate::graphics_contract::HEIGHT)
|
(480, 270)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink;
|
fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink;
|
||||||
|
|||||||
@@ -1,27 +1,13 @@
|
|||||||
#[derive(Debug)]
|
|
||||||
pub struct Sample {
|
pub struct Sample {
|
||||||
pub sample_rate: u32,
|
pub sample_rate: u32,
|
||||||
pub channels: u8,
|
|
||||||
pub data: Vec<i16>,
|
pub data: Vec<i16>,
|
||||||
pub loop_start: Option<u32>,
|
pub loop_start: Option<u32>,
|
||||||
pub loop_end: Option<u32>,
|
pub loop_end: Option<u32>,
|
||||||
pub default_volume: u8,
|
|
||||||
pub default_pan: u8,
|
|
||||||
pub default_pitch: f64,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Sample {
|
impl Sample {
|
||||||
pub fn new(sample_rate: u32, data: Vec<i16>) -> Self {
|
pub fn new(sample_rate: u32, data: Vec<i16>) -> Self {
|
||||||
Self {
|
Self { sample_rate, data, loop_start: None, loop_end: None }
|
||||||
sample_rate,
|
|
||||||
channels: 1,
|
|
||||||
data,
|
|
||||||
loop_start: None,
|
|
||||||
loop_end: None,
|
|
||||||
default_volume: 255,
|
|
||||||
default_pan: 128,
|
|
||||||
default_pitch: 1.0,
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn with_loop(mut self, start: u32, end: u32) -> Self {
|
pub fn with_loop(mut self, start: u32, end: u32) -> Self {
|
||||||
@@ -31,14 +17,6 @@ impl Sample {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn frames_len(&self) -> usize {
|
pub fn frames_len(&self) -> usize {
|
||||||
self.data.len() / self.channels.max(1) as usize
|
self.data.len()
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_channels(mut self, channels: u8) -> Result<Self, String> {
|
|
||||||
if !(1..=2).contains(&channels) || !self.data.len().is_multiple_of(channels as usize) {
|
|
||||||
return Err("audio sample channels/frame count".into());
|
|
||||||
}
|
|
||||||
self.channels = channels;
|
|
||||||
Ok(self)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -224,8 +224,6 @@ 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;
|
||||||
@@ -233,11 +231,11 @@ impl SceneViewportResolver {
|
|||||||
if drift_x.abs() <= self.hysteresis_safe_px {
|
if drift_x.abs() <= self.hysteresis_safe_px {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if drift_x > trigger {
|
if drift_x > self.hysteresis_trigger_px {
|
||||||
next.x += 1;
|
next.x += 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if drift_x < -trigger {
|
if drift_x < -self.hysteresis_trigger_px {
|
||||||
next.x -= 1;
|
next.x -= 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
@@ -250,11 +248,11 @@ impl SceneViewportResolver {
|
|||||||
if drift_y.abs() <= self.hysteresis_safe_px {
|
if drift_y.abs() <= self.hysteresis_safe_px {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if drift_y > trigger {
|
if drift_y > self.hysteresis_trigger_px {
|
||||||
next.y += 1;
|
next.y += 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if drift_y < -trigger {
|
if drift_y < -self.hysteresis_trigger_px {
|
||||||
next.y -= 1;
|
next.y -= 1;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
@@ -435,34 +433,20 @@ 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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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: 22, y: 13 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 17, y: 10 });
|
||||||
assert_eq!(update.layer_anchors[0], TileAnchor { x: 22, y: 13 });
|
assert_eq!(update.layer_anchors[0], TileAnchor { x: 17, y: 10 });
|
||||||
assert_eq!(update.layer_anchors[1], TileAnchor { x: 22, y: 13 });
|
assert_eq!(update.layer_anchors[1], TileAnchor { x: 17, y: 10 });
|
||||||
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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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);
|
||||||
|
|
||||||
@@ -477,38 +461,24 @@ 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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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: 22, y: 13 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 17, y: 10 });
|
||||||
}
|
}
|
||||||
|
|
||||||
#[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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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 > 22);
|
assert!(update.master_anchor.x > 17);
|
||||||
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, .. }
|
||||||
@@ -519,32 +489,18 @@ 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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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: 41, y: 50 });
|
assert_eq!(update.master_anchor, TileAnchor { x: 46, y: 53 });
|
||||||
assert_eq!(update.layer_anchors[0], TileAnchor { x: 41, y: 50 });
|
assert_eq!(update.layer_anchors[0], TileAnchor { x: 46, y: 53 });
|
||||||
}
|
}
|
||||||
|
|
||||||
#[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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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);
|
||||||
@@ -559,22 +515,15 @@ mod tests {
|
|||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
assert_eq!(regions.len(), 2);
|
assert_eq!(regions.len(), 2);
|
||||||
assert_eq!(regions[0].x + regions[0].width, 45);
|
assert_eq!(regions[0].x + regions[0].width, 35);
|
||||||
assert_eq!(regions[0].height, 27);
|
assert_eq!(regions[0].height, 21);
|
||||||
assert_eq!(regions[1].width, 44);
|
assert_eq!(regions[1].width, 34);
|
||||||
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(
|
let mut resolver = SceneViewportResolver::new(480, 270, 35, 21, 12, 20);
|
||||||
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();
|
||||||
|
|
||||||
|
|||||||
@@ -1,47 +1,16 @@
|
|||||||
use crate::sample::Sample;
|
use crate::sample::Sample;
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::sync::atomic::{AtomicBool, Ordering};
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, Default)]
|
|
||||||
pub struct AudioBankMetrics {
|
|
||||||
pub cartridge_bytes: usize,
|
|
||||||
pub pcm_bytes: usize,
|
|
||||||
pub canonical_decoded_bytes: usize,
|
|
||||||
pub materialization_ns: u64,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A container for audio assets.
|
/// A container for audio assets.
|
||||||
///
|
///
|
||||||
/// A SoundBank stores multiple audio samples that can be played by the
|
/// A SoundBank stores multiple audio samples that can be played by the
|
||||||
/// audio subsystem.
|
/// audio subsystem.
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct SoundBank {
|
pub struct SoundBank {
|
||||||
pub samples: Arc<Vec<Arc<Sample>>>,
|
pub samples: Vec<Arc<Sample>>,
|
||||||
pub name: String,
|
|
||||||
pub alive: Arc<AtomicBool>,
|
|
||||||
pub metrics: AudioBankMetrics,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl SoundBank {
|
impl SoundBank {
|
||||||
pub fn new(samples: Vec<Arc<Sample>>) -> Self {
|
pub fn new(samples: Vec<Arc<Sample>>) -> Self {
|
||||||
let pcm_bytes = samples.iter().map(|s| s.data.len() * 2).sum();
|
Self { samples }
|
||||||
Self {
|
|
||||||
samples: Arc::new(samples),
|
|
||||||
name: String::new(),
|
|
||||||
alive: Arc::new(AtomicBool::new(true)),
|
|
||||||
metrics: AudioBankMetrics { pcm_bytes, ..Default::default() },
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn invalidate(&self) {
|
|
||||||
self.alive.store(false, Ordering::Release);
|
|
||||||
}
|
|
||||||
pub fn resident_copy(&self) -> Self {
|
|
||||||
Self {
|
|
||||||
samples: self.samples.clone(),
|
|
||||||
name: self.name.clone(),
|
|
||||||
alive: Arc::new(AtomicBool::new(true)),
|
|
||||||
metrics: self.metrics,
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -59,19 +59,6 @@ pub enum Syscall {
|
|||||||
AudioSetVolume = 0x3004,
|
AudioSetVolume = 0x3004,
|
||||||
AudioSetPan = 0x3005,
|
AudioSetPan = 0x3005,
|
||||||
AudioSetPitch = 0x3006,
|
AudioSetPitch = 0x3006,
|
||||||
MusicPlay = 0x3010,
|
|
||||||
MusicStop = 0x3011,
|
|
||||||
MusicPause = 0x3012,
|
|
||||||
MusicResume = 0x3013,
|
|
||||||
MusicSetVolume = 0x3014,
|
|
||||||
MusicFadeTo = 0x3015,
|
|
||||||
MusicCrossfade = 0x3016,
|
|
||||||
AudioSetBusVolume = 0x3020,
|
|
||||||
AudioSetEffect = 0x3021,
|
|
||||||
AudioSetSend = 0x3022,
|
|
||||||
AudioUnloadBank = 0x3023,
|
|
||||||
AudioSetGroupVolume = 0x3024,
|
|
||||||
|
|
||||||
FsOpen = 0x4001,
|
FsOpen = 0x4001,
|
||||||
FsRead = 0x4002,
|
FsRead = 0x4002,
|
||||||
FsWrite = 0x4003,
|
FsWrite = 0x4003,
|
||||||
|
|||||||
@@ -31,64 +31,4 @@ pub(crate) const ENTRIES: &[SyscallRegistryEntry] = &[
|
|||||||
.rets(1)
|
.rets(1)
|
||||||
.caps(caps::AUDIO)
|
.caps(caps::AUDIO)
|
||||||
.cost(5),
|
.cost(5),
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicPlay, "music", "play")
|
|
||||||
.args(3)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicStop, "music", "stop")
|
|
||||||
.args(1)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicPause, "music", "pause")
|
|
||||||
.args(1)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicResume, "music", "resume")
|
|
||||||
.args(1)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicSetVolume, "music", "set_volume")
|
|
||||||
.args(2)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicFadeTo, "music", "fade_to")
|
|
||||||
.args(4)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::MusicCrossfade, "music", "crossfade")
|
|
||||||
.args(4)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::AudioSetBusVolume, "audio", "set_bus_volume")
|
|
||||||
.args(2)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::AudioSetEffect, "audio", "set_effect")
|
|
||||||
.args(6)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::AudioSetSend, "audio", "set_send")
|
|
||||||
.args(2)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::AudioUnloadBank, "audio", "unload_bank")
|
|
||||||
.args(2)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
SyscallRegistryEntry::builder(Syscall::AudioSetGroupVolume, "audio", "set_group_volume")
|
|
||||||
.args(2)
|
|
||||||
.rets(1)
|
|
||||||
.caps(caps::AUDIO)
|
|
||||||
.cost(5),
|
|
||||||
];
|
];
|
||||||
|
|||||||
@@ -37,19 +37,6 @@ impl Syscall {
|
|||||||
0x3004 => Some(Self::AudioSetVolume),
|
0x3004 => Some(Self::AudioSetVolume),
|
||||||
0x3005 => Some(Self::AudioSetPan),
|
0x3005 => Some(Self::AudioSetPan),
|
||||||
0x3006 => Some(Self::AudioSetPitch),
|
0x3006 => Some(Self::AudioSetPitch),
|
||||||
0x3010 => Some(Self::MusicPlay),
|
|
||||||
0x3011 => Some(Self::MusicStop),
|
|
||||||
0x3012 => Some(Self::MusicPause),
|
|
||||||
0x3013 => Some(Self::MusicResume),
|
|
||||||
0x3014 => Some(Self::MusicSetVolume),
|
|
||||||
0x3015 => Some(Self::MusicFadeTo),
|
|
||||||
0x3016 => Some(Self::MusicCrossfade),
|
|
||||||
0x3020 => Some(Self::AudioSetBusVolume),
|
|
||||||
0x3021 => Some(Self::AudioSetEffect),
|
|
||||||
0x3022 => Some(Self::AudioSetSend),
|
|
||||||
0x3023 => Some(Self::AudioUnloadBank),
|
|
||||||
0x3024 => Some(Self::AudioSetGroupVolume),
|
|
||||||
|
|
||||||
0x4001 => Some(Self::FsOpen),
|
0x4001 => Some(Self::FsOpen),
|
||||||
0x4002 => Some(Self::FsRead),
|
0x4002 => Some(Self::FsRead),
|
||||||
0x4003 => Some(Self::FsWrite),
|
0x4003 => Some(Self::FsWrite),
|
||||||
@@ -123,19 +110,6 @@ impl Syscall {
|
|||||||
Self::AudioSetVolume => "AudioSetVolume",
|
Self::AudioSetVolume => "AudioSetVolume",
|
||||||
Self::AudioSetPan => "AudioSetPan",
|
Self::AudioSetPan => "AudioSetPan",
|
||||||
Self::AudioSetPitch => "AudioSetPitch",
|
Self::AudioSetPitch => "AudioSetPitch",
|
||||||
Self::MusicPlay => "MusicPlay",
|
|
||||||
Self::MusicStop => "MusicStop",
|
|
||||||
Self::MusicPause => "MusicPause",
|
|
||||||
Self::MusicResume => "MusicResume",
|
|
||||||
Self::MusicSetVolume => "MusicSetVolume",
|
|
||||||
Self::MusicFadeTo => "MusicFadeTo",
|
|
||||||
Self::MusicCrossfade => "MusicCrossfade",
|
|
||||||
Self::AudioSetBusVolume => "AudioSetBusVolume",
|
|
||||||
Self::AudioSetEffect => "AudioSetEffect",
|
|
||||||
Self::AudioSetSend => "AudioSetSend",
|
|
||||||
Self::AudioUnloadBank => "AudioUnloadBank",
|
|
||||||
Self::AudioSetGroupVolume => "AudioSetGroupVolume",
|
|
||||||
|
|
||||||
Self::FsOpen => "FsOpen",
|
Self::FsOpen => "FsOpen",
|
||||||
Self::FsRead => "FsRead",
|
Self::FsRead => "FsRead",
|
||||||
Self::FsWrite => "FsWrite",
|
Self::FsWrite => "FsWrite",
|
||||||
|
|||||||
@@ -385,14 +385,6 @@ 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,14 +64,6 @@ 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(
|
||||||
@@ -170,16 +162,6 @@ 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,41 +10,19 @@ 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 =
|
const CLOSE_BUTTON: Rect = Rect { x: 420, y: 24, w: 16, h: 16 };
|
||||||
Rect { x: prometeu_hal::graphics_contract::WIDTH as i32 - 60, y: 24, w: 16, h: 16 };
|
const VIEWPORT: Rect = Rect { x: 0, y: 0, w: 480, h: 270 };
|
||||||
const VIEWPORT: Rect = Rect {
|
const HOME_PANEL: Rect = Rect { x: 48, y: 58, w: 384, h: 154 };
|
||||||
x: 0,
|
const TITLE_PANEL: Rect = Rect { x: 72, y: 34, w: 336, h: 28 };
|
||||||
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 = prometeu_hal::graphics_contract::WIDTH as i32 - 144;
|
const GAME_ROW_W: i32 = 336;
|
||||||
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 {
|
pub const HUB_SUSPENDED_GAME_KILL_CONTROL: Rect = Rect { x: 288, y: 230, w: 168, h: 24 };
|
||||||
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 {
|
const SHELL_FRAME: Rect = Rect { x: 40, y: 20, w: 400, h: 220 };
|
||||||
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,7 +2,6 @@
|
|||||||
//! 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,7 +37,6 @@ 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 {
|
||||||
@@ -49,26 +48,10 @@ 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()
|
||||||
}
|
}
|
||||||
@@ -77,11 +60,7 @@ 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 {
|
||||||
@@ -156,9 +135,6 @@ 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);
|
||||||
}
|
}
|
||||||
@@ -195,10 +171,6 @@ 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);
|
||||||
@@ -284,24 +256,9 @@ 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.io_active()
|
|| self.session.has_in_flight()
|
||||||
|| self.session.has_deferred_write()
|
|
||||||
|| self.session.is_boot_active()
|
|| self.session.is_boot_active()
|
||||||
{
|
{
|
||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
@@ -309,7 +266,6 @@ 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());
|
||||||
@@ -319,14 +275,13 @@ 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 = operation(&mut session, &worker_control);
|
let result = session.replace_storage(storage, load_existing, &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);
|
||||||
@@ -376,7 +331,6 @@ 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);
|
||||||
@@ -407,37 +361,3 @@ 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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -1,31 +0,0 @@
|
|||||||
//! 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,14 +31,12 @@ 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
|
Error::AccessDenied => 4,
|
||||||
| Error::IdentityMismatch
|
|
||||||
| Error::Io(I::AccessDenied | I::AlreadyExists) => 4,
|
|
||||||
Error::Corrupt => 5,
|
Error::Corrupt => 5,
|
||||||
Error::Indeterminate | Error::Io(I::Indeterminate) => 6,
|
Error::Indeterminate => 6,
|
||||||
Error::Io(I::Unavailable) => 7,
|
Error::Io(I::Unavailable) => 7,
|
||||||
Error::InvalidState | Error::Canceled => 8,
|
Error::InvalidState | Error::Canceled => 8,
|
||||||
Error::Busy | Error::Io(I::Busy) => 9,
|
Error::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,7 +29,6 @@ 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,8 +7,6 @@ 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(
|
||||||
@@ -73,14 +71,12 @@ struct Request {
|
|||||||
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,
|
||||||
@@ -104,82 +100,6 @@ 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
|
||||||
}
|
}
|
||||||
@@ -611,7 +531,6 @@ impl Session {
|
|||||||
job,
|
job,
|
||||||
released: !saves_payload,
|
released: !saves_payload,
|
||||||
saves_payload,
|
saves_payload,
|
||||||
worker_returned: false,
|
|
||||||
});
|
});
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
@@ -755,7 +674,6 @@ impl Session {
|
|||||||
job,
|
job,
|
||||||
released: false,
|
released: false,
|
||||||
saves_payload: true,
|
saves_payload: true,
|
||||||
worker_returned: false,
|
|
||||||
});
|
});
|
||||||
Ok(id)
|
Ok(id)
|
||||||
}
|
}
|
||||||
@@ -774,7 +692,6 @@ 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;
|
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;
|
||||||
@@ -902,7 +819,7 @@ impl Session {
|
|||||||
return Err(Error::Busy);
|
return Err(Error::Busy);
|
||||||
}
|
}
|
||||||
r.released = true;
|
r.released = true;
|
||||||
if r.worker_returned {
|
if self.card.is_some() {
|
||||||
self.request = None;
|
self.request = None;
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
@@ -916,7 +833,7 @@ impl Session {
|
|||||||
r.control.cancel();
|
r.control.cancel();
|
||||||
r.released = true;
|
r.released = true;
|
||||||
}
|
}
|
||||||
if !self.io_active() {
|
if self.card.is_some() {
|
||||||
self.request = None;
|
self.request = None;
|
||||||
}
|
}
|
||||||
self.removal_pending = false;
|
self.removal_pending = false;
|
||||||
@@ -952,23 +869,7 @@ impl Session {
|
|||||||
load_existing: bool,
|
load_existing: bool,
|
||||||
control: &PublicationControl,
|
control: &PublicationControl,
|
||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
self.replace_storage_with(move || Ok(storage), load_existing, false, control)
|
if self.has_in_flight() || self.boot_active || self.mode.is_none() {
|
||||||
}
|
|
||||||
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()
|
||||||
@@ -981,18 +882,11 @@ impl Session {
|
|||||||
{
|
{
|
||||||
self.uncertain_target = card.attempted_publication.clone();
|
self.uncertain_target = card.attempted_publication.clone();
|
||||||
}
|
}
|
||||||
if let Some(card) = &self.card {
|
let known = self.card.as_ref().map(|c| (c.current().card_id, c.known_exclusions()));
|
||||||
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;
|
||||||
let candidate = Card::mount(open()?)?;
|
self.card = Some(Card::mount(storage)?);
|
||||||
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
|
||||||
@@ -1079,15 +973,14 @@ impl Session {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
pub fn detach(&mut self) -> Result<()> {
|
pub fn detach(&mut self) -> Result<()> {
|
||||||
if self.deferred.is_some() || self.io_active() {
|
if self.deferred.is_some()
|
||||||
|
|| 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,8 +16,6 @@ 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| {
|
||||||
|
|||||||
@@ -960,7 +960,7 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
|||||||
self.inner.sync()
|
self.inner.sync()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::MUSIC, BankType::SCENE] {
|
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] {
|
||||||
let (card, disk) = formatted();
|
let (card, disk) = formatted();
|
||||||
drop(card);
|
drop(card);
|
||||||
let events: Events = Arc::default();
|
let events: Events = Arc::default();
|
||||||
@@ -985,37 +985,8 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
BankType::SOUNDS => {
|
BankType::SOUNDS => {
|
||||||
let mut bytes = vec![0u8; 88];
|
(vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1}))
|
||||||
bytes[..4].copy_from_slice(b"SBNK");
|
|
||||||
bytes[4] = 1;
|
|
||||||
bytes[49] = 1;
|
|
||||||
bytes[80] = 255;
|
|
||||||
bytes[81] = 128;
|
|
||||||
for (at, value) in [
|
|
||||||
(8, 1u32),
|
|
||||||
(20, 960),
|
|
||||||
(24, 500000),
|
|
||||||
(32, u32::MAX),
|
|
||||||
(52, 44100),
|
|
||||||
(56, 8192),
|
|
||||||
(68, 88),
|
|
||||||
(72, 16384),
|
|
||||||
(84, 65536),
|
|
||||||
] {
|
|
||||||
bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
|
|
||||||
}
|
}
|
||||||
bytes.extend([0x12; 16384]);
|
|
||||||
(bytes, 16472, serde_json::json!({"version":1}))
|
|
||||||
}
|
|
||||||
BankType::MUSIC => (
|
|
||||||
include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-music.mbnk"
|
|
||||||
))
|
|
||||||
.to_vec(),
|
|
||||||
6395,
|
|
||||||
serde_json::json!({"version":1}),
|
|
||||||
),
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
let mut bytes = vec![0; 140];
|
let mut bytes = vec![0; 140];
|
||||||
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
||||||
@@ -1108,12 +1079,6 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
|||||||
assert_eq!(bank.samples[0].sample_rate, 44100);
|
assert_eq!(bank.samples[0].sample_rate, 44100);
|
||||||
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
|
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
|
||||||
}
|
}
|
||||||
BankType::MUSIC => {
|
|
||||||
let bank = banks.music_bank_slot(0).unwrap();
|
|
||||||
assert_eq!(bank.events.len(), 4);
|
|
||||||
assert_eq!(bank.samples.len(), 2);
|
|
||||||
assert_eq!(bank.samples[1].channels, 2);
|
|
||||||
}
|
|
||||||
BankType::SCENE => {
|
BankType::SCENE => {
|
||||||
let bank = banks.scene_bank_slot(0).unwrap();
|
let bank = banks.scene_bank_slot(0).unwrap();
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
|
|||||||
@@ -4,7 +4,6 @@ use crate::services::memcard::MemcardService;
|
|||||||
use prometeu_bytecode::{TRAP_INVALID_SYSCALL, TRAP_OOB, TRAP_TYPE, Value};
|
use prometeu_bytecode::{TRAP_INVALID_SYSCALL, TRAP_OOB, TRAP_TYPE, Value};
|
||||||
use prometeu_hal::app_mode::AppMode;
|
use prometeu_hal::app_mode::AppMode;
|
||||||
use prometeu_hal::asset::{AssetId, AssetOpStatus, BankType};
|
use prometeu_hal::asset::{AssetId, AssetOpStatus, BankType};
|
||||||
use prometeu_hal::audio_bridge::AudioControl;
|
|
||||||
use prometeu_hal::color::Color;
|
use prometeu_hal::color::Color;
|
||||||
use prometeu_hal::glyph::Glyph;
|
use prometeu_hal::glyph::Glyph;
|
||||||
use prometeu_hal::log::{LogLevel, LogSource};
|
use prometeu_hal::log::{LogLevel, LogSource};
|
||||||
@@ -466,7 +465,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
let pan_raw = expect_int(args, 3)?;
|
let pan_raw = expect_int(args, 3)?;
|
||||||
let pitch = expect_number(args, 4, "pitch")?;
|
let pitch = expect_number(args, 4, "pitch")?;
|
||||||
|
|
||||||
if !(0..8).contains(&voice_id_raw) {
|
if !(0..16).contains(&voice_id_raw) {
|
||||||
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
|
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
|
||||||
return Ok(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
@@ -509,7 +508,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
prometeu_hal::LoopMode::On
|
prometeu_hal::LoopMode::On
|
||||||
};
|
};
|
||||||
|
|
||||||
if !(0..8).contains(&voice_id_raw) {
|
if !(0..16).contains(&voice_id_raw) {
|
||||||
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
|
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
|
||||||
return Ok(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
@@ -559,7 +558,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
} else {
|
} else {
|
||||||
1.0
|
1.0
|
||||||
};
|
};
|
||||||
let status = if !(0..8).contains(&voice) {
|
let status = if !(0..16).contains(&voice) {
|
||||||
AudioOpStatus::VoiceInvalid
|
AudioOpStatus::VoiceInvalid
|
||||||
} else if !(0..=255).contains(&value) || !pitch.is_finite() || pitch <= 0.0 {
|
} else if !(0..=255).contains(&value) || !pitch.is_finite() || pitch <= 0.0 {
|
||||||
AudioOpStatus::ArgRangeInvalid
|
AudioOpStatus::ArgRangeInvalid
|
||||||
@@ -576,113 +575,6 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
ret.push_int(status as i64);
|
ret.push_int(status as i64);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
Syscall::MusicPlay
|
|
||||||
| Syscall::MusicStop
|
|
||||||
| Syscall::MusicPause
|
|
||||||
| Syscall::MusicResume
|
|
||||||
| Syscall::MusicSetVolume
|
|
||||||
| Syscall::MusicFadeTo
|
|
||||||
| Syscall::MusicCrossfade
|
|
||||||
| Syscall::AudioSetBusVolume
|
|
||||||
| Syscall::AudioSetEffect
|
|
||||||
| Syscall::AudioSetSend
|
|
||||||
| Syscall::AudioUnloadBank
|
|
||||||
| Syscall::AudioSetGroupVolume => {
|
|
||||||
macro_rules! uint {
|
|
||||||
($i:expr, $max:expr) => {{
|
|
||||||
let n = expect_int(args, $i)?;
|
|
||||||
if !(0..=$max).contains(&n) {
|
|
||||||
ret.push_int(AudioOpStatus::ArgRangeInvalid as i64);
|
|
||||||
return Ok(());
|
|
||||||
}
|
|
||||||
n as u32
|
|
||||||
}};
|
|
||||||
}
|
|
||||||
let status = match syscall {
|
|
||||||
Syscall::MusicPlay => {
|
|
||||||
let group = uint!(0, 1);
|
|
||||||
let bank = uint!(1, 15);
|
|
||||||
let looping = uint!(2, 1);
|
|
||||||
platform.audio_mut().music_play(group as usize, bank as usize, looping != 0)
|
|
||||||
}
|
|
||||||
Syscall::AudioUnloadBank => {
|
|
||||||
let music = uint!(0, 1);
|
|
||||||
let slot = uint!(1, 15);
|
|
||||||
let result = platform.assets().unload_audio(music != 0, slot as usize);
|
|
||||||
ret.push_int(if result == AssetOpStatus::Ok {
|
|
||||||
AudioOpStatus::Ok
|
|
||||||
} else {
|
|
||||||
AudioOpStatus::BankInvalid
|
|
||||||
} as i64);
|
|
||||||
return Ok(());
|
|
||||||
}
|
|
||||||
_ => {
|
|
||||||
let control = match syscall {
|
|
||||||
Syscall::MusicStop => {
|
|
||||||
AudioControl::MusicStop { group: uint!(0, 1) as usize }
|
|
||||||
}
|
|
||||||
Syscall::MusicPause | Syscall::MusicResume => {
|
|
||||||
AudioControl::MusicPause {
|
|
||||||
group: uint!(0, 1) as usize,
|
|
||||||
paused: syscall == Syscall::MusicPause,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Syscall::MusicSetVolume => AudioControl::MusicVolume {
|
|
||||||
group: uint!(0, 1) as usize,
|
|
||||||
gain: uint!(1, 255) as u8,
|
|
||||||
},
|
|
||||||
Syscall::MusicFadeTo => {
|
|
||||||
let group = uint!(0, 1) as usize;
|
|
||||||
let gain = uint!(1, 255) as u8;
|
|
||||||
let ms = uint!(2, (u32::MAX / 48) as i64);
|
|
||||||
let curve = uint!(3, 1);
|
|
||||||
AudioControl::MusicFade {
|
|
||||||
group,
|
|
||||||
gain,
|
|
||||||
frames: ms * 48,
|
|
||||||
smooth: curve != 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Syscall::MusicCrossfade => {
|
|
||||||
let source = uint!(0, 1) as usize;
|
|
||||||
let target = uint!(1, 1) as usize;
|
|
||||||
let ms = uint!(2, (u32::MAX / 48) as i64);
|
|
||||||
let curve = uint!(3, 1);
|
|
||||||
AudioControl::Crossfade {
|
|
||||||
source,
|
|
||||||
target,
|
|
||||||
frames: ms * 48,
|
|
||||||
smooth: curve != 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Syscall::AudioSetGroupVolume => AudioControl::GroupVolume {
|
|
||||||
group: uint!(0, 2) as usize,
|
|
||||||
gain: uint!(1, 255) as u8,
|
|
||||||
},
|
|
||||||
Syscall::AudioSetBusVolume => AudioControl::BusVolume {
|
|
||||||
bus: uint!(0, 2) as usize,
|
|
||||||
gain: uint!(1, 255) as u8,
|
|
||||||
},
|
|
||||||
Syscall::AudioSetSend => AudioControl::SfxSend {
|
|
||||||
voice: uint!(0, 7) as usize,
|
|
||||||
gain: uint!(1, 255) as u8,
|
|
||||||
},
|
|
||||||
Syscall::AudioSetEffect => AudioControl::Effect {
|
|
||||||
group: uint!(0, 2) as usize,
|
|
||||||
cutoff_hz: uint!(1, 24_000),
|
|
||||||
delay_frames: uint!(2, 2000) * 48,
|
|
||||||
feedback: expect_number(args, 3, "feedback")? as f32,
|
|
||||||
wet: expect_number(args, 4, "wet")? as f32,
|
|
||||||
dry: expect_number(args, 5, "dry")? as f32,
|
|
||||||
},
|
|
||||||
_ => unreachable!(),
|
|
||||||
};
|
|
||||||
platform.audio_mut().control(control)
|
|
||||||
}
|
|
||||||
};
|
|
||||||
ret.push_int(status as i64);
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
Syscall::FsOpen => {
|
Syscall::FsOpen => {
|
||||||
let path = expect_string(args, 0, "path")?;
|
let path = expect_string(args, 0, "path")?;
|
||||||
if *self.fs_state != FsState::Mounted {
|
if *self.fs_state != FsState::Mounted {
|
||||||
@@ -857,7 +749,6 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
0 => BankType::GLYPH,
|
0 => BankType::GLYPH,
|
||||||
1 => BankType::SOUNDS,
|
1 => BankType::SOUNDS,
|
||||||
2 => BankType::SCENE,
|
2 => BankType::SCENE,
|
||||||
3 => BankType::MUSIC,
|
|
||||||
other => {
|
other => {
|
||||||
return Err(VmFault::Trap(
|
return Err(VmFault::Trap(
|
||||||
TRAP_TYPE,
|
TRAP_TYPE,
|
||||||
@@ -879,8 +770,6 @@ impl NativeInterface for VmRuntimeHost<'_> {
|
|||||||
let asset_type = match expect_int(args, 0)? as u32 {
|
let asset_type = match expect_int(args, 0)? as u32 {
|
||||||
0 => BankType::GLYPH,
|
0 => BankType::GLYPH,
|
||||||
1 => BankType::SOUNDS,
|
1 => BankType::SOUNDS,
|
||||||
2 => BankType::SCENE,
|
|
||||||
3 => BankType::MUSIC,
|
|
||||||
_ => return Err(VmFault::Trap(TRAP_TYPE, "Invalid asset type".to_string())),
|
_ => return Err(VmFault::Trap(TRAP_TYPE, "Invalid asset type".to_string())),
|
||||||
};
|
};
|
||||||
let telemetry = platform
|
let telemetry = platform
|
||||||
|
|||||||
@@ -187,16 +187,6 @@ 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,7 +25,6 @@ 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)]
|
||||||
@@ -41,19 +40,6 @@ 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 {
|
||||||
@@ -158,7 +144,6 @@ 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;
|
||||||
@@ -181,17 +166,6 @@ 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());
|
||||||
@@ -216,13 +190,13 @@ fn run_worker_loop<B, S>(
|
|||||||
B: RenderWorkerBackend,
|
B: RenderWorkerBackend,
|
||||||
S: RenderWorkerFrameSink,
|
S: RenderWorkerFrameSink,
|
||||||
{
|
{
|
||||||
let report_path = std::env::var_os("PROMETEU_GRAPHICS_METRICS").map(std::path::PathBuf::from);
|
loop {
|
||||||
let mut measurements = Vec::new();
|
let submission = match handoff.wait_take() {
|
||||||
let mut measured_frames = 0usize;
|
RenderWorkerHandoffWait::Submission(submission) => submission,
|
||||||
while let RenderWorkerHandoffWait::Submission(submission) = handoff.wait_take() {
|
RenderWorkerHandoffWait::Shutdown => return,
|
||||||
|
};
|
||||||
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 {
|
||||||
@@ -238,45 +212,13 @@ 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) {
|
||||||
@@ -391,14 +333,6 @@ 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);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -14,16 +14,13 @@ struct Harness {
|
|||||||
}
|
}
|
||||||
impl Harness {
|
impl Harness {
|
||||||
fn new(code: &str, name: &str, args: u16) -> Self {
|
fn new(code: &str, name: &str, args: u16) -> Self {
|
||||||
Self::new_domain(code, "audio", name, args)
|
|
||||||
}
|
|
||||||
fn new_domain(code: &str, module: &str, name: &str, args: u16) -> Self {
|
|
||||||
let mut runtime = VirtualMachineRuntime::new(None);
|
let mut runtime = VirtualMachineRuntime::new(None);
|
||||||
let mut vm = VirtualMachine::default();
|
let mut vm = VirtualMachine::default();
|
||||||
let mut log = LogService::new(4096);
|
let mut log = LogService::new(4096);
|
||||||
let program = serialized_single_function_module(
|
let program = serialized_single_function_module(
|
||||||
assemble(code).unwrap(),
|
assemble(code).unwrap(),
|
||||||
vec![SyscallDecl {
|
vec![SyscallDecl {
|
||||||
module: module.into(),
|
module: "audio".into(),
|
||||||
name: name.into(),
|
name: name.into(),
|
||||||
version: 1,
|
version: 1,
|
||||||
arg_slots: args,
|
arg_slots: args,
|
||||||
@@ -79,7 +76,7 @@ impl Harness {
|
|||||||
fn guest_audio_status_matrix_and_type_traps() {
|
fn guest_audio_status_matrix_and_type_traps() {
|
||||||
for (name, args, inputs, expected) in [
|
for (name, args, inputs, expected) in [
|
||||||
("stop", 1, "PUSH_I32 0", 0),
|
("stop", 1, "PUSH_I32 0", 0),
|
||||||
("stop", 1, "PUSH_I32 7", 0),
|
("stop", 1, "PUSH_I32 15", 0),
|
||||||
("stop", 1, "PUSH_I32 -1", 1),
|
("stop", 1, "PUSH_I32 -1", 1),
|
||||||
("stop", 1, "PUSH_I32 16", 1),
|
("stop", 1, "PUSH_I32 16", 1),
|
||||||
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 0", 0),
|
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 0", 0),
|
||||||
@@ -87,7 +84,7 @@ fn guest_audio_status_matrix_and_type_traps() {
|
|||||||
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 256", 3),
|
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 256", 3),
|
||||||
("set_pan", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
|
("set_pan", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
|
||||||
("set_pan", 2, "PUSH_I32 16\nPUSH_I32 -1", 1),
|
("set_pan", 2, "PUSH_I32 16\nPUSH_I32 -1", 1),
|
||||||
("set_pan", 2, "PUSH_I32 7\nPUSH_I32 255", 0),
|
("set_pan", 2, "PUSH_I32 15\nPUSH_I32 255", 0),
|
||||||
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 1", 0),
|
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 1", 0),
|
||||||
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 0", 3),
|
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 0", 3),
|
||||||
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
|
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
|
||||||
@@ -219,61 +216,3 @@ fn normal_entry_return_is_a_successful_implicit_audio_frame() {
|
|||||||
}
|
}
|
||||||
assert_eq!(h.transport().try_take().unwrap().frame.unwrap().len(), 1);
|
assert_eq!(h.transport().try_take().unwrap().frame.unwrap().len(), 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn music_and_bus_controls_resolve_with_audio_capability_and_validate_without_partial_commands() {
|
|
||||||
use prometeu_drivers::SoundBankPoolInstaller;
|
|
||||||
use prometeu_drivers::bank_format::{DecodedAudioBank, decode_audio_bank};
|
|
||||||
for (module, name, args, inputs, expected) in [
|
|
||||||
("music", "play", 3, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 1", 0),
|
|
||||||
("music", "play", 3, "PUSH_I32 0\nPUSH_I32 16\nPUSH_I32 1", 3),
|
|
||||||
("music", "stop", 1, "PUSH_I32 1", 0),
|
|
||||||
("music", "pause", 1, "PUSH_I32 0", 0),
|
|
||||||
("music", "resume", 1, "PUSH_I32 0", 0),
|
|
||||||
("music", "set_volume", 2, "PUSH_I32 0\nPUSH_I32 255", 0),
|
|
||||||
("music", "fade_to", 4, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 2000\nPUSH_I32 1", 0),
|
|
||||||
("music", "crossfade", 4, "PUSH_I32 0\nPUSH_I32 1\nPUSH_I32 2000\nPUSH_I32 0", 0),
|
|
||||||
("music", "crossfade", 4, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 2000\nPUSH_I32 0", 3),
|
|
||||||
("audio", "set_group_volume", 2, "PUSH_I32 2\nPUSH_I32 255", 0),
|
|
||||||
("audio", "set_bus_volume", 2, "PUSH_I32 2\nPUSH_I32 255", 0),
|
|
||||||
("audio", "set_send", 2, "PUSH_I32 7\nPUSH_I32 128", 0),
|
|
||||||
(
|
|
||||||
"audio",
|
|
||||||
"set_effect",
|
|
||||||
6,
|
|
||||||
"PUSH_I32 2\nPUSH_I32 4000\nPUSH_I32 2000\nPUSH_F64 f64:0x3fe0000000000000\nPUSH_F64 f64:0x3fd3333333333333\nPUSH_F64 f64:0x3fe6666666666666",
|
|
||||||
0,
|
|
||||||
),
|
|
||||||
(
|
|
||||||
"audio",
|
|
||||||
"set_effect",
|
|
||||||
6,
|
|
||||||
"PUSH_I32 2\nPUSH_I32 4000\nPUSH_I32 2001\nPUSH_F64 f64:0x3fe0000000000000\nPUSH_F64 f64:0x3fd3333333333333\nPUSH_F64 f64:0x3fe6666666666666",
|
|
||||||
3,
|
|
||||||
),
|
|
||||||
("audio", "unload_bank", 2, "PUSH_I32 1\nPUSH_I32 0", 0),
|
|
||||||
] {
|
|
||||||
let mut h = Harness::new_domain(
|
|
||||||
&format!("{inputs}\nHOSTCALL 0\nFRAME_SYNC\nHALT"),
|
|
||||||
module,
|
|
||||||
name,
|
|
||||||
args,
|
|
||||||
);
|
|
||||||
let bytes = include_bytes!(concat!(
|
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
|
||||||
"/../../../test-fixtures/audio/mixed-music.mbnk"
|
|
||||||
));
|
|
||||||
let DecodedAudioBank::Music(bank) = decode_audio_bank(bytes, true).unwrap() else {
|
|
||||||
panic!()
|
|
||||||
};
|
|
||||||
h.platform.local_hardware().memory_banks.install_music_bank(0, Arc::new(bank));
|
|
||||||
assert!(h.tick().is_none(), "{module}.{name}");
|
|
||||||
assert_eq!(h.vm.operand_stack_top(1), vec![Value::Int64(expected)], "{module}.{name}");
|
|
||||||
let batch = h.transport().try_take().unwrap().frame;
|
|
||||||
assert_eq!(
|
|
||||||
batch.map_or(0, |v| v.len()),
|
|
||||||
usize::from(expected == 0 && name != "unload_bank"),
|
|
||||||
"{module}.{name}"
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -235,13 +235,12 @@ 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 | Self::BorrowedInline(_) => None,
|
Self::VmOwned => None,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -250,14 +249,12 @@ 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",
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -269,14 +266,11 @@ 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,
|
||||||
@@ -306,16 +300,7 @@ 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(
|
||||||
@@ -578,13 +563,10 @@ 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,
|
||||||
@@ -598,13 +580,10 @@ 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,
|
||||||
@@ -618,13 +597,10 @@ 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,
|
||||||
@@ -638,13 +614,10 @@ 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,
|
||||||
@@ -658,13 +631,10 @@ 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,
|
||||||
@@ -678,13 +648,10 @@ 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,
|
||||||
@@ -698,13 +665,10 @@ 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,
|
||||||
@@ -718,13 +682,10 @@ 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,
|
||||||
@@ -738,13 +699,10 @@ 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,
|
||||||
@@ -758,13 +716,10 @@ 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,
|
||||||
@@ -778,13 +733,10 @@ 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,
|
||||||
@@ -798,13 +750,10 @@ 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,
|
||||||
@@ -818,13 +767,10 @@ 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,
|
||||||
@@ -838,13 +784,10 @@ 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,
|
||||||
@@ -858,13 +801,10 @@ 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,
|
||||||
@@ -878,13 +818,10 @@ 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,
|
||||||
@@ -898,13 +835,10 @@ 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,
|
||||||
@@ -918,13 +852,10 @@ 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,
|
||||||
@@ -938,13 +869,10 @@ 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,
|
||||||
@@ -958,13 +886,10 @@ 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,
|
||||||
@@ -978,13 +903,10 @@ 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,
|
||||||
@@ -1022,7 +944,6 @@ 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)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1032,7 +953,6 @@ 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)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1334,17 +1254,9 @@ 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));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -1358,7 +1270,6 @@ pub fn intrinsic_catalog() -> impl Iterator<Item = &'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())
|
|
||||||
}
|
}
|
||||||
pub fn builtin_constant_catalog() -> impl Iterator<Item = &'static BuiltinConstMeta> {
|
pub fn builtin_constant_catalog() -> impl Iterator<Item = &'static BuiltinConstMeta> {
|
||||||
BUILTIN_CONSTS.iter()
|
BUILTIN_CONSTS.iter()
|
||||||
|
|||||||
@@ -16,15 +16,14 @@ 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,schema_version,arg_nullable,invocation_model,scratch_model,context_access,cost_arg_index,cost_per_byte\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\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},{},{}.{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},2,{},{},{},{},{},{}",
|
"0x{:04X},{},{}.{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
|
||||||
m.id,
|
m.id,
|
||||||
m.id,
|
m.id,
|
||||||
m.owner,
|
m.owner,
|
||||||
@@ -43,13 +42,7 @@ 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();
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,66 +0,0 @@
|
|||||||
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))
|
|
||||||
}
|
|
||||||
@@ -1,131 +0,0 @@
|
|||||||
//! 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,34 +428,6 @@ 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())
|
||||||
@@ -548,18 +520,6 @@ 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,13 +20,10 @@ 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,
|
||||||
|
|||||||
@@ -1,143 +0,0 @@
|
|||||||
//! 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,11 +2,7 @@
|
|||||||
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;
|
||||||
|
|||||||
@@ -20,17 +20,10 @@ 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,4 +1,4 @@
|
|||||||
//! PBX v0 publication: immutable metadata and shared payload, after bindings
|
//! PBX v1 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::string_identity_index::Identity;
|
||||||
use crate::{LoaderPatchError, VmInitError};
|
use crate::{LoaderPatchError, VmInitError};
|
||||||
|
|||||||
@@ -21,13 +21,6 @@ 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,
|
||||||
@@ -36,8 +29,6 @@ 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,10 +485,6 @@ 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..],
|
||||||
@@ -507,7 +503,6 @@ 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 => {
|
||||||
@@ -710,15 +705,6 @@ 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) {
|
||||||
@@ -774,21 +760,6 @@ 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);
|
||||||
@@ -801,12 +772,7 @@ 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() {
|
||||||
let accepted = if native.arg_nullable[part] {
|
require(working[base + part], abi_mask(*abi), part, registry, budget)?;
|
||||||
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 => {
|
||||||
|
|||||||
@@ -87,39 +87,3 @@ 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>>,
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -221,24 +221,6 @@ 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,20 +1,12 @@
|
|||||||
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;
|
||||||
@@ -335,10 +327,8 @@ impl VirtualMachine {
|
|||||||
}
|
}
|
||||||
|
|
||||||
let charged_math = if opcode == OpCode::Intrinsic {
|
let charged_math = if opcode == OpCode::Intrinsic {
|
||||||
lookup_intrinsic_by_id(instr.imm_u32().unwrap()).filter(|m| {
|
lookup_intrinsic_by_id(instr.imm_u32().unwrap())
|
||||||
matches!(m.implementation, crate::IntrinsicImplementation::Host(_))
|
.filter(|m| m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
|
||||||
&& (m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
|
|
||||||
})
|
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
};
|
};
|
||||||
@@ -962,12 +952,6 @@ 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);
|
||||||
}
|
}
|
||||||
@@ -1099,18 +1083,6 @@ 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
|
||||||
@@ -2513,7 +2485,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(&1u16.to_le_bytes()); // unsupported version
|
header[4..6].copy_from_slice(&0u16.to_le_bytes()); // retired version
|
||||||
|
|
||||||
let res = vm.initialize(header);
|
let res = vm.initialize(header);
|
||||||
assert!(
|
assert!(
|
||||||
@@ -2522,11 +2494,11 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_loader_hardening_malformed_pbx_v0() {
|
fn test_loader_hardening_malformed_pbx_v1() {
|
||||||
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());
|
header[4..6].copy_from_slice(&1u16.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);
|
||||||
@@ -3921,7 +3893,3 @@ mod callable_tests;
|
|||||||
|
|
||||||
#[cfg(feature = "resource-diagnostics")]
|
#[cfg(feature = "resource-diagnostics")]
|
||||||
pub mod string_provenance_qualification;
|
pub mod string_provenance_qualification;
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
#[path = "virtual_machine/identity_tests.rs"]
|
|
||||||
mod identity_tests;
|
|
||||||
|
|||||||
@@ -1,110 +0,0 @@
|
|||||||
//! 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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,487 +0,0 @@
|
|||||||
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);
|
|
||||||
}
|
|
||||||
@@ -175,7 +175,7 @@ impl VirtualMachine {
|
|||||||
.expect("result capacity reserved before publication");
|
.expect("result capacity reserved before publication");
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
pub(super) fn collection_size_trap(
|
fn collection_size_trap(
|
||||||
&self,
|
&self,
|
||||||
opcode: OpCode,
|
opcode: OpCode,
|
||||||
pc: u32,
|
pc: u32,
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
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;
|
||||||
|
|||||||
@@ -1,59 +0,0 @@
|
|||||||
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(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,236 +0,0 @@
|
|||||||
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)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,113 +0,0 @@
|
|||||||
//! 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(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -132,39 +132,3 @@ 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}");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -134,96 +134,3 @@ fn provenance_queries_allocate_nothing_at_all_qualification_sizes() {
|
|||||||
assert_eq!(counts, (1, 1), "only snapshot Value storage allocates");
|
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");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
File diff suppressed because one or more lines are too long
@@ -1,23 +0,0 @@
|
|||||||
# 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.
|
|
||||||
@@ -1,51 +0,0 @@
|
|||||||
"""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()
|
|
||||||
@@ -1,152 +0,0 @@
|
|||||||
#[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)]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,105 +0,0 @@
|
|||||||
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()
|
|
||||||
);
|
|
||||||
}
|
|
||||||
@@ -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 00 00 00 00 08 00 00 00
|
"50 42 58 00 01 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_v0_bytes_load_publish_and_execute_through_the_public_sealed_boundary() {
|
fn independent_v1_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_v0_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, 1, LoadCode::UnsupportedFormat, LoadReason::Version, None),
|
(4, 0, 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)),
|
||||||
|
|||||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user