main.cpp

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <exception>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <random>
#include <string>
#include <vector>

#include "graph_preprocess.cpp"
#define SSSP_NO_MAIN
#include "SSSP.cpp"
#include "dijkstra_baseline.cpp"
#include "graph_generate.cpp"

enum class TimingMode { None, AverageOnly, Full };

struct AggregateBenchmark {
    std::uint64_t preprocess_ns = 0;
    std::uint64_t dijkstra_ns = 0;
    std::uint64_t sssp_total_ns = 0;
    std::uint64_t sssp_bmssp_ns = 0;
    std::uint64_t sssp_final_dijkstra_ns = 0;
    std::uint64_t dijkstra_graph_accesses = 0;
    std::uint64_t sssp_graph_accesses = 0;
    std::uint64_t dijkstra_data_accesses = 0;
    std::uint64_t sssp_data_accesses = 0;
    std::uint64_t dijkstra_stride_sum = 0;
    std::uint64_t sssp_stride_sum = 0;
    std::uint64_t dijkstra_stride_count = 0;
    std::uint64_t sssp_stride_count = 0;
    std::uint64_t dijkstra_cache_hits = 0;
    std::uint64_t dijkstra_cache_misses = 0;
    std::uint64_t sssp_cache_hits = 0;
    std::uint64_t sssp_cache_misses = 0;
    std::vector<std::uint64_t> dijkstra_layer_ns;
    std::vector<std::uint64_t> sssp_layer_ns;
};

struct VerificationMetrics {
    std::uint64_t preprocess_ns = 0;
    SSSPBenchmarkStats sssp;
    DijkstraBenchmarkStats dijkstra;
};

struct VerificationResult {
    bool ok = true;
    int mismatch_vertex = -1;
    double bmssp_distance = 0.0;
    double dijkstra_distance = 0.0;
    VerificationMetrics metrics;
};

struct PhaseResult {
    std::string phase_name;
    int graphs_verified = 0;
    AggregateBenchmark aggregate{};
    std::vector<VerificationMetrics> per_graph_metrics;
};

static TimingMode parseTimingMode(const std::string& s) {
    if (s == "none") return TimingMode::None;
    if (s == "avg") return TimingMode::AverageOnly;
    if (s == "full") return TimingMode::Full;
    throw std::invalid_argument("timingMode must be one of: none, avg, full");
}

static std::string jsonEscape(const std::string& in) {
    std::string out;
    out.reserve(in.size() + 8);
    for (char c : in) {
        switch (c) {
            case '\\':
                out += "\\\\";
                break;
            case '"':
                out += "\\\"";
                break;
            case '\n':
                out += "\\n";
                break;
            case '\r':
                out += "\\r";
                break;
            case '\t':
                out += "\\t";
                break;
            default:
                out += c;
                break;
        }
    }
    return out;
}

static void writeUint64Array(std::ostream& os, const std::vector<std::uint64_t>& values) {
    os << "[";
    for (std::size_t i = 0; i < values.size(); ++i) {
        if (i > 0) os << ",";
        os << values[i];
    }
    os << "]";
}

static void writeDoubleArray(std::ostream& os, const std::vector<double>& values) {
    os << "[";
    for (std::size_t i = 0; i < values.size(); ++i) {
        if (i > 0) os << ",";
        os << values[i];
    }
    os << "]";
}

static std::vector<double> perGraphLayerMs(const std::vector<std::uint64_t>& layerNs) {
    std::vector<double> out;
    out.reserve(layerNs.size());
    for (std::uint64_t ns : layerNs) {
        out.push_back(static_cast<double>(ns) / 1e6);
    }
    return out;
}

static std::vector<double> avgLayerMs(const std::vector<std::uint64_t>& layerNs, int graphs) {
    std::vector<double> out;
    out.reserve(layerNs.size());
    if (graphs <= 0) return out;
    for (std::uint64_t ns : layerNs) {
        out.push_back(static_cast<double>(ns) / (1e6 * static_cast<double>(graphs)));
    }
    return out;
}

