Files
aevolution/tests/cellular_inheritance_tests.cpp
dingo a898a35e1b
Foundation / checks (ecs) (push) Successful in 2m26s
Foundation / checks (deploy) (push) Successful in 4m57s
Foundation / checks (network) (push) Successful in 20m53s
Foundation / checks (client) (push) Successful in 22m12s
Foundation / checks (tsan) (push) Successful in 39m45s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 45m41s
Foundation / checks (checks) (push) Canceled after 45m43s
feat(lifecycle): preserve inherited plans in exact populations
2026-10-19 15:19:43 -04:00

346 lines
17 KiB
C++

#include "evo/server/lifecycle/cellular_census.hpp"
#include "evo/server/lifecycle/cellular_migration.hpp"
#include "fixtures/cellular_ecology.hpp"
#include <fstream>
#include <iterator>
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::fixture;
std::vector<CellularLifeIntent> idle(const CellularLives& state, bool frozen = false,
bool bud = false, bool moving = false) {
std::vector<CellularLifeIntent> result;
for (const auto& life : state.lives()) {
CellularLifeIntent input{life.identity.life, {}};
if (life.account != LifeAccount{}) {
input.intent.frozen = frozen;
input.intent.bud = bud && !frozen;
if (moving && !frozen)
input.intent.movement = {1000, 0};
}
result.push_back(input);
}
return result;
}
const CellularOwnedLife& parent(const CellularLives& state) {
const auto life =
std::ranges::find(state.lives(), 100, [](const auto& cell) { return cell.identity.life; });
require(life != state.lives().end(), "inheritance parent missing");
return *life;
}
void closed(const CellularLives& state) {
require(state.current_total() == state.opening_total(), "inheritance stock did not close");
}
Owner initial() {
auto old = opening(7, true, 1);
require(!old->inheritance_upgrade_candidate(), "inheritance skipped prior versions");
old = checked(old->migration_upgrade_candidate(), "boundary upgrade");
require(!old->inheritance_upgrade_candidate(), "inheritance skipped maturation");
old = checked(old->maturation_upgrade_candidate(), "maturation upgrade");
const auto original = old->snapshot();
auto state = checked(old->inheritance_upgrade_candidate(), "inheritance upgrade");
require(old->snapshot() == original && state->tick() == old->tick() &&
state->archive().encode() == old->archive().encode() &&
state->current_total() == old->current_total() &&
parent(*state).identity == parent(*old).identity &&
parent(*state).body == parent(*old).body &&
parent(*state).reserve == parent(*old).reserve &&
parent(*state).offspring_genome == parent(*old).identity.genome &&
state->offspring_revisions().empty(),
"upgrade changed biology");
require(state->format_version() == 8 && state->rules_version() == 10 &&
!state->inheritance_upgrade_candidate(),
"inheritance version boundary");
require(restore(*state)->snapshot() == state->snapshot(), "initial inheritance restore");
return state;
}
void choose_structure(Owner& state, std::uint64_t successor) {
for (unsigned tick = 0; tick < 60'000; ++tick) {
const auto before = parent(*state);
if (before.mutation.offer) {
const auto offer = *before.mutation.offer;
const auto found = std::ranges::find_if(offer.candidates, [](const auto& candidate) {
return candidate.target == biology::Capability::membrane ||
candidate.target == biology::Capability::target_size;
});
const bool selected = found != offer.candidates.end();
const CellularMutationSelection selection{
100, before.mutation.event_index, before.mutation.offer_tick, successor,
selected ? found->operator_id : std::uint16_t{0}};
// Stale and reused identities cannot spend a tick or consume the offer.
const auto bytes = state->snapshot();
auto stale = selection;
++stale.event_index;
require(!state->advance_tick_with_mutations(idle(*state), std::span{&stale, 1}) &&
state->snapshot() == bytes,
"stale plan selection changed state");
stale = selection;
stale.successor_id = before.identity.genome;
require(!state->advance_tick_with_mutations(idle(*state), std::span{&stale, 1}) &&
state->snapshot() == bytes,
"reused plan identity changed state");
auto control = restore(*state);
checked(control->advance_tick_with_mutations(idle(*control), {}), "unselected control");
const auto result =
checked(state->advance_tick_with_mutations(idle(*state), std::span{&selection, 1}),
"plan selection tick");
require(result.mutations.size() == 1 &&
result.mutations.front().result ==
(selected ? CellularMutationResult::offspring_plan_applied
: CellularMutationResult::declined),
"plan selection outcome");
const auto& cell = parent(*state);
const auto& reference = parent(*control);
require(cell.identity == reference.identity && cell.body == reference.body &&
cell.reserve == reference.reserve && cell.growth == reference.growth &&
cell.position == reference.position && state->heat() == control->heat() &&
state->nursery() == control->nursery() &&
state->habitat().snapshot() == control->habitat().snapshot(),
"offspring selection rebuilt or charged the parent's body");
if (selected) {
const auto& revision = state->offspring_revisions().back();
require(cell.offspring_genome == successor && revision.life == 100 &&
revision.previous == before.offspring_genome &&
revision.successor == successor && revision.tick == state->tick() &&
checked(state->archive().current_genome(100), "expressed archive") ==
before.identity.genome &&
checked(state->archive().living_carriers(successor),
"unborn carriers") == 0,
"offspring plan mistaken for an expressed organism");
require(restore(*state)->snapshot() == state->snapshot(), "selected plan restore");
closed(*state);
return;
}
} else
checked(state->advance_tick_with_mutations(idle(*state), {}), "earned offer tick");
closed(*state);
}
throw std::runtime_error("finite feeding never earned a structural offspring choice");
}
std::uint64_t bud(Owner& state) {
for (unsigned tick = 0; tick < 30'000; ++tick) {
const auto plan = parent(*state).offspring_genome;
const auto result =
checked(state->advance_tick_with_mutations(idle(*state, false, true), {}),
"inherited bud tick");
closed(*state);
for (const auto& outcome : result.buds) {
if (outcome.parent_life != 100 || outcome.result != CellularBudResult::budded)
continue;
const auto child =
std::ranges::find(state->lives(), outcome.bud_life,
[](const auto& life) { return life.identity.life; });
require(child != state->lives().end() && child->identity.genome == plan &&
child->offspring_genome == plan && child->parent_life == 100 &&
child->account == LifeAccount{} &&
std::ranges::none_of(result.growth,
[&](const auto& growth) {
return growth.life_id == child->identity.life;
}),
"newborn plan/body identity or phase");
const auto genome = checked(state->archive().find(plan), "inherited genome");
require(checked(biology::metabolic_budget(genome, child->growth, {293150, {}}),
"inherited body")
.body == child->body,
"child body uses parent genome");
return child->identity.life;
}
}
throw std::runtime_error("finite parent never funded inherited offspring");
}
Owner family() {
auto state = initial();
choose_structure(state, 1'000'000);
bud(state);
return state;
}
void continuation(CellularLives& state) {
bool maintained = false;
const auto plan = parent(state).offspring_genome;
const auto history = state.offspring_revisions().size();
for (unsigned tick = 0; tick < 64; ++tick) {
checked(state.advance_tick_with_mutations(idle(state, true), {}), "inherited continuation");
for (const auto& feedback : state.last_tick_feedback())
if (feedback.life_id != 100)
maintained |= feedback.maintenance_cost.value > 0;
require(parent(state).offspring_genome == plan &&
state.offspring_revisions().size() == history,
"continuation lost retained plan");
closed(state);
}
// Maximal funded birth can already be fully grown; maintenance must still run.
require(maintained, "inherited continuation skipped offspring metabolism");
}
void put(std::vector<std::uint8_t>& bytes, std::size_t at, std::uint64_t value,
unsigned width = 8) {
for (unsigned offset = 0; offset < width; ++offset)
bytes.at(at + offset) = static_cast<std::uint8_t>(value >> (offset * 8U));
}
void reseal(std::vector<std::uint8_t>& bytes) {
std::uint64_t value = 14695981039346656037ULL;
for (const auto byte : std::span{bytes}.first(bytes.size() - 8))
value = (value ^ byte) * 1099511628211ULL;
put(bytes, bytes.size() - 8, value);
}
void codecs_and_siblings() {
auto state = family();
const auto first_child = std::ranges::find_if(
state->lives(), [](const auto& life) { return life.parent_life == 100; });
require(first_child != state->lives().end(), "missing first child");
const auto old_child = first_child->identity;
const auto bytes = state->snapshot();
const auto history = bytes.size() - 8 - state->offspring_revisions().size() * 32;
// One founding site, owner-8 header, then life rows. All corruptions carry a
// valid outer checksum; restore must establish biological/history semantics.
const auto corrupt = [&](std::size_t at, std::uint64_t value, unsigned width = 8) {
auto altered = bytes;
put(altered, at, value, width);
reseal(altered);
require(!CellularLives::restore(altered, state->world(), state->region(), state->frame(),
state->tick()),
"forged inherited checkpoint accepted");
};
corrupt(316 + 8 + 504, 0);
corrupt(316 + 8 + 504, 100);
corrupt(316 + 8 + 504, 999'999);
corrupt(history, old_child.life);
corrupt(history + 8, 999'999);
corrupt(history + 16, 100);
corrupt(history + 24, state->tick() + 1);
corrupt(308, 0xFFFF'FFFFULL, 4);
corrupt(312, 1, 4);
corrupt(12, 9, 4);
auto flipped = bytes;
flipped.at(316) ^= 1;
require(!CellularLives::restore(flipped, state->world(), state->region(), state->frame(),
state->tick()),
"checksum damage accepted");
require(!CellularMigration::prepare(*state, *state, 100),
"unsupported migration adapter admitted plans");
CellularBatch old_trace;
old_trace.header = {state->world(), state->region(), state->frame(), {}, {},
state->tick(), state->tick() + 1};
old_trace.header.predecessor.fill(1);
old_trace.header.predecessor_digest.fill(2);
old_trace.ticks.push_back({idle(*state), {}, {}});
const auto encoded = checked(encode_cellular_batch(old_trace), "encode valid old trace");
const auto decoded = checked(decode_cellular_batch(encoded), "decode valid old trace");
const auto replayed = replay_cellular_batch(*state, decoded);
if (replayed)
throw std::runtime_error("old replay admitted inherited owner");
require(replayed.error() == CellularBatchError::version,
"old replay refused for a reason other than version admission");
choose_structure(state, 1'000'001);
require(state->offspring_revisions().size() == 2 && parent(*state).identity.genome == 100,
"later plan lost earlier history or changed parent");
require(checked(state->archive().organism(old_child.organism), "older child archive").genome ==
old_child.genome,
"later plan rewrote earlier child's birth");
state = restore(*state);
bud(state);
state = restore(*state);
bud(state);
require(parent(*state).offspring_genome == 1'000'001 &&
state->offspring_revisions().size() == 2,
"sibling birth reset selected plan");
const auto frozen = parent(*state);
for (unsigned tick = 0; tick < 250; ++tick)
checked(state->advance_tick_with_mutations(idle(*state, true), {}), "frozen inheritance");
const auto after = parent(*state);
require(after.presence == CellularPresence::suspended && after.body == frozen.body &&
after.reserve == frozen.reserve && after.growth == frozen.growth &&
after.mutation == frozen.mutation &&
after.offspring_genome == frozen.offspring_genome,
"offline parent progressed its plan or biology");
require(restore(*state)->snapshot() == state->snapshot(), "suspended plan restore");
}
void legacy_expression_upgrade() {
auto state = opening(7, true, 1);
state = checked(state->migration_upgrade_candidate(), "legacy boundary upgrade");
state = checked(state->maturation_upgrade_candidate(), "legacy maturation upgrade");
bool expressed = false;
for (unsigned tick = 0; tick < 60'000 && !expressed; ++tick) {
const auto before = parent(*state);
if (!before.mutation.offer) {
checked(state->advance_tick_with_mutations(idle(*state), {}), "legacy earned offer");
continue;
}
const CellularMutationSelection selection{
100, before.mutation.event_index, before.mutation.offer_tick, 900'000,
before.mutation.offer->candidates.front().operator_id};
const auto result =
checked(state->advance_tick_with_mutations(idle(*state), std::span{&selection, 1}),
"legacy expression");
expressed = result.mutations.front().result == CellularMutationResult::applied;
}
require(expressed && parent(*state).identity.genome == 900'000,
"legacy mutation was not expressed");
const auto at = state->archive().revisions().back().at.value;
const auto archive = state->archive().encode();
state = checked(state->inheritance_upgrade_candidate(), "expressed parent upgrade");
require(state->archive().encode() == archive && parent(*state).offspring_genome == 900'000,
"upgrade lost expressed revision");
choose_structure(state, 1'000'000);
auto forged = state->snapshot();
put(forged, forged.size() - 8 - 32 + 24, at);
reseal(forged);
require(!CellularLives::restore(forged, state->world(), state->region(), state->frame(),
state->tick()),
"plan selected before its expressed baseline existed");
}
void death_history() {
auto state = family();
for (unsigned tick = 0; tick < 100'000; ++tick) {
checked(state->advance_tick_with_mutations(idle(*state, false, false, true), {}),
"parent ecological death");
closed(*state);
const auto corpse = std::ranges::find(state->corpses(), 100, &CellularOwnedCorpse::life_id);
if (corpse != state->corpses().end()) {
require(corpse->offspring_genome == 1'000'000 &&
state->offspring_revisions().size() == 1,
"death discarded selected plan history");
require(restore(*state)->snapshot() == state->snapshot(), "dead-plan history restore");
return;
}
}
throw std::runtime_error("finite parent did not die after leaving food");
}
void save(const char* path, std::span<const std::uint8_t> bytes) {
std::ofstream file(path, std::ios::binary | std::ios::trunc);
file.write(reinterpret_cast<const char*>(bytes.data()),
static_cast<std::streamsize>(bytes.size()));
require(file.good(), "inheritance checkpoint write");
}
} // namespace
int main(int argc, char** argv) try {
if (argc == 4 && std::string_view{argv[1]} == "--checkpoint") {
auto state = family();
save(argv[2], state->snapshot());
continuation(*state);
save(argv[3], state->snapshot());
return 0;
}
if (argc == 4 && std::string_view{argv[1]} == "--resume") {
std::ifstream file(argv[2], std::ios::binary);
const std::vector<std::uint8_t> bytes{std::istreambuf_iterator<char>{file}, {}};
require(bytes.size() >= 324, "inheritance checkpoint length");
std::uint64_t tick = 0;
for (unsigned offset = 0; offset < 8; ++offset)
tick |= std::uint64_t{bytes[40 + offset]} << (offset * 8U);
auto state = checked(CellularLives::restore(bytes, 207, 1, 1, tick), "new-process plans");
continuation(*state);
save(argv[3], state->snapshot());
return 0;
}
require(argc == 1, "unknown inheritance arguments");
codecs_and_siblings();
legacy_expression_upgrade();
death_history();
return 0;
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 1;
}