perf(firered): link OpenMP + vectorizable dot — ~4x faster AED decoder

The firered-asr target never linked OpenMP, so cpu_matmul_bt's
`#pragma omp parallel for` were no-ops and the AED beam decoder ran
single-threaded (~1443 ms/token at beam 5 on an RTX A1000's CPU). Two fixes:

1. Link firered-asr with OpenMP::OpenMP_CXX so the matmuls actually
   parallelize (the pragmas were already there).
2. Replace the double-accumulate dot in cpu_matmul_bt with cpu_dot() — four
   independent float accumulator chains the compiler can vectorize under
   strict FP. Float accumulation over K~1280 is within ASR-logit tolerance.

Decoder: 1443 -> 365 ms/token (3.95x). issue19-5s 0.2x -> 0.6x RT; issue19-35s
223 s -> 111 s (2x wall). Transcripts byte-identical. Decoder is now partially
bandwidth-bound (reads ~1.5 GB F32 weights per beam) — batching the beams is
the next lever.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: CrispStrobe

src/CMakeLists.txt

@@ -1360,6 +1360,13 @@ set_target_properties(firered-asr PROPERTIES POSITION_INDEPENDENT_CODE ON)
 target_include_directories(firered-asr PUBLIC .)
 target_compile_features   (firered-asr PUBLIC cxx_std_17)
 target_link_libraries     (firered-asr PUBLIC crispasr-core ggml ggml-base ggml-cpu)
+# firered_asr.cpp's CPU decoder/encoder matmuls (cpu_matmul_bt) are
+# `#pragma omp parallel for`, but the target never linked OpenMP — so the
+# pragmas were no-ops and the AED beam decoder ran single-threaded
+# (~1.4 s/token at beam 5). Link OpenMP so the matmuls actually parallelize.
+if (OpenMP_CXX_FOUND)
+    target_link_libraries(firered-asr PUBLIC OpenMP::OpenMP_CXX)
+endif()
 if(NOT MSVC)
     target_compile_options(firered-asr PRIVATE -O3)
 endif()

src/firered_asr.cpp

@@ -692,27 +692,39 @@ static void read_f32_vec(ggml_tensor* t, std::vector<float>& out) {
 
 // CPU matmul: C = A @ B^T where A is [M,K], B is [N,K] → C is [M,N]
 // (B stored as [N,K] row-major, like ggml weight [K,N] with ne[0]=K)
+// Dot product of two length-K float vectors using four independent
+// accumulator chains so the compiler can vectorize the reduction even under
+// strict FP (no -ffast-math / /fp:fast needed). Float accumulation over
+// K~1280 is well within tolerance for ASR logits; the old double-accumulate
+// form forced scalar, non-vectorized code and dominated the decoder.
+static inline float cpu_dot(const float* a, const float* b, int K) {
+    float s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+    int k = 0;
+    for (; k + 4 <= K; k += 4) {
+        s0 += a[k + 0] * b[k + 0];
+        s1 += a[k + 1] * b[k + 1];
+        s2 += a[k + 2] * b[k + 2];
+        s3 += a[k + 3] * b[k + 3];
+    }
+    float s = (s0 + s1) + (s2 + s3);
+    for (; k < K; k++)
+        s += a[k] * b[k];
+    return s;
+}
+
 static void cpu_matmul_bt(const float* A, const float* B, float* C, int M, int K, int N) {
     if (M == 1) {
         // Single-vector × matrix: parallelize over output dimension N.
         // This is the decoder hot path (one token per step).
 #pragma omp parallel for schedule(static)
-        for (int n = 0; n < N; n++) {
-            double s = 0;
-            const float* brow = B + n * K;
-            for (int k = 0; k < K; k++)
-                s += (double)A[k] * (double)brow[k];
-            C[n] = (float)s;
-        }
+        for (int n = 0; n < N; n++)
+            C[n] = cpu_dot(A, B + (size_t)n * K, K);
     } else {
 #pragma omp parallel for schedule(static)
         for (int m = 0; m < M; m++) {
-            for (int n = 0; n < N; n++) {
-                double s = 0;
-                for (int k = 0; k < K; k++)
-                    s += (double)A[m * K + k] * (double)B[n * K + k];
-                C[m * N + n] = (float)s;
-            }
+            const float* arow = A + (size_t)m * K;
+            for (int n = 0; n < N; n++)
+                C[(size_t)m * N + n] = cpu_dot(arow, B + (size_t)n * K, K);
         }
     }
 }