static void mergeBenchmarks(
    const SSSPBenchmarkStats& sssp,
    const DijkstraBenchmarkStats& dijkstra,
    std::uint64_t preprocessNs,
    AggregateBenchmark* agg) {
    if (agg == nullptr) return;
    agg->preprocess_ns += preprocessNs;
    agg->sssp_total_ns += sssp.total_ns;
    agg->sssp_bmssp_ns += sssp.bmssp_ns;
    agg->sssp_final_dijkstra_ns += sssp.final_dijkstra_ns;
    agg->sssp_graph_accesses += sssp.graph_accesses;
    agg->sssp_data_accesses += sssp.data_accesses;
    agg->sssp_stride_sum += sssp.stride_sum;
    agg->sssp_stride_count += sssp.stride_count;
    agg->sssp_cache_hits += sssp.estimated_cache_line_hits;
    agg->sssp_cache_misses += sssp.estimated_cache_line_misses;

    agg->dijkstra_ns += dijkstra.total_ns;
    agg->dijkstra_graph_accesses += dijkstra.graph_accesses;
    agg->dijkstra_data_accesses += dijkstra.data_accesses;
    agg->dijkstra_stride_sum += dijkstra.stride_sum;
    agg->dijkstra_stride_count += dijkstra.stride_count;
    agg->dijkstra_cache_hits += dijkstra.estimated_cache_line_hits;
    agg->dijkstra_cache_misses += dijkstra.estimated_cache_line_misses;

    if (agg->sssp_layer_ns.empty()) {
        agg->sssp_layer_ns.assign(sssp.layer_time_ns.size(), 0ULL);
        agg->dijkstra_layer_ns.assign(dijkstra.layer_time_ns.size(), 0ULL);
    }
    for (std::size_t i = 0; i < sssp.layer_time_ns.size(); ++i) {
        agg->sssp_layer_ns[i] += sssp.layer_time_ns[i];
    }
    for (std::size_t i = 0; i < dijkstra.layer_time_ns.size(); ++i) {
        agg->dijkstra_layer_ns[i] += dijkstra.layer_time_ns[i];
    }
}

static VerificationResult verifyOneGraph(
    int testId,
    const std::vector<std::vector<Edge>>& g,
    int source,
    int expectedOutDegree,
    int debugLevel,
    bool usePreprocess,
    TimingMode timingMode) {
    using Clock = std::chrono::steady_clock;
    const bool collect = timingMode != TimingMode::None;
    const int n = static_cast<int>(g.size());
    (void)testId;

    std::vector<double> bmsspDist;
    VerificationResult result{};
    SSSPBenchmarkStats ssspStats{};

    if (usePreprocess) {
        std::vector<OriginalEdge> originalEdges;
        originalEdges.reserve(static_cast<std::size_t>(n) * static_cast<std::size_t>(std::max(1, expectedOutDegree)));
        for (int u = 0; u < n; ++u) {
            for (const Edge& e : g[static_cast<std::size_t>(u)]) {
                originalEdges.push_back({u, e.to, e.w});
            }
        }
        const auto prepStart = collect ? Clock::now() : Clock::time_point{};
        PreprocessedGraph prep = PreprocessGraphToConstantDegree(n, originalEdges, source);
        const auto prepEnd = collect ? Clock::now() : Clock::time_point{};
        if (collect) {
            result.metrics.preprocess_ns = static_cast<std::uint64_t>(
                std::chrono::duration_cast<std::chrono::nanoseconds>(prepEnd - prepStart).count());
        }
        BMSSPSolver solver(prep.transformedGraph, prep.transformedSource, debugLevel, collect);
        std::vector<double> transformedDist = solver.solveFromSource();
        bmsspDist = RecoverOriginalDistances(transformedDist, prep.originalToTransformedNodes);
        ssspStats = solver.benchmarkStats();
    } else {
        BMSSPSolver solver(g, source, debugLevel, collect);
        bmsspDist = solver.solveFromSource();
        ssspStats = solver.benchmarkStats();
    }

    DijkstraRunResult dijkstraRun = runDijkstra(g, source, collect);
    const std::vector<double>& dijkstraDist = dijkstraRun.dist;

    for (int v = 0; v < n; ++v) {
        const double a = bmsspDist[static_cast<std::size_t>(v)];
        const double b = dijkstraDist[static_cast<std::size_t>(v)];
        const bool bothInf = !std::isfinite(a) && !std::isfinite(b);
        if (!(bothInf || a == b)) {
            result.ok = false;
            result.mismatch_vertex = v;
            result.bmssp_distance = a;
            result.dijkstra_distance = b;
            result.metrics.sssp = ssspStats;
            result.metrics.dijkstra = dijkstraRun.stats;
            return result;
        }
    }

    result.metrics.sssp = ssspStats;
    result.metrics.dijkstra = dijkstraRun.stats;
    return result;
}

