| #include <algorithm> |
| #include <chrono> |
| #include <cstdint> |
| #include <fstream> |
| #include <iostream> |
| #include <limits> |
| #include <sstream> |
| #include <stdexcept> |
| #include <string> |
| #include <sys/resource.h> |
| #include <unordered_set> |
| #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::size_t peak_rss_kib() { |
| rusage usage{}; |
| if (getrusage(RUSAGE_SELF, &usage) != 0) return 0; |
| #if defined(__APPLE__) |
| return static_cast<std::size_t>(usage.ru_maxrss) / 1024; |
| #else |
| return static_cast<std::size_t>(usage.ru_maxrss); |
| #endif |
| } |
|
|
| 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_once(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) + (h << 6) + (h >> 2); |
| } |
| const auto ns = std::chrono::duration<double, std::nano>(Clock::now() - begin).count(); |
| return {ns / static_cast<double>(count), h}; |
| } |
|
|
| std::pair<double, std::uint64_t> probe_median(const DynamicGraph& g, std::size_t count, std::size_t repeats) { |
| std::vector<double> values; |
| values.reserve(repeats); |
| std::uint64_t digest = 0; |
| for (std::size_t i = 0; i < repeats; ++i) { |
| const auto [latency, current_digest] = probe_once(g, count); |
| if (i == 0) digest = current_digest; |
| if (current_digest != digest) throw std::runtime_error("probe digest changed"); |
| values.push_back(latency); |
| } |
| std::sort(values.begin(), values.end()); |
| return {values[values.size() / 2], digest}; |
| } |
|
|
| std::uint64_t mutation_key(VertexId u, VertexId v, bool directed) { |
| if (!directed && v < u) std::swap(u, v); |
| return (static_cast<std::uint64_t>(u) << 32) | static_cast<std::uint64_t>(v); |
| } |
|
|
| UpdateBatch make_mutation_round(const DynamicGraph& g, std::size_t round, std::size_t changed_rows) { |
| UpdateBatch batch; |
| batch.updates.reserve(changed_rows * 2); |
| std::unordered_set<std::uint64_t> reserved_edges; |
| reserved_edges.reserve(changed_rows * 3); |
| 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()]; |
| const auto old_key = mutation_key(u, old_v, g.directed()); |
| if (reserved_edges.contains(old_key)) continue; |
|
|
| auto new_v = static_cast<VertexId>((static_cast<std::uint64_t>(old_v) + 97 + round + i) % n); |
| std::uint64_t new_key = mutation_key(u, new_v, g.directed()); |
| std::size_t tries = 0; |
| for (; tries < 64; ++tries) { |
| new_key = mutation_key(u, new_v, g.directed()); |
| if (new_v != u && !g.has_edge(u, new_v) && !reserved_edges.contains(new_key)) break; |
| new_v = static_cast<VertexId>((static_cast<std::uint64_t>(new_v) + 7919) % n); |
| } |
| if (tries == 64 || new_v == u || g.has_edge(u, new_v) || reserved_edges.contains(new_key)) continue; |
|
|
| reserved_edges.insert(old_key); |
| reserved_edges.insert(new_key); |
| batch.remove(u, old_v); |
| batch.add(u, new_v); |
| } |
| return batch; |
| } |
|
|
| struct EpochRecord { |
| std::size_t epoch{0}, update_operations{0}; |
| double update_ms{0}, compact_ms{0}, storage_ratio{1}, neighbor_ns{0}, latency_ratio{1}; |
| bool consolidated{false}; |
| double consolidation_ms{0}, post_storage_ratio{1}, post_latency_ratio{1}; |
| std::size_t peak_rss_kib{0}; |
| }; |
| } |
|
|
| int main(int argc, char** argv) { |
| if (argc < 2 || argc > 8) { |
| std::cerr << "usage: velographx_steady_state_storage <edge-list> [epochs=60] [rows-per-epoch=4096] [probes=4096] [directed=1] [storage-threshold=1.25] [latency-threshold=1.25]\n"; |
| return 2; |
| } |
| try { |
| const std::string path = argv[1]; |
| const std::size_t epochs = argc >= 3 ? std::stoull(argv[2]) : 60; |
| const std::size_t rows_per_epoch = argc >= 4 ? std::stoull(argv[3]) : 4096; |
| const std::size_t probes = argc >= 5 ? std::stoull(argv[4]) : 4096; |
| const bool directed = argc >= 6 ? std::stoi(argv[5]) != 0 : true; |
| const double storage_threshold = argc >= 7 ? std::stod(argv[6]) : 1.25; |
| const double latency_threshold = argc >= 8 ? std::stod(argv[7]) : 1.25; |
| if (!epochs || !rows_per_epoch || !probes) throw std::runtime_error("positive parameters required"); |
|
|
| 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); |
| std::vector<std::pair<VertexId, VertexId>>().swap(edges); |
|
|
| const auto initial_directed_edges = graph.edge_count_directed(); |
| std::size_t canonical_storage = graph.storage_bytes(); |
| auto [canonical_neighbor_ns, canonical_probe_digest] = probe_median(graph, probes, 5); |
| const auto initial_storage = canonical_storage; |
| const auto initial_neighbor_ns = canonical_neighbor_ns; |
| const velographx::ConsolidationPolicy policy{storage_threshold, latency_threshold}; |
| velographx::ConsolidationController controller; |
|
|
| std::vector<EpochRecord> records; |
| records.reserve(epochs); |
| std::size_t total_update_operations = 0, consolidation_count = 0, storage_trigger_count = 0, latency_trigger_count = 0; |
| std::size_t high_water_storage_bytes = canonical_storage, high_water_rss_kib = peak_rss_kib(), last_consolidation_epoch = 0; |
| double total_update_ms = 0, total_compact_ms = 0, total_consolidation_ms = 0, high_water_storage_ratio = 1, high_water_latency_ratio = 1; |
| std::vector<std::size_t> consolidation_intervals; |
|
|
| const auto campaign_begin = Clock::now(); |
| for (std::size_t epoch = 1; epoch <= epochs; ++epoch) { |
| auto batch = make_mutation_round(graph, epoch - 1, rows_per_epoch); |
| const auto update_operations = batch.updates.size(); |
| total_update_operations += update_operations; |
| 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(); |
| const double update_ms = std::chrono::duration<double, std::milli>(u1 - u0).count(); |
| const double compact_ms = std::chrono::duration<double, std::milli>(c1 - c0).count(); |
| total_update_ms += update_ms; total_compact_ms += compact_ms; |
|
|
| const auto storage = graph.storage_bytes(); |
| const auto [neighbor_ns, probe_digest] = probe_median(graph, probes, 3); |
| const auto signal = velographx::evaluate_consolidation(storage, canonical_storage, neighbor_ns, canonical_neighbor_ns, policy); |
| const bool should_consolidate = controller.observe(signal, epoch); |
| high_water_storage_bytes = std::max(high_water_storage_bytes, storage); |
| high_water_storage_ratio = std::max(high_water_storage_ratio, signal.storage_growth_ratio); |
| high_water_latency_ratio = std::max(high_water_latency_ratio, signal.neighbor_latency_ratio); |
| high_water_rss_kib = std::max(high_water_rss_kib, peak_rss_kib()); |
| EpochRecord record{epoch, update_operations, update_ms, compact_ms, signal.storage_growth_ratio, neighbor_ns, signal.neighbor_latency_ratio, false, 0, 1, 1, high_water_rss_kib}; |
|
|
| if (should_consolidate) { |
| if (signal.storage_limit_exceeded) ++storage_trigger_count; |
| if (signal.latency_limit_exceeded) ++latency_trigger_count; |
| 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 double consolidation_ms = std::chrono::duration<double, std::milli>(s1 - s0).count(); |
| high_water_rss_kib = std::max(high_water_rss_kib, peak_rss_kib()); |
| const auto after_digest = digest_graph(snapshot.graph); |
| const auto [post_neighbor_ns, post_probe_digest] = probe_median(snapshot.graph, probes, 5); |
| if (before_digest != after_digest || before_edges != snapshot.graph.edge_count_directed() || probe_digest != post_probe_digest) throw std::runtime_error("steady-state consolidation correctness gate failed"); |
| record.consolidated = true; record.consolidation_ms = consolidation_ms; |
| record.post_storage_ratio = storage ? static_cast<double>(snapshot.consolidated_storage_bytes) / storage : 1; |
| record.post_latency_ratio = neighbor_ns > 0 ? post_neighbor_ns / neighbor_ns : 1; |
| total_consolidation_ms += consolidation_ms; ++consolidation_count; |
| consolidation_intervals.push_back(epoch - last_consolidation_epoch); last_consolidation_epoch = epoch; |
| controller.mark_consolidated(epoch); |
| graph = std::move(snapshot.graph); canonical_storage = graph.storage_bytes(); canonical_neighbor_ns = post_neighbor_ns; canonical_probe_digest = post_probe_digest; |
| } |
| record.peak_rss_kib = high_water_rss_kib; records.push_back(record); |
| } |
| const double campaign_wall_ms = std::chrono::duration<double, std::milli>(Clock::now() - campaign_begin).count(); |
|
|
| const auto final_before_digest = digest_graph(graph); |
| const auto final_before_edges = graph.edge_count_directed(); |
| if (final_before_edges != initial_directed_edges) throw std::runtime_error("steady-state replacement workload changed edge count"); |
| const auto v0 = Clock::now(); auto final_snapshot = velographx::consolidate_to_csr_snapshot(graph); const auto v1 = Clock::now(); |
| high_water_rss_kib = std::max(high_water_rss_kib, peak_rss_kib()); |
| const auto final_after_digest = digest_graph(final_snapshot.graph); |
| const auto [final_snapshot_neighbor_ns, final_probe_digest] = probe_median(final_snapshot.graph, probes, 3); (void)final_snapshot_neighbor_ns; |
| if (final_before_digest != final_after_digest || final_before_edges != final_snapshot.graph.edge_count_directed() || canonical_probe_digest == 0 || final_probe_digest == 0) throw std::runtime_error("final steady-state correctness validation failed"); |
| const double final_validation_ms = std::chrono::duration<double, std::milli>(v1 - v0).count(); |
|
|
| const double maintenance_ms = total_update_ms + total_compact_ms + total_consolidation_ms; |
| const double update_only_ops_per_s = total_update_ms > 0 ? total_update_operations / (total_update_ms / 1000.0) : 0; |
| const double maintenance_ops_per_s = maintenance_ms > 0 ? total_update_operations / (maintenance_ms / 1000.0) : 0; |
| const double instrumented_ops_per_s = campaign_wall_ms > 0 ? total_update_operations / (campaign_wall_ms / 1000.0) : 0; |
| const double consolidation_share = maintenance_ms > 0 ? total_consolidation_ms / maintenance_ms : 0; |
|
|
| std::cout << '{' << "\"artifact_type\":\"velographx-steady-state-storage\",\"schema_version\":3,\"research_claim\":false," |
| << "\"directed\":" << (directed ? "true" : "false") << ",\"vertices\":" << graph.vertex_count() << ",\"initial_directed_edges\":" << initial_directed_edges << ",\"final_directed_edges\":" << final_before_edges |
| << ",\"epochs\":" << epochs << ",\"rows_per_epoch\":" << rows_per_epoch << ",\"probes\":" << probes << ",\"storage_threshold\":" << storage_threshold << ",\"latency_threshold\":" << latency_threshold |
| << ",\"controller_min_epochs_between\":10,\"controller_latency_breach_samples\":5,\"initial_storage_bytes\":" << initial_storage << ",\"high_water_storage_bytes\":" << high_water_storage_bytes |
| << ",\"high_water_storage_ratio\":" << high_water_storage_ratio << ",\"high_water_rss_kib\":" << high_water_rss_kib << ",\"initial_neighbor_ns\":" << initial_neighbor_ns << ",\"high_water_latency_ratio\":" << high_water_latency_ratio |
| << ",\"total_update_operations\":" << total_update_operations << ",\"total_update_ms\":" << total_update_ms << ",\"total_row_compaction_ms\":" << total_compact_ms << ",\"total_consolidation_ms\":" << total_consolidation_ms |
| << ",\"maintenance_path_ms\":" << maintenance_ms << ",\"campaign_wall_ms\":" << campaign_wall_ms << ",\"consolidation_count\":" << consolidation_count << ",\"storage_trigger_count\":" << storage_trigger_count << ",\"latency_trigger_count\":" << latency_trigger_count |
| << ",\"consolidation_share\":" << consolidation_share << ",\"update_only_ops_per_s\":" << update_only_ops_per_s << ",\"maintenance_amortized_ops_per_s\":" << maintenance_ops_per_s << ",\"instrumented_campaign_ops_per_s\":" << instrumented_ops_per_s |
| << ",\"final_validation_ms\":" << final_validation_ms << ",\"correct\":true,\"consolidation_intervals\":["; |
| for (std::size_t i = 0; i < consolidation_intervals.size(); ++i) { if (i) std::cout << ','; std::cout << consolidation_intervals[i]; } |
| std::cout << "],\"epochs_detail\":["; |
| for (std::size_t i = 0; i < records.size(); ++i) { if (i) std::cout << ','; const auto& r = records[i]; std::cout << "{\"epoch\":" << r.epoch << ",\"update_operations\":" << r.update_operations << ",\"update_ms\":" << r.update_ms << ",\"compact_ms\":" << r.compact_ms << ",\"storage_ratio\":" << r.storage_ratio << ",\"neighbor_ns\":" << r.neighbor_ns << ",\"latency_ratio\":" << r.latency_ratio << ",\"consolidated\":" << (r.consolidated ? "true" : "false") << ",\"consolidation_ms\":" << r.consolidation_ms << ",\"post_storage_ratio\":" << r.post_storage_ratio << ",\"post_latency_ratio\":" << r.post_latency_ratio << ",\"peak_rss_kib\":" << r.peak_rss_kib << '}'; } |
| std::cout << "]}\n"; |
| return 0; |
| } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } |
| } |
|
|
