| #include <algorithm> |
| #include <chrono> |
| #include <cstdint> |
| #include <iostream> |
| #include <random> |
| #include <string_view> |
| #include <vector> |
|
|
| #include "velographx/kernels/intersection.hpp" |
| #include "velographx/kernels/cpu_features.hpp" |
|
|
| using Clock = std::chrono::steady_clock; |
| using VertexId = velographx::kernels::VertexId; |
|
|
| namespace { |
| std::vector<VertexId> make_sorted_unique(std::size_t n, std::uint32_t seed, std::uint32_t max_value) { |
| std::mt19937 rng(seed); |
| std::uniform_int_distribution<std::uint32_t> dist(0, max_value); |
| std::vector<VertexId> out; |
| out.reserve(n); |
| while (out.size() < n) out.push_back(dist(rng)); |
| std::sort(out.begin(), out.end()); |
| out.erase(std::unique(out.begin(), out.end()), out.end()); |
| while (out.size() < n) { |
| out.push_back(out.empty() ? 0u : static_cast<VertexId>(out.back() + 1u)); |
| } |
| return out; |
| } |
|
|
| template <class Fn> |
| double bench(Fn&& fn, std::span<const VertexId> a, std::span<const VertexId> b, std::size_t reps, std::size_t& checksum) { |
| const auto start = Clock::now(); |
| std::size_t local = 0; |
| for (std::size_t i = 0; i < reps; ++i) local += fn(a, b); |
| const auto stop = Clock::now(); |
| checksum ^= local; |
| return std::chrono::duration<double, std::micro>(stop - start).count() / static_cast<double>(reps); |
| } |
|
|
| void emit(std::string_view name, std::size_t a_size, std::size_t b_size, double us, std::size_t count) { |
| std::cout << "{\"benchmark\":\"intersection\",\"kernel\":\"" << name |
| << "\",\"a_size\":" << a_size << ",\"b_size\":" << b_size |
| << ",\"mean_us\":" << us << ",\"intersection_count\":" << count << "}\n"; |
| } |
| } |
|
|
| int main() { |
| constexpr std::size_t reps = 1000; |
| const std::vector<std::pair<std::size_t, std::size_t>> cases{ |
| {8, 8}, {32, 32}, {128, 128}, {32, 1024}, {128, 4096}, {1024, 1024}}; |
| std::size_t checksum = 0; |
|
|
| std::cout << "{\"cpu_best_isa\":\"" << velographx::kernels::best_isa() << "\"}\n"; |
| for (const auto [as, bs] : cases) { |
| auto a = make_sorted_unique(as, static_cast<std::uint32_t>(as + 17), 1u << 20); |
| auto b = make_sorted_unique(bs, static_cast<std::uint32_t>(bs + 29), 1u << 20); |
| const auto reference = velographx::kernels::scalar_intersection(a, b); |
|
|
| emit("scalar", as, bs, |
| bench(velographx::kernels::scalar_intersection, a, b, reps, checksum), reference); |
| emit("galloping", as, bs, |
| bench([&](auto x, auto y) { |
| return x.size() <= y.size() ? velographx::kernels::galloping_intersection(x, y) |
| : velographx::kernels::galloping_intersection(y, x); |
| }, a, b, reps, checksum), reference); |
| emit("adaptive", as, bs, |
| bench(velographx::kernels::adaptive_intersection, a, b, reps, checksum), reference); |
| } |
|
|
| if (checksum == static_cast<std::size_t>(-1)) std::cerr << checksum << '\n'; |
| return 0; |
| } |
|
|
