File size: 4,052 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 | #include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <utility>
#include <vector>
#include "velographx/algorithms.hpp"
#include "velographx/csr_graph.hpp"
namespace {
using Clock = std::chrono::steady_clock;
using velographx::CsrGraph;
using velographx::VertexId;
std::vector<std::pair<VertexId, VertexId>> make_edges(std::size_t vertices, std::size_t degree) {
std::vector<std::pair<VertexId, VertexId>> edges;
edges.reserve(vertices * degree);
for (std::size_t u = 0; u < vertices; ++u) {
for (std::size_t d = 1; d <= degree; ++d) {
const auto v = static_cast<VertexId>((u + d * 7919ULL) % vertices);
if (u != v) edges.emplace_back(static_cast<VertexId>(u), v);
}
}
return edges;
}
std::uint64_t hash_u32(const std::vector<std::uint32_t>& values) {
std::uint64_t h = 1469598103934665603ULL;
for (auto v : values) { h ^= v; h *= 1099511628211ULL; }
return h;
}
std::uint64_t hash_vid(const std::vector<VertexId>& values) {
std::uint64_t h = 1469598103934665603ULL;
for (auto v : values) { h ^= v; h *= 1099511628211ULL; }
return h;
}
std::vector<unsigned> parse_threads(const std::string& text) {
std::set<unsigned> unique;
std::stringstream ss(text);
std::string item;
while (std::getline(ss, item, ',')) if (!item.empty()) unique.insert(static_cast<unsigned>(std::stoul(item)));
if (!unique.count(1)) unique.insert(1);
return {unique.begin(), unique.end()};
}
template <class Task>
std::pair<double, std::uint64_t> run_parallel(std::size_t tasks, unsigned threads, Task&& task) {
std::atomic<std::size_t> next{0};
std::vector<std::uint64_t> digests(tasks);
std::vector<std::thread> workers;
const auto t0 = Clock::now();
for (unsigned t = 0; t < threads; ++t) {
workers.emplace_back([&] {
while (true) {
const auto i = next.fetch_add(1, std::memory_order_relaxed);
if (i >= tasks) break;
digests[i] = task(i);
}
});
}
for (auto& w : workers) w.join();
const auto t1 = Clock::now();
std::uint64_t combined = 0;
for (auto h : digests) combined ^= h + 0x9e3779b97f4a7c15ULL + (combined << 6) + (combined >> 2);
const double sec = std::chrono::duration<double>(t1 - t0).count();
return {sec > 0 ? static_cast<double>(tasks) / sec : 0.0, combined};
}
template <class Task>
void emit_algorithm(const char* name, std::size_t tasks, const std::vector<unsigned>& threads, Task&& task) {
double baseline = 0.0;
std::uint64_t expected = 0;
for (auto t : threads) {
const auto [qps, digest] = run_parallel(tasks, t, task);
if (baseline == 0.0) { baseline = qps; expected = digest; }
if (digest != expected) throw std::runtime_error(std::string(name) + " digest mismatch across threads");
const double speedup = baseline > 0 ? qps / baseline : 0.0;
std::cout << name << ',' << t << ',' << tasks << ',' << qps << ',' << speedup << ','
<< speedup / static_cast<double>(t) << ',' << digest << '\n';
}
}
} // namespace
int main(int argc, char** argv) {
const std::size_t vertices = argc > 1 ? std::stoull(argv[1]) : 50000;
const std::size_t degree = argc > 2 ? std::stoull(argv[2]) : 8;
const std::size_t tasks = argc > 3 ? std::stoull(argv[3]) : 32;
const auto threads = parse_threads(argc > 4 ? argv[4] : "1,2,4");
CsrGraph graph(make_edges(vertices, degree), false);
std::cout << "algorithm,threads,tasks,throughput_per_s,speedup,parallel_efficiency,digest\n";
emit_algorithm("bfs", tasks, threads, [&](std::size_t i) {
const auto src = static_cast<VertexId>((i * 2654435761ULL) % graph.vertex_count());
return hash_u32(velographx::bfs_distances(graph, src));
});
emit_algorithm("connected_components", tasks, threads, [&](std::size_t) {
return hash_vid(velographx::connected_components(graph));
});
emit_algorithm("triangle_count", tasks, threads, [&](std::size_t) {
return velographx::triangle_count(graph);
});
return 0;
}
|