From b620edfd6f8097172acf055402a24620cb078358 Mon Sep 17 00:00:00 2001 From: dingo Date: Sat, 19 Sep 2026 16:35:16 -0400 Subject: [PATCH] Add deterministic transactional lifecycle command scheduler --- CMakeLists.txt | 2 +- README.md | 1 + docs/ROADMAP.md | 7 +- docs/STATUS.md | 26 +++-- docs/adr/0022-sequential-command-scheduler.md | 68 ++++++++++++ docs/adr/README.md | 1 + docs/architecture/SCHEDULER_CONTRACT.md | 44 ++++++++ docs/architecture/SIMULATION_ARCHITECTURE.md | 4 + docs/engineering/VALIDATION.md | 17 +++ include/evo/simulation/scheduler.hpp | 44 ++++++++ src/simulation/scheduler.cpp | 74 +++++++++++++ tests/simulation_tests.cpp | 100 +++++++++++++++++- 12 files changed, 375 insertions(+), 13 deletions(-) create mode 100644 docs/adr/0022-sequential-command-scheduler.md create mode 100644 docs/architecture/SCHEDULER_CONTRACT.md create mode 100644 include/evo/simulation/scheduler.hpp create mode 100644 src/simulation/scheduler.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index ea49edb..b6c202c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -27,7 +27,7 @@ set(EVO_SANITIZER "none" CACHE STRING "none, address (ASan/UBSan), or thread") set_property(CACHE EVO_SANITIZER PROPERTY STRINGS none address thread) include(cmake/ProjectOptions.cmake) -set(evo_simulation_sources src/simulation/world.cpp src/simulation/snapshot.cpp) +set(evo_simulation_sources src/simulation/world.cpp src/simulation/snapshot.cpp src/simulation/scheduler.cpp) add_library(evo_simulation STATIC ${evo_simulation_sources}) add_library(evo::simulation ALIAS evo_simulation) target_include_directories(evo_simulation PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") diff --git a/README.md b/README.md index d545aeb..cfad287 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,7 @@ network service. Dev verification manifests are separate from the simulation. - [Actual validation results](docs/engineering/VALIDATION.md) - [Current delivery status and next steps](docs/STATUS.md) - [Opt-in ECS evaluation and measurements](docs/engineering/ECS_EVALUATION.md) +- [Sequential command scheduling and recovery](docs/architecture/SCHEDULER_CONTRACT.md) Read [AGENTS.md](AGENTS.md) before changing code. Architecture and contracts are authoritative over implementation. No external runtime library is needed for diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 3666319..49505d3 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -28,13 +28,14 @@ independent reviews; dependent tasks begin after their contracts are settled. | 1.3 Canonical local snapshot and restore | simulation/snapshot.cpp, schemas/proof-snapshot.md | 1.2, ADR-0008 | Bounded versioned byte format; validate before publish | Round trip, corruption, overflow, truncation, version rejection | Unsafe parsing, native padding | | 1.4 Freeze deterministic reference result | tests/simulation_tests.cpp | 1.3 | Continuous and restored runs match agreed fingerprint | Golden fingerprint and seeded property ensembles | Test only comparing same broken implementation | | 1.5 Evaluate mature ECS adoption | experiments/ecs/, ADR-0005, ADR-0021 | 1.2, biological component workload sketch | Measured iteration/lifecycle/serialization cost and scoped choice | Opt-in row/EnTT sparse/dense/churn comparison with canonical equality; production decision needs richer biology | Premature general framework | -| 1.6 Establish scheduler and input phases | simulation/scheduler/, core/time/ | 1.4–1.5 | Explicit phase DAG, one writer, immutable jobs and stable merge | Reordered completion gives equal state; command ordering tests | Hidden concurrency nondeterminism | +| 1.6 Establish scheduler and input phases | simulation/scheduler.*, ADR-0022 | 1.4–1.5 | Sequential phase DAG, one writer, immutable bounded commands and atomic commit; parallel jobs deferred | Permuted delivery gives equal state; admission, rollback and recovery tests | Hidden ordering and partial mutation | | 1.7 Add spatial contract | simulation/spatial/, units ADR | 1.5–1.6 | Local coordinates and bounded neighborhood queries | Boundary/wrap/precision properties and brute-force comparison | Planet precision leaking into local physics | The first increment implements 1.1–1.4 as a proof. M1.5 now has an isolated comparison and scoped recommendation; see engineering/ECS_EVALUATION.md for -measured versus still-unmeasured coverage. M1.6–1.7 remain separate work; no -scheduler or generic ECS placeholder is counted as completion. +measured versus still-unmeasured coverage. M1.6 implements the sequential command +boundary in ADR-0022; no parallel job execution is claimed. M1.7 spatial queries +are next. A generic ECS or job framework is not required to complete this proof. ## M2 — Minimal energy ecosystem diff --git a/docs/STATUS.md b/docs/STATUS.md index 327e42f..fb92c34 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -7,7 +7,7 @@ persistent simulation server. The founding vision remains unchanged. ## Completed implementation - Vision, architectural pillars, risks, open-question register, architecture - diagrams, biological contracts, engineering constitution and 21 ADRs. + diagrams, biological contracts, engineering constitution and 22 ADRs. Proposed/deferred choices remain distinct from accepted proof decisions. - M0–M4 task breakdowns with dependencies, acceptance evidence and risks, plus M5–M14 gates in [ROADMAP.md](ROADMAP.md). @@ -37,8 +37,9 @@ Windows checks also pass; full commands and intermediate CI failures are recorde in the validation report. M0's engineering proof is verified; dev cluster execution is the remaining delivery check, not a claim of persistent-world readiness. -The maintainer reports Argo is configured. This workspace has no kubeconfig; -the app/source mapping and completed dev Job are not yet independently verified. +The maintainer confirms Argo is configured and deployment additions will sync +when a pod workload is ready. This workspace has no kubeconfig, so completed dev +Job execution is not independently verified. This is not a blocker for M1. The repository supplies a restricted dev Job and bootstrap examples; image publication does not demonstrate a Kubernetes rollout or world recovery. @@ -58,11 +59,20 @@ for the bounded proof; the general production ECS remains a later measured choic | Priority | Work | Completion evidence | |---|---|---| -| 1 | Verify the existing dev Argo mapping and sync the pinned, validated image | Dev Job Complete with replay_verified=true; no World0 changes | -| 2 | M1.6 scheduler/input contract: ratify phase order and command admission before implementing a sequential scheduler | Stable input order, one writer, deterministic merges and replay equivalence | -| 3 | M1.7 local spatial contract | Neighborhood queries checked against brute force, wrap/boundary/unit tests and measured workload | -| 4 | M2.1 energy/matter ledger | Agreed units/ranges, atomic transfers, nonnegative balances and conservation tests before organisms | -| 5 | M2.2–2.6 first headless energy cycle | Explicit source → producer → consumer → death → decomposition → nutrients; seeded million-tick ledger evidence | +| 1 | M1.7 local spatial contract | Neighborhood queries checked against brute force, wrap/boundary/unit tests and measured workload | +| 2 | M2.1 energy/matter ledger | Agreed units/ranges, atomic transfers, nonnegative balances and conservation tests before organisms | +| 3 | M2.2–2.6 first headless energy cycle | Explicit source → producer → consumer → death → decomposition → nutrients; seeded million-tick ledger evidence | +| Delivery gate | Add/update the dev workload when a deployable increment needs it; Argo is ready | Observe Job/pod completion separately from image publication; no World0 changes | + +M1.6 now implements [the sequential scheduler contract](architecture/SCHEDULER_CONTRACT.md): +exact-tick admission, bounded ordered lifecycle commands, receipts and atomic +rollback on rejection. Windows Release, clang-tidy, ASan and formatting checks +pass. Permutations across 32 seeds, restored continuation, duplicate/late/future +inputs, limits and exhaustion are covered. The no-input golden and snapshot v1 +are unchanged. Linux CI evidence is recorded in the validation report after push. +Nonempty batches copy world state; this favors a clear transaction boundary for +the proof, not a measured realtime performance claim. No thread pool or gameplay +input protocol is introduced. Before biology, resolve the relevant heredity and energetic contracts rather than treating proof particles as organisms. Exact game tick rate, NPC mutation, diff --git a/docs/adr/0022-sequential-command-scheduler.md b/docs/adr/0022-sequential-command-scheduler.md new file mode 100644 index 0000000..630c27e --- /dev/null +++ b/docs/adr/0022-sequential-command-scheduler.md @@ -0,0 +1,68 @@ +# ADR-0022: Transactional sequential command scheduling + +## Status + +Adopted for the synthetic M1.6 proof only. No gameplay input or concurrency policy +is selected by this decision. + +## Context + +M1.5 retains the bounded row store. Before adding systems, replay needs an explicit +input cutoff, total order and failure boundary. The kernel cannot depend on packet +arrival order, clocks, threads or authenticated session state. + +## Decision + +Add `advance(world, target_tick, commands)` in a scheduler module. The target is +the next completed tick (`current_tick + 1`). Admit at most 1,024 immutable +commands, each with a nonzero host-assigned sequence unique within that tick. +Sort by sequence; reject duplicate sequences even if payloads match. Reject past +and future targets rather than queueing, retiming or rolling back. Sequences may +restart in a later tick; the pair (target tick, sequence) is the identity. + +The phase DAG is admission → ordered lifecycle commands → synthetic movement → +tick commit → returned receipts. Commands wrap the existing create/remove API; +they are trusted host lifecycle operations, not player permissions or movement. +Receipts are sorted by sequence and contain the resulting affected entity ID. + +Execute nonempty batches against a private copy; publish by noexcept move only +after every command, receipt allocation and tick succeeds. Any recoverable error +rejects the entire batch. Empty batches call the existing allocation-free tick. +No queue, callbacks, threads or job system are introduced. One owner calls the +kernel; direct lifecycle methods remain available for setup and existing callers. + +## Alternatives Considered + +Arrival-order mutation cannot replay reordered delivery. Per-command partial +success complicates recovery. Undo logs or staged component writes may eventually +reduce copy cost but require broader contracts. An extensible phase executor or +parallel task graph has no measured workload yet. + +## Benefits + +Stable ordering, atomic rejection, bounded admission and an explicit recovery +boundary without changes to the existing snapshot or no-input golden. + +## Costs + +Nonempty ticks copy all current rows and allocate receipts. The host must retain +the admitted command stream externally if it needs replay. Copy performance must +be measured before adopting this approach for a realtime server. + +## Risks + +These operations are not safe to expose directly to clients. A host must validate +authorization, assign ordering keys and bound ingress. A malformed batch can +reject otherwise valid work; host admission must isolate untrusted requests. +Synthetic tests do not validate parallel execution or crash durability. + +## Consequences + +Snapshots remain format/rules v1: no new persistent state or changed movement +laws. Scheduler contract v1 is identified separately; future command journals +must store it with admitted inputs. Checkpoint only at completed ticks, then +replay subsequent admitted batches. There is no pending input inside snapshots. +Future jobs must return immutable, stably keyed results and have explicit merge +conflict rules; implementing that executor remains deferred until actual work +exists. Test permutations, duplicate/late/future admission, lifecycle conflicts, +limits, exhaustion, rollback and restored continuation under NDEBUG. diff --git a/docs/adr/README.md b/docs/adr/README.md index 78c7244..10305ff 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -14,6 +14,7 @@ messaging and metrics. 0016–0019 cover durability/ownership, networking/securi infrastructure and voxels. 0020 scopes Gitea delivery and the stateless dev Job. Each record has the eight required sections. 0021 authorizes the opt-in ECS comparison only, not a production dependency. +0022 adopts the bounded sequential lifecycle-command scheduler for the proof. Every dependency adoption records exact version/commit and integrity hash, transitive license obligations, maintenance/security review, owner and removal diff --git a/docs/architecture/SCHEDULER_CONTRACT.md b/docs/architecture/SCHEDULER_CONTRACT.md new file mode 100644 index 0000000..ea7cb76 --- /dev/null +++ b/docs/architecture/SCHEDULER_CONTRACT.md @@ -0,0 +1,44 @@ +# Sequential scheduler contract v1 + +This implements the scoped decision in [ADR-0022](../adr/0022-sequential-command-scheduler.md). +It is a synthetic lifecycle proof, not a player input protocol. + +```mermaid +flowchart LR + H[Host: validate and assign sequence] --> A[Admit exact next tick / bounded batch] + A --> O[Sort unique sequences] + O --> C[Private candidate: ordered create/remove] + C --> S[Stable entity-order synthetic movement] + S --> P[Commit world and return ordered receipts] + A -->|invalid| R[Reject without changing world] + C -->|invalid| R +``` + +`advance(SimulationWorld&, Tick target, span)` returns +`expected, ScheduleError>`. Errors distinguish admission +failures from command/tick failures; the latter include the existing `Error` cause +and command sequence (zero for the tick itself). No references to input survive +the call. The owner must not mutate world or input concurrently. + +| Boundary | Invariant | +|---|---| +| Admission | Next completed tick only; at most 1,024 commands; nonzero unique sequence per tick | +| Ordering | Sequence alone defines execution; input span order cannot change results | +| Lifecycle | Create starts participating in movement this tick; removed entities do not move; IDs are never reused | +| Conflict | A second removal of the same entity rejects the entire batch, including earlier creations | +| Commit | Errors and allocation exceptions leave original world unchanged; successful call increments tick exactly once | +| Receipt | One affected entity ID per command, in sequence order, published only on success | +| Recovery | Snapshot after tick T plus admitted batches T+1 onward equals uninterrupted execution | +| Retry | Retrying a committed target is rejected; no durable exactly-once acknowledgment is claimed | + +The host assigns sequences before dispatching any future immutable work. Completion +order must not assign them. Permutation tests model reordered delivery, not +concurrent execution. A host journals validated batches and durable outcomes at +its later persistence boundary; it must never assume a returned receipt is durable. +Future-target buffering, session deduplication, authorization and pacing remain +outside this library. There is no player/NPC behavior or offline progression here. + +Existing `tick()` means an empty input tick and preserves the frozen v1 golden. +Existing direct create/remove are setup/tool APIs; a replaying host must use a +single recorded mutation path. This phase chain is deliberately concrete; no +generic registration API or speculative thread pool is part of M1.6. diff --git a/docs/architecture/SIMULATION_ARCHITECTURE.md b/docs/architecture/SIMULATION_ARCHITECTURE.md index c5b0bd4..2015e89 100644 --- a/docs/architecture/SIMULATION_ARCHITECTURE.md +++ b/docs/architecture/SIMULATION_ARCHITECTURE.md @@ -67,6 +67,10 @@ simulation rules change. ## Scheduling and pacing +The sequential lifecycle scheduler and atomic input boundary are specified in +[SCHEDULER_CONTRACT.md](SCHEDULER_CONTRACT.md) and ADR-0022. The input-free tick +remains unchanged; lifecycle commands are synthetic host operations only. + The kernel accepts no `deltaTime` argument. The executable advances an exact requested number of ticks. A future realtime host converts monotonic wall time into tick debt; it must cap catch-up work, emit overload metrics and shed region diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index a7587ed..80f056f 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -130,3 +130,20 @@ results/ecs-gcc142.jsonl; all 56 fingerprints match corresponding Windows sample No production rule or snapshot-format change occurred. This supersedes the pending Linux experiment note above. The final follow-up edits only record results and decision scope; production ECS adoption remains deferred. + +## M1.6 sequential scheduler (2026-09-19) + +Native commands: `tools/windows-check.ps1 -Preset release -Action configure`, +clang-format on changed C++ files, `cmake --build --preset release`, +`ctest --preset release`; then `tools/windows-check.ps1 -Preset analysis -Action check`, +`tools/windows-check.ps1 -Preset asan -Action check` and Release `-Action format`. +All three configurations passed 5/5 CTests; clang-tidy and format-check passed. +Tests execute under NDEBUG and cover six batch permutations across 32 seeds, +an independent direct-lifecycle reference, ordered receipts, restore continuation, +rejected conflicts and malformed admission, the 1,024-command boundary, full entity +capacity and tick/ID exhaustion. Golden `d61ad5bf0c928c76` remains unchanged. + +The copy-and-commit implementation allocates before publishing world state and +statically checks noexcept publication/receipt moves. Allocation-failure injection +was not run. No scheduler throughput claim, concurrency validation, durable input +journal or Kubernetes execution is implied. Linux CI is pending this source push. diff --git a/include/evo/simulation/scheduler.hpp b/include/evo/simulation/scheduler.hpp new file mode 100644 index 0000000..1550e22 --- /dev/null +++ b/include/evo/simulation/scheduler.hpp @@ -0,0 +1,44 @@ +#pragma once + +#include "evo/simulation/world.hpp" + +#include +#include + +namespace evo { +inline constexpr std::uint32_t scheduler_version = 1; +inline constexpr std::size_t max_commands_per_tick = 1'024; + +struct CreateEntity { + Position2 position{}; +}; +struct RemoveEntity { + EntityId id; +}; +struct Command { + std::uint64_t sequence; + std::variant operation; +}; +struct CommandReceipt { + std::uint64_t sequence; + EntityId entity; + auto operator<=>(const CommandReceipt&) const = default; +}; +enum class ScheduleErrorCode : std::uint8_t { + wrong_tick, + batch_limit, + invalid_sequence, + duplicate_sequence, + simulation_failure +}; +struct ScheduleError { + ScheduleErrorCode code; + std::uint64_t sequence{}; + std::optional cause{}; +}; + +// Single-owner call. No input is retained. Rejection leaves world unchanged. +// target is the next completed tick; receipts follow ascending sequence. +[[nodiscard]] std::expected, ScheduleError> +advance(SimulationWorld& world, Tick target, std::span commands = {}); +} // namespace evo diff --git a/src/simulation/scheduler.cpp b/src/simulation/scheduler.cpp new file mode 100644 index 0000000..e80194c --- /dev/null +++ b/src/simulation/scheduler.cpp @@ -0,0 +1,74 @@ +#include "evo/simulation/scheduler.hpp" + +#include +#include +#include +#include + +namespace evo { +std::expected, ScheduleError> +advance(SimulationWorld& world, Tick target, std::span commands) { + if (world.current_tick().value == std::numeric_limits::max()) { + return std::unexpected{ + ScheduleError{ScheduleErrorCode::simulation_failure, 0, Error::tick_exhausted}}; + } + if (target.value != world.current_tick().value + 1) { + return std::unexpected{ScheduleError{ScheduleErrorCode::wrong_tick}}; + } + if (commands.size() > max_commands_per_tick) { + return std::unexpected{ScheduleError{ScheduleErrorCode::batch_limit}}; + } + if (commands.empty()) { + const auto result = world.tick(); + if (!result) { + return std::unexpected{ + ScheduleError{ScheduleErrorCode::simulation_failure, 0, result.error()}}; + } + return std::vector{}; + } + std::vector ordered{commands.begin(), commands.end()}; + std::ranges::sort(ordered, {}, &Command::sequence); + std::uint64_t previous{}; + for (const auto& command : ordered) { + if (command.sequence == 0) { + return std::unexpected{ScheduleError{ScheduleErrorCode::invalid_sequence}}; + } + if (command.sequence == previous) { + return std::unexpected{ + ScheduleError{ScheduleErrorCode::duplicate_sequence, command.sequence}}; + } + previous = command.sequence; + } + auto candidate = world; + std::vector receipts; + receipts.reserve(ordered.size()); + for (const auto& command : ordered) { + EntityId affected{}; + if (const auto* create = std::get_if(&command.operation)) { + const auto result = candidate.create_entity(create->position); + if (!result) { + return std::unexpected{ScheduleError{ScheduleErrorCode::simulation_failure, + command.sequence, result.error()}}; + } + affected = *result; + } else { + affected = std::get(command.operation).id; + const auto result = candidate.remove_entity(affected); + if (!result) { + return std::unexpected{ScheduleError{ScheduleErrorCode::simulation_failure, + command.sequence, result.error()}}; + } + } + receipts.push_back({command.sequence, affected}); + } + const auto result = candidate.tick(); + if (!result) { + return std::unexpected{ + ScheduleError{ScheduleErrorCode::simulation_failure, 0, result.error()}}; + } + static_assert(std::is_nothrow_move_assignable_v); + static_assert(std::is_nothrow_move_constructible_v>); + world = std::move(candidate); + return receipts; +} +} // namespace evo diff --git a/tests/simulation_tests.cpp b/tests/simulation_tests.cpp index 18b9773..b39f1d4 100644 --- a/tests/simulation_tests.cpp +++ b/tests/simulation_tests.cpp @@ -1,6 +1,8 @@ +#include "evo/simulation/scheduler.hpp" #include "evo/simulation/world.hpp" #include "evo/telemetry/sinks.hpp" +#include #include #include #include @@ -217,6 +219,100 @@ void telemetry_is_host_owned() { evo::log_error(log, evo::Error::invalid_snapshot); CHECK(log.str() == "{\"level\":\"error\",\"event\":\"invalid_snapshot\"}\n"); } + +void scheduled_order_and_recovery() { + for (std::uint64_t seed = 0; seed < 32; ++seed) { + auto expected = fixture(seed, 2); + CHECK(expected.remove_entity(evo::EntityId{1})); + CHECK(expected.create_entity({evo::Millimetres{1023}, evo::Millimetres{0}})); + CHECK(expected.create_entity()); + CHECK(expected.tick()); + std::array commands{ + evo::Command{10, evo::RemoveEntity{evo::EntityId{1}}}, + evo::Command{20, evo::CreateEntity{{evo::Millimetres{1023}, evo::Millimetres{0}}}}, + evo::Command{30, evo::CreateEntity{}}}; + do { + auto world = fixture(seed, 2); + const auto receipts = evo::advance(world, evo::Tick{1}, commands); + CHECK(receipts && receipts->size() == 3); + CHECK((*receipts)[0] == (evo::CommandReceipt{10, evo::EntityId{1}})); + CHECK((*receipts)[1] == (evo::CommandReceipt{20, evo::EntityId{3}})); + CHECK((*receipts)[2] == (evo::CommandReceipt{30, evo::EntityId{4}})); + CHECK(world.serialize() == expected.serialize()); + auto restored = evo::SimulationWorld::restore(world.serialize()); + CHECK(restored); + for (std::uint64_t tick = 2; tick < 20; ++tick) { + const std::array next{evo::Command{1, evo::CreateEntity{}}}; + CHECK(evo::advance(world, evo::Tick{tick}, next)); + CHECK(evo::advance(*restored, evo::Tick{tick}, next)); + } + CHECK(restored->serialize() == world.serialize()); + } while (std::ranges::next_permutation(commands, {}, &evo::Command::sequence).found); + } + auto scheduled = fixture(123456, 8); + for (std::uint64_t tick = 1; tick <= 1000; ++tick) { + CHECK(evo::advance(scheduled, evo::Tick{tick})); + } + CHECK(scheduled.state_hash() == 0xd61ad5bf0c928c76ULL); +} + +void scheduled_rejection() { + auto world = fixture(17, 2); + const auto before = world.serialize(); + const auto reject = [&](evo::Tick tick, std::span commands, + evo::ScheduleErrorCode code) { + const auto result = evo::advance(world, tick, commands); + CHECK(!result && result.error().code == code); + CHECK(world.serialize() == before); + return result.error(); + }; + reject(evo::Tick{0}, {}, evo::ScheduleErrorCode::wrong_tick); + reject(evo::Tick{2}, {}, evo::ScheduleErrorCode::wrong_tick); + std::array commands{evo::Command{1, evo::CreateEntity{}}, + evo::Command{1, evo::RemoveEntity{evo::EntityId{1}}}}; + reject(evo::Tick{1}, commands, evo::ScheduleErrorCode::duplicate_sequence); + commands[1].sequence = 0; + reject(evo::Tick{1}, commands, evo::ScheduleErrorCode::invalid_sequence); + commands[1] = evo::Command{2, evo::RemoveEntity{evo::EntityId{99}}}; + auto error = reject(evo::Tick{1}, commands, evo::ScheduleErrorCode::simulation_failure); + CHECK(error.sequence == 2 && error.cause == evo::Error::entity_not_found); + commands[1] = evo::Command{2, evo::CreateEntity{{evo::Millimetres{1024}, {}}}}; + error = reject(evo::Tick{1}, commands, evo::ScheduleErrorCode::simulation_failure); + CHECK(error.cause == evo::Error::invalid_position); + commands = {evo::Command{1, evo::RemoveEntity{evo::EntityId{1}}}, + evo::Command{2, evo::RemoveEntity{evo::EntityId{1}}}}; + reject(evo::Tick{1}, commands, evo::ScheduleErrorCode::simulation_failure); + std::vector large(evo::max_commands_per_tick + 1, + evo::Command{1, evo::CreateEntity{}}); + reject(evo::Tick{1}, large, evo::ScheduleErrorCode::batch_limit); + large.pop_back(); + for (std::size_t index = 0; index < large.size(); ++index) { + large[index].sequence = index + 1; + } + CHECK(evo::advance(world, evo::Tick{1}, large)); + const auto committed = world.serialize(); + const auto retry = evo::advance(world, evo::Tick{1}, large); + CHECK(!retry && retry.error().code == evo::ScheduleErrorCode::wrong_tick); + CHECK(world.serialize() == committed); + + auto full = fixture(1, evo::max_entities); + const auto full_before = full.serialize(); + const std::array create{evo::Command{1, evo::CreateEntity{}}}; + const auto capacity = evo::advance(full, evo::Tick{1}, create); + CHECK(!capacity && capacity.error().cause == evo::Error::entity_limit); + CHECK(full.serialize() == full_before); + for (const auto offset : {32U, 40U}) { + auto bytes = before; + put(bytes, offset, std::numeric_limits::max(), 8); + resign(bytes); + auto exhausted = evo::SimulationWorld::restore(bytes); + CHECK(exhausted); + const auto result = evo::advance(*exhausted, evo::Tick{1}, create); + CHECK(!result && result.error().cause == (offset == 32 ? evo::Error::tick_exhausted + : evo::Error::id_exhausted)); + CHECK(exhausted->serialize() == bytes); + } +} } // namespace int main(int argc, char**) try { @@ -242,7 +338,9 @@ int main(int argc, char**) try { Test{"atomic exhaustion", exhaustion_is_atomic}, Test{"capacity", capacity_boundary}, Test{"canonical empty state", wire_layout_and_empty_state}, - Test{"host telemetry", telemetry_is_host_owned}}; + Test{"host telemetry", telemetry_is_host_owned}, + Test{"scheduled order and recovery", scheduled_order_and_recovery}, + Test{"atomic scheduler rejection", scheduled_rejection}}; int failures = 0; for (const auto& test : tests) { try {