#include "evo/world/local_files.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 T take(std::expected result) { require(result.has_value()); return std::move(*result); } std::int64_t elapsed(Clock::time_point start) { return std::chrono::duration_cast(Clock::now() - start).count(); } ChunkAddress address(Workload kind, std::size_t i) { const auto x = static_cast(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 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 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 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> storage(f.commands); std::vector 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(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 "); 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(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; }