| #include <algorithm> |
| #include <chrono> |
| #include <cmath> |
| #include <cstdint> |
| #include <fstream> |
| #include <iostream> |
| #include <limits> |
| #include <sstream> |
| #include <stdexcept> |
| #include <string> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
|
|
| #include "velographx/incremental/triangles.hpp" |
| #include "velographx/storage/dynamic_graph.hpp" |
| #include "GoldenCounter.h" |
|
|
| namespace { |
| using Edge = std::pair<velographx::VertexId, velographx::VertexId>; |
| using Clock = std::chrono::steady_clock; |
|
|
| std::vector<Edge> load_edges(const std::string& path, std::size_t& vertex_count) { |
| std::ifstream in(path); |
| if (!in) throw std::runtime_error("failed to open edge list"); |
| std::vector<Edge> edges; |
| velographx::VertexId max_vertex = 0; |
| bool saw = false; |
| std::string line; |
| while (std::getline(in, line)) { |
| const auto first = line.find_first_not_of(" \t\r\n"); |
| if (first == std::string::npos || line[first] == '#') continue; |
| std::istringstream row(line); |
| velographx::VertexId u = 0, v = 0; |
| if (!(row >> u >> v) || u == v) continue; |
| if (u > v) std::swap(u, v); |
| edges.emplace_back(u, v); |
| max_vertex = std::max(max_vertex, std::max(u, v)); |
| saw = true; |
| } |
| std::sort(edges.begin(), edges.end()); |
| edges.erase(std::unique(edges.begin(), edges.end()), edges.end()); |
| vertex_count = saw ? static_cast<std::size_t>(max_vertex) + 1 : 0; |
| return edges; |
| } |
|
|
| std::uint64_t edge_key(velographx::VertexId u, velographx::VertexId v) { |
| if (u > v) std::swap(u, v); |
| return (static_cast<std::uint64_t>(u) << 32U) | v; |
| } |
|
|
| velographx::UpdateBatch make_updates(const velographx::DynamicGraph& graph, |
| std::size_t requested, |
| std::uint64_t seed) { |
| velographx::UpdateBatch batch; |
| batch.updates.reserve(requested); |
| std::unordered_set<std::uint64_t> selected; |
| selected.reserve(requested * 2 + 1); |
| const auto n = static_cast<std::uint64_t>(graph.vertex_count()); |
| std::uint64_t state = seed | 1ULL; |
| std::size_t attempts = 0; |
| const std::size_t max_attempts = std::max<std::size_t>(requested * 500, 100000); |
| while (batch.updates.size() < requested && attempts++ < max_attempts) { |
| state = state * 6364136223846793005ULL + 1442695040888963407ULL; |
| const auto u = static_cast<velographx::VertexId>((state >> 17) % n); |
| state = state * 6364136223846793005ULL + 1442695040888963407ULL; |
| const auto v = static_cast<velographx::VertexId>((state >> 17) % n); |
| if (u == v || graph.has_edge(u, v)) continue; |
| if (selected.insert(edge_key(u, v)).second) batch.add(u, v); |
| } |
| if (batch.updates.size() != requested) throw std::runtime_error("could not generate updates"); |
| return batch; |
| } |
|
|
| long long ns(Clock::time_point a, Clock::time_point b) { |
| return std::chrono::duration_cast<std::chrono::nanoseconds>(b - a).count(); |
| } |
| } |
|
|
| int main(int argc, char** argv) { |
| if (argc != 4) { |
| std::cerr << "usage: large_same_run_published_reference <edge-list> <trusted-initial-triangles> <fraction>\n"; |
| return 2; |
| } |
| const std::string dataset = argv[1]; |
| const auto trusted = static_cast<std::uint64_t>(std::stoull(argv[2])); |
| const double fraction = std::stod(argv[3]); |
| if (!(fraction > 0.0)) return 2; |
|
|
| std::size_t vertices = 0; |
| const auto edges = load_edges(dataset, vertices); |
| if (edges.empty()) return 2; |
|
|
| velographx::DynamicGraph graph(vertices, false); |
| graph.bulk_load_edges(edges); |
| velographx::IncrementalTriangleCount triangles(graph, trusted); |
| const std::size_t requested = std::max<std::size_t>(1, static_cast<std::size_t>(std::ceil(edges.size() * fraction))); |
| const auto updates = make_updates(graph, requested, 0x4d595df4d0f33173ULL ^ requested); |
|
|
| const auto vb = Clock::now(); |
| triangles.apply(updates); |
| const auto ve = Clock::now(); |
| const auto vx = triangles.value(); |
|
|
| GoldenCounter golden(std::numeric_limits<int>::max()); |
| for (const auto& [u, v] : edges) golden.insert_edge(u, v, 0); |
| const auto gb = Clock::now(); |
| long long timestamp = 1; |
| for (const auto& op : updates.updates) golden.insert_edge(op.src, op.dst, timestamp++); |
| const auto gu = Clock::now(); |
| const auto gq = Clock::now(); |
| const auto golden_value = golden.triangle_count(); |
| const auto ge = Clock::now(); |
|
|
| const auto fb = Clock::now(); |
| triangles.recompute(); |
| const auto fe = Clock::now(); |
| const auto full = triangles.value(); |
| const bool correct = vx == full && vx == static_cast<std::uint64_t>(golden_value); |
|
|
| std::cout << "dataset,vertices,base_edges,fraction,requested_edges,velographx_update_ns,golden_update_ns,golden_query_ns,golden_answer_ready_ns,full_recompute_ns,velographx_triangles,golden_triangles,recomputed_triangles,correct\n"; |
| std::cout << dataset << ',' << vertices << ',' << edges.size() << ',' << fraction << ',' << requested << ',' |
| << ns(vb, ve) << ',' << ns(gb, gu) << ',' << ns(gq, ge) << ',' << (ns(gb, gu) + ns(gq, ge)) << ',' |
| << ns(fb, fe) << ',' << vx << ',' << golden_value << ',' << full << ',' << (correct ? 1 : 0) << '\n'; |
| return correct ? 0 : 1; |
| } |
|
|
