#pragma once // The model compared at two resolutions in M4.5 and measured in M4.6. It lives in // the test fixtures rather than in the library because ADR-0038 declines to choose // an ecology and nothing here chooses one for it: these are declared measurement // inputs. The comparison and the benchmark share this one definition, so what is // timed is the same model whose error was measured. #include "evo/ecology/cohort.hpp" #include #include #include #include #include namespace evo::fixture { using evo::accounting::Femtograms; using evo::accounting::Inventory; using evo::ecology::AgeClass; using evo::ecology::Cohort; using evo::ecology::cohort_representation_version; using evo::ecology::CohortDraft; using evo::ecology::HabitatId; using evo::ecology::max_age_classes; using evo::ecology::Owner; // Every quantity the model depends on, in one place, so a sensitivity study can // move one and hold the rest. These were constants in M4.5; the defaults are those // constants exactly, so the published envelope is unchanged by the move. struct Rule { std::uint64_t environment_energy = 300; // per tick, shared by the living std::uint64_t matter_intake = 4; // per member per tick, abundant std::uint64_t upkeep_energy = 2; std::uint64_t upkeep_matter = 1; std::uint64_t lifespan = 400; std::uint64_t maturity = 50; std::uint64_t threshold_energy = 100; std::uint64_t investment_energy = 40; std::uint64_t investment_matter = 40; std::uint64_t capacity = 200; // A member that cannot pay its upkeep starves. At class resolution the average // member is asked the same question, which is exactly where resolution bites. [[nodiscard]] constexpr bool starves(std::uint64_t energy) const noexcept { return energy < upkeep_energy; } [[nodiscard]] constexpr bool breeds(std::uint64_t age, std::uint64_t energy) const noexcept { return age >= maturity && energy >= threshold_energy; } [[nodiscard]] constexpr std::uint64_t per_capita(std::uint64_t living) const noexcept { return living == 0 ? 0 : environment_energy / living; } // Who breeds when there are fewer free slots than eligible parents is part of // the rule, not a consequence of how either run happens to iterate: allocating // contested slots in different orders changes which parents reproduce // independently of any averaging, and that divergence is not a resolution // effect. Oldest first, which both resolutions can honour because classes // partition ages. Ordering inside a class is the one thing only the individual // run can see, and that one is a resolution effect. }; // Thrown rather than asserted, because this header is shared by a test and a // benchmark and neither owns the other's harness. It guards arithmetic that would // otherwise become silently order-dependent. struct ModelViolation { const char* what; }; inline void insist(bool condition, const char* what) { if (!condition) { throw ModelViolation{what}; } } // Matter behaves identically in all four channels here, so one number is tracked // and mirrored into the four. Stated rather than left for a reader to infer. [[nodiscard]] inline Inventory spread(std::uint64_t energy, std::uint64_t matter) { return {{energy}, {Femtograms{matter}, Femtograms{matter}, Femtograms{matter}, Femtograms{matter}}}; } struct Census { std::uint64_t living{}; std::uint64_t energy{}; std::uint64_t matter{}; std::uint64_t births{}; std::uint64_t deaths{}; auto operator<=>(const Census&) const = default; }; // --------------------------------------------------------------------------- // Individual resolution. Inventory is tracked as plain values and conservation is // asserted arithmetically: this is the reference fixture, not a contract, and a // ledger reservoir per member would exceed the per-transaction leg bound. // --------------------------------------------------------------------------- struct Member { std::uint64_t age{}; std::uint64_t energy{}; std::uint64_t matter{}; bool alive{true}; }; struct IndividualRun { Rule rule{}; std::vector members; std::uint64_t environment{}; std::uint64_t matter_store{}; std::uint64_t detritus_energy{}; std::uint64_t detritus_matter{}; std::uint64_t births{}; std::uint64_t deaths{}; [[nodiscard]] Census census() const { Census now; for (const auto& member : members) { if (!member.alive) { continue; } ++now.living; now.energy += member.energy; now.matter += member.matter; } now.births = births; now.deaths = deaths; return now; } [[nodiscard]] std::uint64_t total_energy() const { std::uint64_t total = environment + detritus_energy; for (const auto& member : members) { if (member.alive) { total += member.energy; } } return total; } [[nodiscard]] std::uint64_t total_matter() const { std::uint64_t total = matter_store + detritus_matter; for (const auto& member : members) { if (member.alive) { total += member.matter; } } return total; } // What the representation costs to hold. Reported as the state footprint rather // than as process memory, because that is deterministic and comparable across // platforms; it is not a claim about an allocator or about resident size. [[nodiscard]] std::uint64_t footprint_bytes() const { return static_cast(members.size() * sizeof(Member)); } [[nodiscard]] std::uint64_t rows() const { return static_cast(members.size()); } void step() { std::uint64_t living = 0; for (const auto& member : members) { living += member.alive ? 1 : 0; } const auto share = rule.per_capita(living); // Starvation, then upkeep, then intake, then ageing, then breeding. The // aggregate run applies the same five stages in the same order. for (auto& member : members) { if (!member.alive) { continue; } if (rule.starves(member.energy)) { member.alive = false; detritus_energy += member.energy; detritus_matter += member.matter; member.energy = 0; member.matter = 0; ++deaths; } } for (auto& member : members) { if (!member.alive) { continue; } member.energy -= rule.upkeep_energy; detritus_energy += rule.upkeep_energy; const auto paid = std::min(member.matter, rule.upkeep_matter); member.matter -= paid; detritus_matter += paid; } for (auto& member : members) { if (!member.alive) { continue; } // Bounded by what is there so the arithmetic is safe, but the fixture is // sized so it never binds: a shared store that ran out would make intake // depend on the order members are visited in, and a divergence caused by // that would look like one caused by resolution. Checked, not assumed. insist(environment >= share, "environment depleted"); insist(matter_store >= rule.matter_intake, "matter store depleted"); environment -= share; member.energy += share; matter_store -= rule.matter_intake; member.matter += rule.matter_intake; } for (auto& member : members) { if (!member.alive) { continue; } ++member.age; if (member.age >= rule.lifespan) { member.alive = false; detritus_energy += member.energy; detritus_matter += member.matter; member.energy = 0; member.matter = 0; ++deaths; } } std::uint64_t population = 0; for (const auto& member : members) { population += member.alive ? 1 : 0; } // Oldest first, as the rule requires, with the index breaking ties so the // order is total. Insertion order would have allocated contested slots to // different parents than the aggregate run does, which would have shown up // in the comparison as if resolution had caused it. std::vector eligible; for (std::size_t index = 0; index < members.size(); ++index) { const auto& member = members[index]; if (!member.alive || !rule.breeds(member.age, member.energy)) { continue; } if (member.matter < rule.investment_matter) { continue; } eligible.push_back(index); } std::ranges::sort(eligible, [&](std::size_t left, std::size_t right) { if (members[left].age != members[right].age) { return members[left].age > members[right].age; } return left < right; }); for (const auto index : eligible) { if (population >= rule.capacity) { break; } auto& member = members[index]; member.energy -= rule.investment_energy; member.matter -= rule.investment_matter; members.push_back({0, rule.investment_energy, rule.investment_matter, true}); ++population; ++births; } } }; [[nodiscard]] inline IndividualRun founding_individuals(std::uint64_t count, Rule rule = {}) { IndividualRun run; run.rule = rule; // Deliberately spread: variation is what averaging destroys, so a fixture where // everyone is identical would measure nothing. for (std::uint64_t index = 0; index < count; ++index) { run.members.push_back({index % 60, 20 + index, 50 + index, true}); } run.environment = 100'000'000; run.matter_store = 100'000'000; return run; } // Ages ascend with the index, so the oldest member is the last inserted and the // youngest class the first stored. Oldest-first therefore disagrees with both orders // this fixture could have drifted into, which is what lets a control see either. [[nodiscard]] inline IndividualRun founding_contested(std::uint64_t count, std::uint64_t capacity) { IndividualRun run; run.rule.capacity = capacity; for (std::uint64_t index = 0; index < count; ++index) { run.members.push_back({run.rule.maturity + index, 100 + index, 60 + index, true}); } run.environment = 100'000'000; run.matter_store = 100'000'000; return run; } // --------------------------------------------------------------------------- // Aggregate resolution. The class state is advanced by the same five stages applied // to a class average. // --------------------------------------------------------------------------- struct AggregateClass { std::uint64_t age_low{}; std::uint64_t age_high{}; std::uint64_t count{}; std::uint64_t energy{}; // held by the class in total std::uint64_t matter{}; }; struct AggregateRun { Rule rule{}; std::vector classes; std::uint64_t width{}; std::uint64_t environment{}; std::uint64_t matter_store{}; std::uint64_t detritus_energy{}; std::uint64_t detritus_matter{}; std::uint64_t births{}; std::uint64_t deaths{}; [[nodiscard]] Census census() const { Census now; for (const auto& age : classes) { now.living += age.count; now.energy += age.energy; now.matter += age.matter; } now.births = births; now.deaths = deaths; return now; } [[nodiscard]] std::uint64_t total_energy() const { std::uint64_t total = environment + detritus_energy; for (const auto& age : classes) { total += age.energy; } return total; } [[nodiscard]] std::uint64_t total_matter() const { std::uint64_t total = matter_store + detritus_matter; for (const auto& age : classes) { total += age.matter; } return total; } [[nodiscard]] std::uint64_t footprint_bytes() const { return static_cast(classes.size() * sizeof(AggregateClass)); } [[nodiscard]] std::uint64_t rows() const { return static_cast(classes.size()); } void step() { std::uint64_t living = 0; for (const auto& age : classes) { living += age.count; } const auto share = rule.per_capita(living); // Starvation, judged on the class average. This is the resolution error: the // average pays for everyone until it cannot, and then the class goes // together, where individuals would have starved one at a time. for (auto& age : classes) { if (age.count == 0) { continue; } if (rule.starves(age.energy / age.count)) { detritus_energy += age.energy; detritus_matter += age.matter; deaths += age.count; age.count = 0; age.energy = 0; age.matter = 0; } } std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; }); for (auto& age : classes) { const auto owed = rule.upkeep_energy * age.count; age.energy -= owed; detritus_energy += owed; const auto paid = std::min(age.matter, rule.upkeep_matter * age.count); age.matter -= paid; detritus_matter += paid; } for (auto& age : classes) { const auto wanted = share * age.count; // The same bound, and the same reason for checking it: a shared store // that ran out would make intake depend on the order classes are visited // in, which is not a resolution effect. insist(environment >= wanted, "environment depleted"); insist(matter_store >= rule.matter_intake * age.count, "matter store depleted"); environment -= wanted; age.energy += wanted; matter_store -= rule.matter_intake * age.count; age.matter += rule.matter_intake * age.count; } // Ageing shifts the class bounds rather than moving members between classes, // so no member has to be placed by an age the record cannot know. A class is // a birth cohort and stays one. for (auto& age : classes) { ++age.age_low; ++age.age_high; } for (auto& age : classes) { if (age.age_low >= rule.lifespan) { detritus_energy += age.energy; detritus_matter += age.matter; deaths += age.count; age.count = 0; age.energy = 0; age.matter = 0; } } std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; }); std::uint64_t population = 0; for (const auto& age : classes) { population += age.count; } std::uint64_t newborns = 0; std::uint64_t taken_energy = 0; std::uint64_t taken_matter = 0; // Oldest class first, which is the same allocation rule the individual run // follows. The classes are held youngest-first, so this walks them in reverse // rather than relying on the storage order. for (auto& age : std::ranges::reverse_view(classes)) { if (age.count == 0 || population + newborns >= rule.capacity) { continue; } const auto average_energy = age.energy / age.count; const auto average_matter = age.matter / age.count; if (!rule.breeds(age.age_low, average_energy)) { continue; } if (average_matter < rule.investment_matter) { continue; } auto breeding = age.count; if (population + newborns + breeding > rule.capacity) { breeding = rule.capacity - population - newborns; } const auto energy_moved = rule.investment_energy * breeding; const auto matter_moved = rule.investment_matter * breeding; if (energy_moved > age.energy || matter_moved > age.matter) { continue; } age.energy -= energy_moved; age.matter -= matter_moved; taken_energy += energy_moved; taken_matter += matter_moved; newborns += breeding; } if (newborns > 0) { // Ageing shifted every class up by one, so nothing now starts at zero. // The youngest class is extended down to cover the newborns while it is // still narrower than the declared width, and otherwise a new one opens. // That keeps the classes contiguous, ascending and never wider than the // width, which is what makes the state a representable cohort: bounds // that merely shifted would overlap the moment a class was opened part // way through an interval. const auto at = std::ranges::min_element( classes, {}, [](const AggregateClass& age) { return age.age_low; }); if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) { at->age_low = 0; at->count += newborns; at->energy += taken_energy; at->matter += taken_matter; } else { classes.push_back({0, 1, newborns, taken_energy, taken_matter}); } births += newborns; } else { // A class that opened and then had no births still has to grow to the // declared width rather than staying one tick wide for ever, or the // structure would drift towards one class per tick. const auto at = std::ranges::min_element( classes, {}, [](const AggregateClass& age) { return age.age_low; }); if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) { at->age_low = 0; } } std::ranges::sort(classes, {}, [](const AggregateClass& age) { return age.age_low; }); } }; [[nodiscard]] inline AggregateRun founding_classes(const IndividualRun& source, std::uint64_t width) { AggregateRun run; run.rule = source.rule; run.width = width; run.environment = source.environment; run.matter_store = source.matter_store; for (const auto& member : source.members) { if (!member.alive) { continue; } const auto low = member.age / width * width; const auto at = std::ranges::find_if( run.classes, [&](const AggregateClass& age) { return age.age_low == low; }); if (at == run.classes.end()) { run.classes.push_back({low, low + width, 1, member.energy, member.matter}); } else { ++at->count; at->energy += member.energy; at->matter += member.matter; } } std::ranges::sort(run.classes, {}, [](const AggregateClass& age) { return age.age_low; }); insist(run.classes.size() <= max_age_classes, "too many founding classes"); return run; } // Whether the aggregate state is something a cohort record can actually hold. The // experiment is worthless if it measures a model the library could not represent, // so this is checked at every step rather than assumed. [[nodiscard]] inline bool representable(const AggregateRun& run) { if (run.classes.empty()) { return true; // Vacancy is representable; ADR-0036 has a factory for it. } CohortDraft probe; probe.representation_version = cohort_representation_version; probe.habitat = {7}; probe.genome = 3; probe.owner = {11, 1}; probe.last_tick = Tick{0}; probe.revision = 1; probe.conversion = 1; probe.reservoir = {1}; for (const auto& age : run.classes) { probe.classes.push_back( {age.age_low, age.age_high, age.count, spread(age.energy, age.matter), 0}); } return Cohort::create(std::move(probe)).has_value(); } // Every living member as (age, energy, matter), sorted. Comparing censuses is not // enough to establish that the two runs allocate contested breeding slots to the // same parents: whoever breeds hands the same investment to a child either way, so // the totals agree while the distribution does not, and the disagreement only // reaches a census many ticks later. using Portrait = std::vector>; [[nodiscard]] inline Portrait portrait(const IndividualRun& run) { Portrait rows; for (const auto& member : run.members) { if (member.alive) { rows.push_back({member.age, member.energy, member.matter}); } } std::ranges::sort(rows); return rows; } // Only meaningful at width one, where a class holds members of a single age. A class // may still hold several of them, because several can be born in one tick, so each // is expanded into its equal share; the division has to be exact or the expansion // would not be the distribution it claims to be, and that is checked. [[nodiscard]] inline Portrait portrait(const AggregateRun& run) { Portrait rows; for (const auto& age : run.classes) { insist(age.count > 0, "empty class in a portrait"); insist(age.energy % age.count == 0, "class energy does not divide"); insist(age.matter % age.count == 0, "class matter does not divide"); for (std::uint64_t index = 0; index < age.count; ++index) { rows.push_back({age.age_low, age.energy / age.count, age.matter / age.count}); } } std::ranges::sort(rows); return rows; } // One run of the comparison at a declared class width: what each resolution ended // with, and what the aggregate one cost to hold. struct Comparison { std::uint64_t width{}; std::uint64_t ticks{}; std::uint64_t individual_living{}; std::uint64_t aggregate_living{}; std::uint64_t individual_energy{}; std::uint64_t aggregate_energy{}; std::uint64_t individual_rows{}; std::uint64_t aggregate_rows{}; std::uint64_t individual_bytes{}; std::uint64_t aggregate_bytes{}; std::uint64_t living_gap_per_thousand{}; std::uint64_t energy_gap_per_thousand{}; bool aggregate_survived{}; }; [[nodiscard]] inline std::uint64_t gap_per_thousand(std::uint64_t left, std::uint64_t right) { const auto high = std::max(left, right); const auto low = std::min(left, right); if (high == 0) { return 0; } return (high - low) * 1000 / high; } // Runs both resolutions over the same horizon and reports what each ended with. // Conservation is checked on both sides at every tick, and the aggregate state is // checked to be a representable cohort at every tick, so the result describes this // library rather than a model it could not hold. [[nodiscard]] inline Comparison compare(std::uint64_t founders, std::uint64_t width, std::uint64_t ticks, Rule rule = {}) { auto individual = founding_individuals(founders, rule); auto aggregate = founding_classes(individual, width); const auto opening_energy = individual.total_energy(); const auto opening_matter = individual.total_matter(); insist(aggregate.total_energy() == opening_energy, "opening energy differs"); insist(aggregate.total_matter() == opening_matter, "opening matter differs"); for (std::uint64_t tick = 0; tick < ticks; ++tick) { individual.step(); aggregate.step(); insist(individual.total_energy() == opening_energy, "individual energy not conserved"); insist(individual.total_matter() == opening_matter, "individual matter not conserved"); insist(aggregate.total_energy() == opening_energy, "aggregate energy not conserved"); insist(aggregate.total_matter() == opening_matter, "aggregate matter not conserved"); insist(aggregate.classes.size() <= max_age_classes, "too many classes"); insist(representable(aggregate), "aggregate state is not a representable cohort"); } const auto left = individual.census(); const auto right = aggregate.census(); return {width, ticks, left.living, right.living, left.energy, right.energy, individual.rows(), aggregate.rows(), individual.footprint_bytes(), aggregate.footprint_bytes(), gap_per_thousand(left.living, right.living), gap_per_thousand(left.energy, right.energy), right.living > 0}; } } // namespace evo::fixture