e2e gemm: real-activation workloads for Qwen3.5-4B, Llama-3.1-8B, OLMoE-1B-7B; unified quantized gemm definitions

TASKS.md

@@ -21,11 +21,11 @@ How each source's baseline is chosen and marked is explained under *Notes on the
 | Source | Definitions | SVE ★ / ✓ / ? / ✗ / — | SVE2 ★ / ✓ / ? / ✗ / — | SME2 ★ / ✓ / ? / ✗ / — |
 |---|---|---|---|---|
 | ncnn | 23 | 0 / 23 / 0 / 0 / 0 | 0 / 23 / 0 / 0 / 0 | 0 / 23 / 0 / 0 / 0 |
-| llama.cpp | 26 | 0 / 26 / 0 / 0 / 0 | 0 / 26 / 0 / 0 / 0 | 0 / 26 / 0 / 0 / 0 |
+| llama.cpp | 26 | 0 / 16 / 10 / 0 / 0 | 0 / 16 / 10 / 0 / 0 | 0 / 16 / 10 / 0 / 0 |
 | SIMD Loops | 47 | 27 / 0 / 0 / 3 / 17 | 11 / 18 / 0 / 7 / 11 | 7 / 16 / 0 / 8 / 16 |
 | KleidiAI | 10 | 3 / 0 / 0 / 0 / 7 | 0 / 2 / 0 / 0 / 8 | 7 / 0 / 0 / 0 / 3 |
-| e2e (llama.cpp GEMMs) | 18 | 0 / 18 / 0 / 0 / 0 | 0 / 18 / 0 / 0 / 0 | 0 / 18 / 0 / 0 / 0 |
-| **All** | **124** | 30 / 67 / 0 / 3 / 24 | 11 / 87 / 0 / 7 / 19 | 14 / 83 / 0 / 8 / 19 |
+| e2e (llama.cpp GEMMs) | 22 | 0 / 13 / 9 / 0 / 0 | 0 / 13 / 9 / 0 / 0 | 0 / 13 / 9 / 0 / 0 |
+| **All** | **122** | 30 / 52 / 13 / 3 / 24 | 11 / 72 / 13 / 7 / 19 | 14 / 68 / 13 / 8 / 19 |
 
 ## ncnn (23)
 
@@ -59,21 +59,21 @@ How each source's baseline is chosen and marked is explained under *Notes on the
 
 | Definition | Op | Workloads | Eval set | Subset | SVE | SVE2 | SME2 |
 |---|---|---|---|---|---|---|---|
