| #include <algorithm> |
| #include <chrono> |
| #include <cstdint> |
| #include <iomanip> |
| #include <iostream> |
| #include <set> |
| #include <utility> |
| #include <vector> |
|
|
| #include <boost/graph/adjacency_list.hpp> |
|
|
| #include "velographx/csr_graph.hpp" |
| #include "velographx/incremental/bfs.hpp" |
| #include "velographx/storage/dynamic_graph.hpp" |
|
|
| namespace boost_adapter { |
|
|
| using velographx::UpdateBatch; |
| using velographx::VertexId; |
| using Storage = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS>; |
|
|
| struct Graph { |
| explicit Graph(std::size_t vertices) : storage(vertices) {} |
| Storage storage; |
| std::uint64_t version{0}; |
| }; |
|
|
| std::size_t vx_vertex_count(const Graph& graph) { return boost::num_vertices(graph.storage); } |
| bool vx_is_directed(const Graph&) { return false; } |
| std::uint64_t vx_version(const Graph& graph) { return graph.version; } |
|
|
| template <class Fn> |
| void vx_for_each_neighbor(const Graph& graph, VertexId u, Fn&& fn) { |
| const auto [begin, end] = boost::adjacent_vertices(u, graph.storage); |
| for (auto it = begin; it != end; ++it) fn(static_cast<VertexId>(*it)); |
| } |
|
|
| bool vx_has_edge(const Graph& graph, VertexId u, VertexId v) { |
| return boost::edge(u, v, graph.storage).second; |
| } |
|
|
| void vx_apply_updates(Graph& graph, const UpdateBatch& batch) { |
| if (batch.empty()) return; |
| for (const auto& op : batch.updates) { |
| if (op.src >= boost::num_vertices(graph.storage) || |
| op.dst >= boost::num_vertices(graph.storage)) { |
| continue; |
| } |
| if (op.add) { |
| if (!boost::edge(op.src, op.dst, graph.storage).second) { |
| boost::add_edge(op.src, op.dst, graph.storage); |
| } |
| } else { |
| boost::remove_edge(op.src, op.dst, graph.storage); |
| } |
| } |
| ++graph.version; |
| } |
|
|
| } |
|
|
| namespace { |
|
|
| using velographx::BasicIncrementalBFS; |
| using velographx::CsrGraph; |
| using velographx::DynamicGraph; |
| using velographx::UpdateBatch; |
| using velographx::VertexId; |
|
|
| std::vector<std::pair<VertexId, VertexId>> make_graph(std::size_t vertices) { |
| std::set<std::pair<VertexId, VertexId>> unique; |
| constexpr VertexId offsets[] = {1, 7, 31, 127}; |
| for (VertexId u = 0; u < vertices; ++u) { |
| for (auto offset : offsets) { |
| const auto v = static_cast<VertexId>((static_cast<std::size_t>(u) + offset) % vertices); |
| if (u == v) continue; |
| const auto edge = std::minmax(u, v); |
| unique.insert({edge.first, edge.second}); |
| } |
| } |
| return {unique.begin(), unique.end()}; |
| } |
|
|
| std::vector<UpdateBatch> make_incremental_batches(std::size_t vertices) { |
| std::vector<UpdateBatch> batches; |
| batches.reserve(5); |
| for (VertexId i = 0; i < 5; ++i) { |
| UpdateBatch batch; |
| const auto u = static_cast<VertexId>((i * 17) % vertices); |
| const auto ring = static_cast<VertexId>((static_cast<std::size_t>(u) + 1) % vertices); |
| const auto chord = static_cast<VertexId>((static_cast<std::size_t>(u) + 3) % vertices); |
| batch.remove(std::min(u, ring), std::max(u, ring), i * 2); |
| batch.add(std::min(u, chord), std::max(u, chord), i * 2 + 1); |
| batches.push_back(std::move(batch)); |
| } |
| return batches; |
| } |
|
|
| template <class Graph> |
| double median_recompute_us(Graph& graph, VertexId source, std::vector<std::uint32_t>& distances) { |
| BasicIncrementalBFS<Graph> bfs(graph, source); |
| std::vector<double> samples; |
| samples.reserve(5); |
| for (int rep = 0; rep < 5; ++rep) { |
| const auto begin = std::chrono::steady_clock::now(); |
| bfs.recompute(); |
| const auto end = std::chrono::steady_clock::now(); |
| samples.push_back(std::chrono::duration<double, std::micro>(end - begin).count()); |
| } |
| std::sort(samples.begin(), samples.end()); |
| distances = bfs.distances(); |
| return samples[samples.size() / 2]; |
| } |
|
|
| std::uint64_t digest(const std::vector<std::uint32_t>& distances) { |
| std::uint64_t h = 1469598103934665603ULL; |
| for (auto d : distances) { |
| h ^= static_cast<std::uint64_t>(d); |
| h *= 1099511628211ULL; |
| } |
| return h; |
| } |
|
|
| } |
|
|
| int main(int argc, char** argv) { |
| const std::size_t vertices = argc > 1 ? static_cast<std::size_t>(std::stoull(argv[1])) : 8192; |
| const VertexId source = 0; |
| const auto edges = make_graph(vertices); |
|
|
| DynamicGraph dynamic(vertices, false); |
| dynamic.bulk_load_edges(edges); |
| CsrGraph csr(edges, false); |
| boost_adapter::Graph boost_graph(vertices); |
| for (const auto& [u, v] : edges) boost::add_edge(u, v, boost_graph.storage); |
|
|
| std::vector<std::uint32_t> dynamic_dist; |
| std::vector<std::uint32_t> csr_dist; |
| std::vector<std::uint32_t> boost_dist; |
| const auto dynamic_us = median_recompute_us(dynamic, source, dynamic_dist); |
| const auto csr_us = median_recompute_us(csr, source, csr_dist); |
| const auto boost_us = median_recompute_us(boost_graph, source, boost_dist); |
| const bool recompute_exact = dynamic_dist == csr_dist && dynamic_dist == boost_dist; |
|
|
| BasicIncrementalBFS<DynamicGraph> dynamic_incremental(dynamic, source); |
| BasicIncrementalBFS<boost_adapter::Graph> boost_incremental(boost_graph, source); |
| std::vector<double> dynamic_apply_samples; |
| std::vector<double> boost_apply_samples; |
| bool incremental_exact = true; |
| for (const auto& batch : make_incremental_batches(vertices)) { |
| auto begin = std::chrono::steady_clock::now(); |
| dynamic_incremental.apply(batch); |
| auto end = std::chrono::steady_clock::now(); |
| dynamic_apply_samples.push_back(std::chrono::duration<double, std::micro>(end - begin).count()); |
|
|
| begin = std::chrono::steady_clock::now(); |
| boost_incremental.apply(batch); |
| end = std::chrono::steady_clock::now(); |
| boost_apply_samples.push_back(std::chrono::duration<double, std::micro>(end - begin).count()); |
|
|
| incremental_exact = incremental_exact && |
| dynamic_incremental.distances() == boost_incremental.distances(); |
| } |
| std::sort(dynamic_apply_samples.begin(), dynamic_apply_samples.end()); |
| std::sort(boost_apply_samples.begin(), boost_apply_samples.end()); |
| const auto dynamic_apply_us = dynamic_apply_samples[dynamic_apply_samples.size() / 2]; |
| const auto boost_apply_us = boost_apply_samples[boost_apply_samples.size() / 2]; |
| const bool exact = recompute_exact && incremental_exact; |
|
|
| std::cout << std::fixed << std::setprecision(3) |
| << "{\"schema_version\":1," |
| << "\"benchmark\":\"same-algorithm-storage-bfs\"," |
| << "\"backend\":\"boost-adjacency-list\"," |
| << "\"algorithm\":\"BasicIncrementalBFS\"," |
| << "\"vertices\":" << vertices << ',' |
| << "\"edges\":" << edges.size() << ',' |
| << "\"source\":" << source << ',' |
| << "\"repetitions\":5," |
| << "\"incremental_batches\":5," |
| << "\"exact\":" << (exact ? "true" : "false") << ',' |
| << "\"recompute_exact\":" << (recompute_exact ? "true" : "false") << ',' |
| << "\"incremental_exact\":" << (incremental_exact ? "true" : "false") << ',' |
| << "\"digest\":" << digest(dynamic_incremental.distances()) << ',' |
| << "\"dynamic_graph_median_us\":" << dynamic_us << ',' |
| << "\"csr_graph_median_us\":" << csr_us << ',' |
| << "\"boost_median_us\":" << boost_us << ',' |
| << "\"dynamic_incremental_median_us\":" << dynamic_apply_us << ',' |
| << "\"boost_incremental_median_us\":" << boost_apply_us |
| << "}\n"; |
|
|
| return exact ? 0 : 2; |
| } |
|
|