static void writeBenchmarkSummary(
    std::ostream& os,
    const std::string& phase,
    const AggregateBenchmark& agg,
    int graphs,
    TimingMode timingMode) {
    if (timingMode == TimingMode::None || graphs <= 0) return;
    auto nsToMs = [](std::uint64_t ns) -> double { return static_cast<double>(ns) / 1e6; };
    os << std::fixed << std::setprecision(3);
    os << "[timing][" << phase << "] avg_preprocess_ms=" << nsToMs(agg.preprocess_ns) / graphs
       << " avg_sssp_total_ms=" << nsToMs(agg.sssp_total_ns) / graphs
       << " avg_sssp_bmssp_ms=" << nsToMs(agg.sssp_bmssp_ns) / graphs
       << " avg_sssp_final_dijkstra_ms=" << nsToMs(agg.sssp_final_dijkstra_ns) / graphs
       << " avg_dijkstra_ms=" << nsToMs(agg.dijkstra_ns) / graphs
       << "\n";

    if (timingMode == TimingMode::Full) {
        const double ssspAvgStride = agg.sssp_stride_count == 0
                                         ? 0.0
                                         : static_cast<double>(agg.sssp_stride_sum) / agg.sssp_stride_count;
        const double dijAvgStride = agg.dijkstra_stride_count == 0
                                        ? 0.0
                                        : static_cast<double>(agg.dijkstra_stride_sum) / agg.dijkstra_stride_count;
        os << "[timing][" << phase << "] graph_accesses_sssp=" << agg.sssp_graph_accesses
           << " graph_accesses_dijkstra=" << agg.dijkstra_graph_accesses
           << " data_accesses_sssp=" << agg.sssp_data_accesses
           << " data_accesses_dijkstra=" << agg.dijkstra_data_accesses
           << " avg_stride_sssp=" << ssspAvgStride
           << " avg_stride_dijkstra=" << dijAvgStride
           << " est_cache_hit_rate_sssp="
           << (agg.sssp_cache_hits + agg.sssp_cache_misses == 0
                   ? 0.0
                   : static_cast<double>(agg.sssp_cache_hits) /
                         static_cast<double>(agg.sssp_cache_hits + agg.sssp_cache_misses))
           << " est_cache_hit_rate_dijkstra="
           << (agg.dijkstra_cache_hits + agg.dijkstra_cache_misses == 0
                   ? 0.0
                   : static_cast<double>(agg.dijkstra_cache_hits) /
                         static_cast<double>(agg.dijkstra_cache_hits + agg.dijkstra_cache_misses))
           << "\n";
        os << "[timing][" << phase << "] layer_times_ms (first 10 layers):";
        for (std::size_t i = 0; i < std::min<std::size_t>(10, agg.sssp_layer_ns.size()); ++i) {
            const double ssspMs = nsToMs(agg.sssp_layer_ns[i]) / graphs;
            const double dijMs = nsToMs(agg.dijkstra_layer_ns[i]) / graphs;
            os << " L" << i << "{sssp=" << ssspMs << ",dij=" << dijMs << "}";
        }
        os << "\n";
    }
}

