#include "evo/server/lifecycle/cellular_migration_trace.hpp" #include #include namespace evo::server { namespace { constexpr std::array magic{'A', 'E', 'V', 'M', 'I', 'G', '0', '1'}; constexpr std::array maturing_magic{'A', 'E', 'V', 'M', 'I', 'G', '0', '2'}; template bool zero(const T& bytes) { return std::ranges::all_of(bytes, [](auto byte) { return byte == 0; }); } bool valid_request(const CellularMigrationRequest& request) { const auto& s = request.source; const auto& d = request.destination; if (zero(request.request) || request.genome == 0 || s.region == 0 || d.region == 0 || s.region > cellular_bud_max_region || d.region > cellular_bud_max_region || s.region == d.region || zero(s.predecessor_digest) || zero(d.predecessor_digest)) return false; auto ids = std::array{s.predecessor, d.predecessor, s.commit, d.commit}; if (std::ranges::any_of(ids, [](const auto& id) { return zero(id); })) return false; std::ranges::sort(ids); return std::ranges::adjacent_find(ids) == ids.end(); } bool shape(const CellularMigrationTrace& trace) { if ((trace.format_version != 1 && trace.format_version != 2) || (trace.representation != CellularMigrationRepresentation::individual && trace.representation != CellularMigrationRepresentation::population) || trace.world == 0 || trace.frame == 0 || trace.tick == 0 || !valid_request(trace.request) || trace.transferred == accounting::Inventory{} || trace.members.empty() || trace.members.size() > biology::max_cellular_tick_lives || !std::ranges::is_sorted(trace.members) || std::ranges::adjacent_find(trace.members) != trace.members.end()) return false; return std::ranges::all_of(trace.members, [](auto id) { return id >= cellular_bud_namespace && ((id >> 32U) & cellular_bud_max_region) != 0 && (id & 0xFFFF'FFFFULL) != 0; }); } const CellularLives* state(const CellularLives& owner) { return &owner; } const CellularLives* state(const CellularPopulation& owner) { return &owner.state(); } template std::expected record(const Owner& source, const Owner& destination, const CellularMigrationRequest& request, CellularMigrationRepresentation representation) { if (!valid_request(request) || request.source.region != state(source)->region() || request.destination.region != state(destination)->region()) return std::unexpected(CellularMigrationError::identity); auto execution = CellularMigration::prepare(source, destination, request.genome); if (!execution) return std::unexpected(execution.error()); CellularMigrationTrace trace{ representation, state(source)->world(), state(source)->frame(), state(source)->tick(), request, execution->transferred, execution->members}; trace.format_version = state(source)->rules_version() == cellular_lives_maturation_rules ? 2 : 1; if (!shape(trace)) return std::unexpected(CellularMigrationError::format); return Recorded{std::move(trace), std::move(*execution)}; } template auto replay(const Owner& source, const Owner& destination, const CellularMigrationRequest& trusted, const CellularMigrationTrace& trace, CellularMigrationRepresentation representation) -> decltype(CellularMigration::prepare(source, destination, trusted.genome)) { if (!shape(trace)) return std::unexpected(CellularMigrationError::format); const auto version = state(source)->rules_version() == cellular_lives_maturation_rules ? 2U : 1U; if (trace.format_version != version) return std::unexpected(CellularMigrationError::version); if (trace.request != trusted || trace.representation != representation || trace.world != state(source)->world() || trace.frame != state(source)->frame() || trace.tick != state(source)->tick() || trusted.source.region != state(source)->region() || trusted.destination.region != state(destination)->region()) return std::unexpected(CellularMigrationError::identity); auto execution = CellularMigration::prepare(source, destination, trusted.genome); if (!execution) return std::unexpected(execution.error()); if (execution->members != trace.members) return std::unexpected(CellularMigrationError::identity); if (execution->transferred != trace.transferred) return std::unexpected(CellularMigrationError::conservation); return execution; } std::uint64_t checksum(std::span bytes) { std::uint64_t value = 14695981039346656037ULL; for (const auto byte : bytes) value = (value ^ byte) * 1099511628211ULL; return value; } void put(std::vector& out, std::uint64_t value, unsigned width = 8) { for (unsigned i = 0; i < width; ++i) out.push_back(static_cast(value >> (8U * i))); } template void append(std::vector& out, const T& bytes) { out.insert(out.end(), bytes.begin(), bytes.end()); } class Reader { public: explicit Reader(std::span bytes) : bytes_(bytes) {} std::uint64_t get(unsigned width = 8) { std::uint64_t value = 0; for (unsigned i = 0; i < width; ++i) value |= std::uint64_t{bytes_[at_++]} << (8U * i); return value; } template std::array array() { std::array result{}; for (auto& byte : result) byte = static_cast(get(1)); return result; } private: std::span bytes_; std::size_t at_{}; }; } // namespace std::expected prepare_migration_trace(const CellularLives& source, const CellularLives& destination, const CellularMigrationRequest& request) { return record(source, destination, request, CellularMigrationRepresentation::individual); } std::expected prepare_migration_trace(const CellularPopulation& source, const CellularPopulation& destination, const CellularMigrationRequest& request) { return record(source, destination, request, CellularMigrationRepresentation::population); } std::expected replay_migration_trace(const CellularLives& source, const CellularLives& destination, const CellularMigrationRequest& trusted, const CellularMigrationTrace& trace) { return replay(source, destination, trusted, trace, CellularMigrationRepresentation::individual); } std::expected replay_migration_trace(const CellularPopulation& source, const CellularPopulation& destination, const CellularMigrationRequest& trusted, const CellularMigrationTrace& trace) { return replay(source, destination, trusted, trace, CellularMigrationRepresentation::population); } std::expected, CellularMigrationError> encode_migration_trace(const CellularMigrationTrace& trace) { if (!shape(trace)) return std::unexpected(CellularMigrationError::format); std::vector bytes; bytes.reserve(migration_trace_header_bytes + 8 * trace.members.size() + 8); append(bytes, trace.format_version == 1 ? magic : maturing_magic); put(bytes, trace.format_version, 4); put(bytes, static_cast(trace.representation), 4); for (const auto value : {trace.world, trace.frame, trace.tick, trace.request.genome}) put(bytes, value); append(bytes, trace.request.request); for (const auto* endpoint : {&trace.request.source, &trace.request.destination}) { put(bytes, endpoint->region); append(bytes, endpoint->predecessor); append(bytes, endpoint->predecessor_digest); append(bytes, endpoint->commit); } put(bytes, trace.transferred.energy.value); for (const auto mass : trace.transferred.matter) put(bytes, mass.value); put(bytes, trace.members.size(), 4); put(bytes, 0, 4); for (const auto id : trace.members) put(bytes, id); put(bytes, checksum(bytes)); return bytes; } std::expected decode_migration_trace(std::span bytes) { if (bytes.size() < migration_trace_header_bytes + 8 || bytes.size() > max_migration_trace_bytes) return std::unexpected(CellularMigrationError::format); Reader end(bytes.last(8)); if (end.get() != checksum(bytes.first(bytes.size() - 8))) return std::unexpected(CellularMigrationError::checksum); Reader in(bytes); const auto tag = in.array<8>(); if (tag != magic && tag != maturing_magic) return std::unexpected(CellularMigrationError::format); const auto version = in.get(4); if ((version != 1 && version != 2) || (version == 1 ? tag != magic : tag != maturing_magic)) return std::unexpected(CellularMigrationError::version); const auto representation = in.get(4); if (representation != 1 && representation != 2) return std::unexpected(CellularMigrationError::version); CellularMigrationTrace trace; trace.format_version = static_cast(version); trace.representation = static_cast(representation); trace.world = in.get(); trace.frame = in.get(); trace.tick = in.get(); trace.request.genome = in.get(); trace.request.request = in.array<16>(); for (auto* endpoint : {&trace.request.source, &trace.request.destination}) { endpoint->region = in.get(); endpoint->predecessor = in.array<16>(); endpoint->predecessor_digest = in.array<32>(); endpoint->commit = in.array<16>(); } trace.transferred.energy.value = in.get(); for (auto& mass : trace.transferred.matter) mass.value = in.get(); const auto count = in.get(4); if (in.get(4) != 0 || count == 0 || count > biology::max_cellular_tick_lives || bytes.size() != migration_trace_header_bytes + 8 * count + 8) return std::unexpected(CellularMigrationError::format); trace.members.reserve(static_cast(count)); for (std::uint64_t i = 0; i < count; ++i) trace.members.push_back(in.get()); const auto encoded = encode_migration_trace(trace); if (!encoded || !std::ranges::equal(*encoded, bytes)) return std::unexpected(CellularMigrationError::format); return trace; } } // namespace evo::server