Files
aevolution/src/ecology/cohort.cpp
T
dingoandClaude Opus 5 5a4c34a903 An epoch cannot order two writes an owner makes inside it
Two defects from review of 1c8b292.

Replacement checked the ownership epoch and nothing that ordered two writes made
inside one, so an owner could replay its own earlier record: a cohort installed
at tick 1,000 holding 50 picojoules accepted its own tick-900 record holding 100,
restoring inventory the installed one had already spent. A cohort now carries a
revision that strictly increases within an epoch, and a repeated revision is
refused as well as an older one, because a write has to be strictly later rather
than merely not earlier. A newer epoch may restart the series, since re-acquiring
ownership begins a new one, but the interval boundary is checked independently of
both, so neither advancing a revision nor re-acquiring ownership rewinds
simulated time. A later revision at the same boundary stays legitimate: that is a
correction, not a rewind.

The implicit move emptied a cohort's age classes while keeping its habitat,
genome and owner, so a moved-from record was exactly the invalid cohort create
refuses to build, and the registry accepted through a move what it rejects
through construction. The type is copy-only now, so a move decays to a copy and
the source stays whole. ADR-0030 made the genome copy-only for this same reason
in M3.1; the precedent existed and was not applied when this type was written.

Both fixes were confirmed load-bearing by reverting each alone. Removing either
ordering check fails the new regression. Removing the copy declarations fails to
compile, and not only through the static assertion: with that also removed, MSVC
proves the code after the class-count check unreachable, having established that
a moved-from vector is empty and the check always throws. That is a compile-time
proof rather than an execution, so the runtime path was checked separately under
ASan, where the same mutation exits 1.

Release 34/34, analysis, ASan 34/34 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 09:05:05 -04:00

189 lines
7.4 KiB
C++

