Complete M5.8 bounded world restart proof

This commit is contained in:
dingo
2026-09-26 20:33:43 -04:00
parent a2a12fdc69
commit 5aeb18a4aa
11 changed files with 448 additions and 5 deletions
+214
View File
@@ -0,0 +1,214 @@
#include "evo/world/local_files.hpp"
#include <array>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <exception>
#include <filesystem>
#include <iomanip>
#include <iostream>
#include <memory>
#include <source_location>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
namespace {
using namespace evo::world;
using Clock = std::chrono::steady_clock;
constexpr WorldIdentity identity{58, 1};
constexpr BaseDescriptor descriptor{123456};
constexpr std::size_t budget = std::size_t{4} * 1024 * 1024;
constexpr std::size_t chunk_count = 8;
enum class Workload : std::uint8_t { uniform, sparse, heavy };
void require(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("world proof check at line " + std::to_string(at.line()));
}
template <typename T, typename E> T take(std::expected<T, E> result) {
require(result.has_value());
return std::move(*result);
}
std::int64_t elapsed(Clock::time_point start) {
return std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - start).count();
}
ChunkAddress address(Workload kind, std::size_t i) {
const auto x = static_cast<std::int64_t>(i);
return {kind == Workload::sparse ? (x - 4) * 8000 : x - 4, 0, -1000};
}
std::uint32_t removed(Workload kind, std::size_t chunk, std::uint32_t cell) {
if (kind == Workload::sparse && chunk == 0 && cell == 0)
return fill_scale;
if (kind == Workload::heavy && chunk < 4 && cell < 1024)
return 1 + cell % 257;
return 0;
}
std::uint64_t fingerprint(std::span<const std::uint8_t> bytes) {
std::uint64_t result = 14695981039346656037ULL;
for (auto byte : bytes)
result = (result ^ byte) * 1099511628211ULL;
return result;
}
// Regression baselines are set after analytical cell/inventory validation.
constexpr std::array<std::uint64_t, 3> goldens{0xdb06d14d81c62c8cULL, 0x9cd2752316152d88ULL,
0x0dc4f24dc24f58e0ULL};
void audit(const ChunkStore& state, Workload kind) {
require(state.size() == chunk_count);
std::uint64_t expected_debris{}, remaining{};
for (std::size_t c = 0; c < chunk_count; ++c) {
const auto view = take(state.view(address(kind, c)));
for (std::uint32_t i = 0; i < base_chunk_cells; ++i) {
const auto sample =
take(state.read(view, take(local_from_ordinal(i, base_chunk_edge))));
const auto cut = removed(kind, c, i);
require(sample.fill() == fill_scale - cut);
require(sample.material().value == (cut == fill_scale ? 0 : 1));
expected_debris += cut;
remaining += sample.fill();
}
}
require(take(state.debris({1})).value == expected_debris);
require(take(state.debris({2})).value == 0);
require(remaining + expected_debris ==
chunk_count * base_chunk_cells * std::uint64_t{fill_scale});
}
void regenerate(ChunkStore& state, Workload kind) {
// The last chunk is never edited. Check against the versioned generator after eviction.
const auto a = address(kind, chunk_count - 1);
const auto old = take(state.view(a));
require(state.evict(old).has_value());
const auto fresh = take(state.load(a));
require(!state.read(old, {}));
const auto generated = take(generate_base_chunk(descriptor, a));
for (std::uint32_t i = 0; i < base_chunk_cells; ++i) {
require(take(state.read(fresh, take(local_from_ordinal(i, base_chunk_edge)))) ==
generated[i]);
}
}
struct Fixture {
std::unique_ptr<ChunkStore> state;
WorldBytes base, journal, final;
std::int64_t generation_ns{}, edits_ns{}, journal_ns{}, encode_ns{};
std::size_t base_accounted{}, final_accounted{}, commands{}, cuts{};
};
Fixture fixture(Workload kind) {
Fixture f;
const auto begin = Clock::now();
f.state = take(ChunkStore::create(descriptor, chunk_count, budget,
{{VolumeUnits{10'000'000}, VolumeUnits{10'000'000}}}));
for (std::size_t i = 0; i < chunk_count; ++i)
(void)take(f.state->load(address(kind, i)));
f.generation_ns = elapsed(begin);
f.base_accounted = f.state->accounted_bytes();
f.base = take(f.state->snapshot(identity));
f.commands = kind == Workload::heavy ? 64U : (kind == Workload::sparse ? 1U : 0U);
const auto per_command = kind == Workload::heavy ? 64U : 1U;
std::vector<std::array<CellCut, 64>> storage(f.commands);
std::vector<ExcavationRequest> requests;
requests.reserve(f.commands);
EditReceipt last{};
for (std::size_t command = 0; command < f.commands; ++command) {
for (std::uint32_t k = 0; k < per_command; ++k) {
const auto c = kind == Workload::heavy ? k / 16 : 0;
const auto ordinal =
kind == Workload::heavy ? static_cast<std::uint32_t>(command) * 16 + k % 16 : 0;
const auto a = address(kind, c);
storage[command][k] = {a, take(local_from_ordinal(ordinal, base_chunk_edge)),
take(f.state->view(a)).revision(), removed(kind, c, ordinal)};
}
ExcavationRequest r{command + 1, 1, std::span{storage[command]}.first(per_command), 0};
r.digest = take(excavation_digest(r));
const auto start = Clock::now();
last = take(f.state->excavate(r));
f.edits_ns += elapsed(start);
requests.push_back(r);
}
f.cuts = f.commands * per_command;
audit(*f.state, kind);
if (!requests.empty())
require(take(f.state->excavate(requests.back())) == last);
const auto encode_start = Clock::now();
f.final = take(f.state->snapshot(identity));
f.encode_ns = elapsed(encode_start);
const auto journal_start = Clock::now();
f.journal = take(make_edit_journal(f.base, identity, requests, budget));
f.journal_ns = elapsed(journal_start);
f.final_accounted = f.state->accounted_bytes();
return f;
}
} // namespace
int main(int argc, char** argv) try {
if (argc != 4)
throw std::runtime_error(
"usage: evo-world-proof <prepare|compact|verify> <uniform|sparse|heavy> <root>");
const std::string_view phase{argv[1]}, name{argv[2]};
require(phase == "prepare" || phase == "compact" || phase == "verify");
require(name == "uniform" || name == "sparse" || name == "heavy");
const auto kind = name == "uniform" ? Workload::uniform
: (name == "sparse" ? Workload::sparse : Workload::heavy);
const std::filesystem::path root{argv[3]};
if (phase == "prepare") {
require(std::filesystem::create_directory(root));
} else {
require(std::filesystem::is_directory(root));
}
auto reference = fixture(kind);
const auto hash = fingerprint(reference.final);
const auto golden = goldens[static_cast<std::size_t>(kind)];
require(golden == hash);
auto files = take(LocalWorldFiles::open(root, identity, budget));
std::int64_t publish_ns{}, recovery_ns{}, compaction_ns{}, regeneration_ns{};
if (phase == "prepare") {
require(!files->current());
auto base = take(ChunkStore::restore(reference.base, identity, budget));
const auto start = Clock::now();
require(files->checkpoint(*base).has_value());
require(files->publish_journal(reference.base, reference.journal).has_value());
publish_ns = elapsed(start);
} else {
const auto head = files->current().value_or(FileCommit{});
require(head.generation == (phase == "compact" ? 2U : 3U));
require(head.has_journal == (phase == "compact"));
}
const auto recover_start = Clock::now();
auto restored = take(files->recover());
recovery_ns = elapsed(recover_start);
require(take(restored->snapshot(identity)) == reference.final);
audit(*restored, kind);
if (phase == "compact") {
const auto start = Clock::now();
const auto committed = take(files->checkpoint(*restored));
compaction_ns = elapsed(start);
require(committed.generation == 3 && !committed.has_journal);
}
if (phase == "verify") {
const auto start = Clock::now();
regenerate(*restored, kind);
regeneration_ns = elapsed(start);
audit(*restored, kind);
}
std::cout << "{\"phase\":\"" << phase << "\",\"workload\":\"" << name
<< "\",\"seed\":123456,\"chunks\":8,\"resident_budget\":" << budget
<< ",\"commands\":" << reference.commands << ",\"cuts\":" << reference.cuts
<< ",\"base_accounted_bytes\":" << reference.base_accounted
<< ",\"final_accounted_bytes\":" << reference.final_accounted
<< ",\"snapshot_bytes\":" << reference.final.size()
<< ",\"journal_bytes\":" << reference.journal.size()
<< ",\"debris_volume\":" << take(reference.state->debris({1})).value << ",\"hash\":\""
<< std::hex << hash << std::dec << "\",\"generation_ns\":" << reference.generation_ns
<< ",\"edits_ns\":" << reference.edits_ns << ",\"encode_ns\":" << reference.encode_ns
<< ",\"journal_build_ns\":" << reference.journal_ns
<< ",\"publish_ns\":" << publish_ns << ",\"recovery_ns\":" << recovery_ns
<< ",\"compaction_ns\":" << compaction_ns
<< ",\"regeneration_ns\":" << regeneration_ns << "}\n";
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
} catch (...) {
return 1;
}