Function measure_accuracy

benchmark/ctrack_benchmark.cpp:270–365

Measure accuracy by comparing known timings with CTRACK measurements

// Measure accuracy by comparing known timings with CTRACK measurements
std::pair<double, double> measure_accuracy()
{
    std::cout << "\n=== Measuring Accuracy ===" << std::endl;

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

    // Run a controlled test with known timings
    const int test_iterations = 100;
    for (int i = 0; i < test_iterations; ++i)
    {
        level_1_function(10);
    }

    // Get results
    auto results = ctrack::result_as_string();

    // Expected timings per iteration (in nanoseconds):
    // leaf_function: 1000ns (called 20 times per iteration) = 20,000ns total per iteration
    // level_3_function: 500ns + 2*1000ns = 2500ns (called 10 times per iteration) = 25,000ns total per iteration
    // level_2_function: 300ns + 10*2500ns = 25,300ns (called 1 time per iteration) = 25,300ns total per iteration
    // level_1_function: 200ns + 25,300ns = 25,500ns (called 1 time per iteration) = 25,500ns total per iteration

    struct ExpectedTiming
    {
        std::string name;
        double expected_total_ns;
        int call_count;
    };

    std::vector<ExpectedTiming> expected_timings = {
        {"leaf_function", 1000.0 * 20 * test_iterations, 20 * test_iterations},
        {"level_3_function", 2500.0 * 10 * test_iterations, 10 * test_iterations},
        {"level_2_function", 25300.0 * 1 * test_iterations, 1 * test_iterations},
        {"level_1_function", 25500.0 * 1 * test_iterations, 1 * test_iterations}};

    double total_expected_time = 0.0;
    double total_actual_time = 0.0;
    double max_absolute_error = 0.0;

    if (g_config.verbose)
    {
        std::cout << "Function accuracy analysis:" << std::endl;
    }

    for (const auto &timing : expected_timings)
    {
        double actual_ns = parse_function_timing(results, timing.name);
        if (actual_ns > 0)
        {
            double expected_ns = timing.expected_total_ns;
            double absolute_error = std::abs(actual_ns - expected_ns);
            double percent_error = (absolute_error / expected_ns) * 100.0;

            total_expected_time += expected_ns;
            total_actual_time += actual_ns;
            max_absolute_error = (std::max)(max_absolute_error, absolute_error);