#include "evo/core/random.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace { constexpr std::uint64_t max_id = 200'000; constexpr std::size_t max_count = 100'000; constexpr std::uint64_t seed = 123456; void require(bool condition, const char* message) { if (!condition) { throw std::runtime_error(message); } } struct Record { std::uint64_t id{}, counter{}, motion{}, capture{}; std::uint8_t mask{}; bool operator==(const Record&) const = default; }; struct State { std::uint64_t high_water{}; std::vector rows; bool operator==(const State&) const = default; }; bool valid(const Record& row) { return row.id > 0 && row.id <= max_id && row.mask <= 3 && ((row.mask & 1U) != 0 || row.motion == 0) && ((row.mask & 2U) != 0 || row.capture == 0); } Record initial(std::uint64_t id, std::uint64_t world_seed, std::uint32_t density) { evo::Random rng{world_seed ^ id}; const bool motion = rng.next() % 100 < density; const bool capture = rng.next() % 100 < density; return {id, id * 7, motion ? 2U : 0U, capture ? 5U : 0U, static_cast((motion ? 1U : 0U) | (capture ? 2U : 0U))}; } // Records requested container bytes, not allocator bookkeeping or process RSS. class CountingResource final : public std::pmr::memory_resource { public: std::size_t live{}, peak{}, calls{}; private: void* do_allocate(std::size_t bytes, std::size_t alignment) override { auto* result = std::pmr::new_delete_resource()->allocate(bytes, alignment); live += bytes; peak = std::max(peak, live); ++calls; return result; } void do_deallocate(void* pointer, std::size_t bytes, std::size_t alignment) override { if (bytes > live) { std::terminate(); } live -= bytes; std::pmr::new_delete_resource()->deallocate(pointer, bytes, alignment); } bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override { return this == &other; } }; class Rows { public: explicit Rows(std::pmr::memory_resource& resource) : rows_{&resource} {} void create(Record row) { require(valid(row) && row.id > high_water_ && rows_.size() < max_count, "Invalid row creation"); rows_.push_back(row); high_water_ = row.id; } bool remove(std::uint64_t id) { const auto it = std::ranges::lower_bound(rows_, id, {}, &Record::id); if (it == rows_.end() || it->id != id) { return false; } rows_.erase(it); return true; } void tick() { for (auto& row : rows_) { row.counter += 3; } for (auto& row : rows_) { if ((row.mask & 1U) != 0) { row.counter += row.motion++; } } for (auto& row : rows_) { if ((row.mask & 2U) != 0) { row.counter += row.capture; row.capture += 2; } } } State state() const { return {high_water_, {rows_.begin(), rows_.end()}}; } void restore_high_water(std::uint64_t value) { require(value >= high_water_ && value <= max_id, "Invalid row high-water mark"); high_water_ = value; } private: std::pmr::vector rows_; std::uint64_t high_water_{}; }; struct Identity { std::uint64_t value; }; struct Counter { std::uint64_t value; }; struct Motion { std::uint64_t rate; }; struct Capture { std::uint64_t rate; }; // EnTT passes storage allocators explicitly. A standard allocator-traits bridge // avoids polymorphic_allocator injecting a second allocator during construction. template struct ResourceAllocator { using value_type = T; std::pmr::memory_resource* resource = std::pmr::get_default_resource(); ResourceAllocator() = default; explicit ResourceAllocator(std::pmr::memory_resource& value) : resource{&value} {} template ResourceAllocator(const ResourceAllocator& other) noexcept : resource{other.resource} {} T* allocate(std::size_t count) { return std::pmr::polymorphic_allocator{resource}.allocate(count); } void deallocate(T* pointer, std::size_t count) noexcept { std::pmr::polymorphic_allocator{resource}.deallocate(pointer, count); } template bool operator==(const ResourceAllocator& other) const noexcept { return resource->is_equal(*other.resource); } }; class EnttStore { public: explicit EnttStore(std::pmr::memory_resource& resource) : registry_{ResourceAllocator{resource}}, handles_{&resource} {} void create(Record row) { require(valid(row) && row.id > high_water_ && count_ < max_count, "Invalid EnTT creation"); const auto entity = registry_.create(); registry_.emplace(entity, row.id); registry_.emplace(entity, row.counter); if ((row.mask & 1U) != 0) { registry_.emplace(entity, row.motion); } if ((row.mask & 2U) != 0) { registry_.emplace(entity, row.capture); } handles_.resize(static_cast(row.id + 1), entt::null); handles_[static_cast(row.id)] = entity; high_water_ = row.id; ++count_; } bool remove(std::uint64_t id) { if (id >= handles_.size()) { return false; } auto& entity = handles_[static_cast(id)]; if (entity == entt::null) { return false; } registry_.destroy(entity); entity = entt::null; --count_; return true; } void tick() { for (auto&& [entity, counter] : registry_.view().each()) { static_cast(entity); counter.value += 3; } for (auto&& [entity, counter, motion] : registry_.view().each()) { static_cast(entity); counter.value += motion.rate++; } for (auto&& [entity, counter, capture] : registry_.view().each()) { static_cast(entity); counter.value += capture.rate; capture.rate += 2; } } State state() const { State result{high_water_, {}}; result.rows.reserve(count_); for (auto&& [entity, identity, counter] : registry_.view().each()) { const auto* motion = registry_.try_get(entity); const auto* capture = registry_.try_get(entity); result.rows.push_back( {identity.value, counter.value, motion ? motion->rate : 0, capture ? capture->rate : 0, static_cast((motion ? 1U : 0U) | (capture ? 2U : 0U))}); } std::ranges::sort(result.rows, {}, &Record::id); return result; } void restore_high_water(std::uint64_t value) { require(value >= high_water_ && value <= max_id, "Invalid EnTT high-water mark"); high_water_ = value; } private: entt::basic_registry> registry_; std::pmr::vector handles_; std::uint64_t high_water_{}; std::size_t count_{}; }; using Bytes = std::vector; constexpr std::array magic{'E', 'C', 'S', 'P', 'R', 'F', '0', '1'}; void put(Bytes& bytes, std::uint64_t value) { for (unsigned index = 0; index < 8; ++index) { bytes.push_back(static_cast(value & 255U)); value >>= 8U; } } Bytes encode(const State& state) { Bytes bytes{magic.begin(), magic.end()}; bytes.reserve(24 + state.rows.size() * 33); put(bytes, state.high_water); put(bytes, state.rows.size()); for (const auto& row : state.rows) { put(bytes, row.id); put(bytes, row.counter); put(bytes, row.motion); put(bytes, row.capture); bytes.push_back(row.mask); } return bytes; } enum class DecodeError : std::uint8_t { invalid }; std::expected decode(std::span bytes) { if (bytes.size() < 24 || bytes.size() > 24 + 33 * max_count || !std::ranges::equal(bytes.first(8), magic)) { return std::unexpected(DecodeError::invalid); } std::size_t offset = 8; const auto get = [&]() { std::uint64_t value = 0; for (unsigned shift = 0; shift < 64; shift += 8) { value |= static_cast(bytes[offset++]) << shift; } return value; }; const auto high_water = get(); const auto count = get(); if (high_water > max_id || count > max_count || bytes.size() != 24 + count * 33) { return std::unexpected(DecodeError::invalid); } State result{high_water, {}}; result.rows.reserve(static_cast(count)); std::uint64_t previous = 0; for (std::uint64_t index = 0; index < count; ++index) { Record row{get(), get(), get(), get(), bytes[offset++]}; if (!valid(row) || row.id <= previous || row.id > high_water) { return std::unexpected(DecodeError::invalid); } previous = row.id; result.rows.push_back(row); } return result; } template void restore(Store& store, const Bytes& bytes) { const auto state = decode(bytes); require(state.has_value(), "Rejected experimental snapshot"); for (const auto row : state->rows) { store.create(row); } store.restore_high_water(state->high_water); } template void fill(Store& store, std::uint64_t count, std::uint64_t world_seed, std::uint32_t density) { for (std::uint64_t id = 1; id <= count; ++id) { store.create(initial(id, world_seed, density)); } } template void advance(Store& store, std::uint64_t ticks) { for (std::uint64_t tick = 0; tick < ticks; ++tick) { store.tick(); } } template void churn(Store& store, std::uint64_t count, std::uint64_t world_seed, std::uint32_t density) { for (std::uint64_t id = 10; id <= count; id += 10) { require(store.remove(id), "Churn removal failed"); } for (std::uint64_t id = count + 1; id <= count + count / 10; ++id) { store.create(initial(id, world_seed, density)); } } Record closed_form(Record row, std::uint64_t ticks) { row.counter += 3 * ticks; if ((row.mask & 1U) != 0) { row.counter += ticks * row.motion + ticks * (ticks - 1) / 2; row.motion += ticks; } if ((row.mask & 2U) != 0) { row.counter += ticks * row.capture + ticks * (ticks - 1); row.capture += 2 * ticks; } return row; } template void verify_store() { CountingResource memory; { Store store{memory}; store.create({1, 10, 2, 5, 3}); advance(store, 3); require(store.state().rows == std::vector{{1, 49, 5, 11, 3}}, "Hand-computed fixture mismatch"); bool duplicate_rejected = false; try { store.create({1, 0, 0, 0, 0}); } catch (const std::runtime_error&) { duplicate_rejected = true; } require(duplicate_rejected, "Duplicate ID accepted"); require(store.remove(1) && !store.remove(1), "Stale identity accepted"); const auto bytes = encode(store.state()); Store restored{memory}; restore(restored, bytes); require(restored.state().high_water == 1, "Deleted high-water mark lost"); bool reused = true; try { restored.create({1, 0, 0, 0, 0}); } catch (const std::runtime_error&) { reused = false; } require(!reused, "Restore allowed ID reuse"); restored.create({2, 0, 0, 0, 0}); } require(memory.live == 0, "Store allocations leaked"); } void verify() { verify_store(); verify_store(); for (const auto count : {0U, 1U, 103U}) { for (const auto density : {0U, 10U, 100U}) { for (std::uint64_t test_seed = 0; test_seed < 8; ++test_seed) { CountingResource rows_memory, entt_memory; { Rows rows{rows_memory}; EnttStore entt{entt_memory}; fill(rows, count, test_seed, density); fill(entt, count, test_seed, density); advance(rows, 17); advance(entt, 17); require(rows.state() == entt.state(), "Store state differs after updates"); for (const auto row : rows.state().rows) { require(row == closed_form(initial(row.id, test_seed, density), 17), "Closed-form result differs"); } churn(rows, count, test_seed, density); churn(entt, count, test_seed, density); const auto bytes = encode(rows.state()); require(bytes == encode(entt.state()), "Canonical bytes differ after churn"); Rows resumed_rows{rows_memory}; EnttStore resumed_entt{entt_memory}; restore(resumed_rows, bytes); restore(resumed_entt, bytes); advance(rows, 5); advance(entt, 5); advance(resumed_rows, 5); advance(resumed_entt, 5); require(rows.state() == entt.state() && rows.state() == resumed_rows.state() && rows.state() == resumed_entt.state(), "Restored continuation differs"); } require(rows_memory.live == 0 && entt_memory.live == 0, "Unbalanced allocations"); } } } auto bytes = encode(State{1, {{1, 0, 0, 0, 0}}}); require(decode(bytes).has_value(), "Valid codec fixture rejected"); bytes.back() = 4; require(!decode(bytes), "Invalid mask accepted"); bytes.pop_back(); require(!decode(bytes), "Truncated input accepted"); require(!decode(encode(State{2, {{1, 0, 0, 0, 0}, {1, 0, 0, 0, 0}}})), "Duplicate snapshot IDs accepted"); require(!decode(encode(State{0, {{1, 0, 0, 0, 0}}})), "Invalid watermark accepted"); require(!decode(encode(State{1, {{1, 0, 1, 0, 0}}})), "Absent capability payload accepted"); bytes = encode(State{}); bytes[0] = 0; require(!decode(bytes), "Unknown format accepted"); bytes = encode(State{}); bytes[16] = 255; require(!decode(bytes), "Invalid count/length accepted"); } template double timed(Function&& function) { const auto start = std::chrono::steady_clock::now(); function(); return std::chrono::duration(std::chrono::steady_clock::now() - start).count(); } std::uint64_t fingerprint(const Bytes& bytes) { std::uint64_t result = 14695981039346656037ULL; for (const auto value : bytes) { result = (result ^ value) * 1099511628211ULL; } return result; } template Bytes measure(std::string_view name, std::uint64_t count, std::uint32_t density, int sample) { CountingResource memory, restore_memory; Bytes bytes; { Store store{memory}; const auto create_seconds = timed([&] { fill(store, count, seed, density); }); const auto tick_seconds = timed([&] { advance(store, 100); }); const auto churn_seconds = timed([&] { churn(store, count, seed, density); }); const auto export_seconds = timed([&] { bytes = encode(store.state()); }); Store restored{restore_memory}; const auto restore_seconds = timed([&] { restore(restored, bytes); }); require(encode(restored.state()) == bytes, "Measured restore differs"); if (sample >= 0) { std::cout << "{\"store\":\"" << name << "\",\"entities\":" << count << ",\"density_percent\":" << density << ",\"seed\":" << seed << ",\"ticks\":100,\"sample\":" << sample << ",\"create_s\":" << create_seconds << ",\"tick_s\":" << tick_seconds << ",\"churn_s\":" << churn_seconds << ",\"export_s\":" << export_seconds << ",\"restore_s\":" << restore_seconds << ",\"live_bytes\":" << memory.live << ",\"peak_bytes\":" << memory.peak << ",\"allocations\":" << memory.calls << ",\"hash\":\"" << std::hex << fingerprint(bytes) << std::dec << "\"}\n"; } } require(memory.live == 0 && restore_memory.live == 0, "Measured store allocations leaked"); return bytes; } } // namespace int main(int argc, char** argv) try { if (argc != 2 || (std::string_view{argv[1]} != "--verify" && std::string_view{argv[1]} != "--measure")) { std::cerr << "Usage: evo-ecs-experiment --verify|--measure\n"; return 2; } verify(); if (std::string_view{argv[1]} == "--verify") { std::cout << "ECS experiment contracts passed\n"; return 0; } std::cout << "{\"experiment\":\"ecs-storage-v1\",\"entt\":\"4.0.0\",\"compiler\":\"" #if defined(__clang__) << "Clang " << __clang_version__ #elif defined(_MSC_VER) << "MSVC " << _MSC_VER #elif defined(__GNUC__) << "GCC " << __VERSION__ #endif << "\",\"build\":\"" #if defined(NDEBUG) << "release" #else << "debug" #endif << "\"}\n"; for (const auto count : {1'000U, 10'000U}) { for (const auto density : {10U, 100U}) { for (int sample = -1; sample < 7; ++sample) { Bytes rows, entt; if (sample % 2 == 0) { rows = measure("rows", count, density, sample); entt = measure("entt4", count, density, sample); } else { entt = measure("entt4", count, density, sample); rows = measure("rows", count, density, sample); } require(rows == entt, "Measured adapters produced different canonical bytes"); } } } return 0; } catch (const std::exception& error) { try { std::cerr << error.what() << '\n'; } catch (...) { // Reporting failure must not let an exception escape the process boundary. return 1; } return 1; } catch (...) { return 1; }