Foundation / checks (deploy) (push) Successful in 3m26s
Foundation / checks (ecs) (push) Successful in 1m54s
Foundation / checks (client) (push) Successful in 12m36s
Foundation / checks (network) (push) Successful in 13m35s
Foundation / checks (tsan) (push) Successful in 7m48s
Foundation / checks (checks) (push) Successful in 32m51s
Foundation / checks (postgres) (push) Successful in 46m20s
Foundation / postgres-tools (push) Successful in 1m35s
Foundation / image (push) Successful in 2m32s
Foundation / server-image (push) Successful in 4m14s
ADR-0097. The second evolution-dev load drill (image 7952185d) held 20 sessions with client budgets met (response p95 111 ms, outcome p95 about 1.2 s, 20 Hz, no starvation) but the server over its own: tick work p99 48-70 ms (25 ms budget), session layer 1.2-2.0 ms per session at p99 (0.5 ms budget), governor refusing and shedding to level 3 to little effect. ReplicationServer::tick re-encoded every environment cell and organism for each session. Sessions with the same requested interest (no perception predicate) now share one encoding per tick; markers stay per session. Locally 21 sessions: about 970 us -> 360 us per tick. The drill now waits for two consecutive calm reports before the bots. The dev overlay's REGION_RETAINED listed the deployed build itself (61df6a1,f88bee2), which the deploy policy refuses (CI deploy failed on those commits); it now lists only the other builds, keeping 6c96629e, the build of the region head. Refreshes the dev session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
510 lines
23 KiB
C++
510 lines
23 KiB
C++
// M10.5 replication tests (ADR-0093): session protocol v2 snapshot messages, server-side
|
|
// interest, deltas, budgets, baselines and concealment; client-side assembly.
|
|
#include "evo/biology/genome.hpp"
|
|
#include "evo/network/replication.hpp"
|
|
#include "network_test.hpp"
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <map>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
namespace evo::network_test {
|
|
namespace {
|
|
using namespace evo::network;
|
|
constexpr world::WorldIdentity identity{11, 12};
|
|
constexpr std::uint32_t mask = (1U << 0) | (1U << 1) | (1U << 7);
|
|
constexpr std::int64_t slice = -7;
|
|
|
|
client::EnvironmentCell cell(std::int64_t x, std::int64_t y, std::uint64_t quantity = 30) {
|
|
client::EnvironmentCell c;
|
|
c.voxel = {x, y, slice};
|
|
c.chunk_revision = 40;
|
|
c.habitat = {{100}, {200}, {0}, {1000}, {500}, {10}};
|
|
c.volume = {1000ULL * 500 * 10};
|
|
c.substrate = {1};
|
|
c.terrain_material = {2};
|
|
c.terrain_fill = 1000;
|
|
c.presence[0] = client::FieldPresence::present;
|
|
c.quantity[0] = quantity;
|
|
c.presence[1] = client::FieldPresence::missing;
|
|
c.presence[7] = client::FieldPresence::present;
|
|
c.quantity[7] = 0xFFFF'FFFF'FFFF'0000ULL;
|
|
c.moisture_status = world::MoistureStatus::available;
|
|
c.moisture = {3, 50};
|
|
return c;
|
|
}
|
|
client::OrganismCell organism(std::uint64_t id, std::int64_t x, std::int64_t y) {
|
|
using biology::Capability;
|
|
const auto genome = biology::Genome::create({7,
|
|
1,
|
|
1,
|
|
{},
|
|
{{Capability::energy_conversion, 400, 0},
|
|
{Capability::membrane, 10, 0},
|
|
{Capability::movement, 50, 0},
|
|
{Capability::target_size, 8'000'000, 0}}});
|
|
CHECK(genome);
|
|
const biology::EnvironmentState temperate{
|
|
293'150, {{1'000'000'000}, {accounting::Femtograms{1'000'000'000}, {}, {}, {}}}};
|
|
auto c = client::present_organism(id, {x, y, slice}, {100}, {200}, *genome, {500, 0}, temperate,
|
|
client::OrganismState::alive);
|
|
CHECK(c);
|
|
return *c;
|
|
}
|
|
// A 21 x 21 slice centred on the origin, plus organisms.
|
|
struct World {
|
|
std::map<std::pair<std::int64_t, std::int64_t>, std::uint64_t> quantity;
|
|
std::vector<client::OrganismCell> organisms;
|
|
std::uint64_t revision{1};
|
|
World() {
|
|
for (std::int64_t x = -10; x <= 10; ++x)
|
|
for (std::int64_t y = -10; y <= 10; ++y)
|
|
quantity[{x, y}] = 30;
|
|
}
|
|
ReplicationSource source() const {
|
|
ReplicationSource s;
|
|
s.identity = identity;
|
|
s.field_revision = revision;
|
|
s.organism_revision = revision;
|
|
s.mask = mask;
|
|
for (const auto& [xy, q] : quantity)
|
|
s.environment.push_back(cell(xy.first, xy.second, q));
|
|
s.organisms = organisms;
|
|
return s;
|
|
}
|
|
};
|
|
ReplicationLimits limits() {
|
|
return ReplicationLimits{};
|
|
}
|
|
// Delivers chunks (optionally dropping some) and returns the acknowledgements.
|
|
std::vector<SnapshotAck> deliver(SnapshotAssembler& client,
|
|
const std::vector<SnapshotChunk>& chunks,
|
|
const std::set<std::size_t>& drop = {}) {
|
|
std::vector<SnapshotAck> acks;
|
|
for (std::size_t i = 0; i < chunks.size(); ++i) {
|
|
if (drop.contains(i))
|
|
continue;
|
|
// Every chunk crosses the real codec as one datagram.
|
|
const auto bytes = encode_session(chunks[i]);
|
|
CHECK(bytes.size() <= session_datagram_bytes);
|
|
const auto decoded = decode_session(bytes);
|
|
CHECK(decoded && std::get<SnapshotChunk>(*decoded) == chunks[i]);
|
|
const auto accepted = client.accept(std::get<SnapshotChunk>(*decoded));
|
|
CHECK(accepted);
|
|
const auto complete = accepted.value_or(std::nullopt);
|
|
if (complete)
|
|
acks.push_back(*complete);
|
|
}
|
|
return acks;
|
|
}
|
|
std::size_t bytes_of(const std::vector<SnapshotChunk>& chunks) {
|
|
std::size_t n = 0;
|
|
for (const auto& c : chunks)
|
|
n += encode_session(c).size();
|
|
return n;
|
|
}
|
|
const std::vector<SnapshotChunk>&
|
|
for_session(const std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>>& out,
|
|
std::uint64_t session) {
|
|
const auto it = std::ranges::find_if(out, [&](const auto& e) { return e.first == session; });
|
|
CHECK(it != out.end());
|
|
return it->second;
|
|
}
|
|
|
|
void codec_v2() {
|
|
const SessionInterest interest{-3, 4, -7, 7};
|
|
const auto i = decode_session(encode_session(interest));
|
|
CHECK(i && std::get<SessionInterest>(*i) == interest);
|
|
const SnapshotAck ack{5, 9};
|
|
CHECK(std::get<SnapshotAck>(*decode_session(encode_session(ack))) == ack);
|
|
SnapshotChunk chunk{5, 9, 7, 3, 4, mask, -7, 1, 2, {1, 2, 3}};
|
|
auto bytes = encode_session(chunk);
|
|
CHECK(std::get<SnapshotChunk>(*decode_session(bytes)) == chunk);
|
|
// Versions 1-3 (frozen, deployed) are no longer accepted (v4, ADR-0096).
|
|
for (const std::uint8_t old : {std::uint8_t{1}, std::uint8_t{2}, std::uint8_t{3}}) {
|
|
auto previous = encode_session(ack);
|
|
previous.at(4) = old;
|
|
CHECK(refused(decode_session(previous), SessionCodecError::unsupported_version));
|
|
}
|
|
// Header rules: fresh baselines are 0 and always older; index < count <= 16; epoch, tick.
|
|
for (const auto& bad : {SnapshotChunk{5, 9, 9, 3, 4, mask, -7, 0, 1, {}},
|
|
SnapshotChunk{5, 9, 0, 3, 4, mask, -7, 1, 1, {}},
|
|
SnapshotChunk{5, 9, 0, 3, 4, mask, -7, 0, 17, {}},
|
|
SnapshotChunk{5, 9, 0, 3, 4, mask, -7, 0, 0, {}},
|
|
SnapshotChunk{0, 9, 0, 3, 4, mask, -7, 0, 1, {}},
|
|
SnapshotChunk{5, 0, 0, 3, 4, mask, -7, 0, 1, {}}})
|
|
CHECK(refused(decode_session(encode_session(bad)), SessionCodecError::invalid_value));
|
|
chunk.records.assign(max_snapshot_records_bytes, 0);
|
|
CHECK(encode_session(chunk).size() == session_datagram_bytes &&
|
|
decode_session(encode_session(chunk)));
|
|
chunk.records.push_back(0); // One byte more than a datagram.
|
|
CHECK(refused(decode_session(encode_session(chunk)), SessionCodecError::wrong_length));
|
|
const auto empty = encode_session(SnapshotChunk{5, 9, 0, 3, 4, mask, -7, 0, 1, {}});
|
|
for (std::size_t n = 0; n < empty.size(); ++n) // Every truncation of the header.
|
|
CHECK(!decode_session(std::span{empty}.first(n)));
|
|
}
|
|
|
|
void convergence_and_deltas() {
|
|
auto server = *ReplicationServer::create(limits());
|
|
World world;
|
|
CHECK(server.open(1, 5));
|
|
const auto clamped = server.set_interest(1, {0, 0, slice, 30});
|
|
CHECK(clamped && clamped->radius == 7); // 15 x 15 = 225 cells at most.
|
|
SnapshotAssembler client{identity, 5};
|
|
const auto source = [&](const SessionInterest&) { return world.source(); };
|
|
// A fresh 225-cell baseline exceeds 16 KiB: it arrives nearest first over a few ticks.
|
|
std::uint64_t tick = 1;
|
|
std::size_t first_size = 0;
|
|
for (; tick <= 6; ++tick) {
|
|
const auto out = server.tick(tick, source, {});
|
|
const auto& chunks = for_session(out, 1);
|
|
CHECK(bytes_of(chunks) <= 16384 && chunks.size() <= 16);
|
|
CHECK(chunks.front().baseline == (tick == 1 ? 0 : tick - 1));
|
|
for (const auto& a : deliver(client, chunks))
|
|
server.acknowledge(1, a);
|
|
if (tick == 1)
|
|
first_size = client.latest()->environment.size();
|
|
if (client.latest()->environment.size() == 225)
|
|
break;
|
|
}
|
|
CHECK(first_size > 50 && first_size < 225 && tick <= 4);
|
|
// Nearest first: the first snapshot holds the cells closest to the focus.
|
|
// Leak assertion: nothing outside the interest square ever arrives.
|
|
const auto env = client.environment();
|
|
CHECK(env && env->cells().size() == 225);
|
|
CHECK(std::ranges::all_of(env->cells(), [](const auto& c) {
|
|
return c.voxel.x >= -7 && c.voxel.x <= 7 && c.voxel.y >= -7 && c.voxel.y <= 7;
|
|
}));
|
|
// Converged and unchanged: one empty chunk per tick keeps the cadence.
|
|
++tick;
|
|
auto out = server.tick(tick, source, {});
|
|
CHECK(for_session(out, 1).size() == 1 && for_session(out, 1)[0].records.empty());
|
|
for (const auto& a : deliver(client, for_session(out, 1)))
|
|
server.acknowledge(1, a);
|
|
const auto find = [&](std::int64_t x, std::int64_t y) {
|
|
return std::ranges::find_if(client.latest()->environment, [&](const auto& c) {
|
|
return c.voxel.x == x && c.voxel.y == y;
|
|
});
|
|
};
|
|
const auto step = [&] {
|
|
out = server.tick(++tick, source, {});
|
|
for (const auto& a : deliver(client, for_session(out, 1)))
|
|
server.acknowledge(1, a);
|
|
};
|
|
for (int i = 0; i < 4; ++i)
|
|
step(); // Every cell was last sent at least 4 ticks ago.
|
|
// Changes are sent when due: near every tick, far (radius > 3) every 4 ticks.
|
|
world.quantity[{1, 1}] = 99;
|
|
world.quantity[{6, 6}] = 77;
|
|
step(); // Both were last sent long ago: both due.
|
|
CHECK(find(1, 1)->quantity[0] == 99 && find(6, 6)->quantity[0] == 77);
|
|
world.quantity[{1, 1}] = 100;
|
|
world.quantity[{6, 6}] = 78;
|
|
step(); // Near again at once; the far cell was updated a tick ago and waits.
|
|
CHECK(for_session(out, 1)[0].records == encode_record(cell(1, 1, 100)));
|
|
CHECK(find(1, 1)->quantity[0] == 100 && find(6, 6)->quantity[0] == 77);
|
|
int waited = 1;
|
|
while (find(6, 6)->quantity[0] != 78 && waited < 8) {
|
|
step();
|
|
++waited;
|
|
}
|
|
CHECK(find(6, 6)->quantity[0] == 78 && waited == 4);
|
|
// Removal: a cell that disappears is removed from the client's view.
|
|
world.quantity.erase(std::pair<std::int64_t, std::int64_t>{0, 0});
|
|
++tick;
|
|
for (const auto& a : deliver(client, for_session(server.tick(tick, source, {}), 1)))
|
|
server.acknowledge(1, a);
|
|
CHECK(find(0, 0) == client.latest()->environment.end() &&
|
|
client.latest()->environment.size() == 224);
|
|
// Loss: a dropped chunk leaves the snapshot incomplete (no ack); the next delta is
|
|
// against the older acknowledged snapshot and the client still converges.
|
|
for (std::int64_t x = -7; x <= 7; ++x)
|
|
world.quantity[{x, 2}] = 500; // Enough changes for several chunks.
|
|
++tick;
|
|
out = server.tick(tick, source, {});
|
|
CHECK(for_session(out, 1).size() > 1);
|
|
CHECK(deliver(client, for_session(out, 1), {0}).empty());
|
|
const auto acked_before = client.latest()->tick;
|
|
++tick;
|
|
out = server.tick(tick, source, {});
|
|
CHECK(for_session(out, 1).front().baseline == acked_before);
|
|
for (const auto& a : deliver(client, for_session(out, 1)))
|
|
server.acknowledge(1, a);
|
|
CHECK(client.latest()->tick == tick && find(3, 2)->quantity[0] == 500);
|
|
// Without acks for more than 40 ticks the server falls back to a fresh baseline.
|
|
const auto fresh_before = server.stats().fresh_baselines;
|
|
for (int i = 0; i < 40; ++i) // The acknowledged baseline survives 40 ticks...
|
|
CHECK(for_session(server.tick(++tick, source, {}), 1).front().baseline != 0);
|
|
out = server.tick(++tick, source, {});
|
|
CHECK(for_session(out, 1).front().baseline == 0 &&
|
|
server.stats().fresh_baselines == fresh_before + 1);
|
|
// Baselines are bounded: an ack for an evicted snapshot is ignored (still fresh).
|
|
server.acknowledge(1, {5, tick - 30});
|
|
out = server.tick(++tick, source, {});
|
|
CHECK(for_session(out, 1).front().baseline == 0);
|
|
server.acknowledge(1, {4, tick}); // Another epoch: ignored.
|
|
out = server.tick(++tick, source, {});
|
|
CHECK(for_session(out, 1).front().baseline == 0);
|
|
// A new interest starts from a fresh baseline; the client's view follows it.
|
|
server.acknowledge(1, {5, tick});
|
|
CHECK(server.set_interest(1, {5, 5, slice, 2}));
|
|
out = server.tick(++tick, source, {});
|
|
CHECK(for_session(out, 1).front().baseline == 0);
|
|
SnapshotAssembler moved{identity, 5};
|
|
for (const auto& a : deliver(moved, for_session(out, 1)))
|
|
server.acknowledge(1, a);
|
|
const auto small = moved.environment();
|
|
CHECK(small && small->cells().size() == 25 &&
|
|
std::ranges::all_of(small->cells(), [](const auto& c) {
|
|
return c.voxel.x >= 3 && c.voxel.x <= 7 && c.voxel.y >= 3 && c.voxel.y <= 7;
|
|
}));
|
|
}
|
|
|
|
void concealment() {
|
|
auto server = *ReplicationServer::create(limits());
|
|
World world;
|
|
world.organisms = {organism(1, 0, 0), organism(2, 1, 1), organism(3, 9, 9)};
|
|
CHECK(server.open(1, 5) && server.open(2, 5));
|
|
CHECK(server.set_interest(1, {0, 0, slice, 3}) && server.set_interest(2, {0, 0, slice, 3}));
|
|
// Session 1 cannot perceive organism 2 (e.g. concealed); session 2 can.
|
|
const Perceives perceives = [](std::uint64_t session, const client::OrganismCell& o) {
|
|
return !(session == 1 && o.id == 2);
|
|
};
|
|
const auto out =
|
|
server.tick(1, [&](const SessionInterest&) { return world.source(); }, perceives);
|
|
std::vector<std::uint8_t> one, two;
|
|
for (const auto& c : for_session(out, 1))
|
|
one.insert(one.end(), c.records.begin(), c.records.end());
|
|
for (const auto& c : for_session(out, 2))
|
|
two.insert(two.end(), c.records.begin(), c.records.end());
|
|
const auto contains = [](const std::vector<std::uint8_t>& hay,
|
|
const std::vector<std::uint8_t>& needle) {
|
|
return std::search(hay.begin(), hay.end(), needle.begin(), needle.end()) != hay.end();
|
|
};
|
|
// Leak assertions on the encoded bytes: concealed and out-of-interest organisms are absent.
|
|
CHECK(contains(one, encode_record(world.organisms[0])) &&
|
|
!contains(one, encode_record(world.organisms[1])));
|
|
CHECK(contains(two, encode_record(world.organisms[1])));
|
|
CHECK(!contains(one, encode_record(world.organisms[2])) &&
|
|
!contains(two, encode_record(world.organisms[2])));
|
|
SnapshotAssembler client{identity, 5};
|
|
(void)deliver(client, for_session(out, 1));
|
|
const auto seen = client.organisms();
|
|
CHECK(seen && seen->cells().size() == 1 && seen->cells()[0].id == 1);
|
|
}
|
|
|
|
void client_robustness() {
|
|
SnapshotAssembler client{identity, 5};
|
|
const auto record = encode_record(cell(0, 0));
|
|
SnapshotChunk c{5, 3, 0, 1, 1, mask, slice, 0, 1, record};
|
|
CHECK(client.accept(c) && client.latest() && client.latest()->tick == 3);
|
|
// Stale and foreign-epoch chunks are ignored.
|
|
c.tick = 2;
|
|
CHECK(client.accept(c) && client.latest()->tick == 3);
|
|
c.tick = 4;
|
|
c.epoch = 6;
|
|
CHECK(client.accept(c) && client.latest()->tick == 3);
|
|
c.epoch = 5;
|
|
// Malformed records: truncated, unknown kind, another slice, an invalid enumerator.
|
|
auto truncated = c;
|
|
truncated.records.pop_back();
|
|
CHECK(refused(client.accept(truncated), AssemblyError::malformed));
|
|
auto unknown = c;
|
|
unknown.tick = 5;
|
|
unknown.records = {9};
|
|
CHECK(refused(client.accept(unknown), AssemblyError::malformed));
|
|
auto other = c;
|
|
other.tick = 6;
|
|
other.records = encode_record([] {
|
|
auto x = cell(0, 0);
|
|
x.voxel.z = slice + 1;
|
|
return x;
|
|
}());
|
|
CHECK(refused(client.accept(other), AssemblyError::malformed));
|
|
// Parts of one snapshot must agree; a delta against an unknown baseline is dropped.
|
|
SnapshotChunk part{5, 10, 0, 1, 1, mask, slice, 0, 2, record};
|
|
CHECK(client.accept(part));
|
|
auto disagree = part;
|
|
disagree.index = 1;
|
|
disagree.mask = 1;
|
|
CHECK(refused(client.accept(disagree), AssemblyError::malformed));
|
|
SnapshotChunk orphan{5, 11, 7, 1, 1, mask, slice, 0, 1, {}};
|
|
CHECK(client.accept(orphan) && client.latest()->tick == 3);
|
|
// At most four snapshots in assembly.
|
|
for (std::uint64_t t = 20; t < 30; ++t)
|
|
CHECK(client.accept(SnapshotChunk{5, t, 0, 1, 1, mask, slice, 0, 2, record}));
|
|
CHECK(client.partial() <= 4);
|
|
}
|
|
|
|
// Dense interest: 32 sessions with different foci over a 41 x 41 slice; every snapshot within
|
|
// the per-tick budget; a bandwidth and memory report for the record.
|
|
void dense_report() {
|
|
auto server = *ReplicationServer::create(limits());
|
|
World world;
|
|
world.quantity.clear();
|
|
for (std::int64_t x = -20; x <= 20; ++x)
|
|
for (std::int64_t y = -20; y <= 20; ++y)
|
|
world.quantity[{x, y}] = 30;
|
|
std::vector<SnapshotAssembler> clients;
|
|
for (std::uint64_t s = 1; s <= 32; ++s) {
|
|
CHECK(server.open(s, 5));
|
|
// Centres within +-13, so every 15 x 15 interest lies inside the 41 x 41 slice.
|
|
CHECK(server.set_interest(s, {static_cast<std::int64_t>(s % 8) * 3 - 10,
|
|
static_cast<std::int64_t>(s / 8) * 5 - 10, slice, 7}));
|
|
clients.emplace_back(identity, 5);
|
|
}
|
|
CHECK(refused(server.open(33, 5), ReplicationError::full));
|
|
std::size_t max_bytes = 0, total = 0;
|
|
for (std::uint64_t tick = 1; tick <= 40; ++tick) {
|
|
for (std::int64_t x = -20; x <= 20; ++x) // Every tick, a changing row.
|
|
world.quantity[{x, static_cast<std::int64_t>(tick % 41) - 20}] = 100 + tick;
|
|
const auto out =
|
|
server.tick(tick, [&](const SessionInterest&) { return world.source(); }, {});
|
|
CHECK(out.size() == 32);
|
|
for (const auto& [session, chunks] : out) {
|
|
const auto n = bytes_of(chunks);
|
|
max_bytes = std::max(max_bytes, n);
|
|
total += n;
|
|
for (const auto& a : deliver(clients[session - 1], chunks))
|
|
server.acknowledge(session, a);
|
|
}
|
|
}
|
|
CHECK(max_bytes <= 16384);
|
|
CHECK(std::ranges::all_of(clients, [](const auto& c) {
|
|
return c.latest() && c.latest()->environment.size() == 225;
|
|
}));
|
|
const auto stats = server.stats();
|
|
CHECK(stats.retained_entities <= std::size_t{32} * 4 * 225);
|
|
std::printf(
|
|
"replication_report sessions=32 ticks=40 max_bytes_per_tick=%zu mean_bytes_per_tick=%zu "
|
|
"chunks=%llu records=%llu deferred=%llu retained_entities=%zu\n",
|
|
max_bytes, total / (std::size_t{32} * 40), static_cast<unsigned long long>(stats.chunks),
|
|
static_cast<unsigned long long>(stats.records),
|
|
static_cast<unsigned long long>(stats.deferred), stats.retained_entities);
|
|
}
|
|
} // namespace
|
|
|
|
// M10.9a overload shedding (ADR-0097): the encoded radius shrinks and far updates slow without a
|
|
// fresh baseline or a change of the stored interest; the view grows back when the level drops.
|
|
void shedding() {
|
|
auto server = *ReplicationServer::create(limits());
|
|
World world;
|
|
CHECK(server.open(1, 5) && server.set_interest(1, {0, 0, slice, 7}));
|
|
SnapshotAssembler client{identity, 5};
|
|
const auto source = [&](const SessionInterest&) { return world.source(); };
|
|
std::uint64_t tick = 0;
|
|
std::uint64_t baseline = 0;
|
|
const auto step = [&] {
|
|
const auto out = server.tick(++tick, source, {});
|
|
const auto& chunks = for_session(out, 1);
|
|
baseline = chunks.front().baseline;
|
|
for (const auto& a : deliver(client, chunks))
|
|
server.acknowledge(1, a);
|
|
return client.latest()->environment.size();
|
|
};
|
|
while (step() < 225 && tick < 10) {
|
|
}
|
|
CHECK(client.latest()->environment.size() == 225);
|
|
const auto square = [&](std::int64_t r) {
|
|
return std::ranges::all_of(client.latest()->environment, [&](const auto& c) {
|
|
return std::max(std::abs(c.voxel.x), std::abs(c.voxel.y)) <= r;
|
|
});
|
|
};
|
|
server.set_shed(2);
|
|
CHECK(server.shed() == 2 && step() == 121 && square(5) && baseline != 0);
|
|
CHECK(server.interest(1).value_or(SessionInterest{}).radius == 7); // The stored interest.
|
|
server.set_shed(9);
|
|
CHECK(server.shed() == 3 && step() == 49 && square(3) && baseline != 0);
|
|
// Level 3: near radius 2, far updates every 16 ticks. A cell at distance 3 changed twice
|
|
// arrives at once (last sent long ago), then not again for 16 ticks.
|
|
const auto at = [&](std::int64_t x, std::int64_t y) {
|
|
return std::ranges::find_if(client.latest()->environment,
|
|
[&](const auto& c) { return c.voxel.x == x && c.voxel.y == y; })
|
|
->quantity[0];
|
|
};
|
|
for (int i = 0; i < 16; ++i)
|
|
step();
|
|
world.quantity[{3, 0}] = 41;
|
|
world.quantity[{2, 0}] = 42;
|
|
step();
|
|
CHECK(at(3, 0) == 41 && at(2, 0) == 42);
|
|
world.quantity[{3, 0}] = 51;
|
|
world.quantity[{2, 0}] = 52;
|
|
step();
|
|
CHECK(at(2, 0) == 52 && at(3, 0) == 41); // Near: every tick. Far: deferred.
|
|
int waited = 1;
|
|
while (at(3, 0) != 51 && waited < 40) {
|
|
step();
|
|
++waited;
|
|
}
|
|
CHECK(waited == 16);
|
|
// Back to level 0: the full square returns, still from acknowledged baselines.
|
|
server.set_shed(0);
|
|
for (int i = 0; i < 6 && client.latest()->environment.size() < 225; ++i)
|
|
step();
|
|
CHECK(client.latest()->environment.size() == 225 && baseline != 0);
|
|
}
|
|
|
|
// M10.9d (ADR-0097): sessions with the same interest share one encoding of the environment
|
|
// per tick; each still converges on exactly its square, and another interest gets its own.
|
|
// Prints the server's time per tick for 20 sessions (a development reference).
|
|
void shared_interest() {
|
|
auto server = *ReplicationServer::create(limits());
|
|
World world;
|
|
constexpr std::uint64_t sessions = 21;
|
|
std::vector<SnapshotAssembler> clients;
|
|
for (std::uint64_t id = 1; id <= sessions; ++id) {
|
|
CHECK(server.open(id, 5));
|
|
// Session 21 looks elsewhere (centre 3, 0): its own square.
|
|
CHECK(server.set_interest(id, {id == sessions ? 3 : 0, 0, slice, 7}));
|
|
clients.emplace_back(identity, 5);
|
|
}
|
|
const auto source = [&](const SessionInterest&) { return world.source(); };
|
|
std::uint64_t tick = 0;
|
|
std::chrono::nanoseconds spent{};
|
|
const auto step = [&] {
|
|
const auto started = std::chrono::steady_clock::now();
|
|
const auto out = server.tick(++tick, source, {});
|
|
spent += std::chrono::steady_clock::now() - started;
|
|
for (std::uint64_t id = 1; id <= sessions; ++id)
|
|
for (const auto& a : deliver(clients[id - 1], for_session(out, id)))
|
|
server.acknowledge(id, a);
|
|
};
|
|
for (int i = 0; i < 6; ++i)
|
|
step();
|
|
for (std::uint64_t id = 1; id <= sessions; ++id) {
|
|
const auto& view = clients[id - 1].latest()->environment;
|
|
const std::int64_t centre = id == sessions ? 3 : 0;
|
|
CHECK(view.size() == 225 && std::ranges::all_of(view, [&](const auto& c) {
|
|
return std::abs(c.voxel.x - centre) <= 7 && std::abs(c.voxel.y) <= 7;
|
|
}));
|
|
}
|
|
// A change reaches every session that sees it.
|
|
world.quantity[{1, 1}] = 77;
|
|
spent = {};
|
|
for (int i = 0; i < 40; ++i)
|
|
step();
|
|
for (auto& c : clients)
|
|
CHECK(std::ranges::any_of(c.latest()->environment, [](const auto& e) {
|
|
return e.voxel.x == 1 && e.voxel.y == 1 && e.quantity[0] == 77;
|
|
}));
|
|
std::printf("replication shared_interest sessions=%llu us_per_tick=%lld\n",
|
|
static_cast<unsigned long long>(sessions),
|
|
static_cast<long long>(
|
|
std::chrono::duration_cast<std::chrono::microseconds>(spent).count() / 40));
|
|
}
|
|
|
|
void replication_tests() {
|
|
codec_v2();
|
|
shared_interest();
|
|
convergence_and_deltas();
|
|
shedding();
|
|
concealment();
|
|
client_robustness();
|
|
dense_report();
|
|
}
|
|
} // namespace evo::network_test
|