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