M11.1: genome schema 2 with per-second rates (ADR-0099, segment 2)
Foundation / checks (deploy) (push) Successful in 3m32s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m56s
Foundation / checks (network) (push) Successful in 13m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / checks (checks) (push) Successful in 33m36s
Foundation / checks (postgres) (push) Successful in 45m30s
Foundation / postgres-tools (push) Successful in 20s
Foundation / server-image (push) Successful in 25s
Foundation / image (push) Successful in 2m36s
Foundation / checks (deploy) (push) Successful in 3m32s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m56s
Foundation / checks (network) (push) Successful in 13m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / checks (checks) (push) Successful in 33m36s
Foundation / checks (postgres) (push) Successful in 45m30s
Foundation / postgres-tools (push) Successful in 20s
Foundation / server-image (push) Successful in 25s
Foundation / image (push) Successful in 2m36s
Movement and ingestion are stored per second in schema 2 (ranges x20). Schema 1 records stay valid, are never rewritten, and read as exactly x20 via Genome::per_second; drafts default to schema 1 so existing literals keep their meaning. Development version 1 converts genome rates at its own 50 ms quantum (round down), so phenotypes are unchanged. Mutation keeps the parent's schema and step; the lineage archive header names exactly the highest schema held (all-schema-1 archives keep their bytes); the development-v1 opening names schema 1. No golden changed; two tests that used 2 as an unknown schema now use the next one. Refresh the dev session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -12,7 +12,7 @@ spec:
|
||||
env:
|
||||
- {name: REGION_SESSION, value: "dev"}
|
||||
- {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261009T164435-675a:1791578075"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261009T171039-559d:1791579639"}
|
||||
- {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"}
|
||||
ports:
|
||||
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
|
||||
|
||||
+6
-2
@@ -20,8 +20,12 @@ the maintainer chose directional rounding):
|
||||
- **Segment 1 (done):** `accounting/rates.hpp` converts a per-second rate to a per-tick
|
||||
amount without saved state. Costs round up and capacities down, so rounding never
|
||||
favours the organism. The migration's exact ×20 inverse refuses inexact values.
|
||||
- **Segments 2–3 (next):** genome schema v2, development version 2, and the process and
|
||||
checkpoint fields, with unchanged 50 ms goldens.
|
||||
- **Segment 2 (done):** genome schema 2 stores rates per second. Schema 1 records are
|
||||
read ×20 and never rewritten. Development version 1 converts at its own 50 ms
|
||||
quantum, mutation keeps a lineage's schema, and an archive of schema 1 records keeps
|
||||
its bytes. No behaviour or golden changed.
|
||||
- **Segment 3 (next):** development outputs, feeding and decay limits per second,
|
||||
converted at each process's tick.
|
||||
|
||||
Open from M10 (BACKLOG):
|
||||
- the maintainer's native-client observation, moved to the later 2k drill;
|
||||
|
||||
@@ -77,6 +77,27 @@ contract and a versioned migration that preserves 50 ms behaviour.
|
||||
or not at all, would rescale biology. The goldens at 50 ms are the guard against
|
||||
this.
|
||||
|
||||
## Segment 2 as implemented (2026-10-09)
|
||||
- **Genome schema 2** ([genome-v2.md](../../schemas/genome-v2.md)): movement and
|
||||
ingestion are per second, with ranges ×20. `Genome::per_second` reads either schema.
|
||||
A schema 1 rate reads as exactly ×20.
|
||||
- **Drafts** default to schema 1, so every existing literal keeps its per-tick
|
||||
meaning. New records name schema 2.
|
||||
- **Development version 1 stays defined in 50 ms ticks**
|
||||
(`development_v1_tick_microseconds`). It reads genome rates per second and converts
|
||||
them at that quantum, rounding down (capacities). Its per-tick outputs are unchanged.
|
||||
A schema 1 genome and its exact schema 2 translation develop identically.
|
||||
Development's outputs move to per-second rates in segment 3, at the consumers.
|
||||
- **Mutation** keeps the parent's schema and step. Mutation offers are seeded from the
|
||||
genome's digest, so migrating a lineage's records would change every later offer;
|
||||
no lineage is migrated.
|
||||
- **The lineage archive** header names exactly the highest schema held. An all-schema-1
|
||||
archive, which is what dev worlds hold, keeps its bytes.
|
||||
- **The development opening** (`development-v1`) names schema 1 explicitly; it is a
|
||||
fixed genesis.
|
||||
- **Tests that used 2 as an unknown future schema** now use the next unknown one. The
|
||||
archive decoder refuses a header that misstates its contents.
|
||||
|
||||
## Consequences
|
||||
- Segment 1: `accounting/rates.hpp` (`per_tick`, `exact_per_tick`,
|
||||
`per_second_from_per_tick`) and the `rate-contracts` test.
|
||||
|
||||
@@ -116,6 +116,14 @@ viable organism: validation proves neither developmental feasibility nor
|
||||
biological plausibility, and the schema ranges are expressible bounds rather than
|
||||
balance. Fitness remains an outcome, not a score held in the record.
|
||||
|
||||
### Schema 2 (M11.1, ADR-0099)
|
||||
Schema 2 states the movement and ingestion rates per second (×20 ranges), so biology
|
||||
is no longer tied to the 50 ms tick. Schema 1 records stay valid and are never
|
||||
rewritten. They read as exactly ×20 through `Genome::per_second`. Drafts default to
|
||||
schema 1. Mutation keeps a lineage's schema. Development version 1 converts rates
|
||||
back to its own 50 ms quantum, so nothing behaves differently.
|
||||
See [genome-v2.md](../../schemas/genome-v2.md).
|
||||
|
||||
## Implemented M3.2 development and phenotype
|
||||
|
||||
[ADR-0031](../adr/0031-development-and-phenotype.md) adds `derive_phenotype` and
|
||||
|
||||
@@ -5372,3 +5372,30 @@ Executed:
|
||||
- Windows `debug`: 61/61.
|
||||
|
||||
No biology uses the conversion yet, so no golden is affected.
|
||||
|
||||
## 2026-10-09 — M11.1 time-based rates, segment 2: genome schema 2 (ADR-0099)
|
||||
|
||||
Genome schema 2 stores movement and ingestion per second (ranges ×20;
|
||||
`schemas/genome-v2.md`). Schema 1 records stay valid and read as exactly ×20, and drafts
|
||||
default to schema 1. Development version 1 converts genome rates at its 50 ms quantum.
|
||||
Mutation keeps the parent's schema and step. The lineage archive header names exactly
|
||||
the highest schema held, and the development opening names schema 1.
|
||||
|
||||
New tests:
|
||||
- `schema_v2_rates` (genome);
|
||||
- range boundaries per schema;
|
||||
- `schemas_mix_without_rewriting` (archive);
|
||||
- `schema_v2_rates_develop_identically`: phenotypes and plans equal across schemas, and
|
||||
sub-tick rates round down;
|
||||
- `successors_keep_their_parents_schema` (mutation).
|
||||
|
||||
Two existing tests used 2 as "an unknown future schema". They now use the next unknown
|
||||
schema, and the archive decoder now refuses a header that misstates its contents. No
|
||||
golden changed: the frozen schema 1 record and its digest are byte-identical.
|
||||
|
||||
Executed:
|
||||
- WSL `linux-debug` and `linux-asan`: 61/61 each.
|
||||
- clang-tidy 19 on the changed sources and tests: clean.
|
||||
- The 18 Postgres suites passed, including region upgrade and clone comparison, so
|
||||
checkpoints are unchanged.
|
||||
- Windows `debug`: 61/61.
|
||||
|
||||
@@ -19,6 +19,9 @@ struct EnvironmentState {
|
||||
accounting::Inventory available{};
|
||||
auto operator<=>(const EnvironmentState&) const = default;
|
||||
};
|
||||
// Development version 1 is defined in ticks of this quantum: its per-tick constants and
|
||||
// outputs, and the genome rates it reads (converted from per second, ADR-0099).
|
||||
inline constexpr std::uint64_t development_v1_tick_microseconds = 50'000;
|
||||
// Chosen constants, reviewable as a unit and selected by the genome's
|
||||
// development version. Declared model parameters, not balance.
|
||||
struct DevelopmentRules {
|
||||
|
||||
@@ -25,10 +25,12 @@ inline constexpr std::size_t capability_count = 7;
|
||||
enum class Unit : std::uint8_t {
|
||||
per_thousand,
|
||||
micrometres,
|
||||
micrometres_per_tick,
|
||||
micrometres_per_tick, // Schema 1: per 50 ms tick.
|
||||
femtograms,
|
||||
femtograms_per_tick,
|
||||
millikelvin
|
||||
femtograms_per_tick, // Schema 1: per 50 ms tick.
|
||||
millikelvin,
|
||||
micrometres_per_second, // Schema 2 (ADR-0099).
|
||||
femtograms_per_second // Schema 2 (ADR-0099).
|
||||
};
|
||||
struct CapabilitySpec {
|
||||
Unit unit;
|
||||
@@ -42,8 +44,8 @@ struct CapabilitySpec {
|
||||
return 1U << static_cast<std::uint8_t>(kind);
|
||||
}
|
||||
// Chosen schema constants, reviewable as a unit. These are ranges of expressible
|
||||
// capability, not balance, stats or a power score.
|
||||
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema{
|
||||
// capability, not balance, stats or a power score. Schema 1 states rates per 50 ms tick.
|
||||
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v1{
|
||||
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
|
||||
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
|
||||
CapabilitySpec{Unit::micrometres_per_tick, 0, 100'000, false,
|
||||
@@ -54,6 +56,23 @@ inline constexpr std::array<CapabilitySpec, capability_count> capability_schema{
|
||||
capability_bit(Capability::energy_conversion)},
|
||||
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
|
||||
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
|
||||
// Schema 2 (ADR-0099): the same capabilities with rates per second. Each rate range is
|
||||
// schema 1's times 20, so every schema 1 value has an exact schema 2 equivalent.
|
||||
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v2{
|
||||
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
|
||||
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
|
||||
CapabilitySpec{Unit::micrometres_per_second, 0, 2'000'000, false,
|
||||
capability_bit(Capability::membrane)},
|
||||
CapabilitySpec{Unit::femtograms_per_second, 0, 20'000'000, false,
|
||||
capability_bit(Capability::membrane)},
|
||||
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
|
||||
capability_bit(Capability::energy_conversion)},
|
||||
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
|
||||
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
|
||||
// The current schema's table.
|
||||
inline constexpr const auto& capability_schema = capability_schema_v2;
|
||||
// Schema 1 rates are per tick of this quantum.
|
||||
inline constexpr std::uint64_t schema_v1_tick_microseconds = 50'000;
|
||||
|
||||
struct CapabilityRecord {
|
||||
Capability kind{};
|
||||
@@ -69,6 +88,10 @@ struct GenomeDraft {
|
||||
std::uint32_t development_version{};
|
||||
std::vector<std::uint64_t> parents;
|
||||
std::vector<CapabilityRecord> capabilities;
|
||||
// The schema the parameters are written in. Schema 1 is the default so an existing
|
||||
// literal keeps its meaning (rates per 50 ms tick); new records name schema 2. Last,
|
||||
// so positional initialisers are unaffected.
|
||||
std::uint32_t schema_version{1};
|
||||
};
|
||||
enum class GenomeError : std::uint8_t {
|
||||
unsupported_version,
|
||||
@@ -83,7 +106,16 @@ enum class GenomeError : std::uint8_t {
|
||||
digest_mismatch,
|
||||
invalid_encoding
|
||||
};
|
||||
inline constexpr std::uint32_t genome_schema_version = 1;
|
||||
// The current schema. Schema 1 records stay valid and are never rewritten (ADR-0099).
|
||||
inline constexpr std::uint32_t genome_schema_version = 2;
|
||||
inline constexpr std::uint32_t genome_schema_v1 = 1;
|
||||
// The capability table of a supported schema (1 or 2); nullptr otherwise.
|
||||
[[nodiscard]] constexpr const std::array<CapabilitySpec, capability_count>*
|
||||
capability_schema_for(std::uint32_t schema) noexcept {
|
||||
return schema == genome_schema_v1 ? &capability_schema_v1
|
||||
: schema == genome_schema_version ? &capability_schema_v2
|
||||
: nullptr;
|
||||
}
|
||||
inline constexpr std::size_t max_parents = 2;
|
||||
inline constexpr std::size_t max_genome_bytes = 256;
|
||||
|
||||
@@ -108,7 +140,7 @@ class Genome {
|
||||
return origin_event_;
|
||||
}
|
||||
[[nodiscard]] std::uint32_t schema_version() const noexcept {
|
||||
return genome_schema_version;
|
||||
return schema_version_;
|
||||
}
|
||||
[[nodiscard]] std::uint32_t development_version() const noexcept {
|
||||
return development_version_;
|
||||
@@ -124,6 +156,11 @@ class Genome {
|
||||
[[nodiscard]] bool carries(Capability kind) const noexcept;
|
||||
[[nodiscard]] std::expected<std::uint32_t, GenomeError>
|
||||
parameter(Capability kind) const noexcept;
|
||||
// A rate capability (movement, ingestion) per second, whatever the schema: a
|
||||
// schema 1 per-tick value times 20, exactly. Other capabilities are returned as
|
||||
// stored.
|
||||
[[nodiscard]] std::expected<std::uint64_t, GenomeError>
|
||||
per_second(Capability kind) const noexcept;
|
||||
// Covers identity and ancestry, so distinct origins never share a digest.
|
||||
// An integrity and deduplication aid, never a content key and never authenticity.
|
||||
[[nodiscard]] std::uint64_t content_digest() const noexcept {
|
||||
@@ -134,6 +171,7 @@ class Genome {
|
||||
private:
|
||||
Genome() = default;
|
||||
[[nodiscard]] std::vector<std::uint8_t> body() const;
|
||||
std::uint32_t schema_version_{genome_schema_v1};
|
||||
std::uint64_t id_{};
|
||||
std::uint64_t origin_event_{};
|
||||
std::uint32_t development_version_{};
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
# Genome record, schema version 2
|
||||
|
||||
Scope: schema 2 of the immutable genome record ([genome-v1.md](genome-v1.md),
|
||||
[ADR-0030](../docs/adr/0030-immutable-genome-record.md)). It changes only the units of
|
||||
the two rate capabilities, per [ADR-0099](../docs/adr/0099-time-based-biological-rates.md).
|
||||
Its encoder and decoder are `src/biology/genome.cpp`, which reads schemas 1 and 2.
|
||||
|
||||
## Layout
|
||||
The layout is byte for byte that of schema 1, except offset 8, which holds 2. The
|
||||
magic stays `AEVOGEN1`; the schema field, not the magic, selects the capability table.
|
||||
The digest and checksum rules are unchanged. The digest covers the schema field, so a
|
||||
schema 1 record and its schema 2 translation are distinct records with distinct
|
||||
digests.
|
||||
|
||||
## Capability table
|
||||
|
||||
| Kind | Unit (schema 2) | Range | Schema 1 unit and range |
|
||||
|---|---|---|---|
|
||||
| energy conversion | per thousand | 1-1000, required | same |
|
||||
| membrane | micrometres | 1-10,000, required | same |
|
||||
| movement | **micrometres per second** | 0-2,000,000 | um per 50 ms tick, 0-100,000 |
|
||||
| ingestion | **femtograms per second** | 0-20,000,000 | fg per 50 ms tick, 0-1,000,000 |
|
||||
| reproduction | per thousand | 1-1000 | same |
|
||||
| target size | femtograms | 1-1,000,000,000, required | same |
|
||||
| thermal tolerance | millikelvin | 1-100,000 | same |
|
||||
|
||||
Each rate range is schema 1's times 20, so every schema 1 value has an exact schema 2
|
||||
equivalent.
|
||||
|
||||
## Compatibility
|
||||
- **Schema 1 records** stay valid and are never rewritten. `Genome::per_second` reads
|
||||
a schema 1 rate as exactly 20 times its per-tick value.
|
||||
- **Drafts** default to schema 1, so existing literals keep their meaning. New
|
||||
records name schema 2.
|
||||
- **Mutation** keeps the parent's schema and that schema's adjustment step, one
|
||||
hundredth of the range.
|
||||
- **Lineage archives** name the highest schema they hold. An archive of schema 1
|
||||
records keeps its exact bytes.
|
||||
- **Unknown schemas** fail closed.
|
||||
@@ -1,5 +1,7 @@
|
||||
#include "evo/biology/development.hpp"
|
||||
|
||||
#include "evo/accounting/rates.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
|
||||
@@ -96,13 +98,23 @@ derive_phenotype(const Genome& genome, GrowthState growth, EnvironmentState envi
|
||||
phenotype.conversion_per_thousand =
|
||||
static_cast<std::uint32_t>(*genome.parameter(Capability::energy_conversion));
|
||||
// A capability the genome does not carry yields nothing, whatever the size.
|
||||
// Development version 1 is defined in 50 ms ticks: genome rates (per second) enter it
|
||||
// at that quantum, rounded down as capacities (ADR-0099; exact for schema 1 records).
|
||||
const auto rate_per_tick = [](std::uint64_t per_second) {
|
||||
return accounting::per_tick(per_second, development_v1_tick_microseconds,
|
||||
accounting::Rounding::down);
|
||||
};
|
||||
if (genome.carries(Capability::movement)) {
|
||||
phenotype.movement_speed =
|
||||
static_cast<std::uint32_t>(*genome.parameter(Capability::movement));
|
||||
const auto speed = rate_per_tick(*genome.per_second(Capability::movement));
|
||||
if (!speed || *speed > std::numeric_limits<std::uint32_t>::max()) {
|
||||
return std::unexpected{DevelopmentError::overflow};
|
||||
}
|
||||
phenotype.movement_speed = static_cast<std::uint32_t>(*speed);
|
||||
}
|
||||
if (genome.carries(Capability::ingestion)) {
|
||||
const auto intake = rate_per_tick(*genome.per_second(Capability::ingestion));
|
||||
std::uint64_t uptake{};
|
||||
if (!multiply(uptake, *genome.parameter(Capability::ingestion), phenotype.surface)) {
|
||||
if (!intake || !multiply(uptake, *intake, phenotype.surface)) {
|
||||
return std::unexpected{DevelopmentError::overflow};
|
||||
}
|
||||
phenotype.ingestion_rate = uptake / rules->reference_surface;
|
||||
|
||||
+40
-12
@@ -1,5 +1,7 @@
|
||||
#include "evo/biology/genome.hpp"
|
||||
|
||||
#include "evo/accounting/rates.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace evo::biology {
|
||||
@@ -57,14 +59,17 @@ class Reader {
|
||||
|
||||
constexpr std::uint32_t every_capability = (1U << capability_count) - 1U;
|
||||
|
||||
const CapabilitySpec& spec(Capability kind) noexcept {
|
||||
return capability_schema[static_cast<std::size_t>(kind)];
|
||||
}
|
||||
|
||||
std::expected<void, GenomeError> validate(std::uint64_t id, std::uint64_t origin,
|
||||
std::uint32_t development,
|
||||
std::expected<void, GenomeError> validate(std::uint32_t schema, std::uint64_t id,
|
||||
std::uint64_t origin, std::uint32_t development,
|
||||
std::span<const std::uint64_t> parents,
|
||||
std::span<const CapabilityRecord> capabilities) {
|
||||
const auto* table = capability_schema_for(schema);
|
||||
if (table == nullptr) {
|
||||
return std::unexpected{GenomeError::unsupported_version};
|
||||
}
|
||||
const auto spec = [table](Capability kind) -> const CapabilitySpec& {
|
||||
return (*table)[static_cast<std::size_t>(kind)];
|
||||
};
|
||||
if (id == 0 || origin == 0) {
|
||||
return std::unexpected{GenomeError::invalid_identity};
|
||||
}
|
||||
@@ -112,7 +117,7 @@ std::expected<void, GenomeError> validate(std::uint64_t id, std::uint64_t origin
|
||||
}
|
||||
for (std::size_t index = 0; index < capability_count; ++index) {
|
||||
const auto kind = static_cast<Capability>(index);
|
||||
if (capability_schema[index].required && (present & capability_bit(kind)) == 0) {
|
||||
if ((*table)[index].required && (present & capability_bit(kind)) == 0) {
|
||||
return std::unexpected{GenomeError::missing_capability};
|
||||
}
|
||||
}
|
||||
@@ -153,7 +158,7 @@ std::vector<std::uint8_t> Genome::body() const {
|
||||
std::vector<std::uint8_t> bytes;
|
||||
bytes.reserve(max_genome_bytes);
|
||||
bytes.insert(bytes.end(), magic.begin(), magic.end());
|
||||
append(bytes, genome_schema_version, 4);
|
||||
append(bytes, schema_version_, 4);
|
||||
append(bytes, development_version_, 4);
|
||||
append(bytes, id_, 8);
|
||||
append(bytes, origin_event_, 8);
|
||||
@@ -184,12 +189,13 @@ std::expected<Genome, GenomeError> Genome::create(const GenomeDraft& draft) {
|
||||
if (draft.parents.size() > max_parents) {
|
||||
return std::unexpected{GenomeError::invalid_ancestry};
|
||||
}
|
||||
if (const auto valid = validate(draft.id, draft.origin_event, draft.development_version,
|
||||
draft.parents, ordered);
|
||||
if (const auto valid = validate(draft.schema_version, draft.id, draft.origin_event,
|
||||
draft.development_version, draft.parents, ordered);
|
||||
!valid) {
|
||||
return std::unexpected{valid.error()};
|
||||
}
|
||||
Genome genome;
|
||||
genome.schema_version_ = draft.schema_version;
|
||||
genome.id_ = draft.id;
|
||||
genome.origin_event_ = draft.origin_event;
|
||||
genome.development_version_ = draft.development_version;
|
||||
@@ -209,7 +215,8 @@ std::expected<Genome, GenomeError> Genome::decode(std::span<const std::uint8_t>
|
||||
}
|
||||
Reader reader{bytes};
|
||||
static_cast<void>(reader.read(magic.size()));
|
||||
if (reader.read(4) != genome_schema_version) {
|
||||
const auto schema = static_cast<std::uint32_t>(reader.read(4));
|
||||
if (capability_schema_for(schema) == nullptr) {
|
||||
return std::unexpected{GenomeError::unsupported_version};
|
||||
}
|
||||
const auto development = static_cast<std::uint32_t>(reader.read(4));
|
||||
@@ -254,10 +261,12 @@ std::expected<Genome, GenomeError> Genome::decode(std::span<const std::uint8_t>
|
||||
const auto prerequisites = static_cast<std::uint32_t>(reader.read(4));
|
||||
capabilities.push_back({static_cast<Capability>(kind), parameter, prerequisites});
|
||||
}
|
||||
if (const auto valid = validate(id, origin, development, parents, capabilities); !valid) {
|
||||
if (const auto valid = validate(schema, id, origin, development, parents, capabilities);
|
||||
!valid) {
|
||||
return std::unexpected{valid.error()};
|
||||
}
|
||||
Genome genome;
|
||||
genome.schema_version_ = schema;
|
||||
genome.id_ = id;
|
||||
genome.origin_event_ = origin;
|
||||
genome.development_version_ = development;
|
||||
@@ -285,4 +294,23 @@ std::expected<std::uint32_t, GenomeError> Genome::parameter(Capability kind) con
|
||||
}
|
||||
return std::unexpected{GenomeError::missing_capability};
|
||||
}
|
||||
|
||||
std::expected<std::uint64_t, GenomeError> Genome::per_second(Capability kind) const noexcept {
|
||||
const auto stored = parameter(kind);
|
||||
if (!stored) {
|
||||
return std::unexpected{stored.error()};
|
||||
}
|
||||
const auto unit = capability_schema_v1[static_cast<std::size_t>(kind)].unit;
|
||||
const bool per_tick = unit == Unit::micrometres_per_tick || unit == Unit::femtograms_per_tick;
|
||||
if (schema_version_ == genome_schema_v1 && per_tick) {
|
||||
// Exact: a 50 ms tick is a twentieth of a second (ADR-0099).
|
||||
const auto rate =
|
||||
accounting::per_second_from_per_tick(*stored, schema_v1_tick_microseconds);
|
||||
if (!rate) {
|
||||
return std::unexpected{GenomeError::parameter_out_of_range};
|
||||
}
|
||||
return *rate;
|
||||
}
|
||||
return std::uint64_t{*stored};
|
||||
}
|
||||
} // namespace evo::biology
|
||||
|
||||
+14
-3
@@ -234,7 +234,11 @@ std::vector<std::uint8_t> LineageArchive::encode() const {
|
||||
(organisms_.size() * archived_organism_bytes) + 8);
|
||||
put(out, archive_magic, 8);
|
||||
put(out, lineage_archive_format, 4);
|
||||
put(out, genome_schema_version, 4);
|
||||
// The highest genome schema held: an archive of schema 1 records keeps its bytes.
|
||||
std::uint32_t schema = genome_schema_v1;
|
||||
for (const auto& g : genomes_)
|
||||
schema = std::max(schema, g.schema_version());
|
||||
put(out, schema, 4);
|
||||
put(out, genomes_.size(), 4);
|
||||
put(out, organisms_.size(), 4);
|
||||
put(out, 0, 8); // Total length, patched below.
|
||||
@@ -261,7 +265,9 @@ std::expected<LineageArchive, ArchiveCodecError>
|
||||
LineageArchive::decode(std::span<const std::uint8_t> bytes) {
|
||||
if (bytes.size() < archive_header_bytes + 8 || get(bytes, 0, 8) != archive_magic)
|
||||
return std::unexpected{ArchiveCodecError::format};
|
||||
if (get(bytes, 8, 4) != lineage_archive_format || get(bytes, 12, 4) != genome_schema_version)
|
||||
const auto schema = get(bytes, 12, 4);
|
||||
if (get(bytes, 8, 4) != lineage_archive_format || schema < genome_schema_v1 ||
|
||||
schema > genome_schema_version)
|
||||
return std::unexpected{ArchiveCodecError::version};
|
||||
const auto genomes = get(bytes, 16, 4);
|
||||
const auto organisms = get(bytes, 20, 4);
|
||||
@@ -275,6 +281,7 @@ LineageArchive::decode(std::span<const std::uint8_t> bytes) {
|
||||
return std::unexpected{ArchiveCodecError::checksum};
|
||||
|
||||
LineageArchive archive;
|
||||
std::uint32_t highest = genome_schema_v1;
|
||||
std::size_t at = archive_header_bytes;
|
||||
for (std::uint64_t g = 0; g < genomes; ++g) {
|
||||
if (at + 2 > body.size())
|
||||
@@ -284,12 +291,16 @@ LineageArchive::decode(std::span<const std::uint8_t> bytes) {
|
||||
if (length == 0 || length > max_genome_bytes || at + length > body.size())
|
||||
return std::unexpected{ArchiveCodecError::format};
|
||||
const auto genome = Genome::decode(body.subspan(at, length));
|
||||
if (!genome)
|
||||
if (!genome || genome->schema_version() > schema)
|
||||
return std::unexpected{ArchiveCodecError::genome};
|
||||
highest = std::max(highest, genome->schema_version());
|
||||
if (!archive.admit(*genome))
|
||||
return std::unexpected{ArchiveCodecError::history};
|
||||
at += length;
|
||||
}
|
||||
// Canonical: the header names exactly the highest schema held (ADR-0099).
|
||||
if (highest != schema)
|
||||
return std::unexpected{ArchiveCodecError::version};
|
||||
if (body.size() - at != organisms * archived_organism_bytes)
|
||||
return std::unexpected{ArchiveCodecError::format};
|
||||
for (std::uint64_t o = 0; o < organisms; ++o, at += archived_organism_bytes) {
|
||||
|
||||
@@ -28,8 +28,10 @@ constexpr std::array<MutationOperator, 4 * capability_count> catalog = [] {
|
||||
// One rule rather than a constant per capability: a hundredth of the declared
|
||||
// range, at least one. Granularity follows the range, which is a stated model
|
||||
// choice and not a claim about biology.
|
||||
constexpr std::uint32_t adjustment_step(Capability kind) noexcept {
|
||||
const auto& limits = capability_schema[static_cast<std::size_t>(kind)];
|
||||
// The step comes from the genome's own schema, so a schema 1 lineage keeps its steps.
|
||||
constexpr std::uint32_t adjustment_step(const std::array<CapabilitySpec, capability_count>& table,
|
||||
Capability kind) noexcept {
|
||||
const auto& limits = table[static_cast<std::size_t>(kind)];
|
||||
const auto span = limits.maximum - limits.minimum;
|
||||
return span / 100 == 0 ? 1 : span / 100;
|
||||
}
|
||||
@@ -72,12 +74,16 @@ std::uint64_t bounded(Random& stream, std::uint64_t bound) noexcept {
|
||||
std::optional<GenomeDraft> apply(const Genome& genome, const MutationOperator& entry,
|
||||
std::uint64_t id, std::uint64_t origin_event) {
|
||||
GenomeDraft draft;
|
||||
// A successor keeps its parent's schema: its parameters are the parent's, in the
|
||||
// parent's units (ADR-0099), and a lineage's offers never shift by migration.
|
||||
draft.schema_version = genome.schema_version();
|
||||
draft.id = id;
|
||||
draft.origin_event = origin_event;
|
||||
draft.development_version = genome.development_version();
|
||||
draft.parents = {genome.id()};
|
||||
draft.capabilities.assign(genome.capabilities().begin(), genome.capabilities().end());
|
||||
const auto& limits = capability_schema[static_cast<std::size_t>(entry.target)];
|
||||
const auto& table = *capability_schema_for(genome.schema_version());
|
||||
const auto& limits = table[static_cast<std::size_t>(entry.target)];
|
||||
const auto carried =
|
||||
std::ranges::find(draft.capabilities, entry.target, &CapabilityRecord::kind);
|
||||
const auto present = carried != draft.capabilities.end();
|
||||
@@ -86,7 +92,7 @@ std::optional<GenomeDraft> apply(const Genome& genome, const MutationOperator& e
|
||||
if (!present) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto step = adjustment_step(entry.target);
|
||||
const auto step = adjustment_step(table, entry.target);
|
||||
// Refused rather than clamped: a clamp would make two operators agree
|
||||
// and would offer a no-op as a real choice.
|
||||
if (carried->parameter > limits.maximum - step) {
|
||||
@@ -99,7 +105,7 @@ std::optional<GenomeDraft> apply(const Genome& genome, const MutationOperator& e
|
||||
if (!present) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto step = adjustment_step(entry.target);
|
||||
const auto step = adjustment_step(table, entry.target);
|
||||
if (carried->parameter < limits.minimum + step) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
@@ -58,6 +58,7 @@ std::unique_ptr<EnvironmentalCommunity> community(world::WorldIdentity id) {
|
||||
}
|
||||
std::optional<biology::Genome> genome(std::uint64_t id, std::uint64_t parent) {
|
||||
biology::GenomeDraft draft;
|
||||
draft.schema_version = biology::genome_schema_v1; // development-v1 is fixed (ADR-0099).
|
||||
draft.id = id;
|
||||
draft.origin_event = id;
|
||||
draft.development_version = 1;
|
||||
|
||||
@@ -117,6 +117,30 @@ void capability_prerequisites() {
|
||||
CHECK(with->maintenance == without->maintenance);
|
||||
}
|
||||
|
||||
// ADR-0099: development version 1 reads genome rates per second at its 50 ms quantum.
|
||||
// A schema 1 genome and its exact schema 2 translation develop identically, and a schema
|
||||
// 2 rate that is not a whole number per tick rounds down (a capacity).
|
||||
void schema_v2_rates_develop_identically() {
|
||||
auto old = draft();
|
||||
old.capabilities.push_back({Capability::movement, 250, 0});
|
||||
old.capabilities.push_back({Capability::ingestion, 120'000, 0});
|
||||
auto now = old;
|
||||
now.schema_version = genome_schema_version;
|
||||
now.capabilities[3].parameter = 5'000; // 250 per tick, per second.
|
||||
now.capabilities[4].parameter = 2'400'000; // 120000 per tick, per second.
|
||||
for (const std::uint32_t realized : {250U, 500U, 1000U}) {
|
||||
const auto a = derive_phenotype(build(old), {realized, 0}, temperate);
|
||||
const auto b = derive_phenotype(build(now), {realized, 0}, temperate);
|
||||
CHECK(a && b && *a == *b);
|
||||
const auto pa = plan_development(build(old), {realized, 0}, temperate);
|
||||
const auto pb = plan_development(build(now), {realized, 0}, temperate);
|
||||
CHECK(pa && pb && *pa == *pb);
|
||||
}
|
||||
now.capabilities[3].parameter = 5'019; // 250.95 per tick.
|
||||
const auto rounded = derive_phenotype(build(now), {1000, 0}, temperate);
|
||||
CHECK(rounded && rounded->movement_speed == 250);
|
||||
}
|
||||
|
||||
void thermal_shortfall_is_reported_not_enforced() {
|
||||
auto source = draft();
|
||||
source.capabilities.push_back({Capability::thermal_tolerance, 5'000, 0});
|
||||
@@ -272,6 +296,7 @@ int main() try {
|
||||
damage_is_not_genome();
|
||||
identical_inputs_give_identical_phenotypes();
|
||||
capability_prerequisites();
|
||||
schema_v2_rates_develop_identically();
|
||||
thermal_shortfall_is_reported_not_enforced();
|
||||
rule_versions_and_invalid_growth();
|
||||
availability_bounds_do_not_wrap();
|
||||
|
||||
+68
-21
@@ -115,30 +115,38 @@ void capability_and_range_rules() {
|
||||
draft = founder();
|
||||
draft.capabilities.push_back({Capability::thermal_tolerance, 1, 1U << capability_count});
|
||||
reject(draft, GenomeError::unknown_capability);
|
||||
// Every boundary of every declared range, from both sides.
|
||||
for (std::size_t index = 0; index < capability_count; ++index) {
|
||||
const auto kind = static_cast<Capability>(index);
|
||||
const auto& limits = capability_schema[index];
|
||||
for (const auto value : {limits.minimum, limits.maximum}) {
|
||||
draft = founder();
|
||||
// Every boundary of every declared range, from both sides, in each schema's own table.
|
||||
for (const auto schema : {genome_schema_v1, genome_schema_version}) {
|
||||
const auto& table = *capability_schema_for(schema);
|
||||
const auto fresh = [&] {
|
||||
auto d = founder();
|
||||
d.schema_version = schema;
|
||||
return d;
|
||||
};
|
||||
for (std::size_t index = 0; index < capability_count; ++index) {
|
||||
const auto kind = static_cast<Capability>(index);
|
||||
const auto& limits = table[index];
|
||||
for (const auto value : {limits.minimum, limits.maximum}) {
|
||||
draft = fresh();
|
||||
std::erase_if(draft.capabilities,
|
||||
[kind](const auto& record) { return record.kind == kind; });
|
||||
draft.capabilities.push_back({kind, value, limits.mandates});
|
||||
const auto accepted = Genome::create(draft);
|
||||
CHECK(accepted && *accepted->parameter(kind) == value);
|
||||
}
|
||||
if (limits.minimum > 0) {
|
||||
draft = fresh();
|
||||
std::erase_if(draft.capabilities,
|
||||
[kind](const auto& record) { return record.kind == kind; });
|
||||
draft.capabilities.push_back({kind, limits.minimum - 1, limits.mandates});
|
||||
reject(draft, GenomeError::parameter_out_of_range);
|
||||
}
|
||||
draft = fresh();
|
||||
std::erase_if(draft.capabilities,
|
||||
[kind](const auto& record) { return record.kind == kind; });
|
||||
draft.capabilities.push_back({kind, value, limits.mandates});
|
||||
const auto accepted = Genome::create(draft);
|
||||
CHECK(accepted && *accepted->parameter(kind) == value);
|
||||
}
|
||||
if (limits.minimum > 0) {
|
||||
draft = founder();
|
||||
std::erase_if(draft.capabilities,
|
||||
[kind](const auto& record) { return record.kind == kind; });
|
||||
draft.capabilities.push_back({kind, limits.minimum - 1, limits.mandates});
|
||||
draft.capabilities.push_back({kind, limits.maximum + 1, limits.mandates});
|
||||
reject(draft, GenomeError::parameter_out_of_range);
|
||||
}
|
||||
draft = founder();
|
||||
std::erase_if(draft.capabilities,
|
||||
[kind](const auto& record) { return record.kind == kind; });
|
||||
draft.capabilities.push_back({kind, limits.maximum + 1, limits.mandates});
|
||||
reject(draft, GenomeError::parameter_out_of_range);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -245,7 +253,7 @@ void encoded_record_rules() {
|
||||
CHECK(!tampered && tampered.error() == GenomeError::digest_mismatch);
|
||||
// An unsupported schema version fails closed before anything else is read.
|
||||
auto future = bytes;
|
||||
future[8] = 2;
|
||||
future[8] = static_cast<std::uint8_t>(genome_schema_version + 1);
|
||||
reseal(future);
|
||||
const auto ahead = Genome::decode(future);
|
||||
CHECK(!ahead && ahead.error() == GenomeError::unsupported_version);
|
||||
@@ -313,6 +321,44 @@ void frozen_record_compatibility() {
|
||||
CHECK(*restored == *genome);
|
||||
}
|
||||
|
||||
// Schema 2 (ADR-0099): rates per second. Schema 1 records stay valid, unrewritten, and
|
||||
// read as exactly twenty times their per-tick values.
|
||||
void schema_v2_rates() {
|
||||
auto v1 = founder();
|
||||
v1.capabilities.push_back({Capability::movement, 5'000, 0});
|
||||
v1.capabilities.push_back({Capability::ingestion, 1'000'000, 0}); // Schema 1 maximum.
|
||||
const auto old = Genome::create(v1);
|
||||
CHECK(old && old->schema_version() == genome_schema_v1);
|
||||
CHECK(old->per_second(Capability::movement) == std::uint64_t{100'000});
|
||||
CHECK(old->per_second(Capability::ingestion) == std::uint64_t{20'000'000});
|
||||
CHECK(old->per_second(Capability::target_size) == std::uint64_t{5'000}); // Not a rate.
|
||||
CHECK(!old->per_second(Capability::thermal_tolerance));
|
||||
auto v2 = v1;
|
||||
v2.schema_version = genome_schema_version;
|
||||
v2.capabilities[3].parameter = 100'000; // Movement, per second.
|
||||
v2.capabilities[4].parameter = 20'000'000;
|
||||
const auto now = Genome::create(v2);
|
||||
CHECK(now && now->schema_version() == 2);
|
||||
CHECK(now->per_second(Capability::movement) == old->per_second(Capability::movement));
|
||||
CHECK(now->per_second(Capability::ingestion) == old->per_second(Capability::ingestion));
|
||||
// The same meaning in another schema is another record.
|
||||
CHECK(now->content_digest() != old->content_digest());
|
||||
const auto restored = Genome::decode(now->encode());
|
||||
CHECK(restored && *restored == *now && restored->schema_version() == 2);
|
||||
// Ranges are per schema: a schema 2 rate may exceed schema 1's per-tick maximum.
|
||||
v2.capabilities[4].parameter = 20'000'001;
|
||||
reject(v2, GenomeError::parameter_out_of_range);
|
||||
v1.capabilities[4].parameter = 1'000'001;
|
||||
reject(v1, GenomeError::parameter_out_of_range);
|
||||
auto unknown = founder();
|
||||
unknown.schema_version = 3;
|
||||
reject(unknown, GenomeError::unsupported_version);
|
||||
auto bytes = Genome::create(founder())->encode();
|
||||
bytes[8] = 3; // Schema field; decode refuses before the checksum matters.
|
||||
CHECK(!Genome::decode(bytes) &&
|
||||
Genome::decode(bytes).error() == GenomeError::unsupported_version);
|
||||
}
|
||||
|
||||
void moves_preserve_validity() {
|
||||
const auto original = Genome::create(founder());
|
||||
const auto other = Genome::create(descendant());
|
||||
@@ -349,6 +395,7 @@ int main() try {
|
||||
canonical_encoding();
|
||||
encoded_record_rules();
|
||||
frozen_record_compatibility();
|
||||
schema_v2_rates();
|
||||
moves_preserve_validity();
|
||||
std::cout << "PASS genome schema, ancestry, development graph and canonical encoding\n";
|
||||
return 0;
|
||||
|
||||
+27
-1
@@ -20,8 +20,10 @@ void check(bool condition, std::source_location location = std::source_location:
|
||||
}
|
||||
}
|
||||
#define CHECK(expression) check(static_cast<bool>(expression))
|
||||
Genome descend(std::uint64_t id, std::uint64_t parent, std::uint32_t conversion = 400) {
|
||||
Genome descend(std::uint64_t id, std::uint64_t parent, std::uint32_t conversion = 400,
|
||||
std::uint32_t schema = genome_schema_v1) {
|
||||
GenomeDraft source;
|
||||
source.schema_version = schema;
|
||||
source.id = id;
|
||||
source.origin_event = id;
|
||||
source.development_version = 1;
|
||||
@@ -380,6 +382,29 @@ void the_archive_decoder_refuses_damage_and_disorder() {
|
||||
CHECK(!LineageArchive::decode(std::span{bytes}.first(39)));
|
||||
}
|
||||
|
||||
// ADR-0099: the header names the highest genome schema held, so an archive of schema 1
|
||||
// records keeps its exact bytes, and a mixed archive round-trips.
|
||||
void schemas_mix_without_rewriting() {
|
||||
const auto old = with_history().encode();
|
||||
CHECK(field(old, 12, 4) == genome_schema_v1);
|
||||
auto archive = branching();
|
||||
CHECK(archive.admit(descend(6, 4, 400, genome_schema_version)));
|
||||
const auto bytes = archive.encode();
|
||||
CHECK(field(bytes, 12, 4) == genome_schema_version);
|
||||
const auto decoded = LineageArchive::decode(bytes);
|
||||
CHECK(decoded && decoded->encode() == bytes);
|
||||
CHECK(decoded->find(6)->schema_version() == 2 && decoded->find(4)->schema_version() == 1);
|
||||
// A header that understates its records is refused.
|
||||
auto understated = bytes;
|
||||
set(understated, 12, genome_schema_v1, 4);
|
||||
reseal(understated);
|
||||
CHECK(!LineageArchive::decode(understated));
|
||||
auto unknown = old;
|
||||
set(unknown, 12, 3, 4);
|
||||
reseal(unknown);
|
||||
CHECK(!LineageArchive::decode(unknown));
|
||||
}
|
||||
|
||||
void a_full_archive_round_trips() {
|
||||
LineageArchive archive;
|
||||
CHECK(archive.admit(descend(1, 0)));
|
||||
@@ -411,6 +436,7 @@ int main() try {
|
||||
the_archive_round_trips_canonically();
|
||||
the_archive_decoder_refuses_damage_and_disorder();
|
||||
a_full_archive_round_trips();
|
||||
schemas_mix_without_rewriting();
|
||||
std::cout << "PASS lineage retention, branching ancestry and provisional absence\n";
|
||||
return 0;
|
||||
} catch (...) {
|
||||
|
||||
@@ -137,7 +137,8 @@ void only_legitimate_operators_are_offered() {
|
||||
CHECK(offered);
|
||||
for (const auto& candidate : offered->candidates) {
|
||||
// A required capability can never be shed, however it is drawn.
|
||||
const auto& limits = capability_schema[static_cast<std::size_t>(candidate.target)];
|
||||
const auto& limits = (*capability_schema_for(
|
||||
genome.schema_version()))[static_cast<std::size_t>(candidate.target)];
|
||||
CHECK(!(candidate.effect == MutationEffect::shed && limits.required));
|
||||
// Acquiring only ever applies to something the parent lacks, and
|
||||
// adjusting only to something it carries.
|
||||
@@ -320,6 +321,37 @@ void invalid_contexts_are_refused() {
|
||||
CHECK(mutation_catalog().size() == 4 * capability_count);
|
||||
}
|
||||
} // namespace
|
||||
// ADR-0099: a successor keeps its parent's schema and that schema's adjustment step, so
|
||||
// a schema 1 lineage is never migrated by mutating, and a schema 2 one steps per second.
|
||||
void successors_keep_their_parents_schema() {
|
||||
for (const auto schema : {genome_schema_v1, genome_schema_version}) {
|
||||
auto source = draft();
|
||||
source.schema_version = schema;
|
||||
source.capabilities.push_back(
|
||||
{Capability::movement, schema == genome_schema_v1 ? 50'000U : 1'000'000U, 0});
|
||||
const auto parent = build(source);
|
||||
const auto step = schema == genome_schema_v1 ? 1'000U : 20'000U; // 1/100 of the range.
|
||||
bool adjusted = false;
|
||||
// Offers are seeded; search seeds (deterministically) for the movement adjustment.
|
||||
for (std::uint64_t seed = 1; seed <= 200 && !adjusted; ++seed) {
|
||||
const auto offered = mutation_candidates(parent, context(seed, 8));
|
||||
CHECK(offered);
|
||||
for (const auto& candidate : offered->candidates) {
|
||||
const auto successor = select_mutation(parent, context(seed, 8), *offered,
|
||||
candidate.operator_id, 99, 42);
|
||||
CHECK(successor && successor->schema_version() == schema);
|
||||
if (candidate.target == Capability::movement &&
|
||||
candidate.effect == MutationEffect::adjust_up) {
|
||||
CHECK(*successor->parameter(Capability::movement) ==
|
||||
*parent.parameter(Capability::movement) + step);
|
||||
adjusted = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
CHECK(adjusted);
|
||||
}
|
||||
}
|
||||
|
||||
int main() try {
|
||||
the_same_context_always_offers_the_same_candidates();
|
||||
offers_are_canonical_and_unranked();
|
||||
@@ -330,6 +362,7 @@ int main() try {
|
||||
reported_cost_is_what_the_budget_charges();
|
||||
invalid_contexts_are_refused();
|
||||
every_eligible_operator_is_offered_and_none_is_favoured();
|
||||
successors_keep_their_parents_schema();
|
||||
std::cout << "PASS mutation catalog, uniform seeded offers and guarded selection\n";
|
||||
return 0;
|
||||
} catch (...) {
|
||||
|
||||
Reference in New Issue
Block a user