What

Three OpenCL backend fixes that let the Qwen3-VL / SigLIP vision encoder
run correctly and fast on Adreno (Snapdragon OpenCL), so the vision
(mmproj/clip) tower can move off the CPU. On a Samsung S25 (Adreno 830)
this gives a ~2.3x faster vision encode with no accuracy loss vs the
CPU baseline.

Targets temp-9341 (the 9341 integration branch). All three commits
touch only ggml-opencl.cpp. Intended to publish as qvac-fabric 9341.1.0.

Commits

1. support antialiased BILINEAR upscale when upsampling — supports_op
   rejected BILINEAR|ANTIALIAS, forcing the Qwen3-VL position-embedding
   interpolation onto the CPU and splitting the compute graph (3 splits).
   Antialiasing only affects downsampling; when upsampling (the vision
   tower's case) the result is identical to plain bilinear, which the
   existing kernel already computes. Accepting it keeps the whole CLIP
   graph on OpenCL (graph splits 3 → 1).
2. build flash-attn kernels without finite-math — the kernels were
   built with -cl-finite-math-only / -cl-fast-relaxed-math /
   -cl-unsafe-math-optimizations, which let the compiler assume no
   Inf/NaN. Flash-attention initialises its online-softmax running max to
   -INFINITY and masks padded score rows (k_row >= n_kv) with
   -INFINITY; with n_kv not a multiple of the tile width those paths are
   exercised, so finite-math miscompiles them. Strip those three flags for
   the FA programs (keep -cl-mad-enable).
3. treat null attention mask as bidirectional, not causal (the
   decisive accuracy fix) — the FA dispatch inferred causal masking from
   shape: is_causal = (mask == NULL && n_q > 1 && n_q == n_kv). A null
   mask means no masking (bidirectional — the SigLIP vision/embedding
   encoders); causal attention always supplies an explicit -INFINITY
   causal mask in this codebase. The heuristic made the bidirectional
   Qwen3-VL vision tower attend causally, so each patch only saw
   earlier patches and the image embedding was corrupted. Set
   is_causal = 0 unconditionally — causality is always expressed via the
   explicit mask.

Why it's safe for the LLM

The LLM already passes a real causal kq_mask filled with -INFINITY
(llama-graph.cpp build_attn), so it was already is_causal = 0 and
relies on that mask; incremental decode (n_q=1) uses the single-query
kernel which ignores is_causal. The shape-heuristic's causal branch was
only ever hit by bidirectional encoders passing a null mask, so removing
it cannot change LLM behaviour. The fix benefits all bidirectional
encoders (vision + embeddings) on Adreno OpenCL, not just this model.

Scope

Deliberately minimal — only the changes the validated path needs. The
vision tower casts K/V to F16 (clip.cpp), so its attention dispatches the
mixed flash_attn_f32_f16 kernel; commits 2 and 3 cover that kernel
(no-finite-math is applied to all FA programs; is_causal is host-side).

Validation

• On-device (S25 / Adreno 830, isolated vision-encode, 3-rep medians):
  CPU 2180ms → OpenCL 945ms = 2.31x, output correct in both.
• Built + tested across all six qvac-fabric consumers via the monorepo
  overlay (classification-ggml, embed-llamacpp, llm-llamacpp, ocr-ggml,
  translation-nmtcpp, vla-ggml) — android-arm64 (the OpenCL build)
  green; no consumer build/test regressions.

Consumer validation CI (9341.1.1 rollout Phase A)

Validated from monorepo branch test/QVAC-21297-fabric-9341.1.1-overlay — a shared vcpkg overlay port pinning this PR's head (fe61104b, built from source in every consumer's CI; no registry/baseline changes), dispatched per consumer via workflow_dispatch:

On-device benchmark (S25 Ultra / Adreno 830, OpenCL — AWS Device Farm)

4-run CPU-matched A/B (2 baseline + 2 fixed, paired by the build-invariant CPU mmproj-encode fingerprint), Qwen3.5-0.8B + mmproj-Q8_0, projector CPU-vs-GPU per run, lmms-eval quality gate:

• Accuracy restored and neutral: GPU projector == CPU (Δ 0.0 pp) with this PR's fixes — versus the stock OpenCL GPU projector's corrupted encodes (−4.1 pp at base preset, −18.8 pp at full). The decisive fix is null-mask ⇒ bidirectional attention (the SigLIP tower was being force-cast to causal).
• Speed: the fixed GPU projector is ~23 % faster than the shipping CPU projector on vision-encode (~19 % faster TTFT); within-run GPU-vs-CPU speedup ~1.43× on the lmms-eval fixture, up to ~2.31× on the isolated single-image best case (matches the number in Validation above). Correct attention costs ~31 % vs the buggy-but-fast stock GPU baseline — still well under CPU.

• To see the specific tasks where the Asana app for GitHub is being used, see below:
  • https://app.asana.com/0/0/1215998138052535