-| `gemm_bf16_n1024_k2048` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_bf16_n1408_k2048` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_bf16_n2048_k1024` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_bf16_n2048_k1408` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_bf16_n2048_k2048` | gemm | 24 | ✓ | ✓ | ✓ | ✓ | ✓ |
-| `gemm_q4_k_m_n1024_k2048` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q4_k_m_n1408_k2048` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q4_k_m_n2048_k1024` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q4_k_m_n2048_k1536` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q4_k_m_n2048_k2048` | gemm | 24 | ✓ | ✓ | ✓ | ✓ | ✓ |
-| `gemm_q8_0_n1024_k2048` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q8_0_n1408_k2048` | gemm | 24 | ✓ | ✓ | ✓ | ✓ | ✓ |
-| `gemm_q8_0_n2048_k1024` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q8_0_n2048_k1408` | gemm | 24 | ✓ |  | ✓ | ✓ | ✓ |
-| `gemm_q8_0_n2048_k2048` | gemm | 24 | ✓ | ✓ | ✓ | ✓ | ✓ |
+| `gemm_bf16_n1024_k2048` | gemm | 20 | ✓ |  | ✓ | ✓ | ✓ |
+| `gemm_bf16_n1408_k2048` | gemm | 20 | ✓ |  | ✓ | ✓ | ✓ |
+| `gemm_bf16_n2048_k1024` | gemm | 20 | ✓ |  | ✓ | ✓ | ✓ |
+| `gemm_bf16_n2048_k1408` | gemm | 20 | ✓ |  | ✓ | ✓ | ✓ |
+| `gemm_bf16_n2048_k2048` | gemm | 20 | ✓ | ✓ | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n1024_k2048` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n1408_k2048` | gemm | 20 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n2048_k1024` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n2048_k1536` | gemm | 20 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n2048_k2048` | gemm | 20 | ✓ | ✓ | ? | ? | ? |
+| `gemm_q8_0_n1024_k2048` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q8_0_n1408_k2048` | gemm | 20 | ✓ | ✓ | ? | ? | ? |
+| `gemm_q8_0_n2048_k1024` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q8_0_n2048_k1408` | gemm | 20 | ✓ |  | ? | ? | ? |
+| `gemm_q8_0_n2048_k2048` | gemm | 20 | ✓ | ✓ | ? | ? | ? |
 | `gqa_bf16_h32_d128_kvh8` | gqa | 20 | ✓ |  | ✓ | ✓ | ✓ |
 | `mha_bf16_h16_d128_kvh16` | mha | 20 | ✓ | ✓ | ✓ | ✓ | ✓ |
 | `mla_decode_bf16_h16_lora512_rope64_v128` | mla_decode | 20 | ✓ |  | ✓ | ✓ | ✓ |
@@ -84,7 +84,7 @@ How each source's baseline is chosen and marked is explained under *Notes on the
 | `moe_q4_k_m_e64_k8_d2048_ff1024` | moe | 20 | ✓ | ✓ | ✓ | ✓ | ✓ |
 | `moe_q8_0_e60_k4_d2048_ff1408` | moe | 20 | ✓ |  | ✓ | ✓ | ✓ |
 | `moe_q8_0_e64_k8_d2048_ff1024` | moe | 20 | ✓ | ✓ | ✓ | ✓ | ✓ |
-| `rms_norm_fp32_d2048` | rms_norm | 24 | ✓ | ✓ | ✓ | ✓ | ✓ |
+| `rms_norm_fp32_d2048` | rms_norm | 20 | ✓ | ✓ | ✓ | ✓ | ✓ |
 
 ## SIMD Loops (47)
 
@@ -157,30 +157,34 @@ Loops without the Eval set mark are in the dataset but not in the main results.
 | `gemm_qs4c32_n256_k512` | gemm | 13 | ✓ |  | ★ | — | — |
 | `gemm_qs4cx_sme2_n256_k512` | gemm | 13 | ✓ |  | — | — | ★ |
 
-## e2e (llama.cpp GEMMs) (18)
+## e2e (llama.cpp GEMMs) (22)
 
-These definitions load only with the e2e branch for now (code repo issue #94).
+These definitions load only with the e2e branch for now (code repo issue #94). Qwen3.5-4B, Llama-3.1-8B and OLMoE-1B-7B (Q4_K_M and Q8_0 GGUFs); each model keeps the operators that make up the first 90% of its per-quantization decode weight bytes. OLMoE's baselines have run on Graviton4 only as part of the SQNR calibration, with no speedup recorded, so they are marked `?`.
 
 | Definition | Op | Workloads | Eval set | Subset | SVE | SVE2 | SME2 |
 |---|---|---|---|---|---|---|---|
-| `gemm_ggml_q4_K_n1024_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n1024_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n14336_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n2560_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n2560_k9216` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n4096_k14336` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n4096_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n4096_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n8192_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q4_K_n9216_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q5_K_n2560_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q5_K_n8192_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n1024_k2560` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n1024_k4096` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n128256_k4096` | gemm | 4 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n248320_k2560` | gemm | 4 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n2560_k9216` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
-| `gemm_ggml_q6_K_n4096_k14336` | gemm | 6 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n1024_k2048` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n14336_k4096` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n2048_k1024` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q4_K_n2048_k2048` | gemm | 20 | ✓ | ✓ | ? | ? | ? |
+| `gemm_q4_K_n2560_k9216` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n4096_k14336` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n4096_k2560` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n4096_k4096` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n8192_k2560` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q4_K_n9216_k2560` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q5_K_n2560_k4096` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q5_K_n8192_k2560` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q6_K_n128256_k4096` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q6_K_n2048_k1024` | gemm | 19 |  |  | ? | ? | ? |
+| `gemm_q6_K_n2048_k2048` | gemm | 20 |  |  | ? | ? | ? |
+| `gemm_q6_K_n248320_k2560` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q6_K_n2560_k9216` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q6_K_n4096_k14336` | gemm | 20 |  |  | ✓ | ✓ | ✓ |
+| `gemm_q6_K_n50304_k2048` | gemm | 20 |  |  | ? | ? | ? |
+| `gemm_q8_0_n1024_k2048` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q8_0_n2048_k1024` | gemm | 19 | ✓ |  | ? | ? | ? |
+| `gemm_q8_0_n2048_k2048` | gemm | 20 | ✓ | ✓ | ? | ? | ? |
 
 ## Notes on ✗
 

definitions/gemm/{gemm_ggml_q4_K_n1024_k4096.json → gemm_q4_K_n1024_k2048.json}

@@ -1,14 +1,14 @@
 {
-  "name": "gemm_ggml_q4_K_n1024_k4096",
+  "name": "gemm_q4_K_n1024_k2048",
   "op_type": "gemm",
-  "description": "llama blk.N.attn_k.weight\u00d732, blk.N.attn_v.weight\u00d716: N=1024 K=4096, ggml Q4_K block rows (e2e, 2.5% of decode bytes)",
+  "description": "olmoe blk.N.ffn_gate_exps.weightx16 (experts 64), blk.N.ffn_up_exps.weightx16 (experts 64): N=1024 K=2048, ggml Q4_K block rows (e2e, 40.8% of decode bytes)",
   "tags": [
     "status:active",
-    "model:llama-3.1-8b",
+    "model:olmoe-1b-7b",
     "baseline-solution:llama.cpp",
     "correctness:sqnr",
-    "e2e:llama-3.1-8b",
-    "e2e-share:0.0246"
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.4078"
   ],
   "axes": {
     "M": {
@@ -20,15 +20,15 @@
     },
     "K": {
       "type": "const",
-      "value": 4096
+      "value": 2048
     },
     "K_blk": {
       "type": "const",
-      "value": 16
+      "value": 8
     },
     "K_bytes": {
       "type": "const",
-      "value": 2304
+      "value": 1152
     }
   },
   "inputs": {

definitions/gemm/{gemm_ggml_q4_K_n2560_k4096.json → gemm_q4_K_n1408_k2048.json}

@@ -1,14 +1,12 @@
 {
-  "name": "gemm_ggml_q4_K_n2560_k4096",
+  "name": "gemm_q4_K_n1408_k2048",
   "op_type": "gemm",
-  "description": "qwen35 blk.N.attn_output.weight\u00d78: N=2560 K=4096, ggml Q4_K block rows (e2e, 1.7% of decode bytes)",
+  "description": "qwen1.5-moe-a2.7b expert ffn N=1408 K=2048, ggml Q4_K block rows",
   "tags": [
     "status:active",
-    "model:qwen3.5-4b",
+    "model:qwen1.5-moe-a2.7b",
     "baseline-solution:llama.cpp",
-    "correctness:sqnr",
-    "e2e:qwen3.5-4b",
-    "e2e-share:0.0173"
+    "correctness:sqnr"
   ],
   "axes": {
     "M": {
@@ -16,19 +14,19 @@
     },
     "N": {
       "type": "const",
-      "value": 2560
+      "value": 1408
     },
     "K": {
       "type": "const",
-      "value": 4096
+      "value": 2048
     },
     "K_blk": {
       "type": "const",
-      "value": 16
+      "value": 8
     },
     "K_bytes": {
       "type": "const",
-      "value": 2304
+      "value": 1152
     }
   },
   "inputs": {

definitions/gemm/{gemm_ggml_q4_K_n14336_k4096.json → gemm_q4_K_n14336_k4096.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n14336_k4096",
+  "name": "gemm_q4_K_n14336_k4096",
   "op_type": "gemm",
   "description": "llama blk.N.ffn_gate.weight\u00d732, blk.N.ffn_up.weight\u00d732: N=14336 K=4096, ggml Q4_K block rows (e2e, 45.8% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n1024_k2560.json → gemm_q4_K_n2048_k1024.json}

@@ -1,14 +1,14 @@
 {
-  "name": "gemm_ggml_q4_K_n1024_k2560",
+  "name": "gemm_q4_K_n2048_k1024",
   "op_type": "gemm",
-  "description": "qwen35 blk.N.attn_k.weight\u00d78, blk.N.attn_v.weight\u00d73: N=1024 K=2560, ggml Q4_K block rows (e2e, 0.6% of decode bytes)",
+  "description": "olmoe blk.N.ffn_down_exps.weightx8 (experts 64): N=2048 K=1024, ggml Q4_K block rows (e2e, 10.2% of decode bytes)",
   "tags": [
     "status:active",
-    "model:qwen3.5-4b",
+    "model:olmoe-1b-7b",
     "baseline-solution:llama.cpp",
     "correctness:sqnr",
-    "e2e:qwen3.5-4b",
-    "e2e-share:0.0059"
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.1019"
   ],
   "axes": {
     "M": {
@@ -16,19 +16,19 @@
     },
     "N": {
       "type": "const",
-      "value": 1024
+      "value": 2048
     },
     "K": {
       "type": "const",
-      "value": 2560
+      "value": 1024
     },
     "K_blk": {
       "type": "const",
-      "value": 10
+      "value": 4
     },
     "K_bytes": {
       "type": "const",
-      "value": 1440
+      "value": 576
     }
   },
   "inputs": {

definitions/gemm/gemm_q4_K_n2048_k1536.json

@@ -0,0 +1,59 @@
+{
+  "name": "gemm_q4_K_n2048_k1536",
+  "op_type": "gemm",
+  "description": "qwen1.5-moe-a2.7b expert ffn N=2048 K=1536, ggml Q4_K block rows (K rounded up from 1408 to 1536, the next multiple of 256 a k-quant block needs)",
+  "tags": [
+    "status:active",
+    "model:qwen1.5-moe-a2.7b",
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr"
+  ],
+  "axes": {
+    "M": {
+      "type": "var"
+    },
+    "N": {
+      "type": "const",
+      "value": 2048
+    },
+    "K": {
+      "type": "const",
+      "value": 1536
+    },
+    "K_blk": {
+      "type": "const",
+      "value": 6
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 864
+    }
+  },
+  "inputs": {
+    "A": {
+      "shape": [
+        "M",
+        "K"
+      ],
+      "dtype": "bfloat16"
+    },
+    "B": {
+      "shape": [
+        "N",
+        "K_bytes"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "C": {
+      "shape": [
+        "M",
+        "N"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "constraints": [],
+  "reference": "import numpy as np\n\n\ndef unpack_scales_k4(s12):\n    # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8]\n    s12 = s12.astype(np.uint8)\n    sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32)\n    mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32)\n    for j in range(4):\n        sc[..., j] = s12[..., j] & 63\n        mn[..., j] = s12[..., j + 4] & 63\n    for j in range(4, 8):\n        sc[..., j] = (s12[..., j + 4] & 0xF) | ((s12[..., j - 4] >> 6) << 4)\n        mn[..., j] = (s12[..., j + 4] >> 4) | ((s12[..., j] >> 6) << 4)\n    return sc, mn\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q4_K(B):\n    # B: uint8 [N, K/256 * 144] rows of ggml block_q4_K\n    # {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 144\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 144)\n    d = f16(blk[:, :, 0:2])\n    dmin = f16(blk[:, :, 2:4])\n    sc, mn = unpack_scales_k4(blk[:, :, 4:16])\n    qs = blk[:, :, 16:144].reshape(n_rows, nb, 4, 32)\n    q = np.empty((n_rows, nb, 4, 2, 32), dtype=np.float32)\n    q[:, :, :, 0, :] = qs & 0x0F\n    q[:, :, :, 1, :] = qs >> 4\n    ds = np.repeat(d[..., None] * sc, 32, axis=-1)\n    dm = np.repeat(dmin[..., None] * mn, 32, axis=-1)\n    w = ds * q.reshape(n_rows, nb, 256) - dm\n    return w.reshape(n_rows, nb * 256)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // {\"dequant_ggml_q4_K\": 144, \"dequant_ggml_q5_K\": 176, \"dequant_ggml_q6_K\": 210}[\"dequant_ggml_q4_K\"]) * 256\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q4_K(B[i:i + step]).T\n    return out\n"
+}

definitions/gemm/gemm_q4_K_n2048_k2048.json

@@ -0,0 +1,61 @@
+{
+  "name": "gemm_q4_K_n2048_k2048",
+  "op_type": "gemm",
+  "description": "olmoe blk.N.attn_k.weightx16, blk.N.attn_output.weightx16, blk.N.attn_q.weightx16, blk.N.attn_v.weightx8: N=2048 K=2048, ggml Q4_K block rows (e2e, 17.8% of decode bytes)",
+  "tags": [
+    "status:active",
+    "model:olmoe-1b-7b",
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr",
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.1785"
+  ],
+  "axes": {
+    "M": {
+      "type": "var"
+    },
+    "N": {
+      "type": "const",
+      "value": 2048
+    },
+    "K": {
+      "type": "const",
+      "value": 2048
+    },
+    "K_blk": {
+      "type": "const",
+      "value": 8
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 1152
+    }
+  },
+  "inputs": {
+    "A": {
+      "shape": [
+        "M",
+        "K"
+      ],
+      "dtype": "bfloat16"
+    },
+    "B": {
+      "shape": [
+        "N",
+        "K_bytes"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "C": {
+      "shape": [
+        "M",
+        "N"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "constraints": [],
+  "reference": "import numpy as np\n\n\ndef unpack_scales_k4(s12):\n    # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8]\n    s12 = s12.astype(np.uint8)\n    sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32)\n    mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32)\n    for j in range(4):\n        sc[..., j] = s12[..., j] & 63\n        mn[..., j] = s12[..., j + 4] & 63\n    for j in range(4, 8):\n        sc[..., j] = (s12[..., j + 4] & 0xF) | ((s12[..., j - 4] >> 6) << 4)\n        mn[..., j] = (s12[..., j + 4] >> 4) | ((s12[..., j] >> 6) << 4)\n    return sc, mn\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q4_K(B):\n    # B: uint8 [N, K/256 * 144] rows of ggml block_q4_K\n    # {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 144\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 144)\n    d = f16(blk[:, :, 0:2])\n    dmin = f16(blk[:, :, 2:4])\n    sc, mn = unpack_scales_k4(blk[:, :, 4:16])\n    qs = blk[:, :, 16:144].reshape(n_rows, nb, 4, 32)\n    q = np.empty((n_rows, nb, 4, 2, 32), dtype=np.float32)\n    q[:, :, :, 0, :] = qs & 0x0F\n    q[:, :, :, 1, :] = qs >> 4\n    ds = np.repeat(d[..., None] * sc, 32, axis=-1)\n    dm = np.repeat(dmin[..., None] * mn, 32, axis=-1)\n    w = ds * q.reshape(n_rows, nb, 256) - dm\n    return w.reshape(n_rows, nb * 256)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // {\"dequant_ggml_q4_K\": 144, \"dequant_ggml_q5_K\": 176, \"dequant_ggml_q6_K\": 210}[\"dequant_ggml_q4_K\"]) * 256\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q4_K(B[i:i + step]).T\n    return out\n"
+}

definitions/gemm/{gemm_ggml_q4_K_n2560_k9216.json → gemm_q4_K_n2560_k9216.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n2560_k9216",
+  "name": "gemm_q4_K_n2560_k9216",
   "op_type": "gemm",
   "description": "qwen35 blk.N.ffn_down.weight\u00d716: N=2560 K=9216, ggml Q4_K block rows (e2e, 7.8% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n4096_k14336.json → gemm_q4_K_n4096_k14336.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n4096_k14336",
+  "name": "gemm_q4_K_n4096_k14336",
   "op_type": "gemm",
   "description": "llama blk.N.ffn_down.weight\u00d716: N=4096 K=14336, ggml Q4_K block rows (e2e, 11.5% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n4096_k2560.json → gemm_q4_K_n4096_k2560.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n4096_k2560",
+  "name": "gemm_q4_K_n4096_k2560",
   "op_type": "gemm",
   "description": "qwen35 blk.N.attn_gate.weight\u00d724: N=4096 K=2560, ggml Q4_K block rows (e2e, 5.2% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n4096_k4096.json → gemm_q4_K_n4096_k4096.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n4096_k4096",
+  "name": "gemm_q4_K_n4096_k4096",
   "op_type": "gemm",
   "description": "llama blk.N.attn_output.weight\u00d732, blk.N.attn_q.weight\u00d732: N=4096 K=4096, ggml Q4_K block rows (e2e, 13.1% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n8192_k2560.json → gemm_q4_K_n8192_k2560.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n8192_k2560",
+  "name": "gemm_q4_K_n8192_k2560",
   "op_type": "gemm",
   "description": "qwen35 blk.N.attn_q.weight\u00d78: N=8192 K=2560, ggml Q4_K block rows (e2e, 3.5% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q4_K_n9216_k2560.json → gemm_q4_K_n9216_k2560.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q4_K_n9216_k2560",
+  "name": "gemm_q4_K_n9216_k2560",
   "op_type": "gemm",
   "description": "qwen35 blk.N.ffn_gate.weight\u00d732, blk.N.ffn_up.weight\u00d732: N=9216 K=2560, ggml Q4_K block rows (e2e, 31.1% of decode bytes)",
   "tags": [

definitions/gemm/gemm_q4_k_m_n1024_k2048.json

@@ -1,73 +0,0 @@
-{
-  "name": "gemm_q4_k_m_n1024_k2048",
-  "op_type": "gemm",
-  "description": "expert ffn N=1024 K=2048",
-  "tags": [
-    "status:active",
-    "model:olmoe-1b-7b",
-    "baseline-solution:llama.cpp",
-    "correctness:sqnr"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1024
-    },
-    "K": {
-      "type": "const",
-      "value": 2048
-    },
-    "K_half": {
-      "type": "const",
-      "value": 1024
-    },
-    "K_sub": {
-      "type": "const",
-      "value": 64
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "bfloat16"
-    },
-    "B_q4": {
-      "shape": [
-        "N",
-        "K_half"
-      ],
-      "dtype": "uint8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    },
-    "B_mins": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\n\n\ndef dq4k(q4, scales, mins):\n    K = q4.shape[-1] * 2\n    lo = (q4 & 0x0F).astype(np.float32)\n    hi = (q4 >> 4).astype(np.float32)\n    nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32)\n    nib[..., 0::2] = lo\n    nib[..., 1::2] = hi\n    s = np.repeat(scales.astype(np.float32), 32, axis=-1)\n    m = np.repeat(mins.astype(np.float32), 32, axis=-1)\n    return s * nib - m\n\n\ndef run(A, B_q4, B_scales, B_mins):\n    A_f = A.astype(np.float32)\n    B_f = dq4k(B_q4, B_scales, B_mins)\n    return A_f @ B_f.T\n"
-}

definitions/gemm/gemm_q4_k_m_n1408_k2048.json

@@ -1,73 +0,0 @@
-{
-  "name": "gemm_q4_k_m_n1408_k2048",
-  "op_type": "gemm",
-  "description": "expert ffn N=1408 K=2048",
-  "tags": [
-    "status:active",
-    "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp",
-    "correctness:sqnr"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1408
-    },
-    "K": {
-      "type": "const",
-      "value": 2048
-    },
-    "K_half": {
-      "type": "const",
-      "value": 1024
-    },
-    "K_sub": {
-      "type": "const",
-      "value": 64
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "bfloat16"
-    },
-    "B_q4": {
-      "shape": [
-        "N",
-        "K_half"
-      ],
-      "dtype": "uint8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    },
-    "B_mins": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\n\n\ndef dq4k(q4, scales, mins):\n    K = q4.shape[-1] * 2\n    lo = (q4 & 0x0F).astype(np.float32)\n    hi = (q4 >> 4).astype(np.float32)\n    nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32)\n    nib[..., 0::2] = lo\n    nib[..., 1::2] = hi\n    s = np.repeat(scales.astype(np.float32), 32, axis=-1)\n    m = np.repeat(mins.astype(np.float32), 32, axis=-1)\n    return s * nib - m\n\n\ndef run(A, B_q4, B_scales, B_mins):\n    A_f = A.astype(np.float32)\n    B_f = dq4k(B_q4, B_scales, B_mins)\n    return A_f @ B_f.T\n"
-}

definitions/gemm/gemm_q4_k_m_n2048_k1024.json

@@ -1,73 +0,0 @@
-{
-  "name": "gemm_q4_k_m_n2048_k1024",
-  "op_type": "gemm",
-  "description": "expert ffn N=2048 K=1024",
-  "tags": [
-    "status:active",
-    "model:olmoe-1b-7b",
-    "baseline-solution:llama.cpp",
-    "correctness:sqnr"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 2048
-    },
-    "K": {
-      "type": "const",
-      "value": 1024
-    },
-    "K_half": {
-      "type": "const",
-      "value": 512
-    },
-    "K_sub": {
-      "type": "const",
-      "value": 32
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "bfloat16"
-    },
-    "B_q4": {
-      "shape": [
-        "N",
-        "K_half"
-      ],
-      "dtype": "uint8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    },
-    "B_mins": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\n\n\ndef dq4k(q4, scales, mins):\n    K = q4.shape[-1] * 2\n    lo = (q4 & 0x0F).astype(np.float32)\n    hi = (q4 >> 4).astype(np.float32)\n    nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32)\n    nib[..., 0::2] = lo\n    nib[..., 1::2] = hi\n    s = np.repeat(scales.astype(np.float32), 32, axis=-1)\n    m = np.repeat(mins.astype(np.float32), 32, axis=-1)\n    return s * nib - m\n\n\ndef run(A, B_q4, B_scales, B_mins):\n    A_f = A.astype(np.float32)\n    B_f = dq4k(B_q4, B_scales, B_mins)\n    return A_f @ B_f.T\n"
-}

definitions/gemm/gemm_q4_k_m_n2048_k1536.json

@@ -1,73 +0,0 @@
-{
-  "name": "gemm_q4_k_m_n2048_k1536",
-  "op_type": "gemm",
-  "description": "expert ffn N=2048 K=1536 (K rounded up from 1408 to 1536, the next multiple of 256, since Q4_K requires the reduction dim divisible by 256; real GGML would fall back to Q5_0 for the unrounded 1408 shape)",
-  "tags": [
-    "status:active",
-    "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp",
-    "correctness:sqnr"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 2048
-    },
-    "K": {
-      "type": "const",
-      "value": 1536
-    },
-    "K_half": {
-      "type": "const",
-      "value": 768
-    },
-    "K_sub": {
-      "type": "const",
-      "value": 48
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "bfloat16"
-    },
-    "B_q4": {
-      "shape": [
-        "N",
-        "K_half"
-      ],
-      "dtype": "uint8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    },
-    "B_mins": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\n\n\ndef dq4k(q4, scales, mins):\n    K = q4.shape[-1] * 2\n    lo = (q4 & 0x0F).astype(np.float32)\n    hi = (q4 >> 4).astype(np.float32)\n    nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32)\n    nib[..., 0::2] = lo\n    nib[..., 1::2] = hi\n    s = np.repeat(scales.astype(np.float32), 32, axis=-1)\n    m = np.repeat(mins.astype(np.float32), 32, axis=-1)\n    return s * nib - m\n\n\ndef run(A, B_q4, B_scales, B_mins):\n    A_f = A.astype(np.float32)\n    B_f = dq4k(B_q4, B_scales, B_mins)\n    return A_f @ B_f.T\n"
-}

definitions/gemm/gemm_q4_k_m_n2048_k2048.json

@@ -1,73 +0,0 @@
-{
-  "name": "gemm_q4_k_m_n2048_k2048",
-  "op_type": "gemm",
-  "description": "expert ffn N=2048 K=2048",
-  "tags": [
-    "status:active",
-    "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp",
-    "correctness:sqnr"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 2048
-    },
-    "K": {
-      "type": "const",
-      "value": 2048
-    },
-    "K_half": {
-      "type": "const",
-      "value": 1024
-    },
-    "K_sub": {
-      "type": "const",
-      "value": 64
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "bfloat16"
-    },
-    "B_q4": {
-      "shape": [
-        "N",
-        "K_half"
-      ],
-      "dtype": "uint8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    },
-    "B_mins": {
-      "shape": [
-        "N",
-        "K_sub"
-      ],
-      "dtype": "float16"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\n\n\ndef dq4k(q4, scales, mins):\n    K = q4.shape[-1] * 2\n    lo = (q4 & 0x0F).astype(np.float32)\n    hi = (q4 >> 4).astype(np.float32)\n    nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32)\n    nib[..., 0::2] = lo\n    nib[..., 1::2] = hi\n    s = np.repeat(scales.astype(np.float32), 32, axis=-1)\n    m = np.repeat(mins.astype(np.float32), 32, axis=-1)\n    return s * nib - m\n\n\ndef run(A, B_q4, B_scales, B_mins):\n    A_f = A.astype(np.float32)\n    B_f = dq4k(B_q4, B_scales, B_mins)\n    return A_f @ B_f.T\n"
-}

definitions/gemm/{gemm_ggml_q5_K_n2560_k4096.json → gemm_q5_K_n2560_k4096.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q5_K_n2560_k4096",
+  "name": "gemm_q5_K_n2560_k4096",
   "op_type": "gemm",
   "description": "qwen35 blk.N.ssm_out.weight\u00d724: N=2560 K=4096, ggml Q5_K block rows (e2e, 6.3% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q5_K_n8192_k2560.json → gemm_q5_K_n8192_k2560.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q5_K_n8192_k2560",
+  "name": "gemm_q5_K_n8192_k2560",
   "op_type": "gemm",
   "description": "qwen35 blk.N.attn_qkv.weight\u00d724: N=8192 K=2560, ggml Q5_K block rows (e2e, 12.7% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q6_K_n128256_k4096.json → gemm_q6_K_n128256_k4096.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q6_K_n128256_k4096",
+  "name": "gemm_q6_K_n128256_k4096",
   "op_type": "gemm",
   "description": "llama output.weight\u00d71: N=128256 K=4096, ggml Q6_K block rows (e2e, 9.3% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q6_K_n1024_k2560.json → gemm_q6_K_n2048_k1024.json}

@@ -1,14 +1,14 @@
 {
-  "name": "gemm_ggml_q6_K_n1024_k2560",
+  "name": "gemm_q6_K_n2048_k1024",
   "op_type": "gemm",
-  "description": "qwen35 blk.N.attn_v.weight\u00d75: N=1024 K=2560, ggml Q6_K block rows (e2e, 0.4% of decode bytes)",
+  "description": "olmoe blk.N.ffn_down_exps.weightx8 (experts 64): N=2048 K=1024, ggml Q6_K block rows (e2e, 14.9% of decode bytes)",
   "tags": [
     "status:active",
-    "model:qwen3.5-4b",
+    "model:olmoe-1b-7b",
     "baseline-solution:llama.cpp",
     "correctness:sqnr",
-    "e2e:qwen3.5-4b",
-    "e2e-share:0.0039"
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.1487"
   ],
   "axes": {
     "M": {
@@ -16,19 +16,19 @@
     },
     "N": {
       "type": "const",
-      "value": 1024
+      "value": 2048
     },
     "K": {
       "type": "const",
-      "value": 2560
+      "value": 1024
     },
     "K_blk": {
       "type": "const",
-      "value": 10
+      "value": 4
     },
     "K_bytes": {
       "type": "const",
-      "value": 2100
+      "value": 840
     }
   },
   "inputs": {

definitions/gemm/{gemm_ggml_q6_K_n1024_k4096.json → gemm_q6_K_n2048_k2048.json}

@@ -1,14 +1,14 @@
 {
-  "name": "gemm_ggml_q6_K_n1024_k4096",
+  "name": "gemm_q6_K_n2048_k2048",
   "op_type": "gemm",
-  "description": "llama blk.N.attn_v.weight\u00d716: N=1024 K=4096, ggml Q6_K block rows (e2e, 1.2% of decode bytes)",
+  "description": "olmoe blk.N.attn_v.weightx8: N=2048 K=2048, ggml Q6_K block rows (e2e, 3.7% of decode bytes)",
   "tags": [
     "status:active",
-    "model:llama-3.1-8b",
+    "model:olmoe-1b-7b",
     "baseline-solution:llama.cpp",
     "correctness:sqnr",
-    "e2e:llama-3.1-8b",
-    "e2e-share:0.0119"
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.0372"
   ],
   "axes": {
     "M": {
@@ -16,19 +16,19 @@
     },
     "N": {
       "type": "const",
-      "value": 1024
+      "value": 2048
     },
     "K": {
       "type": "const",
-      "value": 4096
+      "value": 2048
     },
     "K_blk": {
       "type": "const",
-      "value": 16
+      "value": 8
     },
     "K_bytes": {
       "type": "const",
-      "value": 3360
+      "value": 1680
     }
   },
   "inputs": {

definitions/gemm/{gemm_ggml_q6_K_n248320_k2560.json → gemm_q6_K_n248320_k2560.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q6_K_n248320_k2560",
+  "name": "gemm_q6_K_n248320_k2560",
   "op_type": "gemm",
   "description": "qwen35 token_embd.weight\u00d71: N=248320 K=2560, ggml Q6_K block rows (e2e, 19.1% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q6_K_n2560_k9216.json → gemm_q6_K_n2560_k9216.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q6_K_n2560_k9216",
+  "name": "gemm_q6_K_n2560_k9216",
   "op_type": "gemm",
   "description": "qwen35 blk.N.ffn_down.weight\u00d716: N=2560 K=9216, ggml Q6_K block rows (e2e, 11.3% of decode bytes)",
   "tags": [

definitions/gemm/{gemm_ggml_q6_K_n4096_k14336.json → gemm_q6_K_n4096_k14336.json}

@@ -1,5 +1,5 @@
 {
-  "name": "gemm_ggml_q6_K_n4096_k14336",
+  "name": "gemm_q6_K_n4096_k14336",
   "op_type": "gemm",
   "description": "llama blk.N.ffn_down.weight\u00d716: N=4096 K=14336, ggml Q6_K block rows (e2e, 16.7% of decode bytes)",
   "tags": [

definitions/gemm/gemm_q6_K_n50304_k2048.json

@@ -0,0 +1,61 @@
+{
+  "name": "gemm_q6_K_n50304_k2048",
+  "op_type": "gemm",
+  "description": "olmoe output.weightx1: N=50304 K=2048, ggml Q6_K block rows (e2e, 11.4% of decode bytes)",
+  "tags": [
+    "status:active",
+    "model:olmoe-1b-7b",
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr",
+    "e2e:olmoe-1b-7b-q4_k_m",
+    "e2e-share:0.1141"
+  ],
+  "axes": {
+    "M": {
+      "type": "var"
+    },
+    "N": {
+      "type": "const",
+      "value": 50304
+    },
+    "K": {
+      "type": "const",
+      "value": 2048
+    },
+    "K_blk": {
+      "type": "const",
+      "value": 8
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 1680
+    }
+  },
+  "inputs": {
+    "A": {
+      "shape": [
+        "M",
+        "K"
+      ],
+      "dtype": "bfloat16"
+    },
+    "B": {
+      "shape": [
+        "N",
+        "K_bytes"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "C": {
+      "shape": [
+        "M",
+        "N"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "constraints": [],
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q6_K(B):\n    # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K\n    # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 210\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 210)\n    ql = blk[:, :, 0:128].reshape(n_rows, nb, 2, 64)\n    qh = blk[:, :, 128:192].reshape(n_rows, nb, 2, 32)\n    sc = np.ascontiguousarray(blk[:, :, 192:208]).view(np.int8).astype(np.float32)\n    d = f16(blk[:, :, 208:210])\n    q = np.empty((n_rows, nb, 2, 4, 32), dtype=np.float32)\n    lo = ql[:, :, :, 0:32]\n    hi = ql[:, :, :, 32:64]\n    q[:, :, :, 0, :] = (lo & 0x0F) | (((qh >> 0) & 3) << 4)\n    q[:, :, :, 1, :] = (hi & 0x0F) | (((qh >> 2) & 3) << 4)\n    q[:, :, :, 2, :] = (lo >> 4) | (((qh >> 4) & 3) << 4)\n    q[:, :, :, 3, :] = (hi >> 4) | (((qh >> 6) & 3) << 4)\n    ds = np.repeat(d[..., None] * sc, 16, axis=-1)\n    w = ds * (q.reshape(n_rows, nb, 256) - 32.0)\n    return w.reshape(n_rows, nb * 256)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // {\"dequant_ggml_q4_K\": 144, \"dequant_ggml_q5_K\": 176, \"dequant_ggml_q6_K\": 210}[\"dequant_ggml_q6_K\"]) * 256\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q6_K(B[i:i + step]).T\n    return out\n"
+}

definitions/gemm/gemm_q8_0_n1024_k2048.json

@@ -1,11 +1,14 @@
 {
   "name": "gemm_q8_0_n1024_k2048",
   "op_type": "gemm",
-  "description": "expert ffn N=1024 K=2048",
+  "description": "olmoe blk.N.ffn_gate_exps.weightx16 (experts 64), blk.N.ffn_up_exps.weightx16 (experts 64): N=1024 K=2048, ggml Q8_0 block rows (e2e, 45.3% of decode bytes)",
   "tags": [
     "status:active",
     "model:olmoe-1b-7b",
-    "baseline-solution:llama.cpp"
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr",
+    "e2e:olmoe-1b-7b-q8_0",
+    "e2e-share:0.4530"
   ],
   "axes": {
     "M": {
@@ -22,6 +25,10 @@
     "K_blk": {
       "type": "const",
       "value": 64
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 2176
     }
   },
   "inputs": {
@@ -30,28 +37,14 @@
         "M",
         "K"
       ],
-      "dtype": "int8"
-    },
-    "A_scales": {
-      "shape": [
-        "M",
-        "K_blk"
-      ],
-      "dtype": "float16"
+      "dtype": "bfloat16"
     },
     "B": {
       "shape": [
         "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_blk"
+        "K_bytes"
       ],
-      "dtype": "float16"
+      "dtype": "uint8"
     }
   },
   "outputs": {
@@ -64,5 +57,5 @@
     }
   },
   "constraints": [],
-  "reference": "import numpy as np\ndef run(A, A_scales, B, B_scales):\n    M = A.shape[0]; blk = 32\n    A_f = (A.reshape(M, -1, blk).astype(np.float32)\n           * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048)\n    B_f = (B.reshape(1024, -1, blk).astype(np.float32)\n           * B_scales.astype(np.float32)[:, :, np.newaxis]).reshape(1024, 2048)\n    return A_f @ B_f.T\n"
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q8_0(B):\n    # B: uint8 [N, K/32 * 34] rows of ggml block_q8_0 {fp16 d; int8 qs[32]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 34\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 34)\n    d = f16(blk[:, :, 0:2])\n    qs = np.ascontiguousarray(blk[:, :, 2:34]).view(np.int8).astype(np.float32)\n    w = qs * d[..., None]\n    return w.reshape(n_rows, nb * 32)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // 34) * 32\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q8_0(B[i:i + step]).T\n    return out\n"
 }

definitions/gemm/gemm_q8_0_n1408_k2048.json

@@ -1,11 +1,12 @@
 {
   "name": "gemm_q8_0_n1408_k2048",
   "op_type": "gemm",
-  "description": "expert ffn N=1408 K=2048",
+  "description": "qwen1.5-moe-a2.7b expert ffn N=1408 K=2048, ggml Q8_0 block rows",
   "tags": [
     "status:active",
     "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp"
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr"
   ],
   "axes": {
     "M": {
@@ -22,6 +23,10 @@
     "K_blk": {
       "type": "const",
       "value": 64
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 2176
     }
   },
   "inputs": {
@@ -30,28 +35,14 @@
         "M",
         "K"
       ],
-      "dtype": "int8"
-    },
-    "A_scales": {
-      "shape": [
-        "M",
-        "K_blk"
-      ],
-      "dtype": "float16"
+      "dtype": "bfloat16"
     },
     "B": {
       "shape": [
         "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_blk"
+        "K_bytes"
       ],
-      "dtype": "float16"
+      "dtype": "uint8"
     }
   },
   "outputs": {
@@ -64,5 +55,5 @@
     }
   },
   "constraints": [],
-  "reference": "import numpy as np\ndef run(A, A_scales, B, B_scales):\n    M = A.shape[0]; blk = 32\n    A_f = (A.reshape(M, -1, blk).astype(np.float32)\n           * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048)\n    B_f = (B.reshape(1408, -1, blk).astype(np.float32)\n           * B_scales.astype(np.float32)[:, :, np.newaxis]).reshape(1408, 2048)\n    return A_f @ B_f.T\n"
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q8_0(B):\n    # B: uint8 [N, K/32 * 34] rows of ggml block_q8_0 {fp16 d; int8 qs[32]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 34\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 34)\n    d = f16(blk[:, :, 0:2])\n    qs = np.ascontiguousarray(blk[:, :, 2:34]).view(np.int8).astype(np.float32)\n    w = qs * d[..., None]\n    return w.reshape(n_rows, nb * 32)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // 34) * 32\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q8_0(B[i:i + step]).T\n    return out\n"
 }

definitions/gemm/gemm_q8_0_n2048_k1024.json

@@ -1,11 +1,14 @@
 {
   "name": "gemm_q8_0_n2048_k1024",
   "op_type": "gemm",
-  "description": "expert ffn N=2048 K=1024",
+  "description": "olmoe blk.N.ffn_down_exps.weightx16 (experts 64): N=2048 K=1024, ggml Q8_0 block rows (e2e, 22.7% of decode bytes)",
   "tags": [
     "status:active",
     "model:olmoe-1b-7b",
-    "baseline-solution:llama.cpp"
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr",
+    "e2e:olmoe-1b-7b-q8_0",
+    "e2e-share:0.2265"
   ],
   "axes": {
     "M": {
@@ -22,6 +25,10 @@
     "K_blk": {
       "type": "const",
       "value": 32
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 1088
     }
   },
   "inputs": {
@@ -30,28 +37,14 @@
         "M",
         "K"
       ],
-      "dtype": "int8"
-    },
-    "A_scales": {
-      "shape": [
-        "M",
-        "K_blk"
-      ],
-      "dtype": "float16"
+      "dtype": "bfloat16"
     },
     "B": {
       "shape": [
         "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_blk"
+        "K_bytes"
       ],
-      "dtype": "float16"
+      "dtype": "uint8"
     }
   },
   "outputs": {
@@ -64,5 +57,5 @@
     }
   },
   "constraints": [],
-  "reference": "import numpy as np\ndef run(A, A_scales, B, B_scales):\n    M = A.shape[0]; blk = 32\n    A_f = (A.reshape(M, -1, blk).astype(np.float32)\n           * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 1024)\n    B_f = (B.reshape(2048, -1, blk).astype(np.float32)\n           * B_scales.astype(np.float32)[:, :, np.newaxis]).reshape(2048, 1024)\n    return A_f @ B_f.T\n"
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q8_0(B):\n    # B: uint8 [N, K/32 * 34] rows of ggml block_q8_0 {fp16 d; int8 qs[32]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 34\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 34)\n    d = f16(blk[:, :, 0:2])\n    qs = np.ascontiguousarray(blk[:, :, 2:34]).view(np.int8).astype(np.float32)\n    w = qs * d[..., None]\n    return w.reshape(n_rows, nb * 32)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // 34) * 32\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q8_0(B[i:i + step]).T\n    return out\n"
 }

definitions/gemm/gemm_q8_0_n2048_k1408.json

@@ -1,11 +1,12 @@
 {
   "name": "gemm_q8_0_n2048_k1408",
   "op_type": "gemm",
-  "description": "expert ffn N=2048 K=1408",
+  "description": "qwen1.5-moe-a2.7b expert ffn N=2048 K=1408, ggml Q8_0 block rows",
   "tags": [
     "status:active",
     "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp"
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr"
   ],
   "axes": {
     "M": {
@@ -22,6 +23,10 @@
     "K_blk": {
       "type": "const",
       "value": 44
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 1496
     }
   },
   "inputs": {
@@ -30,28 +35,14 @@
         "M",
         "K"
       ],
-      "dtype": "int8"
-    },
-    "A_scales": {
-      "shape": [
-        "M",
-        "K_blk"
-      ],
-      "dtype": "float16"
+      "dtype": "bfloat16"
     },
     "B": {
       "shape": [
         "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_blk"
+        "K_bytes"
       ],
-      "dtype": "float16"
+      "dtype": "uint8"
     }
   },
   "outputs": {
@@ -64,5 +55,5 @@
     }
   },
   "constraints": [],
-  "reference": "import numpy as np\ndef run(A, A_scales, B, B_scales):\n    M = A.shape[0]; blk = 32\n    A_f = (A.reshape(M, -1, blk).astype(np.float32)\n           * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 1408)\n    B_f = (B.reshape(2048, -1, blk).astype(np.float32)\n           * B_scales.astype(np.float32)[:, :, np.newaxis]).reshape(2048, 1408)\n    return A_f @ B_f.T\n"
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q8_0(B):\n    # B: uint8 [N, K/32 * 34] rows of ggml block_q8_0 {fp16 d; int8 qs[32]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 34\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 34)\n    d = f16(blk[:, :, 0:2])\n    qs = np.ascontiguousarray(blk[:, :, 2:34]).view(np.int8).astype(np.float32)\n    w = qs * d[..., None]\n    return w.reshape(n_rows, nb * 32)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // 34) * 32\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q8_0(B[i:i + step]).T\n    return out\n"
 }

definitions/gemm/gemm_q8_0_n2048_k2048.json

@@ -1,11 +1,14 @@
 {
   "name": "gemm_q8_0_n2048_k2048",
   "op_type": "gemm",
-  "description": "attn proj N=2048 K=2048",
+  "description": "olmoe blk.N.attn_k.weightx16, blk.N.attn_output.weightx16, blk.N.attn_q.weightx16, blk.N.attn_v.weightx16: N=2048 K=2048, ggml Q8_0 block rows (e2e, 22.6% of decode bytes)",
   "tags": [
     "status:active",
-    "model:qwen1.5-moe-a2.7b",
-    "baseline-solution:llama.cpp"
+    "model:olmoe-1b-7b",
+    "baseline-solution:llama.cpp",
+    "correctness:sqnr",
+    "e2e:olmoe-1b-7b-q8_0",
+    "e2e-share:0.2264"
   ],
   "axes": {
     "M": {
@@ -22,6 +25,10 @@
     "K_blk": {
       "type": "const",
       "value": 64
+    },
+    "K_bytes": {
+      "type": "const",
+      "value": 2176
     }
   },
   "inputs": {
@@ -30,28 +37,14 @@
         "M",
         "K"
       ],
-      "dtype": "int8"
-    },
-    "A_scales": {
-      "shape": [
-        "M",
-        "K_blk"
-      ],
-      "dtype": "float16"
+      "dtype": "bfloat16"
     },
     "B": {
       "shape": [
         "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B_scales": {
-      "shape": [
-        "N",
-        "K_blk"
+        "K_bytes"
       ],
-      "dtype": "float16"
+      "dtype": "uint8"
     }
   },
   "outputs": {
@@ -64,5 +57,5 @@
     }
   },
   "constraints": [],
-  "reference": "import numpy as np\ndef run(A, A_scales, B, B_scales):\n    M = A.shape[0]; blk = 32\n    A_f = (A.reshape(M, -1, blk).astype(np.float32)\n           * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048)\n    B_f = (B.reshape(2048, -1, blk).astype(np.float32)\n           * B_scales.astype(np.float32)[:, :, np.newaxis]).reshape(2048, 2048)\n    return A_f @ B_f.T\n"
+  "reference": "import numpy as np\n\n\ndef f16(b):\n    # little-endian fp16 bytes [..., 2] -> float32 [...]\n    return np.ascontiguousarray(b).view(\"<f2\")[..., 0].astype(np.float32)\n\n\ndef dequant_ggml_q8_0(B):\n    # B: uint8 [N, K/32 * 34] rows of ggml block_q8_0 {fp16 d; int8 qs[32]}\n    n_rows, k_bytes = B.shape\n    nb = k_bytes // 34\n    blk = np.ascontiguousarray(B).reshape(n_rows, nb, 34)\n    d = f16(blk[:, :, 0:2])\n    qs = np.ascontiguousarray(blk[:, :, 2:34]).view(np.int8).astype(np.float32)\n    w = qs * d[..., None]\n    return w.reshape(n_rows, nb * 32)\n\n\ndef run(A, B):\n    # Chunk over weight rows: dequantizing all of B at once needs ~4x N*K*4\n    # bytes of temporaries (10+ GB for a 248320 x 2560 lm_head), which does\n    # not fit an 8 GB box. ~128 MB of fp32 weights per chunk keeps the peak\n    # under ~1 GB regardless of N.\n    A_f = A.astype(np.float32)\n    n_rows, k_bytes = B.shape\n    K = (k_bytes // 34) * 32\n    step = max(256, ((128 << 20) // (K * 4)) // 256 * 256)\n    out = np.empty((A_f.shape[0], n_rows), dtype=np.float32)\n    for i in range(0, n_rows, step):\n        out[:, i:i + step] = A_f @ dequant_ggml_q8_0(B[i:i + step]).T\n    return out\n"
 }

expected_sets_sve.json

@@ -30,11 +30,11 @@
   "gemm_bf16_n2048_k1024",
   "gemm_bf16_n2048_k1408",
   "gemm_bf16_n2048_k2048",
-  "gemm_q4_k_m_n1024_k2048",
-  "gemm_q4_k_m_n1408_k2048",
-  "gemm_q4_k_m_n2048_k1024",
-  "gemm_q4_k_m_n2048_k1536",
-  "gemm_q4_k_m_n2048_k2048",
+  "gemm_q4_K_n1024_k2048",
+  "gemm_q4_K_n1408_k2048",
+  "gemm_q4_K_n2048_k1024",
+  "gemm_q4_K_n2048_k1536",
+  "gemm_q4_K_n2048_k2048",
   "gemm_q8_0_n1024_k2048",
   "gemm_q8_0_n1408_k2048",
   "gemm_q8_0_n2048_k1024",

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n1024_k2560.json → gemm_q4_K_n1024_k2048.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n1024_k2560",
-  "definition": "gemm_ggml_q4_K_n1024_k2560",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n1024_k2048",
+  "definition": "gemm_q4_K_n1024_k2048",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n1024_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n1024_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [
@@ -29,7 +29,7 @@
     },
     {
       "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1024;\nconstexpr int64_t kK = 2560;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
+      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1024;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
     },
     {
       "path": "kernel.cpp",

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n1024_k4096.json → gemm_q4_K_n1408_k2048.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n1024_k4096",
-  "definition": "gemm_ggml_q4_K_n1024_k4096",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n1408_k2048",
+  "definition": "gemm_q4_K_n1408_k2048",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n1024_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n1408_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [
@@ -29,7 +29,7 @@
     },
     {
       "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1024;\nconstexpr int64_t kK = 4096;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
+      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1408;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
     },
     {
       "path": "kernel.cpp",

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n14336_k4096.json → gemm_q4_K_n14336_k4096.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n14336_k4096",
-  "definition": "gemm_ggml_q4_K_n14336_k4096",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n14336_k4096",
+  "definition": "gemm_q4_K_n14336_k4096",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n14336_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n14336_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n2560_k4096.json → gemm_q4_K_n2048_k1024.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n2560_k4096",
-  "definition": "gemm_ggml_q4_K_n2560_k4096",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n2048_k1024",
+  "definition": "gemm_q4_K_n2048_k1024",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n2560_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n2048_k1024. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [
@@ -29,7 +29,7 @@
     },
     {
       "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2560;\nconstexpr int64_t kK = 4096;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
+      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 1024;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
     },
     {
       "path": "kernel.cpp",

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_K_n2048_k1536.json

@@ -0,0 +1,39 @@
+{
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n2048_k1536",
+  "definition": "gemm_q4_K_n2048_k1536",
+  "dataset": "llama.cpp",
+  "author": "baseline-llamacpp-arm",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n2048_k1536. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "spec": {
+    "language": "cpp",
+    "target_hardware": [
+      "graviton3",
+      "aarch64-sve",
+      "graviton4",
+      "aarch64-sve2",
+      "apple-m"
+    ],
+    "dependencies": [],
+    "isa_features": [],
+    "compile_flags": [
+      "-O3",
+      "-std=c++17"
+    ],
+    "link_flags": [],
+    "entry_point": "binding.cpp::armbench_entry_gemm"
+  },
+  "sources": [
+    {
+      "path": "gemm.h",
+      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (passed through\n// as-is by the Python adapter: the Definition's B tensor is the block rows).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
+    },
+    {
+      "path": "binding.cpp",
+      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 1536;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
+    },
+    {
+      "path": "kernel.cpp",
+      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
+    }
+  ]
+}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_K_n2048_k2048.json

@@ -0,0 +1,39 @@
+{
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n2048_k2048",
+  "definition": "gemm_q4_K_n2048_k2048",
+  "dataset": "llama.cpp",
+  "author": "baseline-llamacpp-arm",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n2048_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "spec": {
+    "language": "cpp",
+    "target_hardware": [
+      "graviton3",
+      "aarch64-sve",
+      "graviton4",
+      "aarch64-sve2",
+      "apple-m"
+    ],
+    "dependencies": [],
+    "isa_features": [],
+    "compile_flags": [
+      "-O3",
+      "-std=c++17"
+    ],
+    "link_flags": [],
+    "entry_point": "binding.cpp::armbench_entry_gemm"
+  },
+  "sources": [
+    {
+      "path": "gemm.h",
+      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (passed through\n// as-is by the Python adapter: the Definition's B tensor is the block rows).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
+    },
+    {
+      "path": "binding.cpp",
+      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks] (the Definition's uint8 B rows, passed\n// through as-is: no repack, no NULL slots);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
+    },
+    {
+      "path": "kernel.cpp",
+      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
+    }
+  ]
+}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n2560_k9216.json → gemm_q4_K_n2560_k9216.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n2560_k9216",
-  "definition": "gemm_ggml_q4_K_n2560_k9216",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n2560_k9216",
+  "definition": "gemm_q4_K_n2560_k9216",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n2560_k9216. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n2560_k9216. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n4096_k14336.json → gemm_q4_K_n4096_k14336.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n4096_k14336",
-  "definition": "gemm_ggml_q4_K_n4096_k14336",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n4096_k14336",
+  "definition": "gemm_q4_K_n4096_k14336",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n4096_k14336. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n4096_k14336. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n4096_k2560.json → gemm_q4_K_n4096_k2560.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n4096_k2560",
-  "definition": "gemm_ggml_q4_K_n4096_k2560",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n4096_k2560",
+  "definition": "gemm_q4_K_n4096_k2560",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n4096_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n4096_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n4096_k4096.json → gemm_q4_K_n4096_k4096.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n4096_k4096",
-  "definition": "gemm_ggml_q4_K_n4096_k4096",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n4096_k4096",
+  "definition": "gemm_q4_K_n4096_k4096",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n4096_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n4096_k4096. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n8192_k2560.json → gemm_q4_K_n8192_k2560.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n8192_k2560",
-  "definition": "gemm_ggml_q4_K_n8192_k2560",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n8192_k2560",
+  "definition": "gemm_q4_K_n8192_k2560",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n8192_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n8192_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/{gemm_ggml_q4_K_n9216_k2560.json → gemm_q4_K_n9216_k2560.json}

@@ -1,9 +1,9 @@
 {
-  "name": "baseline-llamacpp-arm_gemm_ggml_q4_K_n9216_k2560",
-  "definition": "gemm_ggml_q4_K_n9216_k2560",
+  "name": "baseline-llamacpp-arm_gemm_q4_K_n9216_k2560",
+  "definition": "gemm_q4_K_n9216_k2560",
   "dataset": "llama.cpp",
   "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_ggml_q4_K_n9216_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
+  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_K_n9216_k2560. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
   "spec": {
     "language": "cpp",
     "target_hardware": [

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_k_m_n1024_k2048.json

@@ -1,39 +0,0 @@
-{
-  "name": "baseline-llamacpp-arm_gemm_q4_k_m_n1024_k2048",
-  "definition": "gemm_q4_k_m_n1024_k2048",
-  "dataset": "llama.cpp",
-  "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_k_m_n1024_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2",
-      "apple-m"
-    ],
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [],
-    "entry_point": "binding.cpp::armbench_entry_gemm"
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (repacked by the\n// Python adapter from the flat nibble/scale/min Definition tensors).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1024;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks],\n// [2]=NULL (B_scales, consumed by adapter repack), [3]=NULL (B_mins);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
-    }
-  ]
-}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_k_m_n1408_k2048.json

@@ -1,39 +0,0 @@
-{
-  "name": "baseline-llamacpp-arm_gemm_q4_k_m_n1408_k2048",
-  "definition": "gemm_q4_k_m_n1408_k2048",
-  "dataset": "llama.cpp",
-  "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_k_m_n1408_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2",
-      "apple-m"
-    ],
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [],
-    "entry_point": "binding.cpp::armbench_entry_gemm"
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (repacked by the\n// Python adapter from the flat nibble/scale/min Definition tensors).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 1408;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks],\n// [2]=NULL (B_scales, consumed by adapter repack), [3]=NULL (B_mins);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
-    }
-  ]
-}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_k_m_n2048_k1024.json

@@ -1,39 +0,0 @@
-{
-  "name": "baseline-llamacpp-arm_gemm_q4_k_m_n2048_k1024",
-  "definition": "gemm_q4_k_m_n2048_k1024",
-  "dataset": "llama.cpp",
-  "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_k_m_n2048_k1024. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2",
-      "apple-m"
-    ],
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [],
-    "entry_point": "binding.cpp::armbench_entry_gemm"
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (repacked by the\n// Python adapter from the flat nibble/scale/min Definition tensors).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 1024;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks],\n// [2]=NULL (B_scales, consumed by adapter repack), [3]=NULL (B_mins);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
-    }
-  ]
-}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_k_m_n2048_k1536.json

@@ -1,39 +0,0 @@
-{
-  "name": "baseline-llamacpp-arm_gemm_q4_k_m_n2048_k1536",
-  "definition": "gemm_q4_k_m_n2048_k1536",
-  "dataset": "llama.cpp",
-  "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_k_m_n2048_k1536. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2",
-      "apple-m"
-    ],
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [],
-    "entry_point": "binding.cpp::armbench_entry_gemm"
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (repacked by the\n// Python adapter from the flat nibble/scale/min Definition tensors).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 1536;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks],\n// [2]=NULL (B_scales, consumed by adapter repack), [3]=NULL (B_mins);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
-    }
-  ]
-}

solutions/llama.cpp/baseline-llamacpp-arm/gemm/gemm_q4_k_m_n2048_k2048.json

@@ -1,39 +0,0 @@
-{
-  "name": "baseline-llamacpp-arm_gemm_q4_k_m_n2048_k2048",
-  "definition": "gemm_q4_k_m_n2048_k2048",
-  "dataset": "llama.cpp",
-  "author": "baseline-llamacpp-arm",
-  "description": "llama.cpp (ggml) Q4_K baseline for gemm_q4_k_m_n2048_k2048. binding.cpp bakes the const axes as constexpr and implements armbench_entry_gemm over the void* ABI; kernel.cpp builds + runs the ggml graph against libggml*.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2",
-      "apple-m"
-    ],
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [],
-    "entry_point": "binding.cpp::armbench_entry_gemm"
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Harness contract for the llama.cpp (ggml) gemm baseline.\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is row-major [M, K], B is row-major [N, K], C = A . B^T row-major [M, N].\n// A is bf16 (raw uint16 bit pattern, one value per K element -- NOT\n// block-quantized; weight-only Q4_K design keeps activations at the bf16\n// baseline tier). B is a ggml block_q4_K row: (K/256) 144-byte blocks per\n// row, {fp16 d; fp16 dmin; uint8 scales[12]; uint8 qs[128]} (repacked by the\n// Python adapter from the flat nibble/scale/min Definition tensors).\nint armbench_llamacpp_gemm(const void* A, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K);\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm.h\"\n\nnamespace {\nconstexpr int64_t kN = 2048;\nconstexpr int64_t kK = 2048;\n} // namespace\n\nextern \"C\" {\n// inputs: [0]=A bf16 [M,K], [1]=B block_q4_K [N, K/256 blocks],\n// [2]=NULL (B_scales, consumed by adapter repack), [3]=NULL (B_mins);\n// var_axes: [0]=M\nint armbench_entry_gemm(const void* const* inputs, void* output,\n                        const int64_t* var_axes)\n{\n    return armbench_llamacpp_gemm(inputs[0], inputs[1],\n                                  reinterpret_cast<float*>(output),\n                                  var_axes[0], kN, kK);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n\n#include \"ggml.h\"\n#include \"ggml-cpu.h\"\n\n#include <cstring>\n#include <cstdint>\n#include <vector>\n\nnamespace {\n// bf16 shares fp32's exponent field, so widening is an exact bit-shift.\ninline float bf16_to_f32(uint16_t bits) {\n    uint32_t b = (uint32_t)bits << 16;\n    float f;\n    std::memcpy(&f, &b, sizeof(f));\n    return f;\n}\n} // namespace\n\n// C = A . B^T via ggml_mul_mat(B, A). B is a real Q4_K weight tensor; A\n// arrives as bf16 and is widened to F32 up front (plain scalar loop, outside\n// ggml) because ggml_compute_forward_mul_mat asserts src1->type == F32\n// whenever src0 is a k-quant type (Q4_K's paired vec_dot_type is Q8_K, not\n// bf16 or Q4_K itself). ggml's own library code then dynamically quantizes\n// this F32 activation to Q8_K internally -- nothing else to write here.\n//\n// The graph topology (and the widened-A buffer) depends only on M -- and,\n// like llama.cpp's own graph-reuse (llama_context::process_ubatch /\n// llm_graph_result::can_reuse), once built it is safe to re-run via\n// ggml_graph_compute_with_ctx as long as nothing about the topology changed.\n// bench calls this ABI 56 times per workload (1 correctness + 5 warmup + 50\n// timed) with the same M/pointers, so we cache the widen step and the built\n// graph across calls, only redoing either when the shape or input pointers\n// change (a defensive check -- bench's own ctx is stable per workload, but\n// this keeps the cache correct even if that ever changes).\nnamespace {\nggml_context* g_ctx_in = nullptr;\nggml_context* g_ctx = nullptr;\nggml_cgraph* g_gf = nullptr;\nggml_tensor* g_c = nullptr;\nint64_t g_cached_M = -1;\nconst void *g_cached_A = nullptr, *g_cached_B = nullptr;\nstd::vector<float> g_A_f32;\nstd::vector<uint8_t> g_work;\n} // namespace\n\nint armbench_llamacpp_gemm(const void* A_bf16, const void* B, float* C,\n                           int64_t M, int64_t N, int64_t K)\n{\n    if (M != g_cached_M || A_bf16 != g_cached_A || B != g_cached_B) {\n        if (g_ctx) { ggml_free(g_ctx); g_ctx = nullptr; }\n        if (g_ctx_in) { ggml_free(g_ctx_in); g_ctx_in = nullptr; }\n\n        g_A_f32.resize((size_t)M * K);\n        const uint16_t* a_bits = reinterpret_cast<const uint16_t*>(A_bf16);\n        for (size_t i = 0; i < g_A_f32.size(); ++i) g_A_f32[i] = bf16_to_f32(a_bits[i]);\n\n        ggml_init_params ip_in = { 4 * ggml_tensor_overhead(), nullptr, /*no_alloc=*/true };\n        g_ctx_in = ggml_init(ip_in);\n        if (!g_ctx_in) return -1;\n        ggml_tensor* a = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_F32, K, M);\n        a->data = g_A_f32.data();\n        ggml_tensor* b = ggml_new_tensor_2d(g_ctx_in, GGML_TYPE_Q4_K, K, N);\n        b->data = const_cast<void*>(B);\n\n        const size_t mem =\n            (size_t)N * M * sizeof(float)   // C\n            + (size_t)M * K * sizeof(float) * 2  // cplan: A -> Q8_K scratch (generous)\n            + 16 * ggml_tensor_overhead()\n            + ggml_graph_overhead()\n            + (1u << 20);                   // slack\n        ggml_init_params ip = { mem, nullptr, /*no_alloc=*/false };\n        g_ctx = ggml_init(ip);\n        if (!g_ctx) { ggml_free(g_ctx_in); g_ctx_in = nullptr; return -1; }\n\n        g_c = ggml_mul_mat(g_ctx, b, a);   // [N, M] -> row-major [M, N]\n\n        g_gf = ggml_new_graph(g_ctx);\n        ggml_build_forward_expand(g_gf, g_c);\n\n        g_cached_M = M; g_cached_A = A_bf16; g_cached_B = B;\n    }\n\n    ggml_cplan g_plan = ggml_graph_plan(g_gf, /*n_threads=*/1, nullptr);\n    if (g_work.size() < g_plan.work_size) g_work.resize(g_plan.work_size);\n    g_plan.work_data = g_work.data();\n    const ggml_status st = ggml_graph_compute(g_gf, &g_plan);\n\n    int ret = -1;\n    if (st == GGML_STATUS_SUCCESS) {\n        std::memcpy(C, g_c->data, (size_t)N * M * sizeof(float));\n        ret = 0;\n    }\n    return ret;\n}\n"
-    }
-  ]
-}