File size: 4,821 Bytes
d844fc8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | #include <algorithm>
#include <chrono>
#include <cstdint>
#include <iostream>
#include <limits>
#include <queue>
#include <string>
#include <vector>
#include "velographx/storage/compressed_adjacency.hpp"
#include "velographx/storage/compressed_decode_simd.hpp"
namespace {
using Clock = std::chrono::steady_clock;
using VertexId = velographx::storage::VertexId;
std::vector<std::vector<VertexId>> make_graph(std::size_t vertices, std::size_t degree) {
std::vector<std::vector<VertexId>> rows(vertices);
for (std::size_t u = 0; u < vertices; ++u) {
auto& row = rows[u];
row.reserve(degree * 2);
for (std::size_t d = 1; d <= degree; ++d) {
row.push_back(static_cast<VertexId>((u + d) % vertices));
row.push_back(static_cast<VertexId>((u + vertices - d) % vertices));
}
std::sort(row.begin(), row.end());
row.erase(std::unique(row.begin(), row.end()), row.end());
}
return rows;
}
template <class NeighborProvider>
std::uint64_t bfs_digest(std::size_t vertices, NeighborProvider&& neighbors) {
constexpr auto unreachable = std::numeric_limits<std::uint32_t>::max();
std::vector<std::uint32_t> dist(vertices, unreachable);
std::queue<VertexId> q;
dist[0] = 0;
q.push(0);
while (!q.empty()) {
const auto u = q.front(); q.pop();
const auto row = neighbors(u);
for (auto v : row) {
if (dist[v] != unreachable) continue;
dist[v] = dist[u] + 1;
q.push(v);
}
}
std::uint64_t h = 1469598103934665603ULL;
for (auto d : dist) { h ^= d; h *= 1099511628211ULL; }
return h;
}
template <class F>
double median_ms(F&& f, std::uint64_t expected_digest, int repeats = 5) {
std::vector<double> values;
for (int i = 0; i < repeats; ++i) {
const auto t0 = Clock::now();
const auto digest = f();
const auto t1 = Clock::now();
if (digest != expected_digest) throw std::runtime_error("compressed traversal correctness mismatch");
values.push_back(std::chrono::duration<double, std::milli>(t1 - t0).count());
}
std::sort(values.begin(), values.end());
return values[values.size() / 2];
}
} // namespace
int main(int argc, char** argv) {
using namespace velographx::storage;
const std::size_t vertices = argc > 1 ? std::stoull(argv[1]) : 100000;
const std::size_t degree = argc > 2 ? std::stoull(argv[2]) : 8;
const auto rows = make_graph(vertices, degree);
std::size_t raw_bytes = 0;
for (const auto& row : rows) raw_bytes += row.size() * sizeof(VertexId);
const auto raw_digest = bfs_digest(vertices, [&](VertexId u) { return rows[u]; });
const auto raw_ms = median_ms([&] { return bfs_digest(vertices, [&](VertexId u) { return rows[u]; }); }, raw_digest);
std::vector<std::vector<std::uint8_t>> varbyte(vertices);
std::vector<BlockedAdjacency> blocked(vertices);
std::vector<SimdFriendlyAdjacency> fixed(vertices);
std::size_t varbyte_bytes = 0, blocked_bytes = 0, fixed_bytes = 0;
for (std::size_t u = 0; u < vertices; ++u) {
varbyte[u] = variable_byte_delta_encode(rows[u]);
blocked[u] = blocked_variable_byte_encode(rows[u], 128);
fixed[u] = simd_friendly_delta_encode(rows[u], 128);
varbyte_bytes += varbyte[u].size();
blocked_bytes += blocked[u].payload.size() + blocked[u].block_offsets.size() * sizeof(std::size_t);
fixed_bytes += fixed[u].payload.size() + fixed[u].blocks.size() * sizeof(FixedWidthDeltaBlock);
}
const auto varbyte_ms = median_ms([&] {
return bfs_digest(vertices, [&](VertexId u) { return variable_byte_delta_decode(varbyte[u]); });
}, raw_digest);
const auto blocked_ms = median_ms([&] {
return bfs_digest(vertices, [&](VertexId u) { return blocked_variable_byte_decode(blocked[u]); });
}, raw_digest);
const auto fixed_scalar_ms = median_ms([&] {
return bfs_digest(vertices, [&](VertexId u) { return simd_friendly_delta_decode(fixed[u]); });
}, raw_digest);
const auto fixed_vector_ms = median_ms([&] {
return bfs_digest(vertices, [&](VertexId u) { return simd_friendly_delta_decode_vectorized(fixed[u]); });
}, raw_digest);
auto emit = [&](const char* codec, std::size_t bytes, double ms) {
const double ratio = bytes ? static_cast<double>(raw_bytes) / static_cast<double>(bytes) : 0.0;
const double traversal_ratio = raw_ms > 0.0 ? ms / raw_ms : 0.0;
std::cout << codec << ',' << raw_bytes << ',' << bytes << ',' << ratio << ','
<< raw_ms << ',' << ms << ',' << traversal_ratio << ',' << raw_digest << '\n';
};
std::cout << "codec,raw_bytes,encoded_bytes,compression_ratio,raw_bfs_ms,codec_bfs_ms,relative_to_raw,digest\n";
emit("varbyte", varbyte_bytes, varbyte_ms);
emit("blocked-varbyte", blocked_bytes, blocked_ms);
emit("fixed-width-scalar", fixed_bytes, fixed_scalar_ms);
emit("fixed-width-vectorized", fixed_bytes, fixed_vector_ms);
return 0;
}
|