| #include <algorithm> |
| #include <chrono> |
| #include <cstdint> |
| #include <fstream> |
| #include <iostream> |
| #include <limits> |
| #include <sstream> |
| #include <stdexcept> |
| #include <string> |
| #include <utility> |
| #include <vector> |
|
|
| #include "velographx/storage/consolidation.hpp" |
|
|
| namespace { |
| using Clock = std::chrono::steady_clock; |
| using velographx::DynamicGraph; |
| using velographx::UpdateBatch; |
| using velographx::VertexId; |
|
|
| std::vector<std::pair<VertexId, VertexId>> read_edges(const std::string& path) { |
| std::ifstream in(path); |
| if (!in) throw std::runtime_error("cannot open edge list"); |
| std::vector<std::pair<VertexId, VertexId>> edges; |
| std::string line; |
| while (std::getline(in, line)) { |
| if (line.empty() || line[0] == '#' || line[0] == '%') continue; |
| std::istringstream ss(line); |
| std::uint64_t u = 0, v = 0; |
| if (!(ss >> u >> v)) continue; |
| if (u == v || u > std::numeric_limits<VertexId>::max() || |
| v > std::numeric_limits<VertexId>::max()) continue; |
| edges.emplace_back(static_cast<VertexId>(u), static_cast<VertexId>(v)); |
| } |
| if (edges.empty()) throw std::runtime_error("empty edge list"); |
| return edges; |
| } |
|
|
| std::uint64_t digest_graph(const DynamicGraph& g) { |
| std::uint64_t h = 1469598103934665603ULL; |
| for (std::size_t u = 0; u < g.vertex_count(); ++u) { |
| const auto row = g.neighbors(static_cast<VertexId>(u)); |
| h ^= static_cast<std::uint64_t>(u) + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2); |
| h ^= static_cast<std::uint64_t>(row.size()) + (h << 6) + (h >> 2); |
| for (const auto v : row) h ^= static_cast<std::uint64_t>(v) + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2); |
| } |
| return h; |
| } |
|
|
| std::pair<double, std::uint64_t> probe(const DynamicGraph& g, std::size_t count) { |
| std::uint64_t h = 1469598103934665603ULL; |
| const auto begin = Clock::now(); |
| for (std::size_t i = 0; i < count; ++i) { |
| const auto u = static_cast<VertexId>((i * 11400714819323198485ULL) % g.vertex_count()); |
| const auto row = g.neighbors(u); |
| h ^= static_cast<std::uint64_t>(row.size()) + (h << 6) + (h >> 2); |
| for (const auto v : row) h ^= static_cast<std::uint64_t>(v) + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2); |
| } |
| const auto end = Clock::now(); |
| const auto ns = std::chrono::duration<double, std::nano>(end - begin).count(); |
| return {ns / static_cast<double>(count), h}; |
| } |
|
|
| UpdateBatch make_mutation_round(const DynamicGraph& g, std::size_t round, |
| std::size_t changed_rows) { |
| UpdateBatch batch; |
| batch.updates.reserve(changed_rows * 2); |
| const auto n = g.vertex_count(); |
| for (std::size_t i = 0; i < changed_rows; ++i) { |
| const auto u = static_cast<VertexId>((round * 104729ULL + i * 8191ULL) % n); |
| const auto row = g.neighbors(u); |
| if (row.empty()) continue; |
| const auto old_v = row[(round + i) % row.size()]; |
| VertexId new_v = static_cast<VertexId>((static_cast<std::uint64_t>(old_v) + 97 + round + i) % n); |
| for (std::size_t tries = 0; tries < 32 && |
| (new_v == u || g.has_edge(u, new_v)); ++tries) { |
| new_v = static_cast<VertexId>((static_cast<std::uint64_t>(new_v) + 7919) % n); |
| } |
| if (new_v == u || g.has_edge(u, new_v)) continue; |
| batch.remove(u, old_v); |
| batch.add(u, new_v); |
| } |
| return batch; |
| } |
|
|
| } |
|
|
| int main(int argc, char** argv) { |
| if (argc < 2 || argc > 6) { |
| std::cerr << "usage: velographx_row_patch_accumulation <edge-list> [cycles=20] [rows-per-cycle=64] [probes=1024] [directed=0]\n"; |
| return 2; |
| } |
| try { |
| const std::string path = argv[1]; |
| const std::size_t cycles = argc >= 3 ? std::stoull(argv[2]) : 20; |
| const std::size_t rows_per_cycle = argc >= 4 ? std::stoull(argv[3]) : 64; |
| const std::size_t probes = argc >= 5 ? std::stoull(argv[4]) : 1024; |
| const bool directed = argc >= 6 ? std::stoi(argv[5]) != 0 : false; |
|
|
| auto edges = read_edges(path); |
| VertexId max_v = 0; |
| for (const auto& [u, v] : edges) max_v = std::max(max_v, std::max(u, v)); |
| DynamicGraph graph(static_cast<std::size_t>(max_v) + 1, directed); |
| graph.bulk_load_edges(edges); |
| const auto initial_storage = graph.storage_bytes(); |
| const auto initial_edges = graph.edge_count_directed(); |
| const auto [initial_probe_ns, initial_probe_digest] = probe(graph, probes); |
|
|
| double total_update_ms = 0.0; |
| double total_compact_ms = 0.0; |
| std::size_t applied_updates = 0; |
| for (std::size_t round = 0; round < cycles; ++round) { |
| auto batch = make_mutation_round(graph, round, rows_per_cycle); |
| applied_updates += batch.updates.size(); |
| const auto u0 = Clock::now(); |
| graph.apply(batch); |
| const auto u1 = Clock::now(); |
| const auto c0 = Clock::now(); |
| graph.compact(); |
| const auto c1 = Clock::now(); |
| total_update_ms += std::chrono::duration<double, std::milli>(u1 - u0).count(); |
| total_compact_ms += std::chrono::duration<double, std::milli>(c1 - c0).count(); |
| } |
|
|
| const auto accumulated_storage = graph.storage_bytes(); |
| const auto [before_ns, before_probe_digest] = probe(graph, probes); |
| const auto before_digest = digest_graph(graph); |
| const auto before_edges = graph.edge_count_directed(); |
|
|
| const auto s0 = Clock::now(); |
| auto snapshot = velographx::consolidate_to_csr_snapshot(graph); |
| const auto s1 = Clock::now(); |
| const auto consolidation_ms = std::chrono::duration<double, std::milli>(s1 - s0).count(); |
| const auto [after_ns, after_probe_digest] = probe(snapshot.graph, probes); |
| const auto after_digest = digest_graph(snapshot.graph); |
|
|
| const bool correct = before_digest == after_digest && |
| before_probe_digest == after_probe_digest && |
| before_edges == snapshot.graph.edge_count_directed(); |
| if (!correct) throw std::runtime_error("consolidation correctness gate failed"); |
|
|
| const double storage_growth = initial_storage == 0 ? 0.0 |
| : static_cast<double>(accumulated_storage) / static_cast<double>(initial_storage); |
| const double storage_recovery = accumulated_storage == 0 ? 0.0 |
| : static_cast<double>(snapshot.consolidated_storage_bytes) / |
| static_cast<double>(accumulated_storage); |
|
|
| std::cout << "{" |
| << "\"artifact_type\":\"velographx-row-patch-accumulation\"," |
| << "\"research_claim\":false," |
| << "\"directed\":" << (directed ? "true" : "false") << ',' |
| << "\"vertices\":" << graph.vertex_count() << ',' |
| << "\"initial_directed_edges\":" << initial_edges << ',' |
| << "\"final_directed_edges\":" << before_edges << ',' |
| << "\"cycles\":" << cycles << ',' |
| << "\"rows_per_cycle\":" << rows_per_cycle << ',' |
| << "\"applied_update_operations\":" << applied_updates << ',' |
| << "\"initial_storage_bytes\":" << initial_storage << ',' |
| << "\"accumulated_storage_bytes\":" << accumulated_storage << ',' |
| << "\"consolidated_storage_bytes\":" << snapshot.consolidated_storage_bytes << ',' |
| << "\"storage_growth_ratio\":" << storage_growth << ',' |
| << "\"post_consolidation_storage_ratio\":" << storage_recovery << ',' |
| << "\"initial_neighbor_ns\":" << initial_probe_ns << ',' |
| << "\"pre_consolidation_neighbor_ns\":" << before_ns << ',' |
| << "\"post_consolidation_neighbor_ns\":" << after_ns << ',' |
| << "\"total_update_ms\":" << total_update_ms << ',' |
| << "\"total_row_compaction_ms\":" << total_compact_ms << ',' |
| << "\"consolidation_ms\":" << consolidation_ms << ',' |
| << "\"initial_probe_digest\":" << initial_probe_digest << ',' |
| << "\"logical_digest\":" << before_digest << ',' |
| << "\"correct\":true}\n"; |
| return 0; |
| } catch (const std::exception& e) { |
| std::cerr << e.what() << '\n'; |
| return 1; |
| } |
| } |
|
|
