Foundation / checks (checks) (push) Successful in 42m5s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 2m24s
Foundation / checks (network) (push) Successful in 18m43s
Foundation / checks (postgres) (push) Successful in 44m0s
Foundation / checks (tsan) (push) Successful in 10m8s
Foundation / checks (client) (push) Successful in 15m13s
Foundation / postgres-tools (push) Successful in 31s
Foundation / server-image (push) Successful in 3m18s
Foundation / image (push) Successful in 3m23s
380 lines
18 KiB
C++
380 lines
18 KiB
C++
#include "evo/server/cellular_session_batch.hpp"
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo;
|
|
using namespace evo::server;
|
|
|
|
void check(bool value, std::source_location at = std::source_location::current()) {
|
|
if (!value)
|
|
throw std::runtime_error("cellular session batch line " + std::to_string(at.line()));
|
|
}
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
|
|
accounting::Inventory founder_price(std::uint64_t count) {
|
|
const auto endowment = biology::primitive_endowment();
|
|
CHECK(endowment);
|
|
auto funding = endowment->body;
|
|
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
|
|
funding.energy.value *= count;
|
|
for (auto& channel : funding.matter)
|
|
channel.value *= count;
|
|
return funding;
|
|
}
|
|
|
|
void actions_bind_to_owned_life_and_preserve_other_inputs() {
|
|
auto primitive = PrimitiveLives::create({90, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 1;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
request.account.back() = 2;
|
|
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
|
|
|
|
biology::CellularHabitatConfig habitat_config{
|
|
90,
|
|
1,
|
|
7,
|
|
20'000,
|
|
20'000,
|
|
{{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}},
|
|
{{15'000, 15'000}, 30, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
|
|
auto habitat = biology::CellularHabitat::create(std::move(habitat_config));
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{20'000, 20'000}, 1, 293'150});
|
|
CHECK(state && (*state)->lives().size() == 2);
|
|
|
|
const auto& controlled = (*state)->lives()[0];
|
|
const auto& other = (*state)->lives()[1];
|
|
const auto visible = (*state)->perceive(controlled.identity.life);
|
|
CHECK(visible && visible->size() == 1 &&
|
|
visible->front().address == (biology::CellularPatchAddress{0, 0}));
|
|
const std::array baseline{CellularLifeIntent{controlled.identity.life, {{5, 6}, {}}},
|
|
CellularLifeIntent{other.identity.life, {{7, 8}, {}}}};
|
|
const auto input = network::encode_cellular_action_input({2, -3, 4, true, 0, 0});
|
|
network::CarriedAction action{network::AccountId{controlled.account}, 77, 2,
|
|
network::ActionKind::cellular, input};
|
|
const std::array actions{action};
|
|
const auto prepared = prepare_cellular_session_tick(**state, 2, baseline, actions);
|
|
CHECK(prepared && prepared->intents.lives.size() == 2 && prepared->actions.size() == 1);
|
|
CHECK(prepared->intents.lives[0] ==
|
|
CellularLifeIntent{controlled.identity.life,
|
|
{{-3, 4}, biology::CellularPatchAddress{0, 0}}});
|
|
CHECK(prepared->intents.lives[1] == baseline[1]);
|
|
CHECK(prepared->actions[0] == CellularActionRecord{controlled.account, 77, input});
|
|
|
|
const auto guessed_input =
|
|
network::encode_cellular_action_input({2, 0, 0, true, 15'000, 15'000});
|
|
const network::CarriedAction guessed{network::AccountId{controlled.account}, 78, 2,
|
|
network::ActionKind::cellular, guessed_input};
|
|
const std::array guessed_actions{guessed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, guessed_actions).error() ==
|
|
CellularSessionBatchError::unperceived_target);
|
|
|
|
// ADR-0124: an engulf action becomes the life's engulf intent, and the trace keeps it.
|
|
const auto engulf_input = network::encode_cellular_action_input({2, 1, 0, false, 0, 0, true});
|
|
const network::CarriedAction engulf_action{network::AccountId{controlled.account}, 79, 2,
|
|
network::ActionKind::cellular, engulf_input};
|
|
const std::array engulf_actions{engulf_action};
|
|
const auto engulfing = prepare_cellular_session_tick(**state, 2, baseline, engulf_actions);
|
|
CHECK(engulfing && engulfing->intents.lives[0].intent.engulf &&
|
|
!engulfing->intents.lives[0].intent.intake_target);
|
|
CellularBatch engulf_batch;
|
|
engulf_batch.header = {(*state)->world(), (*state)->region(), (*state)->frame(), {}, {}, 1, 2};
|
|
engulf_batch.header.predecessor.fill(1);
|
|
engulf_batch.header.predecessor_digest.fill(2);
|
|
engulf_batch.ticks.push_back(engulfing->intents);
|
|
CHECK(match_cellular_actions_to_trace(**state, engulf_batch, engulfing->actions));
|
|
const auto engulf_bytes = encode_cellular_batch(engulf_batch);
|
|
CHECK(engulf_bytes);
|
|
const auto engulf_decoded = decode_cellular_batch(*engulf_bytes);
|
|
CHECK(engulf_decoded && *engulf_decoded == engulf_batch);
|
|
auto stripped = engulf_batch;
|
|
stripped.ticks[0].lives[0].intent.engulf = false;
|
|
CHECK(!match_cellular_actions_to_trace(**state, stripped, engulfing->actions));
|
|
|
|
// ADR-0125: a bud action becomes the life's bud intent, kept as kind 3 in the trace.
|
|
const auto bud_input =
|
|
network::encode_cellular_action_input({2, 0, 0, false, 0, 0, false, true});
|
|
const network::CarriedAction bud_action{network::AccountId{controlled.account}, 80, 2,
|
|
network::ActionKind::cellular, bud_input};
|
|
const std::array bud_actions{bud_action};
|
|
const auto budding = prepare_cellular_session_tick(**state, 2, baseline, bud_actions);
|
|
CHECK(budding && budding->intents.lives[0].intent.bud &&
|
|
!budding->intents.lives[0].intent.engulf &&
|
|
!budding->intents.lives[0].intent.intake_target);
|
|
auto bud_batch = engulf_batch;
|
|
bud_batch.ticks[0] = budding->intents;
|
|
CHECK(match_cellular_actions_to_trace(**state, bud_batch, budding->actions));
|
|
const auto bud_bytes = encode_cellular_batch(bud_batch);
|
|
CHECK(bud_bytes);
|
|
const auto bud_decoded = decode_cellular_batch(*bud_bytes);
|
|
CHECK(bud_decoded && *bud_decoded == bud_batch);
|
|
auto unbudded = bud_batch;
|
|
unbudded.ticks[0].lives[0].intent.bud = false;
|
|
CHECK(!match_cellular_actions_to_trace(**state, unbudded, budding->actions));
|
|
CellularBatch batch;
|
|
batch.header = {(*state)->world(), (*state)->region(), (*state)->frame(), {}, {}, 1, 2};
|
|
batch.header.predecessor.fill(1);
|
|
batch.header.predecessor_digest.fill(2);
|
|
batch.ticks.push_back(prepared->intents);
|
|
CHECK(match_cellular_actions_to_trace(**state, batch, prepared->actions));
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*state)->frame();
|
|
head.sequence = 4;
|
|
head.end_tick = (*state)->tick();
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
CHECK(builder->append(2, baseline, actions));
|
|
std::vector<CellularLifeIntent> next_baseline;
|
|
for (const auto& life : builder->candidate().lives())
|
|
next_baseline.push_back({life.identity.life, {}});
|
|
CHECK(builder->append(3, next_baseline, {}));
|
|
CHECK(builder->batch().header.begin_tick == 1 && builder->batch().header.end_tick == 3 &&
|
|
builder->batch().ticks.size() == 2);
|
|
CHECK(builder->actions().size() == 1 && builder->actions()[0] == prepared->actions[0]);
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto repeated_input = network::encode_cellular_action_input({4, 0, 0, false, 0, 0});
|
|
const network::CarriedAction repeated{network::AccountId{controlled.account}, 77, 4,
|
|
network::ActionKind::cellular, repeated_input};
|
|
const std::array repeated_actions{repeated};
|
|
CHECK(builder->append(4, next_baseline, repeated_actions).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
CHECK(builder->append(5, next_baseline, {}).error() == CellularSessionBatchError::tick);
|
|
|
|
auto wrong_head = head;
|
|
++wrong_head.end_tick;
|
|
CHECK(CellularSessionBatchBuilder::create(**state, wrong_head).error() ==
|
|
CellularSessionBatchError::head);
|
|
|
|
auto altered = baseline;
|
|
altered[1].intent.movement.x = 10;
|
|
const auto preserved = prepare_cellular_session_tick(**state, 2, altered, actions);
|
|
CHECK(preserved && preserved->intents.lives[1].intent.movement.x == 10);
|
|
|
|
CHECK(prepare_cellular_session_tick(**state, 3, baseline, actions).error() ==
|
|
CellularSessionBatchError::tick);
|
|
CHECK(
|
|
prepare_cellular_session_tick(**state, 2, std::span{baseline}.first(1), actions).error() ==
|
|
CellularSessionBatchError::intents);
|
|
|
|
const std::array duplicate{action, action};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, duplicate).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
auto unknown = action;
|
|
unknown.account.bytes.back() = 3;
|
|
const std::array unknown_actions{unknown};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, unknown_actions).error() ==
|
|
CellularSessionBatchError::life);
|
|
auto malformed = action;
|
|
malformed.cellular_input = std::array<std::uint8_t, network::cellular_action_input_bytes>{};
|
|
const std::array malformed_actions{malformed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, malformed_actions).error() ==
|
|
CellularSessionBatchError::action);
|
|
}
|
|
|
|
void durable_mutation_reservations_bind_to_the_exact_offer() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 3;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
accounting::Inventory stock{{1'000'000'000'000ULL},
|
|
{{{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL}}}};
|
|
auto habitat =
|
|
biology::CellularHabitat::create({93, 1, 1, 1'000, 1'000, {{{0, 0}, 29, stock}}});
|
|
CHECK(habitat);
|
|
auto created =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 1, 293'150});
|
|
CHECK(created && (*created)->lives().size() == 1);
|
|
auto& owner = **created;
|
|
const auto life_id = owner.lives()[0].identity.life;
|
|
bool offered = false;
|
|
for (std::size_t tick = 0; tick < 10'000 && !offered; ++tick) {
|
|
const std::array intent{CellularLifeIntent{life_id, {{0, 0}, {{0, 0}}}}};
|
|
CHECK(owner.advance_tick(intent));
|
|
const auto current_offer = owner.mutation_offer(life_id);
|
|
CHECK(current_offer);
|
|
offered = current_offer->has_value();
|
|
}
|
|
CHECK(offered);
|
|
auto revision_owner = owner.migrate_to_v3();
|
|
CHECK(revision_owner);
|
|
const auto offer = (*revision_owner)->mutation_offer(life_id);
|
|
CHECK(offer && offer->has_value());
|
|
const auto offered_candidates = offer->value_or(biology::MutationOffer{});
|
|
CHECK(!offered_candidates.candidates.empty());
|
|
const auto& live = (*revision_owner)->lives()[0];
|
|
const auto action_tick = (*revision_owner)->tick() + 1;
|
|
const auto& candidate = offered_candidates.candidates.front();
|
|
persistence::CellularMutationReservation reservation;
|
|
reservation.account = live.account;
|
|
reservation.action_id = 42;
|
|
reservation.region = (*revision_owner)->region();
|
|
reservation.generation = 7;
|
|
reservation.target_tick = action_tick;
|
|
reservation.successor_identity = 999;
|
|
const auto put_field = [&](std::size_t offset, std::uint64_t value, std::size_t bytes) {
|
|
for (std::size_t i = 0; i < bytes; ++i)
|
|
reservation.input[offset + i] = static_cast<std::uint8_t>(value >> (i * 8U));
|
|
};
|
|
put_field(0, action_tick, 8);
|
|
put_field(8, life_id, 8);
|
|
put_field(16, live.mutation.event_index, 8);
|
|
put_field(24, live.mutation.offer_tick, 8);
|
|
put_field(32, candidate.operator_id, 2);
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*revision_owner)->frame();
|
|
head.sequence = 3;
|
|
head.end_tick = (*revision_owner)->tick();
|
|
head.commit.fill(0x31);
|
|
head.digest.fill(0x41);
|
|
auto builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(builder);
|
|
const std::array baseline{CellularLifeIntent{life_id, {}}};
|
|
const std::array reservations{reservation};
|
|
CHECK(builder->append(action_tick, baseline, {}, {}, reservations));
|
|
const CellularMutationActionRecord expected_action{
|
|
live.account,
|
|
reservation.action_id,
|
|
action_tick,
|
|
{life_id, live.mutation.event_index, live.mutation.offer_tick, candidate.operator_id}};
|
|
const CellularMutationSelection expected_selection{
|
|
life_id, live.mutation.event_index, live.mutation.offer_tick,
|
|
reservation.successor_identity, candidate.operator_id};
|
|
CHECK(builder->batch().ticks.back().mutations.size() == 1 &&
|
|
builder->batch().ticks.back().mutations.front() == expected_selection &&
|
|
builder->mutation_actions().size() == 1 &&
|
|
builder->mutation_actions().front() == expected_action &&
|
|
match_cellular_mutation_actions_to_trace(**revision_owner, builder->batch(),
|
|
builder->mutation_actions()));
|
|
const auto replayed = replay_cellular_batch(**revision_owner, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
|
|
auto stale_builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(stale_builder);
|
|
auto stale = reservation;
|
|
stale.input[24] ^= 1U;
|
|
const std::array stale_reservations{stale};
|
|
CHECK(stale_builder->append(action_tick, baseline, {}, {}, stale_reservations).error() ==
|
|
CellularSessionBatchError::mutation);
|
|
CHECK(stale_builder->candidate().snapshot() == (*revision_owner)->snapshot());
|
|
}
|
|
|
|
void builder_batches_reserved_birth_after_empty_tick() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
auto habitat = biology::CellularHabitat::create({93, 1, 1, 1'000, 1'000, {}});
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
|
|
CHECK(state && (*state)->lives().empty());
|
|
persistence::RegionHead head{};
|
|
head.frame = 1;
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
|
|
CellularTickIntents::Birth birth{};
|
|
birth.account.back() = 8;
|
|
birth.request = 13;
|
|
birth.generation = 4;
|
|
birth.identity = 901;
|
|
const std::array births{birth};
|
|
const std::span<const CellularLifeIntent> no_lives{};
|
|
CHECK(builder->append(1, no_lives, {}, births));
|
|
CHECK(builder->candidate().tick() == 1 && builder->candidate().lives().size() == 1 &&
|
|
builder->batch().ticks[0].births == std::vector{birth} && (*state)->lives().empty());
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto snapshot = builder->candidate().snapshot();
|
|
const std::array next_lives{CellularLifeIntent{901, {}}};
|
|
CHECK(builder->append(2, next_lives, {}, births).error() ==
|
|
CellularSessionBatchError::duplicate_birth);
|
|
CHECK(builder->candidate().snapshot() == snapshot && builder->batch().ticks.size() == 1);
|
|
}
|
|
void unavailable_birth_does_not_freeze_the_tick() {
|
|
for (const bool funded : {false, true}) {
|
|
auto primitive =
|
|
PrimitiveLives::create({94, 1, 1, 17, founder_price(funded ? 2 : 1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 1;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {101, 101, 101, 101, {1}}));
|
|
auto habitat = biology::CellularHabitat::create({94, 1, 1, 1000, 1000, {}});
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1000, 1000}, 1, 293150});
|
|
CHECK(state);
|
|
persistence::RegionHead head{};
|
|
head.frame = 1;
|
|
head.end_tick = 1;
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
CellularTickIntents::Birth birth{};
|
|
birth.account.back() = 2;
|
|
birth.request = 1;
|
|
birth.generation = 1;
|
|
birth.identity = 102;
|
|
const std::array births{birth};
|
|
// Movement vacates the nursery in the underfunded case, isolating each refusal.
|
|
const std::array baseline{
|
|
CellularLifeIntent{101, {{static_cast<std::int16_t>(funded ? 0 : 1000), 0}, {}}}};
|
|
// A founder moves only a few um per tick: first move it fully away from the site.
|
|
if (!funded) {
|
|
for (int i = 0; i < 100; ++i)
|
|
CHECK((*state)->advance_tick(baseline));
|
|
head.end_tick = (*state)->tick();
|
|
}
|
|
auto strict = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(strict);
|
|
CHECK(strict->append(head.end_tick + 1, baseline, {}, births).error() ==
|
|
CellularSessionBatchError::invalid_birth);
|
|
CHECK(strict->candidate().tick() == head.end_tick);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder &&
|
|
builder->append_with_birth_refusals(head.end_tick + 1, baseline, {}, births));
|
|
CHECK(builder->refused_births().size() == 1 && builder->refused_births()[0].birth == birth);
|
|
CHECK(
|
|
builder->refused_births()[0].reason ==
|
|
(funded ? CellularLivesError::no_placement : CellularLivesError::insufficient_funding));
|
|
CHECK(builder->candidate().tick() == head.end_tick + 1 &&
|
|
builder->candidate().lives().size() == 1);
|
|
CHECK(builder->batch().ticks.back().births.empty());
|
|
const auto replay = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replay && (*replay)->snapshot() == builder->candidate().snapshot());
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
int main() try {
|
|
actions_bind_to_owned_life_and_preserve_other_inputs();
|
|
durable_mutation_reservations_bind_to_the_exact_offer();
|
|
builder_batches_reserved_birth_after_empty_tick();
|
|
unavailable_birth_does_not_freeze_the_tick();
|
|
std::puts("cellular session batch: ok");
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "%s\n", e.what());
|
|
return 1;
|
|
}
|