Function measure_memory_and_calculation_time

benchmark/ctrack_benchmark.cpp:436–520

Measure memory usage and calculation time

// Measure memory usage and calculation time
std::tuple<double, double, double> measure_memory_and_calculation_time()
{
    std::cout << "\n=== Measuring Memory Usage and Calculation Time ===" << std::endl;

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

    // Measure initial memory
    size_t initial_memory = get_memory_usage();

    // Generate events
    size_t events_per_thread = g_config.total_events / g_config.thread_count;

    if (g_config.verbose)
    {
        std::cout << "Generating " << g_config.total_events << " events across "
                  << g_config.thread_count << " threads..." << std::endl;
    }

    auto gen_start = 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 gen_end = std::chrono::high_resolution_clock::now();

    // Measure memory after event generation
    size_t post_event_memory = get_memory_usage();
    size_t memory_used = post_event_memory - initial_memory;
    double bytes_per_event = (double)memory_used / g_config.total_events;

    if (g_config.verbose)
    {
        auto gen_duration = std::chrono::duration_cast<std::chrono::milliseconds>(gen_end - gen_start).count();
        std::cout << "Event generation took: " << gen_duration << " ms" << std::endl;
        std::cout << "Memory used: " << memory_used / (1024.0 * 1024.0) << " MB" << std::endl;
        std::cout << "Memory per event: " << bytes_per_event << " bytes" << std::endl;
    }

    // Measure calculation time and peak memory usage
    std::atomic<bool> monitoring{true};
    std::atomic<size_t> peak_memory{post_event_memory};

    // Start memory monitoring thread
    std::thread monitor_thread([&monitoring, &peak_memory, initial_memory]()
                               {