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>
189 lines
7.4 KiB
C++
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
|