static void writePhaseJson(
    std::ostream& os,
    const PhaseResult& phase,
    TimingMode timingMode) {
    const AggregateBenchmark& agg = phase.aggregate;
    const int graphs = phase.graphs_verified;
    const double ssspAvgStride = agg.sssp_stride_count == 0
                                     ? 0.0
                                     : static_cast<double>(agg.sssp_stride_sum) / agg.sssp_stride_count;
    const double dijAvgStride = agg.dijkstra_stride_count == 0
                                    ? 0.0
                                    : static_cast<double>(agg.dijkstra_stride_sum) / agg.dijkstra_stride_count;
    const double ssspHitRate = (agg.sssp_cache_hits + agg.sssp_cache_misses == 0)
                                   ? 0.0
                                   : static_cast<double>(agg.sssp_cache_hits) /
                                         static_cast<double>(agg.sssp_cache_hits + agg.sssp_cache_misses);
    const double dijHitRate = (agg.dijkstra_cache_hits + agg.dijkstra_cache_misses == 0)
                                  ? 0.0
                                  : static_cast<double>(agg.dijkstra_cache_hits) /
                                        static_cast<double>(agg.dijkstra_cache_hits + agg.dijkstra_cache_misses);
    os << "    {\n";
    os << "      \"name\": \"" << phase.phase_name << "\",\n";
    os << "      \"graphs_verified\": " << graphs << ",\n";
    os << "      \"timing_enabled\": " << (timingMode == TimingMode::None ? "false" : "true") << ",\n";
    os << "      \"aggregate\": {\n";
    os << "        \"preprocess_ns_total\": " << agg.preprocess_ns << ",\n";
    os << "        \"sssp_total_ns_total\": " << agg.sssp_total_ns << ",\n";
    os << "        \"sssp_bmssp_ns_total\": " << agg.sssp_bmssp_ns << ",\n";
    os << "        \"sssp_final_dijkstra_ns_total\": " << agg.sssp_final_dijkstra_ns << ",\n";
    os << "        \"dijkstra_total_ns_total\": " << agg.dijkstra_ns << ",\n";
    os << "        \"sssp_graph_accesses_total\": " << agg.sssp_graph_accesses << ",\n";
    os << "        \"dijkstra_graph_accesses_total\": " << agg.dijkstra_graph_accesses << ",\n";
    os << "        \"sssp_data_accesses_total\": " << agg.sssp_data_accesses << ",\n";
    os << "        \"dijkstra_data_accesses_total\": " << agg.dijkstra_data_accesses << ",\n";
    os << "        \"sssp_avg_stride\": " << ssspAvgStride << ",\n";
    os << "        \"dijkstra_avg_stride\": " << dijAvgStride << ",\n";
    os << "        \"sssp_est_cache_hit_rate\": " << ssspHitRate << ",\n";
    os << "        \"dijkstra_est_cache_hit_rate\": " << dijHitRate << ",\n";
    os << "        \"avg_preprocess_ms\": "
       << (graphs > 0 ? static_cast<double>(agg.preprocess_ns) / (1e6 * graphs) : 0.0) << ",\n";
    os << "        \"avg_sssp_total_ms\": "
       << (graphs > 0 ? static_cast<double>(agg.sssp_total_ns) / (1e6 * graphs) : 0.0) << ",\n";
    os << "        \"avg_sssp_bmssp_ms\": "
       << (graphs > 0 ? static_cast<double>(agg.sssp_bmssp_ns) / (1e6 * graphs) : 0.0) << ",\n";
    os << "        \"avg_sssp_final_dijkstra_ms\": "
       << (graphs > 0 ? static_cast<double>(agg.sssp_final_dijkstra_ns) / (1e6 * graphs) : 0.0) << ",\n";
    os << "        \"avg_dijkstra_ms\": "
       << (graphs > 0 ? static_cast<double>(agg.dijkstra_ns) / (1e6 * graphs) : 0.0) << ",\n";
    os << "        \"avg_layer_runtime_ms\": {\n";
    os << "          \"sssp\": ";
    writeDoubleArray(os, avgLayerMs(agg.sssp_layer_ns, graphs));
    os << ",\n";
    os << "          \"dijkstra\": ";
    writeDoubleArray(os, avgLayerMs(agg.dijkstra_layer_ns, graphs));
    os << "\n";
    os << "        }\n";
    os << "      },\n";
    os << "      \"per_graph\": [\n";
    for (std::size_t i = 0; i < phase.per_graph_metrics.size(); ++i) {
        const VerificationMetrics& m = phase.per_graph_metrics[i];
        os << "        {\n";
        os << "          \"graph_index\": " << (i + 1) << ",\n";
        os << "          \"preprocess_ns\": " << m.preprocess_ns << ",\n";
        os << "          \"sssp_total_ns\": " << m.sssp.total_ns << ",\n";
        os << "          \"sssp_bmssp_ns\": " << m.sssp.bmssp_ns << ",\n";
        os << "          \"sssp_final_dijkstra_ns\": " << m.sssp.final_dijkstra_ns << ",\n";
        os << "          \"dijkstra_total_ns\": " << m.dijkstra.total_ns << ",\n";
        os << "          \"layer_runtime_ns\": {\n";
        os << "            \"sssp\": ";
        writeUint64Array(os, m.sssp.layer_time_ns);
        os << ",\n";
        os << "            \"dijkstra\": ";
        writeUint64Array(os, m.dijkstra.layer_time_ns);
        os << "\n";
        os << "          },\n";
        os << "          \"layer_runtime_ms\": {\n";
        os << "            \"sssp\": ";
        writeDoubleArray(os, perGraphLayerMs(m.sssp.layer_time_ns));
        os << ",\n";
        os << "            \"dijkstra\": ";
        writeDoubleArray(os, perGraphLayerMs(m.dijkstra.layer_time_ns));
        os << "\n";
        os << "          }\n";
        os << "        }";
        if (i + 1 < phase.per_graph_metrics.size()) os << ",";
        os << "\n";
    }
    os << "      ]\n";
    os << "    }";
}

