Measure aggregate cost and fidelity across scarcity scenarios

This commit is contained in:
dingo
2026-09-26 09:39:53 -04:00
parent 55a728acd4
commit c237e4da97
15 changed files with 1115 additions and 529 deletions
+160
View File
@@ -0,0 +1,160 @@
#include "../fixtures/resolution_model.hpp"
#include <chrono>
#include <cstdio>
#include <exception>
#include <iostream>
#include <string_view>
namespace {
using namespace evo::fixture;
constexpr std::uint64_t ticks = 10'000;
struct Peaks {
std::size_t rows{};
std::size_t payload{};
std::size_t capacity{};
template <typename T> void observe(const std::vector<T>& values) {
rows = std::max(rows, values.size());
payload = std::max(payload, values.size() * sizeof(T));
capacity = std::max(capacity, values.capacity() * sizeof(T));
}
};
template <typename Run> void observe(Peaks& peak, const Run& run) {
if constexpr (requires { run.members; }) {
peak.observe(run.members);
} else {
peak.observe(run.classes);
}
}
template <typename Run>
void timed(Run run, std::string_view kind, std::uint64_t width, unsigned sample) {
Peaks peak;
observe(peak, run);
const auto start = std::chrono::steady_clock::now();
for (std::uint64_t tick = 0; tick < ticks; ++tick) {
run.step();
observe(peak, run);
}
const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
std::chrono::steady_clock::now() - start)
.count();
const auto result = run.census();
// Sample zero warms up the same workload but is not reported.
if (sample == 0) {
return;
}
std::cout << "{\"kind\":\"timing\",\"tier\":\"" << kind
<< "\",\"supply\":" << run.rule.environment_energy << ",\"width\":" << width
<< ",\"sample\":" << sample << ",\"elapsed_ns\":" << ns
<< ",\"peak_rows\":" << peak.rows << ",\"peak_payload_bytes\":" << peak.payload
<< ",\"peak_capacity_bytes\":" << peak.capacity << ",\"living\":" << result.living
<< ",\"energy\":" << result.energy << ",\"matter_per_channel\":" << result.matter
<< "}\n";
}
bool sensitivity(Rule rule, std::uint64_t width) {
auto individual = founding_individuals(100, rule);
auto aggregate = founding_classes(individual, width);
const auto energy = individual.total_energy();
const auto matter = individual.total_matter();
std::uint64_t max_population_gap = 0;
std::uint64_t max_energy_gap = 0;
std::uint64_t max_matter_gap = 0;
bool false_extinction = false;
for (std::uint64_t tick = 0; tick < ticks; ++tick) {
individual.step();
aggregate.step();
insist(individual.total_energy() == energy && aggregate.total_energy() == energy,
"energy conservation failed");
insist(individual.total_matter() == matter && aggregate.total_matter() == matter,
"matter conservation failed");
insist(representable(aggregate), "unrepresentable aggregate");
const auto a = individual.census();
const auto b = aggregate.census();
max_population_gap = std::max(max_population_gap, gap_per_thousand(a.living, b.living));
max_energy_gap = std::max(max_energy_gap, gap_per_thousand(a.energy, b.energy));
max_matter_gap = std::max(max_matter_gap, gap_per_thousand(a.matter, b.matter));
false_extinction = false_extinction || (a.living > 0 && b.living == 0);
}
const auto a = individual.census();
const auto b = aggregate.census();
const auto population_gap = gap_per_thousand(a.living, b.living);
const auto energy_gap = gap_per_thousand(a.energy, b.energy);
const auto matter_gap = gap_per_thousand(a.matter, b.matter);
const bool passes =
!false_extinction && population_gap <= 100 && energy_gap <= 100 && matter_gap <= 100;
std::cout << "{\"kind\":\"sensitivity\",\"supply\":" << rule.environment_energy
<< ",\"width\":" << width << ",\"individual_living\":" << a.living
<< ",\"aggregate_living\":" << b.living
<< ",\"population_gap_ppt\":" << population_gap
<< ",\"energy_gap_ppt\":" << energy_gap << ",\"matter_gap_ppt\":" << matter_gap
<< ",\"max_population_gap_ppt\":" << max_population_gap
<< ",\"max_energy_gap_ppt\":" << max_energy_gap
<< ",\"max_matter_gap_ppt\":" << max_matter_gap
<< ",\"false_extinction\":" << (false_extinction ? "true" : "false")
<< ",\"research_gate_pass\":" << (passes ? "true" : "false") << "}\n";
return passes;
}
} // namespace
int main(int argc, char** argv) try {
if (argc > 2 || (argc == 2 && std::string_view{argv[1]} != "--verify")) {
std::cerr << "usage: evo-resolution-benchmark [--verify]\n";
return 2;
}
const bool verify = argc == 2;
std::cout
<< "{\"kind\":\"metadata\",\"model\":\"resolution-fixture-2\",\"founders\":100,"
"\"ticks\":10000,\"randomness\":\"none\",\"warmups\":1,\"samples\":3,\"compiler\":\""
#if defined(__clang__)
<< "Clang " << __clang_version__
#elif defined(_MSC_VER)
<< "MSVC " << _MSC_VER
#else
<< "GCC " << __VERSION__
#endif
<< "\",\"build\":\""
#if defined(NDEBUG)
<< "release"
#else
<< "debug"
#endif
<< "\"}\n";
for (const auto width : {10U, 25U, 50U, 100U, 200U}) {
bool all_pass = true;
for (const auto supply : {240U, 300U, 360U}) {
Rule rule;
rule.environment_energy = supply;
all_pass = sensitivity(rule, width) && all_pass;
if (!verify) {
for (unsigned sample = 0; sample <= 3; ++sample) {
auto individual = founding_individuals(100, rule);
auto aggregate = founding_classes(individual, width);
// Alternate order to reduce systematic first-run bias.
if (sample % 2 == 0) {
timed(individual, "individual", width, sample);
timed(aggregate, "aggregate", width, sample);
} else {
timed(aggregate, "aggregate", width, sample);
timed(individual, "individual", width, sample);
}
}
}
}
std::cout << "{\"kind\":\"policy\",\"width\":" << width
<< ",\"passes_all_scenarios\":" << (all_pass ? "true" : "false") << "}\n";
}
return 0;
} catch (const ModelViolation& error) {
std::fprintf(stderr, "%s\n", error.what);
return 1;
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
} catch (...) {
std::fputs("unknown benchmark failure\n", stderr);
return 1;
}
+12 -524
View File
@@ -1,5 +1,6 @@
#include "evo/ecology/materialize.hpp"
#include "evo/ecology/population.hpp"
#include "fixtures/resolution_model.hpp"
#include <algorithm>
#include <array>
@@ -23,513 +24,8 @@ void check(bool condition, std::source_location location = std::source_location:
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
// ---------------------------------------------------------------------------
// The rule. Written once, applied at both resolutions: the individual run gives
// it one member at a time and the aggregate run gives it a class average and
// multiplies by the count. It is a fixture constant, not a simulation contract:
// ADR-0038 deliberately declines to choose an ecology, and this does not choose
// one for it. Energy is the only scarce axis so that divergence is attributable.
// ---------------------------------------------------------------------------
namespace rule {
constexpr std::uint64_t environment_energy = 300; // per tick, shared by the living
constexpr std::uint64_t matter_intake = 4; // per member per tick, abundant
constexpr std::uint64_t upkeep_energy = 2;
constexpr std::uint64_t upkeep_matter = 1;
constexpr std::uint64_t lifespan = 400;
constexpr std::uint64_t maturity = 50;
constexpr std::uint64_t threshold_energy = 100;
constexpr std::uint64_t investment_energy = 40;
constexpr std::uint64_t investment_matter = 40;
constexpr 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 the resolution bites.
[[nodiscard]] constexpr bool starves(std::uint64_t energy) noexcept {
return energy < upkeep_energy;
}
[[nodiscard]] constexpr bool breeds(std::uint64_t age, std::uint64_t energy) noexcept {
return age >= maturity && energy >= threshold_energy;
}
[[nodiscard]] constexpr std::uint64_t per_capita(std::uint64_t living) noexcept {
return living == 0 ? 0 : environment_energy / living;
}
// Who breeds when there are fewer free slots than eligible parents. This has to be
// part of the rule rather than a consequence of how each run happens to iterate:
// allocating contested slots in different orders changes which parents reproduce
// independently of any averaging, and a divergence caused by that is not a
// divergence caused by resolution. Oldest first, which both resolutions can honour:
// classes partition ages, so the oldest class holds the oldest members. Ordering
// within a class is the one thing only the individual run can see, and that is a
// resolution effect rather than an implementation difference.
} // namespace rule
// 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.
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
// reservoir per member would exceed the ledger's per-transaction leg bound.
// ---------------------------------------------------------------------------
struct Member {
std::uint64_t age{};
std::uint64_t energy{};
std::uint64_t matter{};
bool alive{true};
};
struct IndividualRun {
std::vector<Member> members;
std::uint64_t environment{};
std::uint64_t detritus_energy{};
std::uint64_t detritus_matter{};
std::uint64_t matter_store{};
std::uint64_t births{};
std::uint64_t deaths{};
std::uint64_t capacity{rule::capacity};
[[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;
}
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 first, 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 that it never binds: if it ever did, intake would depend
// on the order members are visited in, and a divergence caused by that
// would look like a divergence caused by resolution. Checked rather
// than assumed, on both sides.
check(environment >= share);
check(matter_store >= rule::matter_intake);
const auto taken = std::min(share, environment);
environment -= taken;
member.energy += taken;
const auto gathered = std::min(rule::matter_intake, matter_store);
matter_store -= gathered;
member.matter += gathered;
}
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<std::size_t> 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 >= 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;
}
}
};
IndividualRun founding_individuals(std::uint64_t count) {
IndividualRun run;
// 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;
}
// ---------------------------------------------------------------------------
// Aggregate resolution. Real cohort records, real ledger, real conversions. 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 {
std::vector<AggregateClass> 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{};
std::uint64_t capacity{rule::capacity};
[[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;
}
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.
check(environment >= wanted);
check(matter_store >= rule::matter_intake * age.count);
const auto taken = std::min(wanted, environment);
environment -= taken;
age.energy += taken;
const auto gathered = std::min(rule::matter_intake * age.count, matter_store);
matter_store -= gathered;
age.matter += gathered;
}
// Ageing shifts the class bounds rather than moving members between
// classes, so no member ever 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 >= 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 > capacity) {
breeding = 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 shift 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; });
}
};
AggregateRun founding_classes(const IndividualRun& source, std::uint64_t width) {
AggregateRun run;
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; });
check(run.classes.size() <= max_age_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]] 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. The control therefore compares distributions.
using Portrait = std::vector<std::array<std::uint64_t, 3>>;
[[nodiscard]] 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
// rather than assumed.
[[nodiscard]] Portrait portrait(const AggregateRun& run) {
Portrait rows;
for (const auto& age : run.classes) {
check(age.count > 0);
check(age.energy % age.count == 0);
check(age.matter % age.count == 0);
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;
}
// Ages ascend with the index, so the oldest member is the last inserted and the
// youngest class is the first stored. Oldest-first therefore disagrees with both of
// the orders this fixture could have drifted into: allocating in insertion order
// would pick the first member, and walking the classes as stored would pick the
// youngest class. Each of those, introduced alone, makes the two runs choose
// different parents, which is what the control has to be able to see.
IndividualRun founding_contested(std::uint64_t count, std::uint64_t capacity) {
IndividualRun run;
for (std::uint64_t index = 0; index < count; ++index) {
run.members.push_back({rule::maturity + index, 100 + index, 60 + index, true});
}
run.environment = 100'000'000;
run.matter_store = 100'000'000;
run.capacity = capacity;
return run;
}
using namespace evo::fixture;
constexpr Rule rule{};
// ---------------------------------------------------------------------------
// The instrument check. With one member per class a class average is that member,
@@ -575,7 +71,7 @@ void contested_breeding_slots_go_to_the_same_parents() {
constexpr std::uint64_t count = 12;
auto individual = founding_contested(count, count + 1);
auto aggregate = founding_classes(individual, 1);
aggregate.capacity = individual.capacity;
CHECK(aggregate.rule.capacity == individual.rule.capacity);
CHECK(aggregate.classes.size() == count);
CHECK(portrait(individual) == portrait(aggregate));
bool contested = false;
@@ -589,12 +85,13 @@ void contested_breeding_slots_go_to_the_same_parents() {
continue;
}
++living;
if (rule::breeds(member.age + 1, member.energy) &&
member.matter >= rule::investment_matter) {
if (rule.breeds(member.age + 1, member.energy) &&
member.matter >= rule.investment_matter) {
++eligible;
}
}
const auto free_slots = individual.capacity > living ? individual.capacity - living : 0;
const auto free_slots =
individual.rule.capacity > living ? individual.rule.capacity - living : 0;
if (eligible > free_slots && free_slots > 0) {
contested = true;
}
@@ -610,7 +107,7 @@ void contested_breeding_slots_go_to_the_same_parents() {
// allocation and is just the first control again with fewer members.
CHECK(contested);
CHECK(individual.census().births > 0);
CHECK(individual.census().living == individual.capacity);
CHECK(individual.census().living == individual.rule.capacity);
}
// ---------------------------------------------------------------------------
@@ -626,15 +123,6 @@ struct Divergence {
std::uint64_t energy_gap_per_thousand{};
};
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;
}
Divergence measure(std::uint64_t width, std::uint64_t ticks) {
auto individual = founding_individuals(100);
auto aggregate = founding_classes(individual, width);
@@ -754,7 +242,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
// Sized for the capacity rather than the founders: the population grows, and a
// draw of more members than there were founders would otherwise run off the
// end of the ledger and be reported as a stale plan.
std::vector<Inventory> opening(first_member_store + rule::capacity);
std::vector<Inventory> opening(first_member_store + rule.capacity);
opening[escrow.value - 1] = spread(individual.environment, individual.matter_store);
std::vector<ActiveMember> members;
for (std::size_t index = 0; index < individual.members.size(); ++index) {
@@ -776,7 +264,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
gather.tick = Tick{0};
gather.revision = 1;
gather.destination = backing;
for (std::uint64_t low = 0; low < rule::lifespan; low += 50) {
for (std::uint64_t low = 0; low < rule.lifespan; low += 50) {
gather.bounds.push_back({low, low + 50});
}
const auto folded = plan_collapse(members, gather);
@@ -848,7 +336,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
std::uint64_t drawn = 0;
for (std::size_t index = 0; index < cohort.classes().size(); ++index) {
const auto count = cohort.classes()[index].count;
if (count == 0 || drawn + count > rule::capacity) {
if (count == 0 || drawn + count > rule.capacity) {
continue;
}
draws.push_back({index, count});
+617
View File
@@ -0,0 +1,617 @@
#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 <algorithm>
#include <array>
#include <cstdint>
#include <ranges>
#include <vector>
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<Member> 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<std::uint64_t>(members.size() * sizeof(Member));
}
[[nodiscard]] std::uint64_t rows() const {
return static_cast<std::uint64_t>(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<std::size_t> 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<AggregateClass> 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<std::uint64_t>(classes.size() * sizeof(AggregateClass));
}
[[nodiscard]] std::uint64_t rows() const {
return static_cast<std::uint64_t>(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<std::array<std::uint64_t, 3>>;
[[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