Function measure_overhead

benchmark/ctrack_benchmark.cpp:368–433

Measure overhead by comparing with and without CTRACK

// Measure overhead by comparing with and without CTRACK
std::tuple<double, double, double> measure_overhead()
{
    std::cout << "\n=== Measuring Overhead ===" << std::endl;

    const size_t overhead_events = 1'000'000; // 1M events for overhead test
    size_t events_per_thread = overhead_events / g_config.thread_count;

    // Measure without CTRACK
    auto start_no_track = std::chrono::high_resolution_clock::now();
    {
        std::vector<std::thread> threads;
        std::atomic<bool> start_flag{false};

        for (size_t i = 0; i < g_config.thread_count; ++i)
        {
            threads.emplace_back(benchmark_worker_no_track, events_per_thread, std::ref(start_flag));
        }

        start_flag = true;

        for (auto &t : threads)
        {
            t.join();
        }
    }
    auto end_no_track = std::chrono::high_resolution_clock::now();
    auto duration_no_track = std::chrono::duration_cast<std::chrono::microseconds>(end_no_track - start_no_track).count();

    // Clear tracking data by getting and discarding results
    ctrack::result_as_string();

    // Measure with CTRACK
    auto start_track = std::chrono::high_resolution_clock::now();
    {
        std::vector<std::thread> threads;
        std::atomic<bool> start_flag{false};

        for (size_t i = 0; i < g_config.thread_count; ++i)
        {
            threads.emplace_back(benchmark_worker, events_per_thread, std::ref(start_flag));
        }

        start_flag = true;

        for (auto &t : threads)
        {
            t.join();
        }
    }
    auto end_track = std::chrono::high_resolution_clock::now();
    auto duration_track = std::chrono::duration_cast<std::chrono::microseconds>(end_track - start_track).count();

    double overhead_percent = ((double)(duration_track - duration_no_track) / duration_no_track) * 100.0;
    double overhead_ms = (duration_track - duration_no_track) / 1000.0;                               // Convert microseconds to milliseconds
    double overhead_ns_per_event = ((duration_track - duration_no_track) * 1000.0) / overhead_events; // nanoseconds per event

    if (g_config.verbose)
    {