static std::uint64_t graphEdgeCount(const std::vector<std::vector<Edge>>& g) {
    std::uint64_t edges = 0;
    for (const auto& adj : g) {
        edges += static_cast<std::uint64_t>(adj.size());
    }
    return edges;
}

static void writeGraphRecord(
    std::ostream& os,
    const std::string& phase,
    int graphIndex,
    const std::vector<std::vector<Edge>>& g) {
    os << "{\n";
    os << "  \"phase\": \"" << phase << "\",\n";
    os << "  \"graph_index\": " << graphIndex << ",\n";
    os << "  \"num_vertices\": " << g.size() << ",\n";
    os << "  \"num_edges\": " << graphEdgeCount(g) << ",\n";
    os << "  \"adjacency\": [\n";
    bool firstEntry = true;
    for (std::size_t u = 0; u < g.size(); ++u) {
        for (const Edge& e : g[u]) {
            if (!firstEntry) os << ",\n";
            firstEntry = false;
            os << "    {\"u\": " << u << ", \"to\": " << e.to << ", \"w\": " << e.w << "}";
        }
    }
    os << "\n  ]\n";
    os << "}\n";
}

int main(int argc, char** argv) {
    const std::uint64_t seed = 0xC0FFEE123456789ULL;
    int numGraphs = 10000;
    int n = 2000;
    int outDeg = 6;
    int source = 0;
    int debugLevel = 0;
    std::string mode = "both";
    std::string timingModeStr = "none";
    std::string graphTypeStr = "random_fixed";
    double density = 0.01;
    int smallWorldK = 6;
    double smallWorldRewire = 0.1;
    std::string outputBaseName = "run_statistics";

    if (argc >= 2) numGraphs = std::stoi(argv[1]);
    if (argc >= 3) n = std::stoi(argv[2]);
    if (argc >= 4) outDeg = std::stoi(argv[3]);
    if (argc >= 5) debugLevel = std::max(0, std::stoi(argv[4]));
    if (argc >= 6) mode = argv[5];
    if (argc >= 7) timingModeStr = argv[6];
    if (argc >= 8) graphTypeStr = argv[7];
    if (argc >= 9) density = std::stod(argv[8]);
    if (argc >= 10) smallWorldK = std::stoi(argv[9]);
    if (argc >= 11) smallWorldRewire = std::stod(argv[10]);
    if (argc >= 12) outputBaseName = argv[11];

    if (numGraphs <= 0 || n <= 0 || outDeg <= 0 || source < 0 || source >= n ||
        (mode != "both" && mode != "fixed" && mode != "variable")) {
        std::cerr << "Invalid arguments. Usage: main [numGraphs] [n] [outDeg] [debugLevel] [mode] [timingMode] [graphType] [density] [smallWorldK] [smallWorldRewire] [outputBaseName]\n";
        std::cerr << "  mode: fixed | variable | both (default both)\n";
        std::cerr << "  timingMode: none | avg | full (default none)\n";
        std::cerr << "  graphType: random_fixed | random_variable | connected_random | sparse | dense | fully_connected | small_world\n";
        std::cerr << "  outputBaseName: basename for output files (default run_statistics)\n";
        return 1;
    }

    TimingMode timingMode = TimingMode::None;
    GraphType graphType = GraphType::RandomFixed;
    try {
        timingMode = parseTimingMode(timingModeStr);
        graphType = parseGraphType(graphTypeStr);
    } catch (const std::exception& ex) {
        std::cerr << ex.what() << "\n";
        return 1;
    }

    SetSSSPDebugLevel(debugLevel);
    std::mt19937_64 rng(seed);
    GraphGenerateConfig cfg{};
    cfg.n = n;
    cfg.out_degree = outDeg;
    cfg.density = density;
    cfg.small_world_k = smallWorldK;
    cfg.small_world_rewire = smallWorldRewire;

    const std::filesystem::path outputDir("output");
    std::error_code ec;
    std::filesystem::create_directories(outputDir, ec);
    if (ec) {
        std::cerr << "Failed to create output directory: " << ec.message() << "\n";
        return 1;
    }

    const std::string statsFilename = (outputDir / (outputBaseName + ".txt")).string();
    const std::string graphFilename = (outputDir / (outputBaseName + "_graph_format.txt")).string();
    std::ofstream statsOut(statsFilename, std::ios::trunc);
    if (!statsOut) {
        std::cerr << "Failed to open " << statsFilename << " for writing\n";
        return 1;
    }
    std::ofstream graphOut(graphFilename, std::ios::trunc);
    if (!graphOut) {
        std::cerr << "Failed to open " << graphFilename << " for writing\n";
        return 1;
    }
    statsOut << std::fixed << std::setprecision(6);
    graphOut << std::fixed << std::setprecision(6);

    std::cout << "Running suite with seed=" << seed
              << ", graphs=" << numGraphs
              << ", n=" << n
              << ", outDeg=" << outDeg
              << ", mode=" << mode
              << ", timingMode=" << timingModeStr
              << ", graphType=" << graphTypeStr
              << ", outputBaseName=" << outputBaseName << "\n";

    bool allPass = true;
    std::string failurePhase;
    int failureTestId = -1;
    int failureVertex = -1;
    double failureBmssp = 0.0;
    double failureDijkstra = 0.0;
    std::vector<PhaseResult> phaseResults;

    try {
        if (mode == "fixed" || mode == "both") {
            PhaseResult phase{};
            phase.phase_name = "fixed";
            std::cout << "[phase] direct BMSSP graphs\n";
            for (int testId = 1; testId <= numGraphs; ++testId) {
                std::vector<std::vector<Edge>> g = generateGraph(graphType, cfg, rng);
                writeGraphRecord(graphOut, "fixed", testId, g);
                VerificationResult vr = verifyOneGraph(testId, g, source, outDeg, debugLevel, false, timingMode);
                if (!vr.ok) {
                    allPass = false;
                    failurePhase = "fixed";
                    failureTestId = testId;
                    failureVertex = vr.mismatch_vertex;
                    failureBmssp = vr.bmssp_distance;
                    failureDijkstra = vr.dijkstra_distance;
                    break;
                }
                mergeBenchmarks(vr.metrics.sssp, vr.metrics.dijkstra, vr.metrics.preprocess_ns, &phase.aggregate);
                phase.per_graph_metrics.push_back(vr.metrics);
                ++phase.graphs_verified;
                if (testId % 100 == 0 || testId == numGraphs) {
                    std::cout << "[fixed] Verified " << testId << " / " << numGraphs << " graphs\n";
                }
            }
            writeBenchmarkSummary(std::cout, "fixed", phase.aggregate, phase.graphs_verified, timingMode);
            phaseResults.push_back(std::move(phase));
            if (!allPass) {
                std::cerr << "[fixed] Mismatch at test " << failureTestId
                          << ", vertex " << failureVertex
                          << ": bmssp=" << failureBmssp
                          << ", dijkstra=" << failureDijkstra << "\n";
            }
        }

        if (allPass && (mode == "variable" || mode == "both")) {
            PhaseResult phase{};
            phase.phase_name = "variable";
            std::cout << "[phase] preprocessing BMSSP graphs\n";
            for (int testId = 1; testId <= numGraphs; ++testId) {
                std::vector<std::vector<Edge>> g = generateGraph(graphType, cfg, rng);
                writeGraphRecord(graphOut, "variable", testId, g);
                VerificationResult vr = verifyOneGraph(testId, g, source, outDeg, debugLevel, true, timingMode);
                if (!vr.ok) {
                    allPass = false;
                    failurePhase = "variable";
                    failureTestId = testId;
                    failureVertex = vr.mismatch_vertex;
                    failureBmssp = vr.bmssp_distance;
                    failureDijkstra = vr.dijkstra_distance;
                    break;
                }
                mergeBenchmarks(vr.metrics.sssp, vr.metrics.dijkstra, vr.metrics.preprocess_ns, &phase.aggregate);
                phase.per_graph_metrics.push_back(vr.metrics);
                ++phase.graphs_verified;
                if (testId % 100 == 0 || testId == numGraphs) {
                    std::cout << "[variable] Verified " << testId << " / " << numGraphs << " graphs\n";
                }
            }
            writeBenchmarkSummary(std::cout, "variable", phase.aggregate, phase.graphs_verified, timingMode);
            phaseResults.push_back(std::move(phase));
            if (!allPass) {
                std::cerr << "[variable] Mismatch at test " << failureTestId
                          << ", vertex " << failureVertex
                          << ": bmssp=" << failureBmssp
                          << ", dijkstra=" << failureDijkstra << "\n";
            }
        }
    } catch (const std::exception& ex) {
        std::cerr << "Suite exception: " << ex.what() << "\n";
        statsOut << "{\n";
        statsOut << "  \"result\": \"FAIL\",\n";
        statsOut << "  \"failure_type\": \"exception\",\n";
        statsOut << "  \"message\": \"" << jsonEscape(ex.what()) << "\"\n";
        statsOut << "}\n";
        return 3;
    }

    statsOut << "{\n";
    statsOut << "  \"schema_version\": 1,\n";
    statsOut << "  \"result\": \"" << (allPass ? "PASS" : "FAIL") << "\",\n";
    statsOut << "  \"config\": {\n";
    statsOut << "    \"seed\": " << seed << ",\n";
    statsOut << "    \"num_graphs\": " << numGraphs << ",\n";
    statsOut << "    \"n\": " << n << ",\n";
    statsOut << "    \"out_degree\": " << outDeg << ",\n";
    statsOut << "    \"source\": " << source << ",\n";
    statsOut << "    \"debug_level\": " << debugLevel << ",\n";
    statsOut << "    \"mode\": \"" << mode << "\",\n";
    statsOut << "    \"timing_mode\": \"" << timingModeStr << "\",\n";
    statsOut << "    \"graph_type\": \"" << graphTypeStr << "\",\n";
    statsOut << "    \"density\": " << density << ",\n";
    statsOut << "    \"small_world_k\": " << smallWorldK << ",\n";
    statsOut << "    \"small_world_rewire\": " << smallWorldRewire << ",\n";
    statsOut << "    \"output_base_name\": \"" << outputBaseName << "\",\n";
    statsOut << "    \"stats_filename\": \"" << statsFilename << "\",\n";
    statsOut << "    \"graph_filename\": \"" << graphFilename << "\"\n";
    statsOut << "  },\n";
    if (!allPass) {
        statsOut << "  \"failure\": {\n";
        statsOut << "    \"phase\": \"" << failurePhase << "\",\n";
        statsOut << "    \"test_id\": " << failureTestId << ",\n";
        statsOut << "    \"vertex\": " << failureVertex << ",\n";
        statsOut << "    \"bmssp_distance\": " << failureBmssp << ",\n";
        statsOut << "    \"dijkstra_distance\": " << failureDijkstra << "\n";
        statsOut << "  },\n";
    }
    statsOut << "  \"phases\": [\n";
    for (std::size_t i = 0; i < phaseResults.size(); ++i) {
        writePhaseJson(statsOut, phaseResults[i], timingMode);
        if (i + 1 < phaseResults.size()) statsOut << ",";
        statsOut << "\n";
    }
    statsOut << "  ]\n";
    statsOut << "}\n";

    if (allPass) {
        std::cout << "PASS: BMSSP and Dijkstra distances exactly match on all tests.\n";
        return 0;
    }
    return 2;
}