Function test_dispatch_overhead

tests/test_metal_overhead.cpp:53–94

═══════════════════════════════════════════════════════════════════════════════ TEST 1: Pure dispatch overhead — chain of N trivial add ops ═══════════════════════════════════════════════════════════════════════════════

//  TEST 1: Pure dispatch overhead — chain of N trivial add ops
// ═══════════════════════════════════════════════════════════════════════════════
static void test_dispatch_overhead(ggml_backend_t cpu, ggml_backend_t metal) {
    fprintf(stderr, "\n=== TEST 1: Dispatch overhead (chain of N add ops on [1024,72,72] tensors) ===\n\n");
    fprintf(stderr, "  %6s  %10s  %10s  %12s\n", "N_ops", "CPU (ms)", "Metal (ms)", "Overhead/op");

    int counts[] = {1, 10, 50, 100, 250, 500, 1000, 2500};
    double metal_1op = 0;

    for (int N : counts) {
        int max_tensors = N + 20;
        int max_graph = N + 20;

        auto build_and_run = [&](ggml_backend_t backend) -> double {
            size_t ctx_size = ggml_tensor_overhead() * max_tensors + ggml_graph_overhead_custom(max_graph, false);
            ggml_init_params params = {ctx_size, nullptr, true};
            auto* ctx = ggml_init(params);

            auto* a = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 1024, 72, 72); ggml_set_input(a);
            auto* b = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 1024, 72, 72); ggml_set_input(b);
            auto* x = ggml_add(ctx, a, b);
            for (int i = 1; i < N; i++)
                x = ggml_add(ctx, x, b);
            ggml_set_output(x);

            auto* graph = ggml_new_graph_custom(ctx, max_graph, false);
            ggml_build_forward_expand(graph, x);

            std::vector<ggml_tensor*> inputs = {a, b};
            double ms = run_graph(backend, ctx, graph, inputs, 1, 3);
            ggml_free(ctx);
            return ms;
        };

        double cpu_ms = build_and_run(cpu);
        double metal_ms = build_and_run(metal);

        if (N == 1) metal_1op = metal_ms;
        double overhead_per_op = (N > 1) ? (metal_ms - metal_1op) / (N - 1) : 0;

        fprintf(stderr, "  %6d  %8.2f ms  %8.2f ms  %10.3f ms\n",
                N, cpu_ms, metal_ms, overhead_per_op);
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//  TEST 2: Single ViT block as ONE graph vs sum of individual ops