#include "evo/ecology/cohort.hpp"
#include <algorithm>
#include <limits>
#include <utility>
namespace evo::ecology {
namespace {
constexpr auto maximum = std::numeric_limits<std::uint64_t>::max();
[[nodiscard]] bool add(std::uint64_t& total, std::uint64_t amount) noexcept {
if (amount > maximum - total) {
return false;
}
total += amount;
return true;
}
// Summed per channel: a total mass is not an additional inventory, so the
// channels are added separately and any one of them may be what overflows.
[[nodiscard]] bool add(accounting::Inventory& total, const accounting::Inventory& amount) noexcept {
if (!add(total.energy.value, amount.energy.value)) {
return false;
}
for (std::size_t channel = 0; channel < total.matter.size(); ++channel) {
if (!add(total.matter[channel].value, amount.matter[channel].value)) {
return false;
}
}
return true;
}
[[nodiscard]] bool empty(const accounting::Inventory& inventory) noexcept {
return inventory == accounting::Inventory{};
}
// What the registry is keyed by, which is also the uniqueness it enforces: one
// record per habitat and genome.
struct Key {
HabitatId habitat;
std::uint64_t genome;
auto operator<=>(const Key&) const = default;
};
[[nodiscard]] Key key_of(const Cohort& cohort) noexcept {
return {cohort.habitat(), cohort.genome()};
}
} // namespace
std::expected<Cohort, CohortError> Cohort::create(CohortDraft draft) {
if (draft.representation_version != cohort_representation_version) {
return std::unexpected{CohortError::unsupported_version};
}
// Every identity a cohort names has to name something. A zero owner or epoch
// would be a record nobody is responsible for integrating.
if (draft.habitat.value == 0 || draft.genome == 0 || draft.owner.worker == 0 ||
draft.owner.epoch == 0 || draft.revision == 0 || draft.conversion == 0) {
return std::unexpected{CohortError::invalid_identity};
}
if (draft.classes.empty()) {
return std::unexpected{CohortError::no_age_classes};
}
if (draft.classes.size() > max_age_classes) {
return std::unexpected{CohortError::overflow};
}
std::uint64_t count = 0;
accounting::Inventory reserve{};
std::uint64_t residual = 0;
for (std::size_t index = 0; index < draft.classes.size(); ++index) {
const auto& age = draft.classes[index];
// Ascending, non-overlapping and non-empty. An empty or overlapping range
// would make a member's class ambiguous or impossible.
if (age.age_high <= age.age_low) {
return std::unexpected{CohortError::unordered_age_classes};
}
if (index > 0 && age.age_low < draft.classes[index - 1].age_high) {
return std::unexpected{CohortError::unordered_age_classes};
}
// A residual is a fraction of one member. At a whole member it is one.
if (age.residual >= residual_scale) {
return std::unexpected{CohortError::residual_out_of_range};
}
// A class with neither members nor a fraction owed is not a class; it is
// a boundary someone declared and left empty.
if (age.count == 0 && age.residual == 0) {
return std::unexpected{CohortError::empty_age_class};
}
// Reserve belongs to members. A class with no members holding inventory
// would be biomass owned by nobody, which no later transfer could settle.
if (age.count == 0 && !empty(age.reserve)) {
return std::unexpected{CohortError::unowned_reserve};
}
if (!add(count, age.count) || !add(reserve, age.reserve) || !add(residual, age.residual)) {
return std::unexpected{CohortError::overflow};
}
}
Cohort cohort;
cohort.version_ = draft.representation_version;
cohort.habitat_ = draft.habitat;
cohort.genome_ = draft.genome;
cohort.owner_ = draft.owner;
cohort.last_tick_ = draft.last_tick;
cohort.revision_ = draft.revision;
cohort.conversion_ = draft.conversion;
cohort.classes_ = std::move(draft.classes);
cohort.bound_ = draft.bound;
return cohort;
}
std::uint64_t Cohort::count() const noexcept {
std::uint64_t total = 0;
for (const auto& age : classes_) {
// Construction proved this cannot overflow, so the sum is exact here.
total += age.count;
}
return total;
}
accounting::Inventory Cohort::reserve() const noexcept {
accounting::Inventory total{};
for (const auto& age : classes_) {
total.energy.value += age.reserve.energy.value;
for (std::size_t channel = 0; channel < total.matter.size(); ++channel) {
total.matter[channel].value += age.reserve.matter[channel].value;
}
}
return total;
}
std::uint64_t Cohort::residual() const noexcept {
std::uint64_t total = 0;
for (const auto& age : classes_) {
total += age.residual;
}
return total;
}
std::expected<void, CohortError> CohortRegistry::install(const Cohort& cohort) {
const auto wanted = key_of(cohort);
const auto at = std::ranges::lower_bound(cohorts_, wanted, {}, key_of);
if (at != cohorts_.end() && key_of(*at) == wanted) {
return std::unexpected{CohortError::duplicate_cohort};
}
if (cohorts_.size() >= max_cohorts) {
return std::unexpected{CohortError::registry_full};
}
cohorts_.insert(at, cohort);
return {};
}
std::expected<void, CohortError> CohortRegistry::replace(const Cohort& cohort) {
const auto wanted = key_of(cohort);
const auto at = std::ranges::lower_bound(cohorts_, wanted, {}, key_of);
// Habitat and genome are the record's membership, so a replacement changing
// either is not a newer view of this cohort; it names one that is not here.
if (at == cohorts_.end() || key_of(*at) != wanted) {
return std::unexpected{CohortError::unknown_cohort};
}
if (cohort.owner().worker != at->owner().worker) {
return std::unexpected{CohortError::wrong_owner};
}
if (cohort.owner().epoch < at->owner().epoch) {
return std::unexpected{CohortError::stale_epoch};
}
// Within one epoch the revision is what orders two writes. Without it an
// owner could replay its own earlier record and restore inventory the
// installed one had already spent, because the epoch alone cannot tell the
// two apart. A newer epoch may restart the series, since re-acquiring
// ownership begins a new one.
if (cohort.owner().epoch == at->owner().epoch && cohort.revision() <= at->revision()) {
return std::unexpected{CohortError::stale_revision};
}
// Simulated time does not run backwards, whatever the epoch. This holds even
// where a new epoch restarts the revision series, so re-acquiring ownership
// is not a way to rewind the record.
if (cohort.last_tick() < at->last_tick()) {
return std::unexpected{CohortError::backward_tick};
}
*at = cohort;
return {};
}
std::expected<Cohort, CohortError> CohortRegistry::find(HabitatId habitat,
std::uint64_t genome) const {
const Key wanted{habitat, genome};
const auto at = std::ranges::lower_bound(cohorts_, wanted, {}, key_of);
if (at == cohorts_.end() || key_of(*at) != wanted) {
return std::unexpected{CohortError::unknown_cohort};
}
return *at;
}
} // namespace evo::ecology