QVAC-18192 parakeet-cpp: resolve Sortformer head backend internally (force-CPU safety)

The Sortformer force-CPU path (the Mali-Vulkan miscompute workaround) allocated and
computed on the caller-supplied backend, so a caller passing the active GPU backend
(as test_sortformer_parity did) would defeat the workaround on Mali and drive the
CPU-resident head weights through the GPU. Both production engine callers passed the
correct backend, but the contract was a footgun.

Resolve the head backend internally via model_sortformer_backend(model) (CPU on
Mali-Vulkan, the active backend otherwise) and drop the caller-supplied backend
parameter from sortformer_diarize_ggml and sortformer_aosc_step so the contract
cannot be violated. Make model_sortformer_backend const and add an internal
null-backend guard; delete the now-orphaned caller locals.

Author: pratiknarola-t

parakeet-cpp/src/parakeet_ctc.cpp

@@ -1134,7 +1134,7 @@ ggml_backend_t model_active_backend(ParakeetCtcModel & m) {
     return m.impl->backend_active;
 }
 
-ggml_backend_t model_sortformer_backend(ParakeetCtcModel & m) {
+ggml_backend_t model_sortformer_backend(const ParakeetCtcModel & m) {
     if (!m.impl) return nullptr;
     return m.impl->sortformer_force_cpu ? m.impl->backend_cpu
                                         : m.impl->backend_active;

parakeet-cpp/src/parakeet_ctc.h

@@ -342,7 +342,7 @@ ggml_backend_t model_active_backend(ParakeetCtcModel & m);
 
 // Backend for the Sortformer head: the active backend normally, but CPU on
 // Mali-Vulkan (its transformer block 0 miscomputes to NaN; encoder stays on GPU).
-ggml_backend_t model_sortformer_backend(ParakeetCtcModel & m);
+ggml_backend_t model_sortformer_backend(const ParakeetCtcModel & m);
 
 // True when the head is routed to CPU (Mali-Vulkan); the graph then reads the
 // CPU-resident weight copies (model.sortformer_cpu), not the GPU originals.

parakeet-cpp/src/parakeet_engine.cpp

@@ -593,15 +593,10 @@ static DiarizationResult engine_impl_diarize_helper(Engine::Impl & impl,
     sopts.threshold = opts.threshold;
     SortformerDiarizationResult dres;
 
-    ggml_backend_t head_backend = model_sortformer_backend(impl.model);
-    if (!head_backend) {
-        throw std::runtime_error("diarize: no ggml backend for the diarization head");
-    }
-
     int diarize_rc = sortformer_diarize_ggml(impl.model,
                                              enc_out.encoder_out.data(),
                                              enc_out.n_enc_frames, enc_out.d_model,
-                                             head_backend, sopts, dres);
+                                             sopts, dres);
     if (diarize_rc != 0) {
         throw std::runtime_error("diarize: sortformer_diarize failed (rc=" +
                                  std::to_string(diarize_rc) + ")");
@@ -726,16 +721,11 @@ static DiarizationResult engine_impl_diarize_streaming_helper(
     s_opts.threshold = opts.threshold;
     SortformerDiarizationResult dres;
 
-    ggml_backend_t head_backend = model_sortformer_backend(impl.model);
-    if (!head_backend) {
-        throw std::runtime_error("diarize_streaming: no ggml backend for the diarization head");
-    }
-
     if (int rc_ = sortformer_aosc_step(impl.model,
                                        pre_encode.data(),
                                        n_pre_encode_frames, D,
                                        lc, rc, chunk_len_eff,
-                                       cache, cfg, head_backend, s_opts, dres);
+                                       cache, cfg, s_opts, dres);
         rc_ != 0) {
         throw std::runtime_error("diarize_streaming: sortformer_aosc_step failed (rc=" +
                                  std::to_string(rc_) + ")");

parakeet-cpp/src/parakeet_sortformer.cpp

@@ -158,6 +158,9 @@ ggml_tensor * sf_build_graph(ggml_context * ctx,
 
 // Allocate, upload input, compute, and download output for a Sortformer graph.
 // Returns 0 on success, negative on failure.  Caller must free ctx afterwards.
+// `backend` must be the head backend (model_sortformer_backend): it is used only
+// by the force_cpu branch, which requires the CPU backend; the normal path runs
+// through `sched`. sortformer_diarize_ggml resolves it so callers cannot mismatch.
 int sf_exec_graph(ggml_context * ctx, ggml_backend_t backend,
                   ggml_backend_sched_t sched, bool force_cpu,
                   ggml_tensor * x_in, ggml_tensor * x_out,
@@ -630,7 +633,6 @@ void sortformer_cache_reset(SortformerSpeakerCache & cache, int D) {
 int sortformer_diarize_ggml(const ParakeetCtcModel & model,
                             const float * encoder_out,
                             int T_enc, int D_enc,
-                            ggml_backend_t backend,
                             const SortformerDiarizationOptions & opts,
                             SortformerDiarizationResult & out) {
     const auto & enc   = model.encoder_cfg;
@@ -657,6 +659,16 @@ int sortformer_diarize_ggml(const ParakeetCtcModel & model,
     const int head_dim = tf_d / n_heads;
     const auto t0 = std::chrono::steady_clock::now();
 
+    // Resolve the head backend from the model itself (CPU on Mali-Vulkan, the
+    // active backend otherwise). Resolving here -- rather than trusting a caller-
+    // supplied argument -- makes it impossible to drive the force-CPU workaround's
+    // CPU-resident weights through the GPU.
+    ggml_backend_t backend = model_sortformer_backend(model);
+    if (!backend) {
+        std::fprintf(stderr, "sortformer_diarize_ggml: no ggml backend for the diarization head\n");
+        return 1;
+    }
+
     // 1. Context for graph construction (no-alloc)
     const size_t graph_slots = 4096;
     const size_t overhead = ggml_tensor_overhead() * graph_slots
@@ -708,7 +720,6 @@ int sortformer_aosc_step(ParakeetCtcModel & model,
                          int lc, int rc, int chunk_len_eff,
                          SortformerSpeakerCache & cache,
                          const SortformerStreamingConfig & cfg,
-                         ggml_backend_t backend,
                          const SortformerDiarizationOptions & opts,
                          SortformerDiarizationResult & out) {
     const auto & enc   = model.encoder_cfg;
@@ -782,7 +793,7 @@ int sortformer_aosc_step(ParakeetCtcModel & model,
     // 3. Run the diariser over the full cat.
     SortformerDiarizationResult diar_cat;
     if (int rc_ = sortformer_diarize_ggml(model, enc_cat.encoder_out.data(),
-                                          T_cat, D, backend, opts, diar_cat); rc_ != 0) {
+                                          T_cat, D, opts, diar_cat); rc_ != 0) {
         return rc_;
     }
     if (diar_cat.num_spks != num_spks) {

parakeet-cpp/src/parakeet_sortformer.h

@@ -110,10 +110,12 @@ struct SortformerSpeakerCache {
 // Reset to a fresh empty state. Allocates mean_sil_emb to D zeros.
 void sortformer_cache_reset(SortformerSpeakerCache & cache, int D);
 
+// The diarization head backend is resolved internally via model_sortformer_backend
+// (CPU on Mali-Vulkan, the active backend otherwise) so callers cannot accidentally
+// drive the CPU-resident force-CPU path through the GPU.
 int  sortformer_diarize_ggml(const ParakeetCtcModel & model,
                              const float * encoder_out,
                              int T_enc, int D_enc,
-                             ggml_backend_t backend,
                              const SortformerDiarizationOptions & opts,
                              SortformerDiarizationResult & out);
 
@@ -142,7 +144,6 @@ int  sortformer_aosc_step(ParakeetCtcModel & model,
                           int lc, int rc, int chunk_len_eff,
                           SortformerSpeakerCache & cache,
                           const SortformerStreamingConfig & cfg,
-                          ggml_backend_t backend,
                           const SortformerDiarizationOptions & opts,
                           SortformerDiarizationResult & out);
 

parakeet-cpp/test/test_sortformer_parity.cpp

@@ -169,14 +169,12 @@ int main(int argc, char ** argv) {
     std::fprintf(stderr, "[sf-parity] enc  : max_abs=%.4e rel=%.4e  (%s, rel tol=%.1e)\n",
                  max_abs_enc, rel_enc, enc_pass ? "PASS" : "FAIL", enc_rel_tol);
 
-    ggml_backend_t backend = model_active_backend(model);
-    if (!backend) { std::fprintf(stderr, "  error: no active ggml backend\n"); return 8; }
     SortformerDiarizationOptions dopts;
     SortformerDiarizationResult dres;
     if (sortformer_diarize_ggml(model,
                                 enc_out.encoder_out.data(),
                                 enc_out.n_enc_frames, enc_out.d_model,
-                                backend, dopts, dres) != 0) return 9;
+                                dopts, dres) != 0) return 9;
 
     int worst = 0;