215 lines
9.4 KiB
C++
215 lines
9.4 KiB
C++
#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;
|
|
}
|