| #include <algorithm> |
| #include <chrono> |
| #include <cstdint> |
| #include <fstream> |
| #include <iostream> |
| #include <limits> |
| #include <queue> |
| #include <stdexcept> |
| #include <utility> |
| #include <vector> |
|
|
| #include "velographx/incremental/bfs.hpp" |
| #include "velographx/storage/dynamic_graph.hpp" |
|
|
| using velographx::DynamicGraph; |
| using velographx::IncrementalBFS; |
| using velographx::UpdateBatch; |
| using velographx::VertexId; |
|
|
| static std::vector<std::pair<std::uint64_t,std::uint64_t>> read_edges(const char* path) { |
| std::ifstream in(path, std::ios::binary); |
| if (!in) throw std::runtime_error("cannot open input"); |
| std::vector<std::pair<std::uint64_t,std::uint64_t>> edges; |
| std::uint64_t u, v; |
| while (in.read(reinterpret_cast<char*>(&u), sizeof(u))) { |
| if (!in.read(reinterpret_cast<char*>(&v), sizeof(v))) throw std::runtime_error("truncated pair"); |
| edges.emplace_back(u, v); |
| } |
| return edges; |
| } |
|
|
| static std::uint64_t digest(const std::vector<std::uint32_t>& d) { |
| std::uint64_t h = 1469598103934665603ULL; |
| for (std::size_t i=0;i<d.size();++i) { |
| h ^= (static_cast<std::uint64_t>(d[i]) << 32) ^ i; |
| h *= 1099511628211ULL; |
| } |
| return h; |
| } |
|
|
| int main(int argc, char** argv) { |
| if (argc != 5) { |
| std::cerr << "usage: " << argv[0] << " graph root imported_rate batch_size\n"; |
| return 2; |
| } |
| const auto raw = read_edges(argv[1]); |
| const auto root = static_cast<VertexId>(std::stoull(argv[2])); |
| const double imported_rate = std::stod(argv[3]); |
| const std::size_t batch = std::stoull(argv[4]); |
| std::uint64_t maxv = 0; |
| for (auto [u,v] : raw) maxv = std::max(maxv, std::max(u,v)); |
| if (maxv > std::numeric_limits<VertexId>::max()) throw std::runtime_error("vertex id exceeds VeloGraphX domain"); |
| const std::size_t imported = static_cast<std::size_t>(raw.size() * imported_rate); |
|
|
| std::vector<std::pair<VertexId,VertexId>> initial; |
| initial.reserve(imported); |
| for (std::size_t i=0;i<imported;++i) initial.emplace_back(static_cast<VertexId>(raw[i].first), static_cast<VertexId>(raw[i].second)); |
| DynamicGraph graph(static_cast<std::size_t>(maxv)+1, true); |
| graph.bulk_load_edges(initial); |
| IncrementalBFS bfs(graph, root); |
|
|
| std::size_t batches = 0; |
| const auto start = std::chrono::steady_clock::now(); |
| for (std::size_t begin=imported; begin<raw.size(); begin+=batch) { |
| const auto end = std::min(begin+batch, raw.size()); |
| UpdateBatch add; |
| for (std::size_t i=begin;i<end;++i) add.add(static_cast<VertexId>(raw[i].first), static_cast<VertexId>(raw[i].second)); |
| if (!add.empty()) bfs.apply(add); |
|
|
| UpdateBatch del; |
| for (std::size_t i=begin;i<end;++i) { |
| const std::size_t old = i - imported; |
| if (old >= raw.size()) break; |
| del.remove(static_cast<VertexId>(raw[old].first), static_cast<VertexId>(raw[old].second)); |
| } |
| if (!del.empty()) bfs.apply(del); |
| ++batches; |
| } |
| const auto stop = std::chrono::steady_clock::now(); |
|
|
| IncrementalBFS reference(graph, root); |
| const bool correct = bfs.distances() == reference.distances(); |
| std::vector<std::size_t> layers; |
| for (auto x : bfs.distances()) { |
| if (x == IncrementalBFS::unreachable) continue; |
| if (layers.size() <= x) layers.resize(static_cast<std::size_t>(x)+1); |
| ++layers[x]; |
| } |
| const auto wall_us = std::chrono::duration_cast<std::chrono::microseconds>(stop-start).count(); |
| std::cout << "{\"system\":\"VeloGraphX\",\"correct\":" << (correct?"true":"false") |
| << ",\"batches\":" << batches << ",\"wall_us\":" << wall_us |
| << ",\"mean_batch_us\":" << (batches ? static_cast<double>(wall_us)/batches : 0.0) |
| << ",\"distance_digest\":" << digest(bfs.distances()) << ",\"layers\":["; |
| for (std::size_t i=0;i<layers.size();++i) { if (i) std::cout << ','; std::cout << layers[i]; } |
| std::cout << "]}\n"; |
| return correct ? 0 : 3; |
| } |
|
|
