343 lines
12 KiB
C++
343 lines
12 KiB
C++
#include "evo/core/random.hpp"
|
|
#include "evo/world/coordinates.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using Cell = std::uint32_t;
|
|
constexpr Cell rock = 0xffff0001U;
|
|
void check(bool condition) {
|
|
if (!condition) {
|
|
throw std::runtime_error("chunk layout contract failed");
|
|
}
|
|
}
|
|
Cell cell(std::uint16_t material, std::uint32_t fill) {
|
|
const auto value = evo::world::CellSample::create({material}, fill);
|
|
check(value.has_value());
|
|
return static_cast<Cell>(value->material().value) | (static_cast<Cell>(value->fill()) << 16U);
|
|
}
|
|
struct Dense {
|
|
std::vector<Cell> values;
|
|
explicit Dense(const std::vector<Cell>& source, std::uint32_t) : values(source) {}
|
|
Cell get(std::size_t i) const {
|
|
return values.at(i);
|
|
}
|
|
void set(std::size_t i, Cell value) {
|
|
values.at(i) = value;
|
|
}
|
|
std::size_t bytes() const {
|
|
return sizeof(*this) + values.capacity() * sizeof(Cell);
|
|
}
|
|
std::size_t encoded() const {
|
|
return 1 + values.size() * 4;
|
|
}
|
|
};
|
|
struct Palette {
|
|
std::size_t count;
|
|
std::vector<Cell> palette;
|
|
std::vector<std::uint8_t> indexes;
|
|
std::vector<Cell> dense;
|
|
explicit Palette(const std::vector<Cell>& source, std::uint32_t)
|
|
: count(source.size()), palette{source.at(0)} {
|
|
for (std::size_t i = 0; i < count; ++i) {
|
|
set(i, source[i]);
|
|
}
|
|
}
|
|
Cell get(std::size_t i) const {
|
|
if (i >= count) {
|
|
throw std::out_of_range("cell");
|
|
}
|
|
if (!dense.empty()) {
|
|
return dense[i];
|
|
}
|
|
return palette[indexes.empty() ? std::size_t{0} : static_cast<std::size_t>(indexes[i])];
|
|
}
|
|
void set(std::size_t i, Cell value) {
|
|
if (i >= count) {
|
|
throw std::out_of_range("cell");
|
|
}
|
|
if (!dense.empty()) {
|
|
dense[i] = value;
|
|
return;
|
|
}
|
|
auto at = std::ranges::find(palette, value);
|
|
if (at == palette.end()) {
|
|
if (palette.size() == 256) {
|
|
dense.resize(count);
|
|
for (std::size_t j = 0; j < count; ++j) {
|
|
dense[j] = palette[indexes[j]];
|
|
}
|
|
std::vector<Cell>{}.swap(palette);
|
|
std::vector<std::uint8_t>{}.swap(indexes);
|
|
dense[i] = value;
|
|
return;
|
|
}
|
|
palette.push_back(value);
|
|
at = palette.end() - 1;
|
|
}
|
|
const auto slot = static_cast<std::uint8_t>(at - palette.begin());
|
|
if (indexes.empty() && slot == 0) {
|
|
return;
|
|
}
|
|
if (indexes.empty()) {
|
|
indexes.resize(count, 0);
|
|
}
|
|
indexes[i] = slot;
|
|
}
|
|
std::size_t bytes() const {
|
|
return sizeof(*this) + palette.capacity() * 4 + indexes.capacity() + dense.capacity() * 4;
|
|
}
|
|
std::size_t encoded() const {
|
|
if (!dense.empty()) {
|
|
return 1 + count * 4;
|
|
}
|
|
return indexes.empty() ? 5 : 3 + palette.size() * 4 + count;
|
|
}
|
|
};
|
|
struct Pages {
|
|
struct Page {
|
|
std::uint32_t key;
|
|
std::array<Cell, 64> values;
|
|
};
|
|
Cell base;
|
|
std::uint32_t edge;
|
|
std::vector<Page> pages;
|
|
explicit Pages(const std::vector<Cell>& source, std::uint32_t n) : base(source.at(0)), edge(n) {
|
|
for (std::size_t i = 0; i < source.size(); ++i) {
|
|
set(i, source[i]);
|
|
}
|
|
}
|
|
std::pair<std::uint32_t, std::uint32_t> address(std::size_t i) const {
|
|
const auto n = static_cast<std::size_t>(edge);
|
|
if (i >= n * n * n) {
|
|
throw std::out_of_range("cell");
|
|
}
|
|
const auto x = static_cast<std::uint32_t>(i % n);
|
|
const auto y = static_cast<std::uint32_t>((i / n) % n);
|
|
const auto z = static_cast<std::uint32_t>(i / (n * n));
|
|
const auto p = edge / 4;
|
|
return {x / 4 + p * (y / 4 + p * (z / 4)), x % 4 + 4 * (y % 4 + 4 * (z % 4))};
|
|
}
|
|
Cell get(std::size_t i) const {
|
|
const auto [key, offset] = address(i);
|
|
const auto at = std::ranges::lower_bound(pages, key, {}, &Page::key);
|
|
return at == pages.end() || at->key != key ? base : at->values[offset];
|
|
}
|
|
void set(std::size_t i, Cell value) {
|
|
const auto [key, offset] = address(i);
|
|
auto at = std::ranges::lower_bound(pages, key, {}, &Page::key);
|
|
if (at == pages.end() || at->key != key) {
|
|
if (value == base) {
|
|
return;
|
|
}
|
|
Page page{key, {}};
|
|
page.values.fill(base);
|
|
at = pages.insert(at, page);
|
|
}
|
|
at->values[offset] = value;
|
|
if (value == base && std::ranges::all_of(at->values, [&](Cell x) { return x == base; })) {
|
|
pages.erase(at);
|
|
}
|
|
}
|
|
std::size_t bytes() const {
|
|
return sizeof(*this) + pages.capacity() * sizeof(Page);
|
|
}
|
|
std::size_t encoded() const {
|
|
return 9 + pages.size() * (4 + 64 * 4);
|
|
}
|
|
};
|
|
std::vector<Cell> fixture(std::uint32_t edge, std::string_view name) {
|
|
const auto count = static_cast<std::size_t>(edge) * edge * edge;
|
|
std::vector<Cell> values(count, rock);
|
|
for (std::size_t i = 0; i < count; ++i) {
|
|
const auto x = i % edge, y = (i / edge) % edge,
|
|
z = i / (static_cast<std::size_t>(edge) * edge);
|
|
if (name == "sparse" && (i == 1 || i == count / 2 || i == count - 2)) {
|
|
values[i] = 0;
|
|
}
|
|
if (name == "mixed") {
|
|
values[i] = cell(static_cast<std::uint16_t>(1 + (x + 2 * y + 3 * z) % 8), 65535);
|
|
}
|
|
if (name == "excavated" &&
|
|
((x >= edge / 4 && x < 3 * edge / 4 && y >= edge / 4 && y < 3 * edge / 4) ||
|
|
z == edge / 2)) {
|
|
values[i] = 0;
|
|
}
|
|
if (name == "entropy") {
|
|
values[i] = cell(static_cast<std::uint16_t>(1 + i % 1024),
|
|
static_cast<std::uint32_t>(1 + (i / 1024) % 65535));
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
std::uint64_t hash_cell(std::uint64_t hash, Cell value) {
|
|
return (hash ^ value) * 1099511628211ULL;
|
|
}
|
|
template <typename T> void same(const T& layout, const std::vector<Cell>& expected) {
|
|
for (std::size_t i = 0; i < expected.size(); ++i) {
|
|
check(layout.get(i) == expected[i]);
|
|
}
|
|
}
|
|
template <typename T> void bounds(T& layout, std::size_t count) {
|
|
bool read = false, write = false;
|
|
try {
|
|
(void)layout.get(count);
|
|
} catch (const std::out_of_range&) {
|
|
read = true;
|
|
}
|
|
try {
|
|
layout.set(count, rock);
|
|
} catch (const std::out_of_range&) {
|
|
write = true;
|
|
}
|
|
check(read && write);
|
|
}
|
|
using Clock = std::chrono::steady_clock;
|
|
auto ns(Clock::time_point start) {
|
|
return std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - start).count();
|
|
}
|
|
template <typename T>
|
|
void run(std::uint32_t edge, std::string_view pattern, std::string_view kind, unsigned sample,
|
|
bool verify) {
|
|
auto expected = fixture(edge, pattern);
|
|
auto start = Clock::now();
|
|
T layout(expected, edge);
|
|
const auto build_ns = ns(start);
|
|
same(layout, expected);
|
|
const auto initial_bytes = layout.bytes();
|
|
const auto initial_encoded = layout.encoded();
|
|
auto peak = initial_bytes;
|
|
std::uint64_t hash = 14695981039346656037ULL;
|
|
start = Clock::now();
|
|
for (std::size_t i = 0; i < expected.size(); ++i) {
|
|
hash = hash_cell(hash, layout.get(i));
|
|
}
|
|
const auto scan_ns = ns(start);
|
|
std::vector<std::pair<std::size_t, Cell>> edits;
|
|
edits.reserve(4096);
|
|
evo::Random random{123456};
|
|
for (unsigned i = 0; i < 4096; ++i) {
|
|
edits.emplace_back(static_cast<std::size_t>(random.next() % expected.size()),
|
|
i % 2 == 0 ? 0 : rock);
|
|
}
|
|
start = Clock::now();
|
|
for (const auto& [index, value] : edits) {
|
|
layout.set(index, value);
|
|
peak = std::max(peak, layout.bytes());
|
|
}
|
|
const auto edit_ns = ns(start);
|
|
for (const auto& [index, value] : edits) {
|
|
expected[index] = value;
|
|
}
|
|
same(layout, expected);
|
|
bounds(layout, expected.size());
|
|
std::uint64_t final_hash = 14695981039346656037ULL;
|
|
for (std::size_t i = 0; i < expected.size(); ++i) {
|
|
final_hash = hash_cell(final_hash, layout.get(i));
|
|
}
|
|
if (!verify && sample > 0) {
|
|
const auto tiles = static_cast<std::size_t>(128 / edge) * (128 / edge) * (128 / edge);
|
|
std::cout << "{\"edge\":" << edge << ",\"pattern\":\"" << pattern << "\",\"layout\":\""
|
|
<< kind << "\",\"sample\":" << sample << ",\"build_ns\":" << build_ns
|
|
<< ",\"scan_ns\":" << scan_ns << ",\"edit4096_ns\":" << edit_ns
|
|
<< ",\"initial_bytes\":" << initial_bytes << ",\"final_bytes\":" << layout.bytes()
|
|
<< ",\"sampled_peak_bytes\":" << peak
|
|
<< ",\"encoded_estimate\":" << initial_encoded
|
|
<< ",\"tiled128_initial_bytes\":" << initial_bytes * tiles << ",\"hash\":" << hash
|
|
<< ",\"edited_hash\":" << final_hash << "}\n";
|
|
}
|
|
}
|
|
void transitions() {
|
|
std::vector<Cell> input(512, rock);
|
|
Palette palette(input, 8);
|
|
check(palette.indexes.empty());
|
|
for (std::size_t i = 0; i < 256; ++i) {
|
|
palette.set(i, cell(static_cast<std::uint16_t>(i + 2), 65535));
|
|
if (i == 254) {
|
|
check(palette.palette.size() == 256 && palette.dense.empty());
|
|
}
|
|
}
|
|
check(!palette.dense.empty() && palette.palette.empty() && palette.indexes.empty());
|
|
for (std::size_t i = 0; i < 256; ++i) {
|
|
check(palette.get(i) == cell(static_cast<std::uint16_t>(i + 2), 65535));
|
|
}
|
|
Pages pages(input, 8);
|
|
check(pages.pages.empty());
|
|
pages.set(0, 0);
|
|
pages.set(511, 0);
|
|
check(pages.pages.size() == 2);
|
|
pages.set(0, rock);
|
|
pages.set(511, rock);
|
|
check(pages.pages.empty());
|
|
same(pages, input);
|
|
// All representations must recover original logical values after churn;
|
|
// reclaiming retained palette/capacity is explicitly not claimed.
|
|
for (const auto edge : {8U, 16U, 32U, 64U}) {
|
|
auto source = fixture(edge, "uniform");
|
|
Palette a(source, edge);
|
|
Pages b(source, edge);
|
|
Dense c(source, edge);
|
|
for (std::size_t i = 0; i < source.size(); i += 17) {
|
|
a.set(i, 0);
|
|
b.set(i, 0);
|
|
c.set(i, 0);
|
|
}
|
|
for (std::size_t i = 0; i < source.size(); i += 17) {
|
|
a.set(i, rock);
|
|
b.set(i, rock);
|
|
c.set(i, rock);
|
|
}
|
|
same(a, source);
|
|
same(b, source);
|
|
same(c, source);
|
|
}
|
|
}
|
|
} // namespace
|
|
int main(int argc, char** argv) try {
|
|
if (argc > 2 || (argc == 2 && std::string_view{argv[1]} != "--verify")) {
|
|
return 2;
|
|
}
|
|
const bool verify = argc == 2;
|
|
transitions();
|
|
if (!verify) {
|
|
std::cout
|
|
<< "{\"experiment\":\"chunk-layout-v1\",\"seed\":123456,\"edits\":4096,\"compiler\":\""
|
|
#if defined(__clang__)
|
|
<< "Clang " << __clang_version__
|
|
#elif defined(_MSC_VER)
|
|
<< "MSVC " << _MSC_VER
|
|
#else
|
|
<< "GCC " << __VERSION__
|
|
#endif
|
|
<< "\",\"release\":"
|
|
#ifdef NDEBUG
|
|
<< "true"
|
|
#else
|
|
<< "false"
|
|
#endif
|
|
<< "}\n";
|
|
}
|
|
for (const auto edge : {8U, 16U, 32U, 64U}) {
|
|
for (const auto pattern : {"uniform", "sparse", "mixed", "excavated", "entropy"}) {
|
|
for (unsigned sample = 0; sample < (verify ? 1U : 4U); ++sample) {
|
|
run<Dense>(edge, pattern, "dense", sample, verify);
|
|
run<Palette>(edge, pattern, "palette", sample, verify);
|
|
run<Pages>(edge, pattern, "pages4", sample, verify);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
} catch (const std::exception& error) {
|
|
std::fprintf(stderr, "%s\n", error.what());
|
|
return 1;
|
|
} catch (...) {
|
|
return 1;
|
|
}
|