File size: 4,089 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 | #include "velographx/storage/compressed_adjacency.hpp"
#include "velographx/storage/compressed_decode_simd.hpp"
#include <chrono>
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
int main() {
using clock = std::chrono::steady_clock;
using namespace velographx::storage;
struct Family { const char* name; std::uint32_t gap; };
const std::vector<Family> families{{"dense", 1}, {"medium", 16}, {"sparse", 4096}};
constexpr std::size_t values = 100000;
constexpr int repeat = 5;
std::cout << "family,codec,values,encoded_bytes,ratio,encode_us,decode_us\n";
for (const auto& family : families) {
std::vector<VertexId> ids;
ids.reserve(values);
VertexId current = 0;
for (std::size_t i = 0; i < values; ++i) {
current += family.gap + static_cast<std::uint32_t>(i % 7 == 0);
ids.push_back(current);
}
{
long long encode_us = 0, decode_us = 0;
std::vector<std::uint8_t> encoded;
std::vector<VertexId> decoded;
for (int r = 0; r < repeat; ++r) {
auto t0 = clock::now();
encoded = variable_byte_delta_encode(ids);
auto t1 = clock::now();
decoded = variable_byte_delta_decode(encoded);
auto t2 = clock::now();
encode_us += std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count();
decode_us += std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
}
if (decoded != ids) return 2;
std::cout << family.name << ",varbyte," << values << ',' << encoded.size() << ','
<< compression_ratio_bytes(ids, encoded) << ',' << encode_us / repeat << ','
<< decode_us / repeat << '\n';
}
{
long long encode_us = 0, decode_us = 0;
BlockedAdjacency encoded;
std::vector<VertexId> decoded;
for (int r = 0; r < repeat; ++r) {
auto t0 = clock::now();
encoded = blocked_variable_byte_encode(ids, 128);
auto t1 = clock::now();
decoded = blocked_variable_byte_decode(encoded);
auto t2 = clock::now();
encode_us += std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count();
decode_us += std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
}
if (decoded != ids) return 3;
const double ratio = static_cast<double>(ids.size() * sizeof(VertexId)) /
static_cast<double>(encoded.payload.empty() ? 1 : encoded.payload.size());
std::cout << family.name << ",blocked-varbyte," << values << ',' << encoded.payload.size() << ','
<< ratio << ',' << encode_us / repeat << ',' << decode_us / repeat << '\n';
}
{
long long encode_us = 0, scalar_us = 0, vector_us = 0;
SimdFriendlyAdjacency encoded;
std::vector<VertexId> decoded;
for (int r = 0; r < repeat; ++r) {
auto t0 = clock::now();
encoded = simd_friendly_delta_encode(ids, 128);
auto t1 = clock::now();
decoded = simd_friendly_delta_decode(encoded);
auto t2 = clock::now();
auto decoded_vector = simd_friendly_delta_decode_vectorized(encoded);
auto t3 = clock::now();
if (decoded_vector != ids) return 4;
encode_us += std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count();
scalar_us += std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
vector_us += std::chrono::duration_cast<std::chrono::microseconds>(t3 - t2).count();
}
if (decoded != ids) return 5;
std::cout << family.name << ",fixed-width-scalar," << values << ',' << encoded.payload.size() << ','
<< compression_ratio_bytes(ids, encoded) << ',' << encode_us / repeat << ','
<< scalar_us / repeat << '\n';
std::cout << family.name << ",fixed-width-vectorized," << values << ',' << encoded.payload.size() << ','
<< compression_ratio_bytes(ids, encoded) << ',' << encode_us / repeat << ','
<< vector_us / repeat << '\n';
}
}
return 0;
}
|