File size: 5,591 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 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | #include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <iostream>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#ifdef __linux__
#include <sched.h>
#endif
#include "velographx/algorithms.hpp"
#include "velographx/io.hpp"
namespace {
std::uint64_t digest(const std::vector<std::uint32_t>& distances) {
std::uint64_t h = 1469598103934665603ULL;
for (std::uint32_t v : distances) {
h ^= static_cast<std::uint64_t>(v);
h *= 1099511628211ULL;
}
return h;
}
unsigned available_cpu_count() {
#ifdef __linux__
cpu_set_t set;
CPU_ZERO(&set);
if (sched_getaffinity(0, sizeof(set), &set) == 0) {
const auto count = CPU_COUNT(&set);
if (count > 0) return static_cast<unsigned>(count);
}
#endif
return std::max(1u, std::thread::hardware_concurrency());
}
std::vector<unsigned> parse_threads(const std::string& text) {
std::set<unsigned> unique;
std::stringstream stream(text);
std::string item;
while (std::getline(stream, item, ',')) {
if (item.empty()) continue;
const auto value = static_cast<unsigned>(std::stoul(item));
if (value == 0) throw std::invalid_argument("thread counts must be positive");
unique.insert(value);
}
if (unique.empty()) throw std::invalid_argument("thread list is empty");
if (!unique.contains(1)) unique.insert(1);
return {unique.begin(), unique.end()};
}
std::vector<unsigned> default_threads() {
const auto available = available_cpu_count();
std::vector<unsigned> out;
for (unsigned threads = 1; threads <= available && threads <= 64; threads *= 2) {
out.push_back(threads);
if (threads > 32) break;
}
if (out.back() != available && available <= 64) out.push_back(available);
std::sort(out.begin(), out.end());
out.erase(std::unique(out.begin(), out.end()), out.end());
return out;
}
struct Measurement {
unsigned threads{};
std::int64_t total_ns{};
double queries_per_second{};
std::uint64_t digest{};
};
Measurement run_case(const velographx::CsrGraph& graph,
const std::vector<velographx::VertexId>& sources,
unsigned threads) {
using clock = std::chrono::steady_clock;
std::vector<std::uint64_t> digests(sources.size(), 0);
std::atomic<std::size_t> next{0};
const auto begin = clock::now();
std::vector<std::thread> workers;
workers.reserve(threads);
for (unsigned t = 0; t < threads; ++t) {
workers.emplace_back([&] {
for (;;) {
const auto i = next.fetch_add(1, std::memory_order_relaxed);
if (i >= sources.size()) break;
digests[i] = digest(velographx::bfs_distances(graph, sources[i]));
}
});
}
for (auto& worker : workers) worker.join();
const auto end = clock::now();
const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count();
std::uint64_t combined = 0;
for (const auto value : digests) {
combined ^= value + 0x9e3779b97f4a7c15ULL + (combined << 6) + (combined >> 2);
}
const double qps = ns > 0
? static_cast<double>(sources.size()) * 1e9 /
static_cast<double>(ns)
: 0.0;
return {threads, ns, qps, combined};
}
} // namespace
int main(int argc, char** argv) {
if (argc < 2 || argc > 4) {
std::cerr << "usage: velographx_thread_scaling_bfs <edge-list> [queries] [threads-csv]\n";
return 2;
}
try {
const std::filesystem::path path = argv[1];
const std::size_t queries = argc >= 3 ? static_cast<std::size_t>(std::stoull(argv[2])) : 32;
auto requested_threads = argc == 4 ? parse_threads(argv[3]) : default_threads();
const auto available = available_cpu_count();
requested_threads.erase(
std::remove_if(requested_threads.begin(), requested_threads.end(),
[available](unsigned threads) { return threads > available; }),
requested_threads.end());
if (requested_threads.empty()) requested_threads.push_back(1);
const auto graph = velographx::load_edge_list(path, false);
if (graph.vertex_count() == 0 || queries == 0) return 2;
std::vector<velographx::VertexId> sources;
sources.reserve(queries);
for (std::size_t i = 0; i < queries; ++i) {
sources.push_back(static_cast<velographx::VertexId>(
(i * 2654435761ULL) % graph.vertex_count()));
}
std::cout << "threads,queries,total_ns,queries_per_second,speedup,parallel_efficiency,digest\n";
double baseline_qps = 0.0;
std::uint64_t baseline_digest = 0;
for (const auto threads : requested_threads) {
const auto result = run_case(graph, sources, threads);
if (baseline_qps == 0.0) {
baseline_qps = result.queries_per_second;
baseline_digest = result.digest;
}
if (result.digest != baseline_digest) {
std::cerr << "error: BFS digest differs across thread counts\n";
return 3;
}
const double speedup = baseline_qps > 0.0
? result.queries_per_second / baseline_qps
: 0.0;
const double efficiency = speedup / static_cast<double>(threads);
std::cout << result.threads << ',' << queries << ',' << result.total_ns << ','
<< result.queries_per_second << ',' << speedup << ',' << efficiency
<< ',' << result.digest << '\n';
}
} catch (const std::exception& error) {
std::cerr << "error: " << error.what() << '\n';
return 2;
}
return 0;
}
|