| #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]; |
| } |
| } |
|
|
| 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; |
| } |
|
|
