Function run_single_benchmark

examples/benchmark.cpp:198–296

// ── Run a single benchmark (shared logic) ──────────────────────────────────

static BenchWire run_single_benchmark(const std::string & model_path,
                                       bool use_gpu,
                                       const std::string & video_path,
                                       int n_frames,
                                       float px, float py,
                                       int n_threads,
                                       int encode_img_size) {
    BenchWire wire = {};

    auto fail = [&](const char * msg) {
        wire.ok = 0;
        snprintf(wire.error, sizeof(wire.error), "%s", msg);
    };

    // Decode frames
    std::vector<sam3_image> frames(n_frames);
    for (int f = 0; f < n_frames; f++) {
        frames[f] = sam3_decode_video_frame(video_path, f);
        if (frames[f].data.empty()) { fail("decode frame failed"); return wire; }
    }

    // Load model
    int64_t t0 = ggml_time_us();

    sam3_params params;
    params.model_path    = model_path;
    params.use_gpu       = use_gpu;
    params.n_threads     = n_threads;
    params.encode_img_size = encode_img_size;

    auto model = sam3_load_model(params);
    if (!model) { fail("load failed"); return wire; }

    auto state = sam3_create_state(*model, params);
    if (!state) { fail("state failed"); return wire; }

    bool visual_only = sam3_is_visual_only(*model);
    sam3_tracker_ptr tracker;

    if (visual_only) {
        sam3_visual_track_params vtp;
        vtp.max_keep_alive    = 100;
        vtp.recondition_every = 16;
        tracker = sam3_create_visual_tracker(*model, vtp);
    } else {
        sam3_video_params vp;
        vp.hotstart_delay = 0;
        vp.max_keep_alive = 100;
        tracker = sam3_create_tracker(*model, vp);
    }
    if (!tracker) { fail("tracker failed"); return wire; }

    wire.t_load_ms = (ggml_time_us() - t0) / 1000.0;

    // Frame 0: encode + add instance
    t0 = ggml_time_us();

    if (!sam3_encode_image(*state, *model, frames[0])) {