Function benchmark_binary_elementwise_ops

tests/test_performance.cpp:92–133

template<typename T>
void benchmark_binary_elementwise_ops(TestUtils::TestRunner& runner, const BenchmarkConfig& config) {
    const std::vector<std::pair<std::string, std::function<size_t(CactusGraph&, size_t, size_t)>>> ops = {
        {"Add", [](CactusGraph& b, size_t a, size_t c) { return b.add(a, c); }},
        {"Subtract", [](CactusGraph& b, size_t a, size_t c) { return b.subtract(a, c); }},
        {"Multiply", [](CactusGraph& b, size_t a, size_t c) { return b.multiply(a, c); }},
        {"Divide", [](CactusGraph& b, size_t a, size_t c) { return b.divide(a, c); }}
    };

    Precision precision = TestUtils::default_precision<T>();
    std::string prec_str = precision_to_string(precision);
    
    for (const auto& [op_name, op_func] : ops) {
        for (size_t dim : config.dimensions) {
            size_t total_elements = dim * dim;
            
            TestUtils::TestFixture<T> fixture(op_name);
            size_t input_a = fixture.create_input({dim, dim}, precision);
            size_t input_b = fixture.create_input({dim, dim}, precision);
            
            std::vector<T> data_a(total_elements), data_b(total_elements);
            setup_random_data(data_a);
            setup_random_data(data_b);
            
            fixture.set_input_data(input_a, data_a, precision);
            fixture.set_input_data(input_b, data_b, precision);
            
            op_func(fixture.graph(), input_a, input_b);

            double time_ms = time_operation<T>([&]() {
                fixture.execute();
            }, config.iterations);
            
            double gflops = calculate_gflops(total_elements, time_ms);
            
            std::ostringstream details;
            details << std::fixed << std::setprecision(3) << time_ms << "ms, "
                    << std::setprecision(2) << gflops << " GFLOPS";
            runner.log_performance(op_name + " " + std::to_string(dim) + "x" + std::to_string(dim),
                                 details.str());
        }
    }
}

void benchmark_conv1d_ops(TestUtils::TestRunner& runner, const BenchmarkConfig& config) {
    std::vector<std::tuple<size_t, size_t, size_t, size_t>> shapes = {