diff --git a/README.md b/README.md index 61bc5d2bcb9cf01370f43ff53b9cb44733840048..8b9fa9173e544b795feb212d43c334b1f6d6f646 100644 --- a/README.md +++ b/README.md @@ -35,12 +35,12 @@ kernel is checked against the reference and timed against the baseline. | ncnn | 23 | conv2d, conv2d_depthwise, pooling | `baseline-ncnn-arm` | | llama.cpp | 26 | gemm, moe, mha, gqa, mla_decode, mla_prefill, rms_norm | `baseline-llamacpp-arm` | | SIMD Loops | 47 | one loop per definition | `baseline-sve`, `baseline-sve2`, `baseline-sme2` | -| KleidiAI | 10 | gemm, conv2d, conv2d_depthwise | `baseline-kleidiai-arm` | +| KleidiAI | 28 | gemm, conv2d, conv2d_depthwise | `baseline-kleidiai-arm` | | e2e | 18 | gemm on q4_K / q5_K / q6_K weights of Llama-3.1-8B and Qwen3.5-4B | `baseline-llamacpp-arm` | -| **Total** | **124** | | | +| **Total** | **142** | | | -- `expected_sets_sve.json`: the 85 evaluated definitions (23 ncnn, 26 - llama.cpp, 26 SIMD Loops, 10 KleidiAI). +- `expected_sets_sve.json`: the 103 evaluated definitions (23 ncnn, 26 + llama.cpp, 26 SIMD Loops, 28 KleidiAI). - `subset_sve.json` / `subset_sme.json`: a 32-definition subset for the SVE and SME2 tiers; they differ only in the KleidiAI GEMM. diff --git a/TASKS.md b/TASKS.md index 4965cd2027674af6456ef46361d89538a08487fa..ff9ade3bd97408698365ad4e39b05b6413fc42a2 100644 --- a/TASKS.md +++ b/TASKS.md @@ -1,6 +1,6 @@ # Tasks and baselines -Every definition in this dataset, with the expert baseline it is scored against on each hardware tier: whether it runs there, and whether it is specialized for that tier. Generated 2026-10-02 from the dataset, the recorded runs and a check of each baseline's code; the SME2 column was updated on 2026-10-20 from a check of every SIMD Loops baseline on M4, `loop_216` on 2026-10-29 after a tolerance fix in the code repository (PRs #111 and #115), and `loop_032` on 2026-10-29 (`baseline-sme2` removed). +Every definition in this dataset, with the expert baseline it is scored against on each hardware tier: whether it runs there, and whether it is specialized for that tier. Generated 2026-10-02 from the dataset, the recorded runs and a check of each baseline's code; the SME2 column was updated on 2026-10-20 from a check of every SIMD Loops baseline on M4, `loop_216` on 2026-10-29 after a tolerance fix in the code repository (PRs #111 and #115), and `loop_032` on 2026-10-29 (`baseline-sme2` removed). The KleidiAI section was extended on 2026-10-31 with 18 definitions (5 for the Graviton tiers, 13 for M4). | Mark | Meaning | |---|---| @@ -14,7 +14,7 @@ Tiers: **SVE** = Graviton3 (c7g), **SVE2** = Graviton4 (c8g), **SME2** = Apple M How each source's baseline is chosen and marked is explained under *Notes on the baselines* at the end. -**Eval set** = the 85 evaluated kernels listed in `expected_sets_sve.json` (23 ncnn, 26 llama.cpp, 26 SIMD Loops, 10 KleidiAI; the 7 SME2-only KleidiAI kernels are evaluated on M4). **Subset** = the 32-kernel subset; `subset_sve.json` and `subset_sme.json` differ only in the KleidiAI GEMM (`gemm_fp32_n512_k512` vs `gemm_fp32_sme2_n512_k512`), so 33 rows carry the mark. +**Eval set** = the 103 evaluated kernels listed in `expected_sets_sve.json` (23 ncnn, 26 llama.cpp, 26 SIMD Loops, 28 KleidiAI; the 20 SME2-only KleidiAI kernels are evaluated on M4). **Subset** = the 32-kernel subset; `subset_sve.json` and `subset_sme.json` differ only in the KleidiAI GEMM (`gemm_fp32_n512_k512` vs `gemm_fp32_sme2_n512_k512`), so 33 rows carry the mark. ## Summary @@ -23,9 +23,9 @@ How each source's baseline is chosen and marked is explained under *Notes on the | 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 | | 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 | +| KleidiAI | 28 | 3 / 5 / 0 / 0 / 20 | 0 / 7 / 0 / 0 / 21 | 20 / 0 / 0 / 0 / 8 | | 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 | +| **All** | **142** | 30 / 72 / 0 / 3 / 37 | 11 / 92 / 0 / 7 / 32 | 27 / 83 / 0 / 8 / 24 | ## ncnn (23) @@ -140,9 +140,7 @@ Loops without the Eval set mark are in the dataset but not in the main results. | `loop_221` | | 10 | | | — | — | ★ | | `loop_223` | | 10 | | | — | — | ★ | -## KleidiAI (10) - -`gemm_qs4c32_n256_k512` needs 256-bit SVE, which Graviton4 (128-bit) does not have. +## KleidiAI (28) | Definition | Op | Workloads | Eval set | Subset | SVE | SVE2 | SME2 | |---|---|---|---|---|---|---|---| @@ -150,12 +148,30 @@ Loops without the Eval set mark are in the dataset but not in the main results. | `conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1` | conv2d_depthwise | 20 | ✓ | | — | — | ★ | | `conv2d_f16_nhwc_kh3_kw3_valid_c32_c64` | conv2d | 20 | ✓ | | — | — | ★ | | `conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64` | conv2d | 16 | ✓ | | ★ | ✓ | — | +| `conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2` | conv2d | 16 | ✓ | | — | — | ★ | | `gemm_bf16_n512_k512` | gemm | 15 | ✓ | | — | — | ★ | | `gemm_f16_n512_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_f16_qai4c32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_f16_qs4cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_f16_qs8cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_f16act_qs4c32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_f32_bf16_n512_k512` | gemm | 13 | ✓ | | ✓ | ✓ | — | | `gemm_fp32_n512_k512` | gemm | 13 | ✓ | ✓ | ★ | ✓ | — | | `gemm_fp32_sme2_n512_k512` | gemm | 13 | ✓ | ✓ | — | — | ★ | +| `gemm_i32_u8_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qai4c32_n256_k512` | gemm | 13 | ✓ | | ✓ | ✓ | — | +| `gemm_qai4c32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qai8_qsi8cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qai8dxp_qs4c32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | | `gemm_qs4c32_n256_k512` | gemm | 13 | ✓ | | ★ | — | — | +| `gemm_qs4c32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qs4cx_n512_k512` | gemm | 13 | ✓ | | ✓ | ✓ | — | | `gemm_qs4cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qs8cx_n512_k512` | gemm | 13 | ✓ | | ✓ | ✓ | — | +| `gemm_qs8cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_qsu2cx_n256_k512` | gemm | 13 | ✓ | | ✓ | ✓ | — | +| `gemm_qsu2cx_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | +| `gemm_u8_f32_sme2_n256_k512` | gemm | 13 | ✓ | | — | — | ★ | ## e2e (llama.cpp GEMMs) (18) @@ -208,7 +224,5 @@ These definitions load only with the e2e branch for now (code repo issue #94). - **ncnn** → `baseline-ncnn-arm`, the upstream ncnn kernel, the same on every tier. ncnn is built with its SVE options off, so this is NEON code everywhere: ✓, never ★. - **llama.cpp and e2e** → `baseline-llamacpp-arm`, the ggml CPU kernel built natively on each machine. Which kernels reach ggml's SVE code has not been checked, so these are ✓; ggml's KleidiAI path is off. ggml picks its kernel by op, data type and CPU features, not by shape, so a cell with no recorded run is ✓ when the same op and data type ran on that machine (8 llama.cpp definitions on Graviton4). e2e has recorded runs only on Graviton4 and is ✓ on Graviton3 and M4 for the same reason (q4_K ran on both in the llama.cpp set; q5_K and q6_K have not). - **SIMD Loops** → one hand-written Arm baseline per tier. `baseline-sve2` uses SVE2-only instructions in some loops (★) and is SVE code in the rest (✓). Of the 31 `baseline-sme2`, 24 are SVE code run in streaming mode (`__arm_locally_streaming`, tag `sme2-kernel:streaming-sve`) and 7 use ZA (tag `sme2-kernel:za`: the matrix loops 216–221 and 223). Streaming SVE counts as ✓, not ★, because it uses nothing SME adds (ZA, outer products, SME2 multi-vector instructions); the ZA ones are ★. All 32 were run on M4 on 2026-10-20 (3 passes on every workload, code at main bc8c53d): `loop_032` cannot run there, `loop_216` failed 2 workloads at the default tolerance and passes since its tolerance fix (code repository PRs #111 and #115), and the other 30 pass every workload; the 2x check against the auto-vectorized starting point flags 8 of them, which are ✗ (see the notes below). `loop_032` has no SME2 code upstream, and under `-mcpu=apple-m4` its source falls back to NEON, which streaming mode rejects on M4, so its `baseline-sme2` was removed (—). -- **KleidiAI** → `baseline-kleidiai-arm`: each kernel uses either an SVE micro-kernel (Graviton tiers) or an SME2 one (M4), not both. - -The SVE2 column of SIMD Loops (including the notes on ✗) and of the KleidiAI SVE kernels comes from running each baseline directly on a Graviton4 (c8g) on 2026-10-02. On 2026-10-03 the SIMD Loops and KleidiAI baselines were also checked on Graviton3 and Graviton4 against the inclusion rule that a baseline be at most 2x slower than the scalar starting point auto-vectorized for that machine; every failure is in the notes on ✗. +- **KleidiAI** → `baseline-kleidiai-arm`: each kernel uses either an SVE micro-kernel (`gemm_fp32`, `gemm_qs4c32`, `conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64`), a NEON dot-product / i8mm / bf16 one (the 5 quantized and bf16 GEMMs added on 2026-10-31: ✓ on Graviton3 and Graviton4, not specialized for either), or an SME2 one (M4), not a mix. The 13 SME2 definitions added on that date run the SME2 `mopa` micro-kernels (★); `gemm_i32_u8` and `gemm_u8_f32` use KleidiAI's newer `kai_matmul_uker` API. diff --git a/definitions/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json b/definitions/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json new file mode 100644 index 0000000000000000000000000000000000000000..8176d2b3d7fa3a3bf5ad4381c4e9f37b0fce3adb --- /dev/null +++ b/definitions/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json @@ -0,0 +1,77 @@ +{ + "name": "conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", + "op_type": "conv2d", + "description": "'Same' conv2d (Kh=Kw=3, stride=1, pad=1, so H_out=H/W_out=W) in NHWC input / HWIO weight layout (channels-last) \u2014 distinct from this repo's other conv2d definitions (NCHW-style, via ncnn's Mat convention). Chosen deliberately to match Arm KleidiAI's imatmul indirection-buffer convention directly (no transpose needed in the baseline binding, unlike gemm_fp32_n512_k512). SME2-tier counterpart of conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64 (same operator and ABI; baseline is KleidiAI's SME2 imatmul kernel kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa instead of the SVE one).", + "tags": [ + "status:active", + "baseline-solution:kleidiai" + ], + "axes": { + "N": { + "type": "var" + }, + "H": { + "type": "var" + }, + "W": { + "type": "var" + }, + "C_in": { + "type": "const", + "value": 32 + }, + "C_out": { + "type": "const", + "value": 64 + }, + "Kh": { + "type": "const", + "value": 3 + }, + "Kw": { + "type": "const", + "value": 3 + }, + "pad": { + "type": "const", + "value": 1 + }, + "stride": { + "type": "const", + "value": 1 + } + }, + "inputs": { + "input": { + "shape": [ + "N", + "H", + "W", + "C_in" + ], + "dtype": "float32" + }, + "weight": { + "shape": [ + "Kh", + "Kw", + "C_in", + "C_out" + ], + "dtype": "float32" + } + }, + "outputs": { + "output": { + "shape": [ + "N", + "H", + "W", + "C_out" + ], + "dtype": "float32" + } + }, + "constraints": [], + "reference": "import numpy as np\ndef run(input, weight):\n N, H, W, C_in = input.shape\n Kh, Kw, _, C_out = weight.shape\n pad = 1\n padded = np.pad(input, ((0, 0), (pad, pad), (pad, pad), (0, 0)))\n out = np.zeros((N, H, W, C_out), dtype=np.float32)\n for n in range(N):\n for oh in range(H):\n for ow in range(W):\n patch = padded[n, oh:oh + Kh, ow:ow + Kw, :]\n out[n, oh, ow, :] = np.tensordot(patch, weight, axes=([0, 1, 2], [0, 1, 2]))\n return out\n" +} diff --git a/definitions/gemm/gemm_bf16_n512_k512.json b/definitions/gemm/gemm_bf16_n512_k512.json index caf5ebb5d8228df13515e0a5f0a38713be6785ca..3cdc9576f0976e84e8beaa5fff9445e599cffa9d 100644 --- a/definitions/gemm/gemm_bf16_n512_k512.json +++ b/definitions/gemm/gemm_bf16_n512_k512.json @@ -1,24 +1,54 @@ { "name": "gemm_bf16_n512_k512", "op_type": "gemm", - "description": "GEMM+bias, N=512 K=512, compute-precision-only bf16: A[M,K]/B[K,N]/bias[N] are fp32 wire format (the actual KleidiAI packers kai_lhs_pack_bf16p2vlx2_f32_sme2 / kai_rhs_pack_kxn_bf16p2vlx2b_f32_x32_sme both take raw f32 input and truncate to bf16 internally as part of packing -- there is no bf16 data anywhere upstream, this is a lossy compute-precision optimization applied on the fly, analogous to gemm_qs4c32_n256_k512's dynamic LHS quantization, NOT a pre-quantized-weight contract like gemm_q4_k_m_*). B is [K,N] ('kxn' layout, matching the RHS packer's native input layout directly, no transpose needed) -- unlike this repo's other plain gemm definitions, which use [N,K]. Output is float32. Baseline: kai_matmul_clamp_f32_bf16p2vlx2_bf16p2vlx2_2vlx2vl_sme2_mopa. correctness:sqnr because bf16 (7 mantissa bits) truncation is a real, expected precision loss vs an exact fp32 reference -- same reasoning as the other lossy-compute-precision kleidiai baselines. M varies per workload.", + "description": "GEMM+bias, N=512 K=512, compute-precision-only bf16: A[M,K]/B[K,N]/bias[N] are fp32 wire format (the actual KleidiAI packers kai_lhs_pack_bf16p2vlx2_f32_sme2 / kai_rhs_pack_kxn_bf16p2vlx2b_f32_x32_sme both take raw f32 input and truncate to bf16 internally as part of packing -- there is no bf16 data anywhere upstream, this is a lossy compute-precision optimization applied on the fly, analogous to gemm_qs4c32_n256_k512's dynamic LHS quantization, NOT a pre-quantized-weight contract like gemm_q4_k_m_*). B is [K,N] ('kxn' layout, matching the RHS packer's native input layout directly, no transpose needed) -- unlike this repo's other plain gemm definitions, which use [N,K]. Output is float32. Baseline: kai_matmul_clamp_f32_bf16p2vlx2_bf16p2vlx2_2vlx2vl_sme2_mopa. Judged by element tolerance with a matched-ratio bar sized to bf16 (7 mantissa bits) truncation -- no dequantization is involved, so not SQNR. M varies per workload.", "tags": [ "status:active", - "baseline-solution:kleidiai", - "correctness:sqnr" + "baseline-solution:kleidiai" ], "axes": { - "M": { "type": "var" }, - "N": { "type": "const", "value": 512 }, - "K": { "type": "const", "value": 512 } + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 512 + }, + "K": { + "type": "const", + "value": 512 + } }, "inputs": { - "A": { "shape": ["M", "K"], "dtype": "float32" }, - "B": { "shape": ["K", "N"], "dtype": "float32" }, - "bias": { "shape": ["N"], "dtype": "float32" } + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B": { + "shape": [ + "K", + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } }, "outputs": { - "C": { "shape": ["M", "N"], "dtype": "float32" } + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } }, "constraints": [], "reference": "import numpy as np\n\n\ndef run(A, B, bias):\n return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)\n" diff --git a/definitions/gemm/gemm_f16_qai4c32_sme2_n256_k512.json b/definitions/gemm/gemm_f16_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..5063b13a1e15718061ea203a65263d63be676687 --- /dev/null +++ b/definitions/gemm/gemm_f16_qai4c32_sme2_n256_k512.json @@ -0,0 +1,77 @@ +{ + "name": "gemm_f16_qai4c32_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, fp16 activations x block-wise asymmetric int4 weights, fp16 kernel family (SME2): A float16 [M,K] (raw patterns), B_q4 uint8 [N,K/2] adjacent-pair nibbles (byte j: k=2j low, k=2j+1 high), per-block (length 32) fp32 scale B_scales and fp32 additive offset B_zeros [N,K/32] already in the real domain (= -zero_point*scale), fp32 bias [N]; dequant via value=(nibble-8)*scale+zero. The kernel's native output is fp16; the raw ABI allocates float32 outputs, so the binding widens it (exact), and fp16 rounding is part of what the baseline-relative SQNR gate absorbs. M varies per workload. Baseline: kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float16" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "B_zeros": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, B_zeros, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n s = np.repeat(B_scales.astype(np.float32), 32, axis=1)\n z = np.repeat(B_zeros.astype(np.float32), 32, axis=1)\n B = deq * s + z\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_f16_qs4cx_sme2_n256_k512.json b/definitions/gemm/gemm_f16_qs4cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..fc7637e913951810bd2e4733e32f8e36457dbd1c --- /dev/null +++ b/definitions/gemm/gemm_f16_qs4cx_sme2_n256_k512.json @@ -0,0 +1,65 @@ +{ + "name": "gemm_f16_qs4cx_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, fp16 activations x per-channel int4 weights, fp16 kernel family (SME2): A float16 [M,K] (raw patterns), B_q4 uint8 [N,K/2] adjacent-pair nibbles (byte j: k=2j low, k=2j+1 high), zero_point=8, one fp32 scale per output channel, fp32 bias [N]; dequant via value=(nibble-8)*scale. The kernel's native output is fp16; the raw ABI allocates float32 outputs, so the binding widens it (exact), and fp16 rounding is part of what the baseline-relative SQNR gate absorbs. M varies per workload. Baseline: kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float16" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n B = deq * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_f16_qs8cx_sme2_n256_k512.json b/definitions/gemm/gemm_f16_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..5652cae1c0dff91f31bb5de3d21a89c7e341fa47 --- /dev/null +++ b/definitions/gemm/gemm_f16_qs8cx_sme2_n256_k512.json @@ -0,0 +1,61 @@ +{ + "name": "gemm_f16_qs8cx_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, fp16 activations x per-channel int8 weights, fp16 kernel family (SME2): A float16 [M,K] (raw patterns), B_q8 int8 [N,K] + one fp32 scale per output channel (value=q*scale, no zero point), fp32 bias [N]. The kernel's native output is fp16; the raw ABI allocates float32 outputs, so the binding widens it (exact), and fp16 rounding is part of what the baseline-relative SQNR gate absorbs. M varies per workload. Baseline: kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa (LHS via kai_lhs_quant_pack_qai8dxp_f16_neon).", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float16" + }, + "B_q8": { + "shape": [ + "N", + "K" + ], + "dtype": "int8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q8, B_scales, bias):\n B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json b/definitions/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..3caddb339344bfa866919ac75c1c75e583725561 --- /dev/null +++ b/definitions/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json @@ -0,0 +1,64 @@ +{ + "name": "gemm_f16act_qs4c32_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM, N=256 K=512, fp16 activations x block-wise int4 weights (SME2): A is float16 [M,K] (raw 16-bit patterns per the raw ABI), B_q4 uint8 [N,K/2] and f16 per-block scales exactly as gemm_qs4c32_sme2_n256_k512 (block length 32, zero_point=8, split-half nibbles); no bias; f32 output. The mixed fp16-activation / int4-weight case. M varies per workload. Baseline: kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa (needs SME2 and FP16).", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float16" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float16" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales):\n n, k_half = B_q4.shape\n bl = 32\n nb = k_half // (bl // 2)\n lo = (B_q4 & 0x0F).astype(np.float32) - 8.0\n hi = (B_q4 >> 4).astype(np.float32) - 8.0\n deq = np.concatenate([lo.reshape(n, nb, bl // 2), hi.reshape(n, nb, bl // 2)], axis=-1).reshape(n, nb * bl)\n B = deq * np.repeat(B_scales.astype(np.float32), bl, axis=-1)\n return (A.astype(np.float32) @ B.T).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_f32_bf16_n512_k512.json b/definitions/gemm/gemm_f32_bf16_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..28eff2b81e45cd6a3446cf77f415d9d422527467 --- /dev/null +++ b/definitions/gemm/gemm_f32_bf16_n512_k512.json @@ -0,0 +1,54 @@ +{ + "name": "gemm_f32_bf16_n512_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=512 K=512, compute-precision-only bf16 on NEON bfmmla: A[M,K]/B[K,N]/bias[N] are fp32 wire format; the baseline packers (kai_lhs_quant_pack_bf16p8x4_f32_neon, kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon) truncate to bf16 internally, as in gemm_bf16_n512_k512 (the SME2 variant). M varies per workload. Baseline: kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.", + "tags": [ + "status:active", + "baseline-solution:kleidiai" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 512 + }, + "K": { + "type": "const", + "value": 512 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B": { + "shape": [ + "K", + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B, bias):\n return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_i32_u8_sme2_n256_k512.json b/definitions/gemm/gemm_i32_u8_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..2f0a71de69a822b919183e30b6461e6184dae7ec --- /dev/null +++ b/definitions/gemm/gemm_i32_u8_sme2_n256_k512.json @@ -0,0 +1,48 @@ +{ + "name": "gemm_i32_u8_sme2_n256_k512", + "op_type": "gemm", + "description": "Integer GEMM, N=256 K=512: C[m,n] = sum_k A[m,k]*B[n,k] with A uint8 [M,K] and B uint8 [N,K], exact int32 accumulation, no scales or bias. The kernel's native output is int32; this repo's raw ABI always allocates float32 outputs, so the binding converts int32 to float32 (round-to-nearest, identical in reference and baseline; products up to 512*255*255 exceed 2^24 so large values are rounded). Exact match is expected, no SQNR. M varies per workload. Baseline: kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa (SME2).", + "tags": [ + "status:active", + "baseline-solution:kleidiai" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "uint8" + }, + "B": { + "shape": [ + "N", + "K" + ], + "dtype": "uint8" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B):\n return (A.astype(np.int64) @ B.astype(np.int64).T).astype(np.int32).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qai4c32_n256_k512.json b/definitions/gemm/gemm_qai4c32_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..a931600ff5fccc16483c89e883ee1a69d73bb046 --- /dev/null +++ b/definitions/gemm/gemm_qai4c32_n256_k512.json @@ -0,0 +1,77 @@ +{ + "name": "gemm_qai4c32_n256_k512", + "op_type": "gemm", + "description": "GEMM, N=256 K=512, weight-only-quantized ASYMMETRIC int4 with block length 32 (NEON i8mm): A is fp32, B ships as qai4c32 -- uint8 [N,K/2] with adjacent-pair nibbles (byte j holds k=2j in the low nibble, k=2j+1 in the high nibble), plus per-block fp32 scale [N,K/32] and per-block fp32 additive offset B_zeros [N,K/32] already in the real domain (= -zero_point*scale, the form KleidiAI's packer takes; unlike gemm_qs4c32_* which has no offset); dequant via value=(nibble-8)*scale+zero. M varies per workload. Baseline: kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "B_zeros": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, B_zeros, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n s = np.repeat(B_scales.astype(np.float32), 32, axis=1)\n z = np.repeat(B_zeros.astype(np.float32), 32, axis=1)\n B = deq * s + z\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qai4c32_sme2_n256_k512.json b/definitions/gemm/gemm_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..2bbc63541a7dbc5de469e8c168f7d97e9e23f7b3 --- /dev/null +++ b/definitions/gemm/gemm_qai4c32_sme2_n256_k512.json @@ -0,0 +1,77 @@ +{ + "name": "gemm_qai4c32_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM, N=256 K=512, weight-only-quantized ASYMMETRIC int4 with block length 32 (SME2): A is fp32, B ships as qai4c32 -- uint8 [N,K/2] with adjacent-pair nibbles (byte j holds k=2j in the low nibble, k=2j+1 in the high nibble), plus per-block fp32 scale [N,K/32] and per-block fp32 additive offset B_zeros [N,K/32] already in the real domain (= -zero_point*scale, the form KleidiAI's packer takes; unlike gemm_qs4c32_* which has no offset); dequant via value=(nibble-8)*scale+zero. M varies per workload. Baseline: kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "B_zeros": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, B_zeros, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n s = np.repeat(B_scales.astype(np.float32), 32, axis=1)\n z = np.repeat(B_zeros.astype(np.float32), 32, axis=1)\n B = deq * s + z\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json b/definitions/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..071f27a761d2684a9ff894db2069e700a3ed0872 --- /dev/null +++ b/definitions/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json @@ -0,0 +1,76 @@ +{ + "name": "gemm_qai8_qsi8cx_sme2_n256_k512", + "op_type": "gemm", + "description": "Requantized int8 GEMM, N=256 K=512: A int8 [M,K] with per-tensor scale A_scale (symmetric, zero point fixed at 0); B int8 [N,K] with per-channel scale B_scales (symmetric); fp32 bias [N]; int32 accumulation A@B^T, scaled by A_scale*B_scales[n], plus bias, divided by C_scale, rounded to nearest even and clamped to [-128,127] (output zero point fixed at 0). A_scale and C_scale are 1-element fp32 tensors (axis S=1) because the raw ABI passes only tensors, not scalars. Scales must be positive. The kernel's native output is int8; the raw ABI allocates float32 outputs so the binding converts int8 to float32 (exact). M varies per workload. Baseline: kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa (SME2).", + "tags": [ + "status:active", + "baseline-solution:kleidiai" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "S": { + "type": "const", + "value": 1 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "int8" + }, + "A_scale": { + "shape": [ + "S" + ], + "dtype": "float32" + }, + "B_q8": { + "shape": [ + "N", + "K" + ], + "dtype": "int8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "C_scale": { + "shape": [ + "S" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, A_scale, B_q8, B_scales, bias, C_scale):\n acc = A.astype(np.int32) @ B_q8.astype(np.int32).T\n real = acc.astype(np.float32) * (A_scale[0] * B_scales.astype(np.float32))[None, :] + bias.astype(np.float32)\n q = np.rint(real / C_scale[0])\n return np.clip(q, -128, 127).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json b/definitions/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..c86f3a619ee4214c9aab08e6720a273b958f1f18 --- /dev/null +++ b/definitions/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json @@ -0,0 +1,70 @@ +{ + "name": "gemm_qai8dxp_qs4c32_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, weight-only-quantized block-wise int4 with dynamically int8-quantized activations (SME2): A and bias are fp32, B_q4 is uint8 [N,K/2] with adjacent-pair nibbles (byte j holds k=2j in the low nibble and k=2j+1 in the high nibble), zero_point=8, one bfloat16 scale per block of 32 along K (the only scale type this kernel family's RHS packer accepts) ([N,K/32]); dequant via value=(nibble-8)*scale. Unlike gemm_qs4c32_sme2_n256_k512 (per-32-block symmetric int8 LHS, split-half nibbles, no bias), the kernel quantizes the LHS per ROW with an asymmetric zero point (qai8dxp). Judged by SQNR against the baseline. M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "bfloat16" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n s = np.repeat(B_scales.astype(np.float32), 32, axis=1)\n B = deq * s\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qs4c32_sme2_n256_k512.json b/definitions/gemm/gemm_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..947fd0b69493c4817b945a544b917e0c5016ae4f --- /dev/null +++ b/definitions/gemm/gemm_qs4c32_sme2_n256_k512.json @@ -0,0 +1,64 @@ +{ + "name": "gemm_qs4c32_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM, N=256 K=512, weight-only-quantized block-wise int4 (SME2): same wire format as gemm_qs4c32_n256_k512 -- A fp32, B_q4 uint8 [N,K/2] (qs4c32: block length 32, zero_point=8, byte i of each 16-byte block holds element i in the low nibble and element i+16 in the high nibble), per-block f16 scale; dequant via value=(nibble-8)*scale; no bias. SME2 counterpart of the Graviton3 SVE definition. M varies per workload. Baseline: kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + }, + "K_blocks": { + "type": "const", + "value": 16 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N", + "K_blocks" + ], + "dtype": "float16" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales):\n n, k_half = B_q4.shape\n bl = 32\n nb = k_half // (bl // 2)\n lo = (B_q4 & 0x0F).astype(np.float32) - 8.0\n hi = (B_q4 >> 4).astype(np.float32) - 8.0\n deq = np.concatenate([lo.reshape(n, nb, bl // 2), hi.reshape(n, nb, bl // 2)], axis=-1).reshape(n, nb * bl)\n B = deq * np.repeat(B_scales.astype(np.float32), bl, axis=-1)\n return (A.astype(np.float32) @ B.T).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qs4cx_n512_k512.json b/definitions/gemm/gemm_qs4cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..0d8fef75f3eacd76823a3dc2380359a95de759e6 --- /dev/null +++ b/definitions/gemm/gemm_qs4cx_n512_k512.json @@ -0,0 +1,65 @@ +{ + "name": "gemm_qs4cx_n512_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=512 K=512, weight-only-quantized per-channel int4 (NEON i8mm): same wire format as gemm_qs4cx_sme2_n256_k512 -- A and bias fp32, B as qs4cx uint8 [N,K/2] with adjacent-pair nibbles (byte j holds k=2j low, k=2j+1 high), zero_point=8, one fp32 scale per output channel; dequant via value=(nibble-8)*scale. M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 512 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_half": { + "type": "const", + "value": 256 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q4": { + "shape": [ + "N", + "K_half" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q4, B_scales, bias):\n n, k_half = B_q4.shape\n deq = np.empty((n, k_half * 2), dtype=np.float32)\n deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0\n deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0\n B = deq * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qs8cx_n512_k512.json b/definitions/gemm/gemm_qs8cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..b58ff759aaa2ce16a05bd4e7f2c887af1dfe920b --- /dev/null +++ b/definitions/gemm/gemm_qs8cx_n512_k512.json @@ -0,0 +1,61 @@ +{ + "name": "gemm_qs8cx_n512_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=512 K=512, weight-only-quantized per-channel int8 (NEON i8mm): A and bias are fp32, B ships pre-quantized as qsi8cx -- int8 [N,K] (row-major, one row per output channel) plus one fp32 scale per output channel; dequant via value=q*scale, no zero point. LHS is dynamically quantized per row by the baseline (qai8dxp, asymmetric). M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 512 + }, + "K": { + "type": "const", + "value": 512 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q8": { + "shape": [ + "N", + "K" + ], + "dtype": "int8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q8, B_scales, bias):\n B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qs8cx_sme2_n256_k512.json b/definitions/gemm/gemm_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..a2225d1229ccb5df5d5934aa522639ec4b8928f1 --- /dev/null +++ b/definitions/gemm/gemm_qs8cx_sme2_n256_k512.json @@ -0,0 +1,61 @@ +{ + "name": "gemm_qs8cx_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, weight-only-quantized per-channel int8 (SME2): A and bias are fp32, B ships pre-quantized as qsi8cx -- int8 [N,K] (row-major, one row per output channel) plus one fp32 scale per output channel; dequant via value=q*scale, no zero point. LHS is dynamically quantized per row by the baseline (qai8dxp, asymmetric). M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q8": { + "shape": [ + "N", + "K" + ], + "dtype": "int8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q8, B_scales, bias):\n B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qsu2cx_n256_k512.json b/definitions/gemm/gemm_qsu2cx_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..1db4bdbac62f46b45e085b2dfa3ebca8b0fd9a0d --- /dev/null +++ b/definitions/gemm/gemm_qsu2cx_n256_k512.json @@ -0,0 +1,65 @@ +{ + "name": "gemm_qsu2cx_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, weight-only-quantized per-channel 2-bit (NEON dotprod): A and bias are fp32, B ships pre-quantized as qsu2cx -- uint8 [N,K/4], four 2-bit values per byte (byte j holds k=4j in bits 0-1, k=4j+1 in bits 2-3, k=4j+2 in bits 4-5, k=4j+3 in bits 6-7), zero_point=2, one fp32 scale per output channel; dequant via value=(q-2)*scale. K is a multiple of 32. M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_q": { + "type": "const", + "value": 128 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q2": { + "shape": [ + "N", + "K_q" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q2, B_scales, bias):\n n, k_q = B_q2.shape\n deq = np.empty((n, k_q * 4), dtype=np.float32)\n for j in range(4):\n deq[:, j::4] = ((B_q2 >> (2 * j)) & 0x03).astype(np.float32) - 2.0\n B = deq * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_qsu2cx_sme2_n256_k512.json b/definitions/gemm/gemm_qsu2cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..50050c48a9566d680de483371e5fce808b542415 --- /dev/null +++ b/definitions/gemm/gemm_qsu2cx_sme2_n256_k512.json @@ -0,0 +1,65 @@ +{ + "name": "gemm_qsu2cx_sme2_n256_k512", + "op_type": "gemm", + "description": "GEMM+bias, N=256 K=512, weight-only-quantized per-channel 2-bit (SME2): A and bias are fp32, B ships pre-quantized as qsu2cx -- uint8 [N,K/4], four 2-bit values per byte (byte j holds k=4j in bits 0-1, k=4j+1 in bits 2-3, k=4j+2 in bits 4-5, k=4j+3 in bits 6-7), zero_point=2, one fp32 scale per output channel; dequant via value=(q-2)*scale. K is a multiple of 32. M varies per workload. Baseline: kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa.", + "tags": [ + "status:active", + "baseline-solution:kleidiai", + "correctness:sqnr" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "K_q": { + "type": "const", + "value": 128 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "float32" + }, + "B_q2": { + "shape": [ + "N", + "K_q" + ], + "dtype": "uint8" + }, + "B_scales": { + "shape": [ + "N" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B_q2, B_scales, bias):\n n, k_q = B_q2.shape\n deq = np.empty((n, k_q * 4), dtype=np.float32)\n for j in range(4):\n deq[:, j::4] = ((B_q2 >> (2 * j)) & 0x03).astype(np.float32) - 2.0\n B = deq * B_scales.astype(np.float32)[:, None]\n return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/definitions/gemm/gemm_u8_f32_sme2_n256_k512.json b/definitions/gemm/gemm_u8_f32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..ba4474442421273e98ee4ea5ed8c94a13e5b91fa --- /dev/null +++ b/definitions/gemm/gemm_u8_f32_sme2_n256_k512.json @@ -0,0 +1,64 @@ +{ + "name": "gemm_u8_f32_sme2_n256_k512", + "op_type": "gemm", + "description": "Quantized-input GEMM, N=256 K=512: C[m,n] = float(sum_k A[m,k]*B[n,k]) * C_scale[0] + bias[n] with A uint8 [M,K], B uint8 [N,K], exact int32 accumulation then converted to float32, scaled by one global fp32 scale and offset by a per-column fp32 bias. C_scale is a one-element tensor (axis S=1) because the raw ABI passes no scalars. Elementwise tolerance, no SQNR (output is already float32 and the arithmetic is deterministic). M varies per workload. Baseline: kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa (SME2, new-style kai_matmul_uker API).", + "tags": [ + "status:active", + "baseline-solution:kleidiai" + ], + "axes": { + "M": { + "type": "var" + }, + "N": { + "type": "const", + "value": 256 + }, + "K": { + "type": "const", + "value": 512 + }, + "S": { + "type": "const", + "value": 1 + } + }, + "inputs": { + "A": { + "shape": [ + "M", + "K" + ], + "dtype": "uint8" + }, + "B": { + "shape": [ + "N", + "K" + ], + "dtype": "uint8" + }, + "C_scale": { + "shape": [ + "S" + ], + "dtype": "float32" + }, + "bias": { + "shape": [ + "N" + ], + "dtype": "float32" + } + }, + "outputs": { + "C": { + "shape": [ + "M", + "N" + ], + "dtype": "float32" + } + }, + "reference": "import numpy as np\n\n\ndef run(A, B, C_scale, bias):\n acc = (A.astype(np.int64) @ B.astype(np.int64).T).astype(np.int32).astype(np.float32)\n return (acc * C_scale.astype(np.float32)[0] + bias.astype(np.float32)).astype(np.float32)\n" +} diff --git a/expected_sets_sve.json b/expected_sets_sve.json index 2a603e30003bed4296bf5d09ee9cde06f7ab7ade..a6f31c2efe3f6b1f4e8bfdf46dfce05b976d0cac 100644 --- a/expected_sets_sve.json +++ b/expected_sets_sve.json @@ -57,12 +57,30 @@ "conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1", "conv2d_f16_nhwc_kh3_kw3_valid_c32_c64", "conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64", + "conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", "gemm_bf16_n512_k512", "gemm_f16_n512_k512", + "gemm_f16_qai4c32_sme2_n256_k512", + "gemm_f16_qs4cx_sme2_n256_k512", + "gemm_f16_qs8cx_sme2_n256_k512", + "gemm_f16act_qs4c32_sme2_n256_k512", + "gemm_f32_bf16_n512_k512", "gemm_fp32_n512_k512", "gemm_fp32_sme2_n512_k512", + "gemm_i32_u8_sme2_n256_k512", + "gemm_qai4c32_n256_k512", + "gemm_qai4c32_sme2_n256_k512", + "gemm_qai8_qsi8cx_sme2_n256_k512", + "gemm_qai8dxp_qs4c32_sme2_n256_k512", "gemm_qs4c32_n256_k512", - "gemm_qs4cx_sme2_n256_k512" + "gemm_qs4c32_sme2_n256_k512", + "gemm_qs4cx_n512_k512", + "gemm_qs4cx_sme2_n256_k512", + "gemm_qs8cx_n512_k512", + "gemm_qs8cx_sme2_n256_k512", + "gemm_qsu2cx_n256_k512", + "gemm_qsu2cx_sme2_n256_k512", + "gemm_u8_f32_sme2_n256_k512" ], "simd-loop": [ "loop_001", diff --git a/solutions/kleidiai/baseline-kleidiai-arm/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json b/solutions/kleidiai/baseline-kleidiai-arm/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json new file mode 100644 index 0000000000000000000000000000000000000000..f1580c24a083a7e454b4a048157391352bc96ad8 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json @@ -0,0 +1,76 @@ +{ + "name": "baseline-kleidiai-arm_conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", + "definition": "conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2: KleidiAI kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa with its x32p2vlx1 LHS/RHS imatmul packers.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_conv2d", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme to pack the LHS matrix.\n/// -# kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme to pack the RHS matrix.\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS matrix buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix. Must be a multiple of `m_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of `n_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be a multiple of `m_step`.\n/// @param[in] n_idx Column index. Must be a multiple of `n_step`.\n/// @param[in] dst_stride_row Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride_row);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n/// * Packed RHS: @ref kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n/// * Output: @ref kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n///\n/// @param[in] m Number of output rows to be computed.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_packed Packed LHS matrix buffer.\n/// @param[in] rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Row stride in bytes of the output matrix.\n/// @param[in] clamp_min Minimum value to clamp the final result.\n/// @param[in] clamp_max Maximum value to clamp the final result.\n///\n/// @note Clamp minimum and maximum values are cast internally to the destination type before clamping the computed\n/// values.\n///\nvoid kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n void* dst, size_t dst_stride_row, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n#include \"kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n const void* A;\n const void* B;\n void* C;\n uint64_t ldcb;\n uint64_t M;\n uint64_t N;\n uint64_t K;\n float min;\n float max;\n void* accumulator_buffer;\n uint64_t flags;\n} KernelArgs;\n\nstatic const size_t kai_mr = 2;\nstatic const size_t kai_nr = 2;\nstatic const size_t kai_kr = 1;\n\nvoid kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(KernelArgs* args);\n\n// Returns a constant value specific to this kernel that's relative to vector length\nstatic size_t kai_get_kernel_vec_length_constant(void) {\n const size_t kernel_vec_length_constant = kai_get_sme_vector_length_u32() / kai_kr;\n return kernel_vec_length_constant;\n}\n\nsize_t kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void) {\n return kai_mr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void) {\n return kai_nr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n return m_idx * k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(float);\n}\n\nstatic size_t kai_get_rhs_packed_stride_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t k_chunk_count, size_t k_chunk_length) {\n return kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() *\n (sizeof(float) + k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(float));\n}\n\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n const size_t block_idx = n_idx / kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa();\n return block_idx *\n kai_get_rhs_packed_stride_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride_row) {\n KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n\n return m_idx * dst_stride_row + n_idx * sizeof(float);\n}\n\nsize_t kai_get_dst_size_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(size_t m, size_t n) {\n return m * n * sizeof(float);\n}\n\nvoid kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n void* dst, size_t dst_stride_row, float clamp_min, float clamp_max) {\n KernelArgs args;\n\n args.A = lhs_packed;\n args.B = rhs_packed;\n args.C = dst;\n args.ldcb = dst_stride_row;\n args.M = m;\n args.N = n;\n args.K = k_chunk_count * kai_roundup(k_chunk_length, kai_kr);\n args.min = clamp_min;\n args.max = clamp_max;\n args.accumulator_buffer = NULL;\n args.flags = 0;\n\n kai_commit_za();\n\n kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x15, #0x0\n ptrue p0.b\n KAI_ASM_INST(0x25207811) // ptrue pn9.b\n ldr x14, [x0, #0x30]\n ldr w13, [x0, #0x20]\n mov x11, #0x0\n ldr w10, [x0, #0x28]\n ldr x9, [x0, #0x0]\nKAI_ASM_LABEL(label_1) // M loop\n ldr x28, [x0, #0x8]\nKAI_ASM_LABEL(label_2) // N loop\n fmov z22.s, #1.0\n KAI_ASM_INST(0xa040478c) // ld1w { z12.s-z13.s }, pn9.b/Z, [x28]\n KAI_ASM_INST(0xc00800ff) // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n mov x27, x9\n KAI_ASM_INST(0x25aa4570) // whilelt pn8.s, x11, x10, VLx2\n addvl x28, x28, #2\n KAI_ASM_INST(0x808c02c0) // fmopa za0.s, p0/M, p0/M, z22.s, z12.s\n KAI_ASM_INST(0x808d02c1) // fmopa za1.s, p0/M, p0/M, z22.s, z13.s\n KAI_ASM_INST(0x808c02c2) // fmopa za2.s, p0/M, p0/M, z22.s, z12.s\n KAI_ASM_INST(0x808d02c3) // fmopa za3.s, p0/M, p0/M, z22.s, z13.s\n lsr x21, x14, #0x2\n and x20, x14, #0x3\n cbz x21, label_6\n subs x21, x21, #0x1\n KAI_ASM_INST(0xa040c764) // ld1w { z4.s-z7.s }, pn9.b/Z, [x27]\n KAI_ASM_INST(0xa041c768) // ld1w { z8.s-z11.s }, pn9.b/Z, [x27, #0x4, MUL VL]\n addvl x27, x27, #8\n KAI_ASM_INST(0xa040c794) // ld1w { z20.s-z23.s }, pn9.b/Z, [x28]\n KAI_ASM_INST(0xa041c78c) // ld1w { z12.s-z15.s }, pn9.b/Z, [x28, #0x4, MUL VL]\n addvl x28, x28, #8\n ble label_5\nKAI_ASM_LABEL(label_4) // K loop\n KAI_ASM_INST(0x80940080) // fmopa za0.s, p0/M, p0/M, z4.s, z20.s\n subs x21, x21, #0x1\n KAI_ASM_INST(0x80950081) // fmopa za1.s, p0/M, p0/M, z4.s, z21.s\n KAI_ASM_INST(0x809400a2) // fmopa za2.s, p0/M, p0/M, z5.s, z20.s\n KAI_ASM_INST(0x809500a3) // fmopa za3.s, p0/M, p0/M, z5.s, z21.s\n KAI_ASM_INST(0x809600c0) // fmopa za0.s, p0/M, p0/M, z6.s, z22.s\n KAI_ASM_INST(0x809700c1) // fmopa za1.s, p0/M, p0/M, z6.s, z23.s\n KAI_ASM_INST(0x809600e2) // fmopa za2.s, p0/M, p0/M, z7.s, z22.s\n KAI_ASM_INST(0x809700e3) // fmopa za3.s, p0/M, p0/M, z7.s, z23.s\n KAI_ASM_INST(0xa040c764) // ld1w { z4.s-z7.s }, pn9.b/Z, [x27]\n KAI_ASM_INST(0x808c0100) // fmopa za0.s, p0/M, p0/M, z8.s, z12.s\n KAI_ASM_INST(0xa040c794) // ld1w { z20.s-z23.s }, pn9.b/Z, [x28]\n KAI_ASM_INST(0x808d0101) // fmopa za1.s, p0/M, p0/M, z8.s, z13.s\n KAI_ASM_INST(0x808c0122) // fmopa za2.s, p0/M, p0/M, z9.s, z12.s\n KAI_ASM_INST(0x808d0123) // fmopa za3.s, p0/M, p0/M, z9.s, z13.s\n KAI_ASM_INST(0x808e0140) // fmopa za0.s, p0/M, p0/M, z10.s, z14.s\n KAI_ASM_INST(0x808f0141) // fmopa za1.s, p0/M, p0/M, z10.s, z15.s\n KAI_ASM_INST(0x808e0162) // fmopa za2.s, p0/M, p0/M, z11.s, z14.s\n KAI_ASM_INST(0x808f0163) // fmopa za3.s, p0/M, p0/M, z11.s, z15.s\n KAI_ASM_INST(0xa041c768) // ld1w { z8.s-z11.s }, pn9.b/Z, [x27, #0x4, MUL VL]\n addvl x27, x27, #8\n KAI_ASM_INST(0xa041c78c) // ld1w { z12.s-z15.s }, pn9.b/Z, [x28, #0x4, MUL VL]\n addvl x28, x28, #8\n bgt label_4\nKAI_ASM_LABEL(label_5) // K loop tail\n KAI_ASM_INST(0x80940080) // fmopa za0.s, p0/M, p0/M, z4.s, z20.s\n KAI_ASM_INST(0x80950081) // fmopa za1.s, p0/M, p0/M, z4.s, z21.s\n KAI_ASM_INST(0x809400a2) // fmopa za2.s, p0/M, p0/M, z5.s, z20.s\n KAI_ASM_INST(0x809500a3) // fmopa za3.s, p0/M, p0/M, z5.s, z21.s\n KAI_ASM_INST(0x809600c0) // fmopa za0.s, p0/M, p0/M, z6.s, z22.s\n KAI_ASM_INST(0x809700c1) // fmopa za1.s, p0/M, p0/M, z6.s, z23.s\n KAI_ASM_INST(0x809600e2) // fmopa za2.s, p0/M, p0/M, z7.s, z22.s\n KAI_ASM_INST(0x809700e3) // fmopa za3.s, p0/M, p0/M, z7.s, z23.s\n KAI_ASM_INST(0x808c0100) // fmopa za0.s, p0/M, p0/M, z8.s, z12.s\n KAI_ASM_INST(0x808d0101) // fmopa za1.s, p0/M, p0/M, z8.s, z13.s\n KAI_ASM_INST(0x808c0122) // fmopa za2.s, p0/M, p0/M, z9.s, z12.s\n KAI_ASM_INST(0x808d0123) // fmopa za3.s, p0/M, p0/M, z9.s, z13.s\n KAI_ASM_INST(0x808e0140) // fmopa za0.s, p0/M, p0/M, z10.s, z14.s\n KAI_ASM_INST(0x808f0141) // fmopa za1.s, p0/M, p0/M, z10.s, z15.s\n KAI_ASM_INST(0x808e0162) // fmopa za2.s, p0/M, p0/M, z11.s, z14.s\n KAI_ASM_INST(0x808f0163) // fmopa za3.s, p0/M, p0/M, z11.s, z15.s\nKAI_ASM_LABEL(label_6) // K oddments\n cbz x20, label_8\nKAI_ASM_LABEL(label_7) // K oddments: Loop\n KAI_ASM_INST(0xa040477c) // ld1w { z28.s-z29.s }, pn9.b/Z, [x27]\n subs x20, x20, #0x1\n addvl x27, x27, #2\n KAI_ASM_INST(0xa1404787) // ld1w { z7.s, z15.s }, pn9.b/Z, [x28]\n addvl x28, x28, #2\n KAI_ASM_INST(0x80870380) // fmopa za0.s, p0/M, p0/M, z28.s, z7.s\n KAI_ASM_INST(0x808f0381) // fmopa za1.s, p0/M, p0/M, z28.s, z15.s\n KAI_ASM_INST(0x808703a2) // fmopa za2.s, p0/M, p0/M, z29.s, z7.s\n KAI_ASM_INST(0x808f03a3) // fmopa za3.s, p0/M, p0/M, z29.s, z15.s\n bgt label_7\nKAI_ASM_LABEL(label_8) // K oddments: End\n ldr x26, [x0, #0x10]\n sub x25, x13, x15\n cntw x24\n KAI_ASM_INST(0x854ec01a) // ld1rw { z26.s }, p0/Z, [x0, #56]\n ldr x23, [x0, #0x18]\n cmp x25, x24\n KAI_ASM_INST(0x854fc018) // ld1rw { z24.s }, p0/Z, [x0, #60]\n mov x12, #0x0\n csel x22, x25, x24, LT\n add x26, x26, x11, LSL #2 // C += n\n lsr x21, x22, #0x2\n madd x26, x15, x23, x26 // C += m * ldc\n and x20, x22, #0x3\n cbz x21, label_11\nKAI_ASM_LABEL(label_10) // Store to output array: Accumulator row 0 loop\n KAI_ASM_INST(0xc0860404) // mova { z4.s-z7.s }, za0h.s[x12]\n KAI_ASM_INST(0xc086042c) // mova { z12.s-z15.s }, za1h.s[x12]\n KAI_ASM_INST(0xc1b8cb44) // fclamp { z4.s-z7.s }, z26.s, z24.s\n KAI_ASM_INST(0xc1b8cb4c) // fclamp { z12.s-z15.s }, z26.s, z24.s\n add x12, x12, #0x4\n cmp x12, x21, LSL #2\n KAI_ASM_INST(0xa1604344) // st1w { z4.s, z12.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604345) // st1w { z5.s, z13.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604346) // st1w { z6.s, z14.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604347) // st1w { z7.s, z15.s }, p8, [x26]\n add x26, x26, x23\n blt label_10\nKAI_ASM_LABEL(label_11) // Store to output array: Accumulator row 0 oddments\n cbz x20, label_12\n KAI_ASM_INST(0xc0860400) // mova { z0.s-z3.s }, za0h.s[x12]\n KAI_ASM_INST(0xc0860428) // mova { z8.s-z11.s }, za1h.s[x12]\n subs x20, x20, #0x1\n KAI_ASM_INST(0xc1b8cb40) // fclamp { z0.s-z3.s }, z26.s, z24.s\n KAI_ASM_INST(0xc1b8cb48) // fclamp { z8.s-z11.s }, z26.s, z24.s\n KAI_ASM_INST(0xa1604340) // st1w { z0.s, z8.s }, p8, [x26]\n add x26, x26, x23\n beq label_12\n subs x20, x20, #0x1\n KAI_ASM_INST(0xa1604341) // st1w { z1.s, z9.s }, p8, [x26]\n add x26, x26, x23\n beq label_12\n KAI_ASM_INST(0xa1604342) // st1w { z2.s, z10.s }, p8, [x26]\n add x26, x26, x23\nKAI_ASM_LABEL(label_12) // Store to output array: Accumulator row 0 oddments: End\n subs x25, x25, x22\n beq label_16\n cmp x25, x24\n mov x12, #0x0\n csel x20, x25, x24, LT\n lsr x21, x20, #0x2\n and x20, x20, #0x3\n cbz x21, label_14\nKAI_ASM_LABEL(label_13) // Store to output array: Accumulator row 1 loop\n KAI_ASM_INST(0xc0860454) // mova { z20.s-z23.s }, za2h.s[x12]\n KAI_ASM_INST(0xc086047c) // mova { z28.s-z31.s }, za3h.s[x12]\n KAI_ASM_INST(0xc1b8cb54) // fclamp { z20.s-z23.s }, z26.s, z24.s\n KAI_ASM_INST(0xc1b8cb5c) // fclamp { z28.s-z31.s }, z26.s, z24.s\n add x12, x12, #0x4\n cmp x12, x21, LSL #2\n KAI_ASM_INST(0xa1604354) // st1w { z20.s, z28.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604355) // st1w { z21.s, z29.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604356) // st1w { z22.s, z30.s }, p8, [x26]\n add x26, x26, x23\n KAI_ASM_INST(0xa1604357) // st1w { z23.s, z31.s }, p8, [x26]\n add x26, x26, x23\n blt label_13\nKAI_ASM_LABEL(label_14) // Store to output array: Accumulator row 1 oddments\n cbz x20, label_15\n KAI_ASM_INST(0xc0860444) // mova { z4.s-z7.s }, za2h.s[x12]\n KAI_ASM_INST(0xc086046c) // mova { z12.s-z15.s }, za3h.s[x12]\n subs x20, x20, #0x1\n KAI_ASM_INST(0xc1b8cb44) // fclamp { z4.s-z7.s }, z26.s, z24.s\n KAI_ASM_INST(0xc1b8cb4c) // fclamp { z12.s-z15.s }, z26.s, z24.s\n KAI_ASM_INST(0xa1604344) // st1w { z4.s, z12.s }, p8, [x26]\n add x26, x26, x23\n beq label_15\n subs x20, x20, #0x1\n KAI_ASM_INST(0xa1604345) // st1w { z5.s, z13.s }, p8, [x26]\n add x26, x26, x23\n beq label_15\n KAI_ASM_INST(0xa1604346) // st1w { z6.s, z14.s }, p8, [x26]\nKAI_ASM_LABEL(label_15) // Store to output array: Accumulator row 1 oddments: End\nKAI_ASM_LABEL(label_16) // Store to output array: End\n incw x11, ALL, MUL #2\n cmp x11, x10\n blt label_2\n incw x15, ALL, MUL #2\n mov x11, #0x0\n cmp x15, x13\n mov x9, x27\n blt label_1\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Pack the LHS matrix for use with indirect matrix multiplication\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_ptrs Pointer to an array of input pointers consisting of\n/// `roundup(m, m_step) * k_chunk_count` pointers. The pointers are\n/// grouped in blocks of `m_step` rows and `k_chunk_count` columns.\n/// Within each block, the pointers are stored in column-major order.\n/// @param[in] lhs_ptr_offset Offset to add to each pointer of the @ref lhs_ptrs\n/// array, excluding zero pointers.\n/// @param[in] pad_ptr Pointer to chunk used for padding. @ref lhs_ptr_offset is\n/// not applied to this pointer when used in @ref lhs_ptrs. This can\n/// be NULL if there is no padding used @ref lhs_ptrs\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n const void* pad_ptr, void* lhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n#include \"kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nenum {\n MR = 2,\n KR = 1,\n MAX_M_STEP = MR * (KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(float)) / KR,\n};\n\nvoid kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void) {\n return MR * kai_get_sme_vector_length_u32() / KR;\n}\n\nsize_t kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void) {\n return kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n KAI_ASSUME(m_idx % kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme() == 0);\n\n return m_idx * k_chunk_count * kai_roundup(k_chunk_length, KR) * sizeof(float);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m, size_t k_chunk_count, size_t k_chunk_length) {\n const size_t m_end = kai_roundup(m, kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme());\n return kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(m_end, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n const void* pad_ptr, void* lhs_packed) {\n KAI_ASSUME(lhs_ptrs != NULL);\n KAI_ASSUME(lhs_packed != NULL);\n\n const size_t m_step = kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n const size_t table_size = kai_roundup(m, m_step) * k_chunk_count;\n const size_t width = k_chunk_length;\n\n KAI_ASSERT(m_step <= MAX_M_STEP);\n const uint8_t* in[MAX_M_STEP];\n\n uint8_t* out_base = lhs_packed;\n\n kai_commit_za();\n\n for (size_t i_m = 0; i_m < m; i_m += m_step) {\n for (size_t i_k_chunk = 0; i_k_chunk < k_chunk_count; i_k_chunk += 1) {\n const size_t height = KAI_MIN(m - i_m, m_step);\n void* out = out_base;\n out_base += m_step * kai_roundup(k_chunk_length, KR) * sizeof(float);\n for (size_t y = 0; y < height; y += 1) {\n const size_t lhs_ptr_idx = i_m * k_chunk_count + i_k_chunk * m_step + y;\n KAI_ASSERT(lhs_ptr_idx < table_size);\n in[y] = lhs_ptrs[lhs_ptr_idx];\n if (in[y] != pad_ptr) {\n uintptr_t in_ptr = (uintptr_t)in[y] + lhs_ptr_offset;\n in[y] = (const uint8_t*)in_ptr; // NOLINT(performance-no-int-to-ptr)\n }\n }\n\n // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme(height, width, in, out);\n }\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x22, #0x0\n mov x21, x1\n cntw x16\n incw x21\n mov x20, x1\n sub x21, x21, #0x1\n sub x15, x16, #0x1\n udiv x21, x21, x16 // n_passes = ceildiv(width, VL)\n ands x15, x20, x15\n sub x20, x21, #0x1\n sub x14, x16, #0x2\n mov x11, #0x0\n mov x10, x2\n add x9, x2, x16, LSL #3\n cntw x28, ALL, MUL #2\n ldr x27, [x10, #0x0]\n cntw x26, ALL, MUL #3\n lsr x20, x20, #0x1 // n_loops = (n_passes - 1) / 2\n ldr x25, [x9, #0x0]\n and x24, x21, #0x1 // odd_tail = bool(n_passes & 0x1)\n csel x15, x15, x16, NE\n ldr x23, [x10, #0x8]\n ptrue p12.s\n whilelt p11.s, XZR, x0\n ldr x21, [x9, #0x8]\n whilelt p10.s, x16, x0\n mov x22, x22\n whilelt p9.s, x11, x1\n whilelt p8.s, x11, x1\n add x10, x10, #0x10\n add x9, x9, #0x10\n mov x12, #0x0\n cbz x14, label_2\nKAI_ASM_LABEL(label_1) // K loop: Charge: Loop\n KAI_ASM_INST(0x25306163) // psel p3.s, p8.s/Z, p11.s[w12]\n KAI_ASM_INST(0x25306142) // psel p2.s, p8.s/Z, p10.s[w12]\n KAI_ASM_INST(0x25706161) // psel p1.s, p8.s/Z, p11.s[w12, #1]\n KAI_ASM_INST(0x25706140) // psel p0.s, p8.s/Z, p10.s[w12, #1]\n KAI_ASM_INST(0xe0960f60) // ld1w { za0h.s[x12] }, p3/Z, [x27, x22, LSL #2]\n ldr x27, [x10, #0x0]\n KAI_ASM_INST(0xe0960b24) // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09606e1) // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe09602a5) // ld1w { za1h.s[x12, #1] }, p0/Z, [x21, x22, LSL #2]\n add x12, x12, #0x2\n ldr x21, [x9, #0x8]\n add x9, x9, #0x10\n cmp x12, x14\n blt label_1\nKAI_ASM_LABEL(label_2) // K loop: Charge: End\n KAI_ASM_INST(0x25306163) // psel p3.s, p8.s/Z, p11.s[w12]\n KAI_ASM_INST(0x25306142) // psel p2.s, p8.s/Z, p10.s[w12]\n KAI_ASM_INST(0x25706161) // psel p1.s, p8.s/Z, p11.s[w12, #1]\n KAI_ASM_INST(0x25706140) // psel p0.s, p8.s/Z, p10.s[w12, #1]\n mov x10, x2\n add x9, x2, x16, LSL #3\n KAI_ASM_INST(0xe0960f60) // ld1w { za0h.s[x12] }, p3/Z, [x27, x22, LSL #2]\n ldr x27, [x10, #0x0]\n incw x11\n KAI_ASM_INST(0xe0960b24) // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09606e1) // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe09602a5) // ld1w { za1h.s[x12, #1] }, p0/Z, [x21, x22, LSL #2]\n ldr x21, [x9, #0x8]\n add x9, x9, #0x10\n incw x22\n cbz x20, label_8\n mov x20, x20\nKAI_ASM_LABEL(label_3) // K loop: Main loop\n whilelt p8.s, x11, x1\n mov x13, #0x0\n cbz x14, label_5\nKAI_ASM_LABEL(label_4) // K loop: Main loop: First: Loop\n KAI_ASM_INST(0x25316160) // psel p0.s, p8.s/Z, p11.s[w13]\n KAI_ASM_INST(0x25316142) // psel p2.s, p8.s/Z, p10.s[w13]\n KAI_ASM_INST(0x25716161) // psel p1.s, p8.s/Z, p11.s[w13, #1]\n KAI_ASM_INST(0x25716143) // psel p3.s, p8.s/Z, p10.s[w13, #1]\n KAI_ASM_INST(0xe0962368) // ld1w { za2h.s[x13] }, p0/Z, [x27, x22, LSL #2]\n KAI_ASM_INST(0x25317120) // psel p0.s, p12.s/Z, p9.s[w13]\n ldr x27, [x10, #0x0]\n KAI_ASM_INST(0xe0962b2c) // ld1w { za3h.s[x13] }, p2/Z, [x25, x22, LSL #2]\n KAI_ASM_INST(0x25317122) // psel p2.s, p12.s/Z, p9.s[w13]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09626e9) // ld1w { za2h.s[x13, #1] }, p1/Z, [x23, x22, LSL #2]\n KAI_ASM_INST(0x25717121) // psel p1.s, p12.s/Z, p9.s[w13, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe0962ead) // ld1w { za3h.s[x13, #1] }, p3/Z, [x21, x22, LSL #2]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0xe0bfa060) // st1w { za0v.s[x13] }, p0/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0x25717120) // psel p0.s, p12.s/Z, p9.s[w13, #1]\n KAI_ASM_INST(0xe0b0a864) // st1w { za1v.s[x13] }, p2/Z, [x3, x16, LSL #2]\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0bca461) // st1w { za0v.s[x13, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0baa065) // st1w { za1v.s[x13, #1] }, p0/Z, [x3, x26, LSL #2]\n add x13, x13, #0x2\n addvl x3, x3, #4\n cmp x13, x14\n blt label_4\nKAI_ASM_LABEL(label_5) // K loop: Main loop: First: Tail\n KAI_ASM_INST(0x25316160) // psel p0.s, p8.s/Z, p11.s[w13]\n KAI_ASM_INST(0x25316142) // psel p2.s, p8.s/Z, p10.s[w13]\n KAI_ASM_INST(0x25716161) // psel p1.s, p8.s/Z, p11.s[w13, #1]\n KAI_ASM_INST(0x25716143) // psel p3.s, p8.s/Z, p10.s[w13, #1]\n mov x10, x2\n add x9, x2, x16, LSL #3\n KAI_ASM_INST(0xe0962368) // ld1w { za2h.s[x13] }, p0/Z, [x27, x22, LSL #2]\n KAI_ASM_INST(0x25317120) // psel p0.s, p12.s/Z, p9.s[w13]\n ldr x27, [x10, #0x0]\n mov x12, #0x0\n KAI_ASM_INST(0xe0962b2c) // ld1w { za3h.s[x13] }, p2/Z, [x25, x22, LSL #2]\n KAI_ASM_INST(0x25317122) // psel p2.s, p12.s/Z, p9.s[w13]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09626e9) // ld1w { za2h.s[x13, #1] }, p1/Z, [x23, x22, LSL #2]\n KAI_ASM_INST(0x25717121) // psel p1.s, p12.s/Z, p9.s[w13, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe0962ead) // ld1w { za3h.s[x13, #1] }, p3/Z, [x21, x22, LSL #2]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0xe0bfa060) // st1w { za0v.s[x13] }, p0/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0x25717120) // psel p0.s, p12.s/Z, p9.s[w13, #1]\n KAI_ASM_INST(0xe0b0a864) // st1w { za1v.s[x13] }, p2/Z, [x3, x16, LSL #2]\n whilelt p9.s, x11, x1\n incw x11\n KAI_ASM_INST(0xe0bca461) // st1w { za0v.s[x13, #1] }, p1/Z, [x3, x28, LSL #2]\n add x9, x9, #0x10\n incw x22\n KAI_ASM_INST(0xe0baa065) // st1w { za1v.s[x13, #1] }, p0/Z, [x3, x26, LSL #2]\n addvl x3, x3, #4\n whilelt p8.s, x11, x1\n cbz x14, label_7\nKAI_ASM_LABEL(label_6) // K loop: Main loop: Second: Loop\n KAI_ASM_INST(0x25306160) // psel p0.s, p8.s/Z, p11.s[w12]\n KAI_ASM_INST(0x25306142) // psel p2.s, p8.s/Z, p10.s[w12]\n KAI_ASM_INST(0x25706161) // psel p1.s, p8.s/Z, p11.s[w12, #1]\n KAI_ASM_INST(0x25706143) // psel p3.s, p8.s/Z, p10.s[w12, #1]\n KAI_ASM_INST(0xe0960360) // ld1w { za0h.s[x12] }, p0/Z, [x27, x22, LSL #2]\n KAI_ASM_INST(0x25307120) // psel p0.s, p12.s/Z, p9.s[w12]\n ldr x27, [x10, #0x0]\n KAI_ASM_INST(0xe0960b24) // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n KAI_ASM_INST(0x25307122) // psel p2.s, p12.s/Z, p9.s[w12]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09606e1) // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n KAI_ASM_INST(0x25707121) // psel p1.s, p12.s/Z, p9.s[w12, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe0960ea5) // ld1w { za1h.s[x12, #1] }, p3/Z, [x21, x22, LSL #2]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0xe0bf8068) // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0x25707120) // psel p0.s, p12.s/Z, p9.s[w12, #1]\n KAI_ASM_INST(0xe0b0886c) // st1w { za3v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0bc8469) // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0ba806d) // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x26, LSL #2]\n add x12, x12, #0x2\n addvl x3, x3, #4\n cmp x12, x14\n blt label_6\nKAI_ASM_LABEL(label_7) // K loop: Main loop: Second: Tail\n KAI_ASM_INST(0x25306160) // psel p0.s, p8.s/Z, p11.s[w12]\n KAI_ASM_INST(0x25306142) // psel p2.s, p8.s/Z, p10.s[w12]\n KAI_ASM_INST(0x25706161) // psel p1.s, p8.s/Z, p11.s[w12, #1]\n KAI_ASM_INST(0x25706143) // psel p3.s, p8.s/Z, p10.s[w12, #1]\n mov x10, x2\n add x9, x2, x16, LSL #3\n KAI_ASM_INST(0xe0960360) // ld1w { za0h.s[x12] }, p0/Z, [x27, x22, LSL #2]\n KAI_ASM_INST(0x25307120) // psel p0.s, p12.s/Z, p9.s[w12]\n ldr x27, [x10, #0x0]\n KAI_ASM_INST(0xe0960b24) // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n KAI_ASM_INST(0x25307122) // psel p2.s, p12.s/Z, p9.s[w12]\n ldr x25, [x9, #0x0]\n KAI_ASM_INST(0xe09606e1) // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n KAI_ASM_INST(0x25707121) // psel p1.s, p12.s/Z, p9.s[w12, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe0960ea5) // ld1w { za1h.s[x12, #1] }, p3/Z, [x21, x22, LSL #2]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0xe0bf8068) // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0x25707120) // psel p0.s, p12.s/Z, p9.s[w12, #1]\n KAI_ASM_INST(0xe0b0886c) // st1w { za3v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n whilelt p9.s, x11, x1\n subs x20, x20, #0x1\n KAI_ASM_INST(0xe0bc8469) // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n add x9, x9, #0x10\n incw x11\n KAI_ASM_INST(0xe0ba806d) // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x26, LSL #2]\n addvl x3, x3, #4\n incw x22\n bgt label_3\nKAI_ASM_LABEL(label_8) // K loop: Tails\n cbnz x24, label_11\n mov x10, x2\n whilelt p8.s, x11, x1\n mov x12, #0x0\nKAI_ASM_LABEL(label_9) // K loop: Tails: Even: First\n KAI_ASM_INST(0x25307123) // psel p3.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25307122) // psel p2.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25306161) // psel p1.s, p8.s/Z, p11.s[w12]\n KAI_ASM_INST(0x25306140) // psel p0.s, p8.s/Z, p10.s[w12]\n KAI_ASM_INST(0xe0bf8c60) // st1w { za0v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b08864) // st1w { za1v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n addvl x3, x3, #2\n ldr x21, [x10, #0x0]\n ldr x20, [x10, x16, LSL #0x3]\n add x10, x10, #0x8\n KAI_ASM_INST(0xe09606a8) // ld1w { za2h.s[x12] }, p1/Z, [x21, x22, LSL #2]\n KAI_ASM_INST(0xe096028c) // ld1w { za3h.s[x12] }, p0/Z, [x20, x22, LSL #2]\n add x12, x12, #0x1\n cmp x12, x16\n blt label_9\n whilelt p9.s, x11, x1\n whilelt p8.s, x11, x1\n mov x12, #0x0\nKAI_ASM_LABEL(label_10) // K loop: Tails: Even: Second\n KAI_ASM_INST(0x25307121) // psel p1.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25307120) // psel p0.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b0806c) // st1w { za3v.s[x12] }, p0/Z, [x3, x16, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #2\n cmp x12, x15\n blt label_10\n whilelt p8.s, x11, x1\n b label_13\nKAI_ASM_LABEL(label_11) // K loop: Tails: Odd\n mov x12, #0x0\nKAI_ASM_LABEL(label_12) // K loop: Tails: Odd: Loop\n KAI_ASM_INST(0x25307121) // psel p1.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25307120) // psel p0.s, p12.s/Z, p9.s[w12]\n KAI_ASM_INST(0xe0bf8460) // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b08064) // st1w { za1v.s[x12] }, p0/Z, [x3, x16, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #2\n cmp x12, x15\n blt label_12\nKAI_ASM_LABEL(label_13) // K loop: End\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(void);\n\n/// Gets the offset in bytes to the data element in the RHS matrix buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the bias buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx);\n\n/// Gets row stride in bytes of the packed RHS matrix.\n///\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return Row stride in bytes.\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed RHS buffer.\n///\n/// @param[in] n Number of columns.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The size in bytes of the packed RHS buffer.\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Runs the RHS packing function for matrix multiplication.\n///\n/// The pointer of each buffer (RHS, bias and packed RHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * RHS: @ref kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n/// * Bias: @ref kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n/// * Output: @ref kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n///\n/// @param[in] n Number of columns of the output matrix.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n/// @param[in] rhs_stride_row Row stride in bytes of the RHS matrix.\n/// @param[in] rhs RHS matrix data buffer.\n/// @param[in] bias Bias matrix data buffer.\n/// @param[out] rhs_packed Packed RHS matrix.\nvoid kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n void* rhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nenum {\n NR = 2,\n KR = 1,\n};\n\ntypedef struct {\n const void* bias_ptr;\n size_t width;\n size_t height;\n size_t k_chunk_count;\n size_t in_stride;\n size_t out_stride;\n const void* in;\n void* out;\n} KernelArgs;\n\nstatic const size_t kai_num_bytes_input = sizeof(uint32_t);\nstatic const size_t kai_num_bytes_output = sizeof(uint32_t);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\nvoid kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(const KernelArgs* args_ptr);\n\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(void) {\n return NR * kai_get_sme_vector_length_u32() / KR;\n}\n\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx) {\n KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() == 0);\n\n return n_idx * kai_num_bytes_input;\n}\n\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx) {\n return n_idx * kai_num_bytes_bias;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t k_chunk_count, size_t k_chunk_length) {\n return kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() *\n (kai_num_bytes_bias + k_chunk_count * kai_roundup(k_chunk_length, KR) * kai_num_bytes_output);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() == 0);\n\n const size_t block_idx = n_idx / kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme();\n return block_idx *\n kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n, size_t k_chunk_count, size_t k_chunk_length) {\n const size_t n_nr_blocks = kai_roundup(n, kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme());\n return kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n n_nr_blocks, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n void* rhs_packed) {\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(bias != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n\n KernelArgs args;\n args.bias_ptr = bias;\n args.height = k_chunk_length;\n args.width = n;\n args.in = rhs;\n args.out = rhs_packed;\n args.k_chunk_count = k_chunk_count;\n args.in_stride = rhs_stride_row;\n args.out_stride =\n kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(k_chunk_count, k_chunk_length);\n\n kai_commit_za();\n\n kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x14, [x0, #0x8]\n ptrue p2.b\n ldr x13, [x0, #0x38]\n ldr x24, [x0, #0x0]\n ldr x12, [x0, #0x10]\n mov x23, x14\n ldr x22, [x0, #0x18]\n mov x21, x13\n ldr x11, [x0, #0x20]\n ldr x10, [x0, #0x28]\n ldr x9, [x0, #0x30]\nKAI_ASM_LABEL(label_1) // Bias: Full loop\n mov x20, x23\n decw x23, ALL, MUL #2\n whilelt p1.s, XZR, x20\n decw x20\n whilelt p0.s, XZR, x20\n cmp x23, #0x0\n ld1w { z17.s }, p1/Z, [x24]\n ld1w { z16.s }, p0/Z, [x24, #1, MUL VL]\n incb x24, ALL, MUL #2\n st1w { z17.s }, p2, [x21]\n st1w { z16.s }, p2, [x21, #1, MUL VL]\n add x21, x21, x10\n bgt label_1\n incb x13, ALL, MUL #2\n mov x28, x22\nKAI_ASM_LABEL(label_2) // Chunk Loop\n mov x27, x12\n cmp x27, #0x4\n blt label_6\nKAI_ASM_LABEL(label_3) // Main row loop: Head\n mov x26, x9\n mov x25, x13\n add x24, x26, x11\n sub x27, x27, #0x4\n add x23, x24, x11\n mov x22, x14\n add x21, x23, x11\n add x9, x21, x11\nKAI_ASM_LABEL(label_4) // Main row loop: Column loop\n mov x20, x22\n decw x22, ALL, MUL #2\n whilelt p1.s, XZR, x20\n decw x20\n whilelt p0.s, XZR, x20\n cmp x22, #0x0\n ld1w { z23.s }, p1/Z, [x26]\n ld1w { z22.s }, p0/Z, [x26, #1, MUL VL]\n addvl x26, x26, #2\n ld1w { z21.s }, p1/Z, [x24]\n ld1w { z20.s }, p0/Z, [x24, #1, MUL VL]\n addvl x24, x24, #2\n ld1w { z19.s }, p1/Z, [x23]\n ld1w { z18.s }, p0/Z, [x23, #1, MUL VL]\n addvl x23, x23, #2\n ld1w { z17.s }, p1/Z, [x21]\n ld1w { z16.s }, p0/Z, [x21, #1, MUL VL]\n addvl x21, x21, #2\n st1w { z23.s }, p2, [x25]\n st1w { z22.s }, p2, [x25, #1, MUL VL]\n st1w { z21.s }, p2, [x25, #2, MUL VL]\n st1w { z20.s }, p2, [x25, #3, MUL VL]\n st1w { z19.s }, p2, [x25, #4, MUL VL]\n st1w { z18.s }, p2, [x25, #5, MUL VL]\n st1w { z17.s }, p2, [x25, #6, MUL VL]\n st1w { z16.s }, p2, [x25, #7, MUL VL]\n add x25, x25, x10\n bgt label_4\n cmp x27, #0x4\n addvl x13, x13, #8\n bge label_3\n cbz x27, label_10\nKAI_ASM_LABEL(label_6) // Main loop skip\nKAI_ASM_LABEL(label_7) // Tail row loop: Head\n mov x26, x9\n cntw x22, ALL, MUL #8\n add x9, x26, x11\n mov x25, x13\n sub x27, x27, #0x1\n mov x21, x14\nKAI_ASM_LABEL(label_8) // Tail row loop: Column loop\n mov x20, x21\n decw x21, ALL, MUL #2\n whilelt p1.s, XZR, x20\n decw x20\n whilelt p0.s, XZR, x20\n cmp x21, #0x0\n ld1w { z17.s }, p1/Z, [x26]\n ld1w { z16.s }, p0/Z, [x26, #1, MUL VL]\n add x26, x26, x22\n st1w { z17.s }, p2, [x25]\n st1w { z16.s }, p2, [x25, #1, MUL VL]\n add x25, x25, x10\n bgt label_8\n cmp x27, #0x1\n addvl x13, x13, #2\n bge label_7\nKAI_ASM_LABEL(label_10) // Done\n sub x28, x28, #0x1\n cbnz x28, label_2\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI's imatmul_clamp_f32_f32_f32p4vlx1b_6x4vl_sve_mla\n// (pure SVE indirect-GEMM conv2d, clamp-fused) against\n// conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64's raw ABI:\n// armbench_entry_conv2d(input*, output*, weight*, N, H, W)\n// computing a 'same' conv2d (Kh=Kw=3, stride=1, pad=1) in NHWC/HWIO layout.\n// The N images are folded into the GEMM M dimension (M = N*H*W): the indirection\n// table just points each output pixel at its own image, so one imatmul pass covers\n// the whole batch.\n//\n// weight arrives already in KleidiAI's expected \"kxn\" RHS layout \u2014 HWIO\n// [Kh,Kw,C_in,C_out] flattens exactly to [K=Kh*Kw*C_in, N=C_out] row-major,\n// so no transpose is needed here (unlike gemm_fp32_n512_k512's [N,K] B).\n// input feeds the indirection buffer directly \u2014 this kernel variant has an\n// UNPACKED f32 LHS (no separate LHS-pack step, unlike KleidiAI's own SME2\n// conv2d example, which packs both LHS and RHS).\n//\n// Two things the .h docs alone don't make clear, confirmed empirically\n// (crashed otherwise) and against KleidiAI's own test suite\n// (test/tests/imatmul_test.cpp + test/reference/reorder.cpp):\n// 1. This kernel does NOT process an arbitrary M span in one call \u2014 the\n// caller must loop, one call per m_step-sized (or smaller, for the\n// final remainder) chunk, each starting at a multiple of m_step.\n// 2. The indirection buffer is NOT a flat [m_idx][chunk_idx] array. It's\n// block-reordered by m_step: M is padded up to a multiple of m_step,\n// and within each m_step-row block the layout is chunk-major/row-minor\n// (all m_step rows for chunk 0, then all m_step rows for chunk 1, \u2026) \u2014\n// i.e. test/reference/reorder.cpp's reorder_block(flat,\n// M, k_chunk_count, m_step, 1). Each block is passed to its own\n// kai_run_imatmul_clamp_... call at the matching m_start offset.\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h\"\n#include \"kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h\"\n#include \"kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h\"\n\nnamespace {\nconstexpr int C_in = 32;\nconstexpr int C_out = 64;\nconstexpr int Kh = 3;\nconstexpr int Kw = 3;\nconstexpr int PAD = 1;\n\n// True if `data` (size bytes) differs from the cached snapshot, and updates\n// the snapshot to match when it does. Content-based, not pointer-based:\n// bench.cli evaluates many workloads against one compiled .so, and a later,\n// genuinely different workload's input buffer can land at the exact address\n// an earlier (now-freed) workload's buffer used -- a pointer-identity cache\n// would then wrongly treat different data as unchanged and reuse a stale\n// pack. See github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80. (Only\n// needed for buffers that bake in actual VALUES at cache-build time, like\n// the RHS weight pack below -- the indirection buffer further down stores\n// raw addresses, dereferenced fresh on every run call, so pointer+H/W\n// identity is sufficient for it; see its own comment.)\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale =\n snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_conv2d(const float* input, float* output, const float* weight, int N, int H, int W)\n{\n const size_t HW = (size_t)H * (size_t)W;\n const size_t M = (size_t)N * HW; // batch folded into the GEMM M dimension\n const size_t k_chunk_count = (size_t)(Kh * Kw);\n const size_t k_chunk_length = (size_t)C_in;\n const size_t m_step = kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n const size_t num_blocks = (M + m_step - 1) / m_step;\n\n // Zero-filled padding chunk: any indirection entry that would read\n // outside the (pad=1) input bounds points here instead. Pure function of\n // compile-time C_in -- build once ever, never invalidated.\n static float* pad_chunk = nullptr;\n if (pad_chunk == nullptr) {\n pad_chunk = static_cast(std::malloc(sizeof(float) * (size_t)C_in));\n if (pad_chunk == nullptr) return -1;\n std::memset(pad_chunk, 0, sizeof(float) * (size_t)C_in);\n }\n\n // Block-reordered indirection buffer \u2014 see this file's top comment.\n // num_blocks * m_step rows are allocated (M padded up to a multiple of\n // m_step); unused rows in the final block are left as pad_chunk\n // (never actually read, since each call passes the true m_this count).\n // Cached across calls that reuse the same input pointer AND N/H/W. Unlike\n // the RHS weight cache below, pointer identity is safe here (no\n // content-comparison needed): this buffer stores raw ADDRESSES\n // (input + offset), never input's VALUES, and the matmul run call\n // dereferences those addresses fresh on every timed call -- so reusing\n // a table built for the same (pointer, H, W) is byte-identical to\n // rebuilding it, regardless of what data currently lives at that\n // address (github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80).\n static const float* cached_input = nullptr;\n static int cached_N = -1, cached_H = -1, cached_W = -1;\n static const void** indirection = nullptr;\n if (input != cached_input || N != cached_N || H != cached_H || W != cached_W) {\n std::free(indirection);\n const size_t total_slots = num_blocks * m_step * k_chunk_count;\n indirection = static_cast(std::malloc(sizeof(void*) * total_slots));\n if (indirection == nullptr) { cached_input = nullptr; return -1; }\n for (size_t block = 0; block < num_blocks; ++block) {\n const size_t m_block_start = block * m_step;\n for (size_t chunk_idx = 0; chunk_idx < k_chunk_count; ++chunk_idx) {\n const int kh = (int)(chunk_idx / (size_t)Kw);\n const int kw = (int)(chunk_idx % (size_t)Kw);\n for (size_t row = 0; row < m_step; ++row) {\n const size_t dst_idx = block * m_step * k_chunk_count + chunk_idx * m_step + row;\n const size_t m_idx = m_block_start + row;\n if (m_idx >= M) {\n indirection[dst_idx] = pad_chunk;\n continue;\n }\n const size_t n_idx = m_idx / HW;\n const size_t hw_idx = m_idx % HW;\n const int oh = (int)(hw_idx / (size_t)W);\n const int ow = (int)(hw_idx % (size_t)W);\n const int ih = oh - PAD + kh;\n const int iw = ow - PAD + kw;\n if (ih >= 0 && ih < H && iw >= 0 && iw < W) {\n indirection[dst_idx] =\n input + ((n_idx * (size_t)H + (size_t)ih) * (size_t)W + (size_t)iw) * (size_t)C_in;\n } else {\n indirection[dst_idx] = pad_chunk;\n }\n }\n }\n }\n cached_input = input;\n cached_N = N;\n cached_H = H;\n cached_W = W;\n }\n\n // RHS (weight) is already [K=Kh*Kw*C_in, N=C_out] row-major (HWIO) \u2014\n // pack directly, no transpose. Bias required non-null by this packer\n // (same requirement as the plain rhs_pack_kxn used for gemm); zero =\n // no bias term in this definition (this is a fixed, compile-time-only\n // constant buffer, not user data, so it needs no cache key of its own).\n // Cached across calls whose weight content matches the last pack.\n static uint8_t* weight_snapshot = nullptr;\n static size_t weight_snapshot_size = 0;\n static void* rhs_packed = nullptr;\n const size_t weight_bytes = sizeof(float) * (size_t)C_out * k_chunk_count * k_chunk_length;\n if (refresh_cache(weight_snapshot, weight_snapshot_size, weight, weight_bytes)) {\n float* zero_bias = static_cast(std::malloc(sizeof(float) * (size_t)C_out));\n if (zero_bias == nullptr) return -1;\n std::memset(zero_bias, 0, sizeof(float) * (size_t)C_out);\n\n const size_t packed_size = kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n (size_t)C_out, k_chunk_count, k_chunk_length);\n std::free(rhs_packed);\n rhs_packed = std::malloc(packed_size);\n if (rhs_packed == nullptr) {\n std::free(zero_bias);\n return -1;\n }\n\n kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n (size_t)C_out, k_chunk_count, k_chunk_length,\n /*rhs_stride_row=*/(size_t)C_out * sizeof(float),\n /*rhs=*/weight, /*bias=*/zero_bias, /*rhs_packed=*/rhs_packed);\n\n std::free(zero_bias);\n }\n\n // LHS: the pack READS input's values through the indirection table, so it is redone on EVERY call\n // into a grow-only scratch buffer (activation-side work, like a real inference).\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size =\n kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme(M, k_chunk_count, k_chunk_length);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n M, k_chunk_count, k_chunk_length, indirection, /*lhs_ptr_offset=*/0, pad_chunk, lhs_packed);\n }\n\n // SME2 mopa takes the full M in one call (no per-m_step loop, unlike the SVE kernel).\n kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n M, (size_t)C_out, k_chunk_count, k_chunk_length, lhs_packed, rhs_packed, output,\n (size_t)C_out * sizeof(float),\n -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qai4c32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..ce1e4bcfd5992984fab07fdcc551f356378dec59 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qai4c32_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_f16_qai4c32_sme2_n256_k512", + "definition": "gemm_f16_qai4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_f16_qai4c32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\ntypedef struct {\n float* dst; // 0\n const void* lhs_packed; // 0x8\n const void* rhs_packed; // 0x10\n size_t dst_stride_row; // 0x18\n size_t lhs_packed_stride; // 0x20\n size_t rhs_packed_stride; // 0x28\n size_t bias; // 0x30\n size_t m; // 0x38\n size_t n; // 0x40\n size_t k; // 0x48\n size_t bl; // 0x50\n const int32_t* lut; // 0x58\n float min; // 0x60\n float max; // 0x64\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n// Compute args\nstatic const size_t kai_m_step = 1; // Multiple of vector length\nstatic const size_t kai_n_step = 4; // Multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // Multiple of vector length\nstatic const size_t kai_nr = 4; // Multiple of vector length\nstatic const size_t kai_kr = 8;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_sum_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_offset_rhs = 4;\n\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 2;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_bl = 32;\n\n// Look-up table used for int4->int8 convert\nstatic const int32_t lut[16] = {-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};\n\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs + kai_num_bytes_sum_lhs;\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs =\n (bl / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME(bl % kai_bl == 0);\n KAI_ASSUME((k % kai_bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n const size_t nr = kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr * (num_bytes_per_block * num_blocks_per_row);\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((m_idx % mr) == 0);\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, size_t k, size_t bl) {\n KAI_ASSUME((k % bl) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n const size_t m_step = kai_get_m_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t n_step = kai_get_n_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % m_step) == 0);\n KAI_ASSUME((n_idx % n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n void* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(uint16_t));\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t nr = kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.lhs_packed_stride = kai_get_lhs_packed_stride(k, bl);\n args.rhs_packed_stride = kai_get_rhs_packed_stride(k, bl);\n args.bias = args.rhs_packed_stride - nr * kai_num_bytes_bias;\n args.m = m;\n args.n = n;\n args.k = k;\n args.bl = bl;\n args.lut = lut;\n args.min = scalar_min;\n args.max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -128 ]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp x25, x26, [sp, 48]\n stp d8, d9, [sp, 64]\n stp d10, d11, [sp, 80]\n stp d12, d13, [sp, 96]\n stp d14, d15, [sp, 112]\n KAI_ASM_INST(0xd503477f) // smstart\n cntw x14\n ptrue p0.b, all\n KAI_ASM_INST(0x25a07810) // ptrue pn8.s\n cntw x5 // mr\n lsl x5, x5, #2\n whilelt p4.b, xzr, x5\n ldr x6, [x0, #0x58] // lut\n KAI_ASM_INST(0xe11f80c0) // ldr zt0, [x6]\n ldr x19, [x0, #0x10] // rhs_packed\n KAI_ASM_INST(0x8558c009) // ld1rw z9.s, p0/z, [x0, #0x60] // min\n KAI_ASM_INST(0x8559c00a) // ld1rw z10.s, p0/z, [x0, #0x64] //max\n fmov z11.h, #0.0\n ldr\tx4, [x0, #0x50] // bl\n ldr\tx21, [x0, #0x18] // stride\n ldr\tx20, [x0] // dst\n mov x8, #0\n ldr x13, [x0, #0x40] // n\n ldr x23, [x0, #0x48] // k\n KAI_ASM_INST(0x256d6511) //whilelt pn9.h, x8, x13, VLx4\n b.eq label_9 // b.none label_9\nKAI_ASM_LABEL(label_1) // N loop\n ldr\tx9, [x0, #0x38] // m\n ldr\tx22, [x0, #0x8] // lhs_packed\n mov x24, x20\nKAI_ASM_LABEL(label_2) // M Loop\n mov x26, x19\n mov x3, x22\n cmp x9, x14\n csel x15, x9, x14, lo\n lsl x15, x15, #2\n ldr\tx10, [x0, #0x48] // k\n cmp x10, #0\n b.eq label_8\nKAI_ASM_LABEL(label_3) // K Loop\n KAI_ASM_INST(0xc00800ff) // zero {za}\n mov x11, x4\nKAI_ASM_LABEL(label_4) // BL Loop\n KAI_ASM_INST(0xa0404342) //ld1w {z2.s - z3.s}, pn8/z, [x26]\n addvl x26, x26, #2\n ld1h {z8.h}, p0/z, [x3]\n addvl x3, x3, #1\n KAI_ASM_INST(0xc08a4044) // luti4 {z4.b - z5.b}, zt0, z2[0]\n KAI_ASM_INST(0xc08a4066) // luti4 {z6.b - z7.b}, zt0, z3[0]\n KAI_ASM_INST(0xa0840100) // smopa za0.s, p0/m, p0/m, z8.b, z4.b\n KAI_ASM_INST(0xa0850101) // smopa za1.s, p0/m, p0/m, z8.b, z5.b\n KAI_ASM_INST(0xa0860102) // smopa za2.s, p0/m, p0/m, z8.b, z6.b\n KAI_ASM_INST(0xa0870103) // smopa za3.s, p0/m, p0/m, z8.b, z7.b\n subs x11, x11, #4\n b.gt label_4\n mov w12, #0\n mov x25, x24\n ld1b {z17.b}, p4/z, [x3] // lhs sum\n ld1b {z16.b}, p4/z, [x3, #1, mul vl] // lhs scale\n addvl x3, x3, #2\n KAI_ASM_INST(0xa040c354) // ld1w { z20.s - z23.s }, pn8/z, [x26] // rhs zp\n KAI_ASM_INST(0xa041c340) // ld1w { z0.s - z3.s }, pn8/z, [x26, #4, mul vl ] // rhs scale\n addvl x26, x26, #8\n pfalse p3.b\nKAI_ASM_LABEL(label_5)\n pnext p3.s, p0, p3.s\n clastb z19.s, p3, z19.s, z16.s\n clastb z18.s, p3, z18.s, z17.s\n KAI_ASM_INST(0xc006041c) // mova {z28.b-z31.b}, za0h.b[w12, 0:3]\n add w12, w12, #4\n fmul z4.s, z0.s, z19.s\n fmul z5.s, z1.s, z19.s\n fmul z6.s, z2.s, z19.s\n fmul z7.s, z3.s, z19.s\n KAI_ASM_INST(0xc132e39c) // scvtf {z28.s-z31.s}, {z28.s-z31.s}\n cmp x10, x23\n b.ne label_6\n fmul z24.s, z20.s, z18.s\n fmul z25.s, z21.s, z18.s\n fmul z26.s, z22.s, z18.s\n fmul z27.s, z23.s, z18.s\n fmla z24.s, p0/m, z4.s, z28.s\n fmla z25.s, p0/m, z5.s, z29.s\n fmla z26.s, p0/m, z6.s, z30.s\n fmla z27.s, p0/m, z7.s, z31.s\n b label_7\nKAI_ASM_LABEL(label_6)\n KAI_ASM_INST(0xa040272c) // ld1h {z12.h - z13.h}, pn9/z, [x25]\n zip1 z24.h, z12.h, z11.h\n zip2 z25.h, z12.h, z11.h\n zip1 z26.h, z13.h, z11.h\n zip2 z27.h, z13.h, z11.h\n fcvt z24.s, p0/m, z24.h\n fcvt z25.s, p0/m, z25.h\n fcvt z26.s, p0/m, z26.h\n fcvt z27.s, p0/m, z27.h\n fmla z24.s, p0/m, z20.s, z18.s\n fmla z25.s, p0/m, z21.s, z18.s\n fmla z26.s, p0/m, z22.s, z18.s\n fmla z27.s, p0/m, z23.s, z18.s\n fmla z24.s, p0/m, z4.s, z28.s\n fmla z25.s, p0/m, z5.s, z29.s\n fmla z26.s, p0/m, z6.s, z30.s\n fmla z27.s, p0/m, z7.s, z31.s\nKAI_ASM_LABEL(label_7)\n KAI_ASM_INST(0xc120e31c) // fcvt z28.h, {z24.s- z25.s}\n KAI_ASM_INST(0xc120e35d) // fcvt z29.h, {z26.s- z27.s}\n KAI_ASM_INST(0xa060273c) // st1h { z28.h - z29.h }, pn9, [x25]\n add x25, x25, x21\n cmp x12, x15\n blt label_5\n subs x10, x10, x4\n b.gt label_3\nKAI_ASM_LABEL(label_8)\n ldr\tx5, [x0, #0x30]\n add x5, x5, x19\n KAI_ASM_INST(0xa040c0ac) // ld1w {z12.s - z15.s}, pn8/z, [x5] \\n \"\n mov x12, 0\nKAI_ASM_LABEL(label_10)\n KAI_ASM_INST(0xa0402700) // ld1h {z0.h - z1.h}, pn9/z, [x24]\n zip1 z24.h, z0.h, z11.h\n zip2 z25.h, z0.h, z11.h\n zip1 z26.h, z1.h, z11.h\n zip2 z27.h, z1.h, z11.h\n fcvt z24.s, p0/m, z24.h\n fcvt z25.s, p0/m, z25.h\n fcvt z26.s, p0/m, z26.h\n fcvt z27.s, p0/m, z27.h\n fadd z24.s, p0/m, z24.s, z12.s\n fadd z25.s, p0/m, z25.s, z13.s\n fadd z26.s, p0/m, z26.s, z14.s\n fadd z27.s, p0/m, z27.s, z15.s\n KAI_ASM_INST(0xc1aac938) // fclamp { z24.s - z27.s }, z9.s, z10.s\n KAI_ASM_INST(0xc120e31c) // fcvt z28.h, {z24.s- z25.s}\n KAI_ASM_INST(0xc120e35d) // fcvt z29.h, {z26.s- z27.s}\n KAI_ASM_INST(0xa060271c) // st1h { z28.h - z29.h }, pn9, [x24]\n add x24, x24, x21\n add x12, x12, #4\n cmp x12, x15\n blt label_10\n ldr\tx5, [x0, #0x20]\n add x22, x22, x5\n mov x24, x25\n decw x9, all\n cmp x9, #0\n b.gt label_2\n incb x20, all, mul #2\n ldr\tx5, [x0, #0x28]\n add x19, x19, x5\n incb x8, all\n KAI_ASM_INST(0x256d6511) // whilelt pn9.h, x8, x13, VLx4\n b.mi label_1 // b.first label_1\nKAI_ASM_LABEL(label_9)\n KAI_ASM_INST(0xd503467f) // smstop\n ldp d14, d15, [sp, 112]\n ldp d12, d13, [sp, 96]\n ldp d10, d11, [sp, 80]\n ldp d8, d9, [sp, 64]\n ldp x25, x26, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp],128\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_run_lhs_quant_pack_qsi8d32pscalef32_f16_neon to dynamically quantize and pack the LHS matrix in a single\n/// step.\n/// -# @ref kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon or @ref\n/// kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s0s1_f32_f32_f32_neon pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32)\n/// values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of m_step.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32)\n/// values.\n///\n/// @param[in] n_idx Col index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of m_step.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32) and packed\n/// RHS matrix: Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32) and packed.\n/// Output tile: (rows x cols) = 1 VL x 4 VL (Vector Length)\n///\n/// Instruction used: SME2 (MOPA)\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n void* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f16_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f16_neon(size_t mr);\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f16_neon(size_t m_idx, size_t lhs_stride);\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized symmetric per-block (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be\n/// a multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs,\n size_t lhs_stride, void* lhs_packed);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f16_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64 and FEAT_FP16.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f16_neon.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#define FLT16_MAX 65504.0F\n#define FLT16_MIN (-65504.0F)\nstatic const size_t kai_num_bytes_sum = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return bl * sizeof(int8_t) + kai_num_bytes_multiplier + kai_num_bytes_sum;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSERT((k % bl) == 0);\n return k / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t bl) {\n KAI_UNUSED(kr);\n\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block(bl);\n}\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f16_neon(size_t mr) {\n return mr;\n}\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f16_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_UNUSED(sr);\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, mr, kr, bl);\n}\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KAI_UNUSED(sr);\n\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return (num_rows * kai_get_lhs_packed_stride(k, mr, kr, bl));\n}\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f16_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs,\n size_t lhs_stride, void* lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n\n if (m == 0) {\n return;\n }\n const size_t lhs_packed_stride = kai_get_lhs_packed_stride(k, mr, kr, bl);\n const size_t num_rows = m;\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n const size_t mr_block_size = mr * num_bytes_per_block;\n\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n const float16_t* row_src_ptr = (const float16_t*)((const uint8_t*)lhs + (row_idx + m_idx_start) * lhs_stride);\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n for (size_t b = 0; b < num_blocks_per_row; ++b) {\n const float16_t* src_ptr = row_src_ptr + b * bl;\n int8_t* dst_ptr = (int8_t*)lhs_packed + dst_x * k_block_len * sizeof(int8_t) + b * mr_block_size;\n int8_t* param_ptr = (int8_t*)lhs_packed + b * mr_block_size + bl * mr + dst_x * kai_num_bytes_sum;\n // Find absmax for each block\n float16_t absmax = (float16_t)(-FLT16_MAX);\n int32_t k_idx = 0;\n float16x8_t vabsmax = vdupq_n_f16(-FLT16_MAX);\n for (; k_idx < ((int32_t)bl); k_idx += 8) {\n const float16x8_t src = vabsq_f16(vld1q_f16(src_ptr + (size_t)k_idx));\n vabsmax = vmaxq_f16(vabsmax, src);\n }\n // Get the absmax\n absmax = vmaxvq_f16(vabsmax);\n // Maximum/minimum int8 values\n const float qmax = (float)INT8_MAX;\n const float scale0 = absmax == 0.0F ? 0.0F : qmax / absmax;\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n int32_t qsum = 0;\n // Quantize the blocks\n for (k_idx = 0; k_idx < (int32_t)bl; k_idx += k_block_len) {\n for (size_t k_block_idx = 0; k_block_idx < (size_t)k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)k_idx + k_block_idx, k - 1);\n\n const float16_t src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n qsum += v0_s32;\n\n *(dst_ptr) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n *((float*)(param_ptr)) = ((float)qsum) * recip_scale0;\n param_ptr += mr * kai_num_bytes_sum;\n *((float*)(param_ptr)) = recip_scale0;\n }\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((int8_t*)lhs_packed + lhs_packed_stride);\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n#include \"kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_offset_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\nstatic const size_t kai_nr_multiple_of = 4;\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return (bl / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n return nr * (num_bytes_per_block * num_blocks_per_row + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % nr) == 0);\n KAI_UNUSED(kr);\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_UNUSED(kr);\n const size_t num_rows = kai_roundup(n, nr) / nr;\n return num_rows * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nvoid kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t bl, const uint8_t* rhs,\n const void* zero, const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qai4c32p_params* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n KAI_ASSUME((nr % kai_nr_multiple_of) == 0);\n KAI_ASSUME(extra_bytes == 0);\n\n KAI_ASSUME(sr == 2);\n KAI_ASSUME(kr / sr == 4);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(zero != NULL);\n KAI_ASSUME(scale != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(params != NULL);\n KAI_ASSUME(params->rhs_zero_point == 8);\n KAI_ASSUME(params->lhs_zero_point == 1);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t block_length = kr / sr;\n const size_t num_blocks_per_row = k / bl;\n const size_t rhs_stride = k / 2;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride(k, nr, kr, bl);\n\n const size_t dst_packed_block_size = kai_get_num_bytes_per_block(bl) * nr;\n const size_t dst_block_data_size = bl / 2;\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_bias_offset = num_blocks_per_row * dst_packed_block_size;\n const size_t k_block_length_in_bytes = (block_length * sizeof(uint8_t)) / 2;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n float* dst_row_bias = (float*)(dst_row + dst_bias_offset);\n size_t row_idx = dst_row_idx * nr;\n size_t rows_left = n - row_idx;\n for (size_t block_idx = 0; block_idx < num_blocks_per_row; block_idx++) {\n uint8_t* block_dst_row = dst_row + block_idx * dst_packed_block_size;\n float* block_dst_zp = (float*)(block_dst_row + nr * dst_block_data_size);\n float* block_dst_scale = block_dst_zp + nr;\n size_t k_idx = block_idx * bl;\n for (size_t dst_byte_idx = 0; dst_byte_idx < dst_block_data_size; dst_byte_idx += 8) {\n for (size_t nr_idx = 0; nr_idx <= nr - 4; nr_idx += 4) {\n const size_t n0_idx = KAI_MIN(dst_row_idx * nr + nr_idx, n - 1);\n const size_t n1_idx = KAI_MIN(n0_idx + 1, n - 1);\n const size_t n2_idx = KAI_MIN(n0_idx + 2, n - 1);\n const size_t n3_idx = KAI_MIN(n0_idx + 3, n - 1);\n const uint8_t* src_addr_byte = rhs + (k_idx / 2) + dst_byte_idx;\n\n const uint8x8_t vec0_u8 = vld1_u8(src_addr_byte + n0_idx * rhs_stride);\n const uint8x8_t vec1_u8 = vld1_u8(src_addr_byte + n1_idx * rhs_stride);\n const uint8x8_t vec2_u8 = vld1_u8(src_addr_byte + n2_idx * rhs_stride);\n const uint8x8_t vec3_u8 = vld1_u8(src_addr_byte + n3_idx * rhs_stride);\n\n const uint16x4_t vec0_u16 = vreinterpret_u16_u8(vec0_u8);\n const uint16x4_t vec1_u16 = vreinterpret_u16_u8(vec1_u8);\n const uint16x4_t vec2_u16 = vreinterpret_u16_u8(vec2_u8);\n const uint16x4_t vec3_u16 = vreinterpret_u16_u8(vec3_u8);\n\n const uint16x4_t vec01_lo_u16 = vzip1_u16(vec0_u16, vec1_u16);\n const uint16x4_t vec01_hi_u16 = vzip2_u16(vec0_u16, vec1_u16);\n const uint16x4_t vec23_lo_u16 = vzip1_u16(vec2_u16, vec3_u16);\n const uint16x4_t vec23_hi_u16 = vzip2_u16(vec2_u16, vec3_u16);\n\n const uint32x2_t vec01_lo_u32 = vreinterpret_u32_u16(vec01_lo_u16);\n const uint32x2_t vec01_hi_u32 = vreinterpret_u32_u16(vec01_hi_u16);\n const uint32x2_t vec23_lo_u32 = vreinterpret_u32_u16(vec23_lo_u16);\n const uint32x2_t vec23_hi_u32 = vreinterpret_u32_u16(vec23_hi_u16);\n\n const uint32x2_t vin0_u32 = vzip1_u32(vec01_lo_u32, vec23_lo_u32);\n const uint32x2_t vin1_u32 = vzip2_u32(vec01_lo_u32, vec23_lo_u32);\n const uint32x2_t vin2_u32 = vzip1_u32(vec01_hi_u32, vec23_hi_u32);\n const uint32x2_t vin3_u32 = vzip2_u32(vec01_hi_u32, vec23_hi_u32);\n\n const uint8x8_t vin0_u8 = vreinterpret_u8_u32(vin0_u32);\n const uint8x8_t vin1_u8 = vreinterpret_u8_u32(vin1_u32);\n const uint8x8_t vin2_u8 = vreinterpret_u8_u32(vin2_u32);\n const uint8x8_t vin3_u8 = vreinterpret_u8_u32(vin3_u32);\n\n uint8_t* dst_row_offset = block_dst_row + nr_idx * k_block_length_in_bytes;\n vst1_u8(dst_row_offset, vin0_u8);\n vst1_u8(dst_row_offset + nr * k_block_length_in_bytes, vin1_u8);\n vst1_u8(dst_row_offset + 2 * (nr * k_block_length_in_bytes), vin2_u8);\n vst1_u8(dst_row_offset + 3 * (nr * k_block_length_in_bytes), vin3_u8);\n }\n block_dst_row += nr * sizeof(uint8x8_t);\n }\n\n // Adjust the zero points and scales\n for (size_t i = 0; i < nr; ++i) {\n const size_t src_row_idx = KAI_MIN(row_idx + i, n - 1);\n const size_t src_idx = src_row_idx * num_blocks_per_row + block_idx;\n\n block_dst_scale[i] = ((const float*)scale)[src_idx];\n block_dst_zp[i] = ((const float*)zero)[src_idx];\n }\n }\n // Set the bias\n if (bias == NULL) {\n memset(dst_row_bias, 0, nr * kai_num_bytes_bias);\n } else {\n if (rows_left >= nr) {\n memcpy(dst_row_bias, &((const float*)bias)[row_idx], nr * kai_num_bytes_bias);\n } else {\n // Fill remaining values\n memcpy(dst_row_bias, &((const float*)bias)[row_idx], rows_left * kai_num_bytes_bias);\n // Set leftover to 0\n memset(&dst_row_bias[rows_left], 0, (nr - rows_left) * kai_num_bytes_bias);\n }\n }\n }\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qai4c32p_params\n#define kai_rhs_pack_nxk_qai4c32p_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 K values are stored in one byte. These values are stored in blocks\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, //\n size_t rhs_stride); //\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte.\n/// nrx4 => this function can take in generic nr values but the input is expected to have a block depth of 4\n/// Block depth is calculated as kr / sr. The values of these parameters are defined in the matmul ukernel.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] nr The number of N rows to interleave on the same output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] zero The zero point.\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n const void* zero, //\n const void* bias, //\n const void* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_nxk_qai4c32p_params* params);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa against gemm_f16_qai4c32_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f16_neon.h\"\n#include \"kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f16_neon((size_t)M, (size_t)K, BL, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qsi8d32pscalef32_f16_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, A, (size_t)K * sizeof(uint16_t), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* B_zeros_snap = nullptr;\n static size_t B_zeros_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N*(K/BL))\n | refresh_cache(B_zeros_snap, B_zeros_snap_size, B_zeros, sizeof(float)*N*(K/BL))\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon((size_t)N, (size_t)K, nr, kr, BL);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(1, (size_t)N, (size_t)K, nr, kr, sr, BL, B_q4, B_zeros, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n static uint16_t* tmp16 = nullptr;\n static size_t tmp16_cap = 0;\n if ((size_t)M * N > tmp16_cap) {\n std::free(tmp16);\n tmp16 = static_cast(std::malloc(sizeof(uint16_t) * (size_t)M * N));\n tmp16_cap = (size_t)M * N;\n if (tmp16 == nullptr) return -1;\n }\n kai_run_matmul_clamp_f16_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, tmp16, (size_t)N * sizeof(uint16_t), sizeof(uint16_t), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n // fp16 kernel result widened to the raw ABI's fp32 output (exact).\n widen_f16(tmp16, output, (size_t)M * N);\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs4cx_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs4cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..2dc7364998dd1c01ca91a2bfa57d6707ef04ac0a --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs4cx_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_f16_qs4cx_sme2_n256_k512", + "definition": "gemm_f16_qs4cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_f16_qs4cx_sme2_n256_k512: KleidiAI kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -96]!\n stp d8, d9, [sp, 16]\n stp d10, d11, [sp, 32]\n stp d12, d13, [sp, 48]\n stp d14, d15, [sp, 64]\n\n KAI_ASM_INST(0xd503477f) // smstart\n ldr x19, [x0, #0x00] // dst\n ldr x20, [x0, #0x08] // lhs_packed\n ldr x7, [x0, #0x50] // lut\n KAI_ASM_INST(0xe11f80e0) // ldr zt0, [x7]\n cntw x7\n ptrue p2.b\n KAI_ASM_INST(0x8556c81a) // ld1rw { z26.s }, p2/z, [x0, #0x58] // clamp_min\n KAI_ASM_INST(0x8557c81c) // ld1rw { z28.s }, p2/z, [x0, #0x5c] // clamp_max\n ldr x12, [x0, #0x20] // m\n mov z27.d, z26.d\n KAI_ASM_INST(0xc120e35e) // fcvt z30.h, {z26.s-z27.s}\n mov z29.d, z28.d\n KAI_ASM_INST(0xc120e39f) // fcvt z31.h, {z28.s-z29.s}\n\n KAI_ASM_INST(0x25ac17e0) // whilelt p0.s, xzr, x12\nKAI_ASM_LABEL(label_1)\n ldr x8, [x0, #0x10] // rhs_packed\n mov x9, x19\n ldr x13, [x0, #0x28] // n\n cmp x7, x12\n csel x16, x7, x12, lt\n lsl x16, x16, #2\n\n KAI_ASM_INST(0x256d47f0) // whilelt pn8.h, xzr, x13, vlx2\nKAI_ASM_LABEL(label_2)\n mov x10, x20\n mov x11, x8\n mov x17, x9\n KAI_ASM_INST(0x25ad67f1) // whilelt pn9.s, xzr, x13, vlx4\n KAI_ASM_INST(0x256d67f3) // whilelt pn11.h, xzr, x13, vlx4\n\n KAI_ASM_INST(0xc00800ff) // zero {za}\n ldr x14, [x0, #0x40] // m_blk\n add x14, x10, x14\nKAI_ASM_LABEL(label_3)\n KAI_ASM_INST(0xa540a144) // ld1w { z4.s }, p0/z, [x10]\n addvl x10, x10, #1\n KAI_ASM_INST(0xa0402160) // ld1h { z0.h-z1.h }, pn8/z, [x11]\n addvl x11, x11, #2\n KAI_ASM_INST(0xc08a4008) // luti4 { z8.b - z9.b }, zt0, z0[0]\n KAI_ASM_INST(0xc08a402a) // luti4 { z10.b - z11.b }, zt0, z1[0]\n KAI_ASM_INST(0xa0884880) // smopa za0.s, p2/m, p2/m, z4.b, z8.b\n KAI_ASM_INST(0xa0894881) // smopa za1.s, p2/m, p2/m, z4.b, z9.b\n KAI_ASM_INST(0xa08a4882) // smopa za2.s, p2/m, p2/m, z4.b, z10.b\n KAI_ASM_INST(0xa08b4883) // smopa za3.s, p2/m, p2/m, z4.b, z11.b\n cmp x10, x14\n b.lt label_3\n\n // Load RHS row sum, scale factors, and bias.\n KAI_ASM_INST(0xa040c560) // ld1w { z0.s-z3.s }, pn9/z, [x11]\n KAI_ASM_INST(0xa041c564) // ld1w { z4.s-z7.s }, pn9/z, [x11, #4, mul vl]\n KAI_ASM_INST(0xa042c568) // ld1w { z8.s-z11.s }, pn9/z, [x11, #8, mul vl]\n addvl x11, x11, #12\n\n mov x14, #0\n addvl x15, x10, #1\nKAI_ASM_LABEL(label_4)\n KAI_ASM_INST(0x8540c950) // ld1rw { z16.s }, p2/z, [x10]\n KAI_ASM_INST(0x8540c9f1) // ld1rw { z17.s }, p2/z, [x15]\n add x10, x10, #4\n add x15, x15, #4\n\n fmul z20.s, z17.s, z4.s\n fmul z21.s, z17.s, z5.s\n fmul z22.s, z17.s, z6.s\n fmul z23.s, z17.s, z7.s\n\n KAI_ASM_INST(0xc006440c) // mova { z12.b-z15.b }, za0h.b[w14, 0:3]\n\n mla z12.s, p2/m, z16.s, z0.s\n mla z13.s, p2/m, z16.s, z1.s\n mla z14.s, p2/m, z16.s, z2.s\n mla z15.s, p2/m, z16.s, z3.s\n\n KAI_ASM_INST(0xc132e18c) // scvtf { z12.s-z15.s }, { z12.s-z15.s }\n\n fmul z24.s, z12.s, z20.s\n fmul z25.s, z13.s, z21.s\n fmul z26.s, z14.s, z22.s\n fmul z27.s, z15.s, z23.s\n\n fadd z24.s, p2/m, z24.s, z8.s\n fadd z25.s, p2/m, z25.s, z9.s\n fadd z26.s, p2/m, z26.s, z10.s\n fadd z27.s, p2/m, z27.s, z11.s\n\n KAI_ASM_INST(0xc120e31c) // fcvt z28.h, { z24.s-z25.s }\n KAI_ASM_INST(0xc120e35d) // fcvt z29.h, { z26.s-z27.s }\n KAI_ASM_INST(0xc17fc3dc) // fclamp { z28.h-z29.h }, z30.h, z31.h\n KAI_ASM_INST(0xa0602e3c) // st1h { z28.h-z29.h }, pn11, [x17]\n\n ldr x5, [x0, #0x18] // dst_stride_row\n add x17, x17, x5\n add x14, x14, #4\n cmp x14, x16\n b.lt label_4\n\n ldr x14, [x0, #0x38] // rhs_stride\n add x8, x8, x14\n addvl x9, x9, #2\n decb x13, all\n KAI_ASM_INST(0x256d47f0) // whilelt pn8.h, xzr, x13, vlx2\n b.mi label_2\n\n ldr x14, [x0, #0x30] // lhs_stride\n add x20, x20, x14\n ldr x14, [x0, #0x48] // dst_inc\n add x19, x19, x14\n sub x12, x12, x7\n whilelt p0.s, xzr, x12\n b.mi label_1\n\n KAI_ASM_INST(0xd503467f) // smstop\n\n ldp d14, d15, [sp, 64]\n ldp d12, d13, [sp, 48]\n ldp d10, d11, [sp, 32]\n ldp d8, d9, [sp, 16]\n ldp x19, x20, [sp], 96\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural feature check\n\n#include \"kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 64\n\n/// Lut to be indexed by i4 resulting in its value in i8 (i.e. -2 = 1110 -> 1111 1110).\nstatic const int8_t lut[KAI_LUT_NENTRIES] = {\n // clang-format off\n 0, 0, 0, 0,\n 1, 0, 0, 0,\n 2, 0, 0, 0,\n 3, 0, 0, 0,\n 4, 0, 0, 0,\n 5, 0, 0, 0,\n 6, 0, 0, 0,\n 7, 0, 0, 0,\n -8, 0, 0, 0,\n -7, 0, 0, 0,\n -6, 0, 0, 0,\n -5, 0, 0, 0,\n -4, 0, 0, 0,\n -3, 0, 0, 0,\n -2, 0, 0, 0,\n -1, 0, 0, 0\n // clang-format on\n};\n\ntypedef struct {\n void* dst; // 0x00\n const void* lhs_packed; // 0x08\n const void* rhs_packed; // 0x10\n size_t dst_stride_row; // 0x18\n size_t m; // 0x20\n size_t n; // 0x28\n size_t lhs_stride; // 0x30\n size_t rhs_stride; // 0x38\n size_t m_blk; // 0x40\n size_t dst_inc; // 0x48\n const int8_t* lut; // 0x50\n float clamp_min; // 0x58\n float clamp_max; // 0x5c\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // multiple of vector length\nstatic const size_t kai_n_step = 4; // multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // multiple of vector length\nstatic const size_t kai_nr = 4; // multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args\nstatic const size_t kai_num_bytes_qvalue_lhs = sizeof(int8_t);\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\n// RHS format args\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias_rhs = sizeof(float);\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = sizeof(uint16_t);\n// Extra args\nstatic const size_t kai_k_multiple_of = 32;\n\nstatic size_t kai_k_roundedup(size_t k) {\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nstatic size_t kai_get_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n\n return kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa() *\n (k_internal * kai_num_bytes_qvalue_lhs + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\nstatic size_t kai_get_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n\n return kai_get_nr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa() *\n ((k_internal / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs +\n kai_num_bytes_bias_rhs);\n}\n\nsize_t kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSERT((m_idx % kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t n_idx, size_t k) {\n KAI_ASSERT((n_idx % kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSERT((m_idx % kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa()) == 0);\n KAI_ASSERT((n_idx % kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa()) == 0);\n\n return n_idx * kai_num_bytes_dst_value + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n void* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max) {\n KAI_ASSERT(dst_stride_col == sizeof(uint16_t));\n KAI_ASSERT(n > 0);\n KAI_ASSERT(m > 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n\n KernelArgs args;\n const size_t k_internal = kai_k_roundedup(k);\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.lhs_stride = kai_get_lhs_packed_stride(k);\n args.rhs_stride = kai_get_rhs_packed_stride(k);\n args.m_blk = mr * k_internal;\n args.dst_inc = mr * dst_stride_row;\n args.lut = lut;\n args.clamp_min = scalar_min;\n args.clamp_max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qai8dxp_f16_neon to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon to pack the RHS matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix.\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices.\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices.\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 4-bit quantized symmetric per-channel (qsi4cxp) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix.\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in each row of the DST matrix.\n///\n/// @return the destination (DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed.\n/// RHS matrix: Signed 4-bit quantized symmetric per-channel (qsi4cxp) and packed.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// @param[in] rhs_packed The RHS packed matrix.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(uint16_t).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, void* dst, size_t dst_stride_row,\n size_t dst_stride_col, float scalar_min, float scalar_max);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f16_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_FP16_SCALAR_ARITHMETIC) || \\\n !defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_FP16.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qai8dxp_f16_neon.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#define FLT16_MAX 65504.0\n#define FLT16_MIN (-65504.0F)\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f16_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f16_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSUME((kr / sr == 8) || (kr / sr == 4));\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n float16_t const* src_ptr = (float16_t const*)lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n const size_t lhs_row_length = lhs_stride / sizeof(float16_t);\n\n const float16x8_t vmax = vdupq_n_f16((float16_t)FLT16_MIN);\n const float16x8_t vmin = vdupq_n_f16((float16_t)FLT16_MAX);\n\n // As we load 8-element vectors, limit vectorized loop to avoid reading out-of-bounds\n const int32_t blocks_lim_k = num_blocks_k - (8 / k_block_len);\n\n size_t row_idx = 0;\n\n // Improved performance with 4x loop unrolling where packing parameters allow\n if (mr == 4) {\n for (; row_idx + 3 < m; row_idx += 4) {\n // Find min/max for each channel\n int32_t k_idx = 0;\n float16x8_t vmax0 = vmax;\n float16x8_t vmin0 = vmin;\n float16x8_t vmax1 = vmax;\n float16x8_t vmin1 = vmin;\n float16x8_t vmax2 = vmax;\n float16x8_t vmin2 = vmin;\n float16x8_t vmax3 = vmax;\n float16x8_t vmin3 = vmin;\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float16x8_t src0 = vld1q_f16(src_ptr + k_idx);\n const float16x8_t src1 = vld1q_f16(src_ptr + k_idx + lhs_row_length);\n const float16x8_t src2 = vld1q_f16(src_ptr + k_idx + (2 * lhs_row_length));\n const float16x8_t src3 = vld1q_f16(src_ptr + k_idx + (3 * lhs_row_length));\n\n vmax0 = vmaxq_f16(src0, vmax0);\n vmax1 = vmaxq_f16(src1, vmax1);\n vmax2 = vmaxq_f16(src2, vmax2);\n vmax3 = vmaxq_f16(src3, vmax3);\n vmin0 = vminq_f16(src0, vmin0);\n vmin1 = vminq_f16(src1, vmin1);\n vmin2 = vminq_f16(src2, vmin2);\n vmin3 = vminq_f16(src3, vmin3);\n }\n\n float16_t max0 = vmaxvq_f16(vmax0);\n float16_t min0 = vminvq_f16(vmin0);\n float16_t max1 = vmaxvq_f16(vmax1);\n float16_t min1 = vminvq_f16(vmin1);\n float16_t max2 = vmaxvq_f16(vmax2);\n float16_t min2 = vminvq_f16(vmin2);\n float16_t max3 = vmaxvq_f16(vmax3);\n float16_t min3 = vminvq_f16(vmin3);\n // Process leftover elements with a scalar loop.\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float16_t src0 = *(src_ptr + (size_t)k_idx);\n max0 = vmaxh_f16(src0, max0);\n min0 = vminh_f16(src0, min0);\n const float16_t src1 = *(src_ptr + (size_t)k_idx + lhs_row_length);\n max1 = vmaxh_f16(src1, max1);\n min1 = vminh_f16(src1, min1);\n const float16_t src2 = *(src_ptr + (size_t)k_idx + (2 * lhs_row_length));\n max2 = vmaxh_f16(src2, max2);\n min2 = vminh_f16(src2, min2);\n const float16_t src3 = *(src_ptr + (size_t)k_idx + (3 * lhs_row_length));\n max3 = vmaxh_f16(src3, max3);\n min3 = vminh_f16(src3, min3);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n const float rmin1 = fminf(0.0F, min1);\n const float rmax1 = fmaxf(0.0F, max1);\n const float scale1 = rmin1 == rmax1 ? 1.F : (qmax - qmin) / (rmax1 - rmin1);\n const float rmin2 = fminf(0.0F, min2);\n const float rmax2 = fmaxf(0.0F, max2);\n const float scale2 = rmin2 == rmax2 ? 1.F : (qmax - qmin) / (rmax2 - rmin2);\n const float rmin3 = fminf(0.0F, min3);\n const float rmax3 = fmaxf(0.0F, max3);\n const float scale3 = rmin3 == rmax3 ? 1.F : (qmax - qmin) / (rmax3 - rmin3);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n const float recip_scale1 = scale1 ? 1.0F / scale1 : 0.0F;\n const float recip_scale2 = scale2 ? 1.0F / scale2 : 0.0F;\n const float recip_scale3 = scale3 ? 1.0F / scale3 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n const float descaled_min1 = rmin1 * scale1;\n const float descaled_max1 = rmax1 * scale1;\n const float descaled_min2 = rmin2 * scale2;\n const float descaled_max2 = rmax2 * scale2;\n const float descaled_min3 = rmin3 * scale3;\n const float descaled_max3 = rmax3 * scale3;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n const float zero_point_from_min_error1 = qmin + descaled_min1;\n const float zero_point_from_max_error1 = qmax + descaled_max1;\n const float zero_point_from_min_error2 = qmin + descaled_min2;\n const float zero_point_from_max_error2 = qmax + descaled_max2;\n const float zero_point_from_min_error3 = qmin + descaled_min3;\n const float zero_point_from_max_error3 = qmax + descaled_max3;\n\n float zero_point0 = (zero_point_from_min_error0 + zero_point_from_max_error0 > 0) ? qmin - descaled_min0\n : qmax - descaled_max0;\n float zero_point1 = (zero_point_from_min_error1 + zero_point_from_max_error1 > 0) ? qmin - descaled_min1\n : qmax - descaled_max1;\n float zero_point2 = (zero_point_from_min_error2 + zero_point_from_max_error2 > 0) ? qmin - descaled_min2\n : qmax - descaled_max2;\n float zero_point3 = (zero_point_from_min_error3 + zero_point_from_max_error3 > 0) ? qmin - descaled_min3\n : qmax - descaled_max3;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n zero_point1 = fmaxf(zero_point1, qmin);\n zero_point1 = fminf(zero_point1, qmax);\n zero_point2 = fmaxf(zero_point2, qmin);\n zero_point2 = fminf(zero_point2, qmax);\n zero_point3 = fmaxf(zero_point3, qmin);\n zero_point3 = fminf(zero_point3, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n const int32_t nudged_zero_point1 = (int32_t)rintf(zero_point1);\n const int32_t nudged_zero_point2 = (int32_t)rintf(zero_point2);\n const int32_t nudged_zero_point3 = (int32_t)rintf(zero_point3);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len);\n\n // Quantize the channels\n int32_t block_idx = 0;\n const int32_t block_incr = 8 / k_block_len;\n\n for (; block_idx <= blocks_lim_k; block_idx += block_incr) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x8_t src0 = vld1q_f16(src_ptr + k_idx_start);\n const float16x8_t src1 = vld1q_f16(src_ptr + k_idx_start + lhs_row_length);\n const float16x8_t src2 = vld1q_f16(src_ptr + k_idx_start + (2 * lhs_row_length));\n const float16x8_t src3 = vld1q_f16(src_ptr + k_idx_start + (3 * lhs_row_length));\n\n // Scale the values.\n const int32x4_t v0_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src0)), scale0));\n const int32x4_t v0_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src0), scale0));\n const int32x4_t v1_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src1)), scale1));\n const int32x4_t v1_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src1), scale1));\n const int32x4_t v2_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src2)), scale2));\n const int32x4_t v2_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src2), scale2));\n const int32x4_t v3_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src3)), scale3));\n const int32x4_t v3_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src3), scale3));\n\n const int16x4_t v0_0_s16 = vqmovn_s32(v0_0_s32);\n const int16x4_t v0_1_s16 = vqmovn_s32(v0_1_s32);\n const int16x4_t v1_0_s16 = vqmovn_s32(v1_0_s32);\n const int16x4_t v1_1_s16 = vqmovn_s32(v1_1_s32);\n const int16x4_t v2_0_s16 = vqmovn_s32(v2_0_s32);\n const int16x4_t v2_1_s16 = vqmovn_s32(v2_1_s32);\n const int16x4_t v3_0_s16 = vqmovn_s32(v3_0_s32);\n const int16x4_t v3_1_s16 = vqmovn_s32(v3_1_s32);\n\n int16x8_t v0_s16;\n int16x8_t v1_s16;\n int16x8_t v2_s16;\n int16x8_t v3_s16;\n if (k_block_len == 8) {\n v0_s16 = vcombine_s16(v0_0_s16, v0_1_s16);\n v1_s16 = vcombine_s16(v1_0_s16, v1_1_s16);\n v2_s16 = vcombine_s16(v2_0_s16, v2_1_s16);\n v3_s16 = vcombine_s16(v3_0_s16, v3_1_s16);\n } else { // k_block_len == 4\n v0_s16 = vcombine_s16(v0_0_s16, v1_0_s16);\n v1_s16 = vcombine_s16(v2_0_s16, v3_0_s16);\n v2_s16 = vcombine_s16(v0_1_s16, v1_1_s16);\n v3_s16 = vcombine_s16(v2_1_s16, v3_1_s16);\n }\n\n // Add zero points.\n const int16x8_t vnzp0 = vdupq_n_s16((int16_t)nudged_zero_point0);\n const int16x8_t vnzp1 = vdupq_n_s16((int16_t)nudged_zero_point1);\n const int16x8_t vnzp2 = vdupq_n_s16((int16_t)nudged_zero_point2);\n const int16x8_t vnzp3 = vdupq_n_s16((int16_t)nudged_zero_point3);\n\n v0_s16 = vaddq_s16(v0_s16, vnzp0);\n v0_s16 = vmaxq_s16(v0_s16, vdupq_n_s16(INT8_MIN));\n v0_s16 = vminq_s16(v0_s16, vdupq_n_s16(INT8_MAX));\n v1_s16 = vaddq_s16(v1_s16, vnzp1);\n v1_s16 = vmaxq_s16(v1_s16, vdupq_n_s16(INT8_MIN));\n v1_s16 = vminq_s16(v1_s16, vdupq_n_s16(INT8_MAX));\n v2_s16 = vaddq_s16(v2_s16, vnzp2);\n v2_s16 = vmaxq_s16(v2_s16, vdupq_n_s16(INT8_MIN));\n v2_s16 = vminq_s16(v2_s16, vdupq_n_s16(INT8_MAX));\n v3_s16 = vaddq_s16(v3_s16, vnzp3);\n v3_s16 = vmaxq_s16(v3_s16, vdupq_n_s16(INT8_MIN));\n v3_s16 = vminq_s16(v3_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v0_s16);\n int8x8_t v1_s8 = vqmovn_s16(v1_s16);\n int8x8_t v2_s8 = vqmovn_s16(v2_s16);\n int8x8_t v3_s8 = vqmovn_s16(v3_s16);\n\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n vst1_s8((int8_t*)(dst_ptr + sizeof(int8x8_t)), v1_s8);\n vst1_s8((int8_t*)(dst_ptr + 2 * sizeof(int8x8_t)), v2_s8);\n vst1_s8((int8_t*)(dst_ptr + 3 * sizeof(int8x8_t)), v3_s8);\n dst_ptr += block_incr * mr * k_block_len * sizeof(int8_t);\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index.\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0 = (float)(*(src_ptr + k_idx_start));\n const float src1 = (float)(*(src_ptr + k_idx_start + lhs_row_length));\n const float src2 = (float)(*(src_ptr + k_idx_start + (2 * lhs_row_length)));\n const float src3 = (float)(*(src_ptr + k_idx_start + (3 * lhs_row_length)));\n\n // Scale the value.\n int32_t d0_s32 = (int32_t)(roundf(src0 * scale0));\n int32_t d1_s32 = (int32_t)(roundf(src1 * scale1));\n int32_t d2_s32 = (int32_t)(roundf(src2 * scale2));\n int32_t d3_s32 = (int32_t)(roundf(src3 * scale3));\n\n d0_s32 = d0_s32 + nudged_zero_point0;\n d0_s32 = KAI_MAX(d0_s32, INT8_MIN);\n d0_s32 = KAI_MIN(d0_s32, INT8_MAX);\n\n d1_s32 = d1_s32 + nudged_zero_point1;\n d1_s32 = KAI_MAX(d1_s32, INT8_MIN);\n d1_s32 = KAI_MIN(d1_s32, INT8_MAX);\n\n d2_s32 = d2_s32 + nudged_zero_point2;\n d2_s32 = KAI_MAX(d2_s32, INT8_MIN);\n d2_s32 = KAI_MIN(d2_s32, INT8_MAX);\n\n d3_s32 = d3_s32 + nudged_zero_point3;\n d3_s32 = KAI_MAX(d3_s32, INT8_MIN);\n d3_s32 = KAI_MIN(d3_s32, INT8_MAX);\n\n *(int8_t*)dst_ptr = (int8_t)d0_s32;\n *(int8_t*)(dst_ptr + k_block_len * sizeof(int8_t)) = (int8_t)d1_s32;\n *(int8_t*)(dst_ptr + 2 * (k_block_len * sizeof(int8_t))) = (int8_t)d2_s32;\n *(int8_t*)(dst_ptr + 3 * (k_block_len * sizeof(int8_t))) = (int8_t)d3_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n uint8_t* dst_base = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr = dst_base + dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row.\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n *((int32_t*)(dst_ptr + kai_num_bytes_per_offset)) = -nudged_zero_point1;\n *((int32_t*)(dst_ptr + 2 * kai_num_bytes_per_offset)) = -nudged_zero_point2;\n *((int32_t*)(dst_ptr + 3 * kai_num_bytes_per_offset)) = -nudged_zero_point3;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier.\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params.\n *((float*)(dst_ptr)) = recip_scale0;\n *((float*)(dst_ptr + kai_num_bytes_per_multiplier)) = recip_scale1;\n *((float*)(dst_ptr + 2 * kai_num_bytes_per_multiplier)) = recip_scale2;\n *((float*)(dst_ptr + 3 * kai_num_bytes_per_multiplier)) = recip_scale3;\n\n // Update src_ptr. Note: now lhs contains fp16 values (2 bytes each).\n src_ptr += (4 * lhs_row_length);\n\n // Move to the next row as we have interleaved all Mr rows.\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n\n for (; row_idx < num_rows; ++row_idx) {\n // Find min/max for each channel\n int32_t k_idx = 0;\n float16x8_t vmax0 = vmax;\n float16x8_t vmin0 = vmin;\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float16x8_t src0_0 = vld1q_f16(src_ptr + (size_t)k_idx);\n vmax0 = vmaxq_f16(vmax0, src0_0);\n vmin0 = vminq_f16(vmin0, src0_0);\n }\n // Get the max/min\n float16_t max0 = vmaxvq_f16(vmax0);\n float16_t min0 = vminvq_f16(vmin0);\n\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float16_t src0 = *(src_ptr + (size_t)k_idx);\n max0 = vmaxh_f16(src0, max0);\n min0 = vminh_f16(src0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n if (k_block_len == 8) {\n for (; block_idx < blocks_lim_k; ++block_idx) {\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x8_t src_0 = vld1q_f16(src_ptr + k_idx_start);\n\n // Scale the values\n const float32x4_t v0_f32 = vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src_0)), scale0);\n const float32x4_t v1_f32 = vmulq_n_f32(vcvt_high_f32_f16(src_0), scale0);\n const int32x4_t v0_s32 = vcvtnq_s32_f32(v0_f32);\n const int32x4_t v1_s32 = vcvtnq_s32_f32(v1_f32);\n\n const int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n const int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v_s8);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < blocks_lim_k; ++block_idx) {\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x4_t src_0 = vld1_f16(src_ptr + k_idx_start);\n\n // Scale the values\n const float32x4_t v0_f32 = vmulq_n_f32(vcvt_f32_f16(src_0), scale0);\n const int32x4_t v0_s32 = vcvtnq_s32_f32(v0_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n v0_s16 = vadd_s16(v0_s16, vnzp_s16);\n v0_s16 = vmax_s16(v0_s16, vdup_n_s16(INT8_MIN));\n v0_s16 = vmin_s16(v0_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v_s8 = vqmovn_s16(vcombine_s16(v0_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0 = (float)(*(src_ptr + k_idx_start));\n\n // Scale the values\n int32_t d0_s32 = (int32_t)(roundf(src0 * scale0));\n\n d0_s32 = d0_s32 + nudged_zero_point0;\n d0_s32 = KAI_MAX(d0_s32, INT8_MIN);\n d0_s32 = KAI_MIN(d0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)d0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += lhs_row_length;\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f16_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f16_neon(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f16_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n // multiple of 2 because 2 elements in a byte\n KAI_ASSERT((k_internal % 2) == 0);\n\n return nr * ((k_internal / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon_params* params) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % kr) == 0);\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n KAI_ASSERT(params->lhs_zero_point == 1);\n KAI_ASSERT(params->rhs_zero_point == 0 || params->rhs_zero_point == 8);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const int32_t rhs_zero_point = params->rhs_zero_point;\n const size_t rhs_stride = kai_roundup(k, 2) / 2;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(k, nr, kr, sr);\n const size_t dst_nr_block_size = nr * kr * sizeof(uint8_t) / 2;\n\n // Iterate over n src rows in blocks of nr rows\n for (size_t row_idx = 0; row_idx < n; row_idx += nr) {\n int8_t* const dst_row = (int8_t*)rhs_packed + ((row_idx / nr) * rhs_packed_stride);\n\n int32_t* const sums = (int32_t*)(dst_row + (nr * (k_internal / 2)));\n float* const scaling_factors = (float*)((uint8_t*)sums + (nr * kai_num_bytes_sum_rhs));\n // Update destination row pointer\n float* const biases = (float*)((uint8_t*)scaling_factors + (nr * kai_num_bytes_multiplier_rhs));\n\n // initialize sums to 0\n memset(sums, 0, nr * kai_num_bytes_sum_rhs);\n\n // Copy the scaling factors and bias\n size_t rows_left = n - row_idx;\n // Saving scales.\n if (rows_left >= nr) {\n memcpy(scaling_factors, &scale[row_idx], nr * kai_num_bytes_multiplier_rhs);\n } else {\n // Fill remaining values\n memcpy(scaling_factors, &scale[row_idx], rows_left * kai_num_bytes_multiplier_rhs);\n // Set leftover to 0\n memset(&scaling_factors[rows_left], 0, (nr - rows_left) * kai_num_bytes_multiplier_rhs);\n }\n if (bias == NULL) {\n // Set bias to 0\n memset(biases, 0, nr * kai_num_bytes_bias);\n } else {\n if (rows_left >= nr) {\n memcpy(biases, &bias[row_idx], nr * kai_num_bytes_bias);\n } else {\n // Fill remaining values\n memcpy(biases, &bias[row_idx], rows_left * kai_num_bytes_bias);\n // Set leftover to 0\n memset(&biases[rows_left], 0, (nr - rows_left) * kai_num_bytes_bias);\n }\n }\n // Iterate over rows in the nr row block\n for (size_t nr_block_idx = 0; nr_block_idx < nr; ++nr_block_idx) {\n const uint8_t* const src_row = rhs + ((row_idx + nr_block_idx) * rhs_stride);\n // Go to the first kr block for this row in the nr block\n int8_t* dst_kr_block = dst_row + (nr_block_idx * kr / 2);\n\n int32_t sum = 0;\n\n // Iterate over k src columns in blocks of kr columns\n if (rhs_zero_point == 8) {\n for (size_t col_idx = 0; col_idx < k_internal; col_idx += kr) {\n // Iterate over columns in the kr block\n // Kr checked to be multiple of 2 (because 2 values per byte)\n for (size_t kr_block_idx = 0; kr_block_idx < kr; kr_block_idx += 2) {\n // We pad dst with 0s if the rounded k or n values have been exceeded\n if (row_idx + nr_block_idx >= n || col_idx + kr_block_idx >= k) {\n dst_kr_block[kr_block_idx / 2] = 0;\n continue;\n }\n\n // Load the 2 u4 values from source\n const uint8_t dst_byte = src_row[(col_idx + kr_block_idx) / 2];\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n // extract i8 values from the 2 u4 values\n const int8_t first_value = (dst_byte & 0xF) - rhs_zero_point;\n const int8_t second_value =\n col_idx + kr_block_idx + 1 >= k ? 0 : (dst_byte >> 4) - rhs_zero_point;\n\n // Add the i4 value to the row sum\n sum += (int32_t)first_value + (int32_t)second_value;\n\n // Truncate i8 to i4 and write to dst\n const uint8_t hi = second_value & 0x0F;\n const uint8_t lo = first_value & 0x0F;\n dst_kr_block[kr_block_idx / 2] = (hi << 4) | lo;\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n }\n\n // Go to the next kr block for this row in the nr rows\n dst_kr_block += dst_nr_block_size;\n }\n } else {\n for (size_t col_idx = 0; col_idx < k_internal; col_idx += kr) {\n // Iterate over columns in the kr block\n // Kr checked to be multiple of 2 (because 2 values per byte)\n for (size_t kr_block_idx = 0; kr_block_idx < kr; kr_block_idx += 2) {\n // We pad dst with 0s if the rounded k or n values have been\n // exceeded\n if (row_idx + nr_block_idx >= n || col_idx + kr_block_idx >= k) {\n dst_kr_block[kr_block_idx / 2] = 0;\n continue;\n }\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n // Load the 2 u4 values from source\n const int8_t dst_byte = src_row[(col_idx + kr_block_idx) / 2];\n\n // extract i8 values from the 2 u4 values, shift first value\n // back and forth to get the sign right.\n const int8_t first_value = kai_ext_sign_i8_i4(dst_byte & 0xF);\n const int8_t second_value =\n col_idx + kr_block_idx + 1 >= k ? 0 : kai_ext_sign_i8_i4((dst_byte >> 4) & 0xF);\n\n // Add the i4 value to the row sum\n sum += (int32_t)first_value + (int32_t)second_value;\n\n // Truncate i8 to i4 and write to dst\n const uint8_t hi = second_value & 0x0F;\n const uint8_t lo = first_value & 0x0F;\n dst_kr_block[kr_block_idx / 2] = (hi << 4) | lo;\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n }\n\n // Go to the next kr block for this row in the nr rows\n dst_kr_block += dst_nr_block_size;\n }\n }\n\n // save sum\n sums[nr_block_idx] = sum;\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon_params\n#define kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Get the n step value.\n///\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed)\n///\n/// @note The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte. The lower order part of the byte (low) holds\n/// the first nibble (K-index + 0). The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 4-bit quantized symmetric per-channel (qsi4cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte. The lower order part of the byte (low) holds\n/// the first nibble (K-index + 0). The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be an even value.\n/// @param[in] nr The number of N columns to interleave on the same output output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] bias The biases. The bias is set to 0.f if this argument is NULL.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa against gemm_f16_qs4cx_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f16_neon.h\"\n#include \"kai_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon((size_t)M, (size_t)K, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qai8dxp_f16_neon((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(uint16_t), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qsi4cxps1s0_qsu4cxs1s0_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q4, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n static uint16_t* tmp16 = nullptr;\n static size_t tmp16_cap = 0;\n if ((size_t)M * N > tmp16_cap) {\n std::free(tmp16);\n tmp16 = static_cast(std::malloc(sizeof(uint16_t) * (size_t)M * N));\n tmp16_cap = (size_t)M * N;\n if (tmp16 == nullptr) return -1;\n }\n kai_run_matmul_clamp_f16_qai8dxp1vlx8_qsi4cxp4vlx8_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, tmp16, (size_t)N * sizeof(uint16_t), sizeof(uint16_t), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n // fp16 kernel result widened to the raw ABI's fp32 output (exact).\n widen_f16(tmp16, output, (size_t)M * N);\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs8cx_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..65e72a60a774ce7e8fb3517aee03ff2216df8840 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_qs8cx_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_f16_qs8cx_sme2_n256_k512", + "definition": "gemm_f16_qs8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_f16_qs8cx_sme2_n256_k512: KleidiAI kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon to pack the RHS NxK matrix.\n/// -# @ref kai_rhs_pack_kxn_qsi8cxp_qsi8cx_neon to pack the RHS KxN matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) and packed\n/// RHS matrix: Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) and packed.\n/// Output tile: (rows x cols) = 1vl x 4vl\n///\n/// Features used: sme2\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(uint16_t).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n void* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error \"This file must be compiled for AArch64, FEAT_SVE2\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n void* dst; // 0\n const void* lhs_packed; // 0x8\n const void* rhs_packed; // 0x10\n size_t dst_stride_row; // 0x18\n size_t m; // 0x20\n size_t n; // 0x28\n size_t lhs_stride; // 0x30\n size_t rhs_stride; // 0x38\n size_t rhs_row_bytes; // 0x40\n size_t m_blk; // 0x48\n size_t dst_inc; // 0x50\n float clamp_min; // 0x58\n float clamp_max; // 0x5c\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // multiple of vector length\nstatic const size_t kai_n_step = 4; // multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // multiple of vector length\nstatic const size_t kai_nr = 4; // multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_zp_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_qvalue_rhs = 1;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_rsum_rhs = 4;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 2;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n size_t lhs_packed_stride = mr * ((k_internal * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs);\n // Since the LHS matrix is asymmetric with per-row quantization, we must include the\n // the number of bytes to hold the zero point value\n lhs_packed_stride += mr * kai_num_bytes_zp_lhs;\n\n return lhs_packed_stride;\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n size_t rhs_packed_stride = nr * (k_internal * kai_num_bytes_qvalue_rhs);\n rhs_packed_stride += nr * kai_num_bytes_multiplier_rhs;\n // Since the LHS matrix is quantized asymmetric with per-row quantization, we also include\n // the number of bytes for the reduction sum\n rhs_packed_stride += nr * kai_num_bytes_rsum_rhs;\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSERT((m_idx % kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k) {\n KAI_ASSERT((n_idx % kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSERT((m_idx % kai_get_m_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n KAI_ASSERT((n_idx % kai_get_n_step_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n return ((n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return (m * n * kai_num_bytes_dst_value);\n}\n\nvoid kai_run_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n void* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSERT(dst_stride_col == sizeof(uint16_t));\n KAI_ASSERT(n > 0);\n KAI_ASSERT(m > 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n KernelArgs args;\n const size_t k_internal = kai_k_roundedup(k);\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.lhs_stride = kai_get_lhs_packed_stride(k);\n args.rhs_stride = kai_get_rhs_packed_stride(k);\n args.rhs_row_bytes = nr * k_internal;\n args.m_blk = mr * k_internal;\n args.dst_inc = mr * dst_stride_row;\n args.clamp_min = scalar_min;\n args.clamp_max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -96]!\n stp x24, x25, [sp, 16]\n stp d8, d9, [sp, 32]\n stp d10, d11, [sp, 48]\n stp d12, d13, [sp, 64]\n stp d14, d15, [sp, 80]\n KAI_ASM_INST(0xd503477f)\t// \tsmstart\n ldr\tx19, [x0] // dst\n ldr\tx20, [x0, #0x8] // lhs_packed\n cntw\tx7 // mr\n ptrue\tp2.b\n KAI_ASM_INST(0x8556c81e) // ld1rw { z30.s }, p2/z, [x0, #0x58] // clamp_min\n KAI_ASM_INST(0x8557c81f) // ld1rw { z31.s }, p2/z, [x0, #0x5c] // clamp_max\n ldr\tx12, [x0, #0x20] // m\n KAI_ASM_INST(0x25ac17e0)\t// \twhilelt\tp0.s, xzr, x12\nKAI_ASM_LABEL(label_1) // Row Loop\n ldr\tx8, [x0, #0x10] // rhs_packed\n mov\tx9, x19\n ldr\tx13, [x0, #0x28] // n\n cmp\tx7, x12\n csel\tx16, x7, x12, lt\n lsl\tx16, x16, #2\n ldr\tx24, [x0, #0x40] // rhs_row_bytes\n add\tx24, x24, x8\n mov\tx11, x8\n KAI_ASM_INST(0x25784570)\t// \twhilelt\tpn8.h, x11, x24, vlx2\n addvl\tx11, x8, #0x2\n KAI_ASM_INST(0x25784572)\t// \twhilelt\tpn10.h, x11, x24, vlx2\nKAI_ASM_LABEL(label_2) // Column Loop\n mov\tx10, x20\n mov\tx11, x8\n mov\tx17, x9\n KAI_ASM_INST(0x25ad67f1)\t// \twhilelt\tpn9.s, xzr, x13, vlx4\n KAI_ASM_INST(0x256d67f3) // whilelt\tpn11.h, xzr, x13, vlx4\n KAI_ASM_INST(0xc00800ff)\t// \tzero\t{za}\n ldr\tx24, [x0, #0x48] // m_blk\n add\tx14, x10, x24\nKAI_ASM_LABEL(label_3) // Block Loop\n ld1w\t{ z4.s }, p0/z, [x10]\n addvl\tx10, x10, #0x1\n KAI_ASM_INST(0xa0402168)\t// \tld1h\t{ z8.h, z9.h }, pn8/z, [x11]\n KAI_ASM_INST(0xa0884880)\t// \tsmopa\tza0.s, p2/m, p2/m, z4.b, z8.b\n KAI_ASM_INST(0xa0894881)\t// \tsmopa\tza1.s, p2/m, p2/m, z4.b, z9.b\n KAI_ASM_INST(0xa041296a)\t// \tld1h\t{ z10.h, z11.h }, pn10/z, [x11, #0x2, mul vl]\n KAI_ASM_INST(0xa08a4882)\t// \tsmopa\tza2.s, p2/m, p2/m, z4.b, z10.b\n KAI_ASM_INST(0xa08b4883)\t// \tsmopa\tza3.s, p2/m, p2/m, z4.b, z11.b\n addvl\tx11, x11, #0x4\n cmp\tx10, x14\n b.lt\tlabel_3\n KAI_ASM_INST(0xa040c560)\t// \tld1w\t{ z0.s - z3.s }, pn9/z, [x11]\n KAI_ASM_INST(0xa041c564)\t// \tld1w\t{ z4.s - z7.s }, pn9/z, [x11, #0x4, mul vl]\n KAI_ASM_INST(0xa042c568)\t// \tld1w\t{ z8.s - z11.s }, pn9/z, [x11, #0x8, mul vl]\n addvl\tx11, x11, #0xc\n mov\tx14, #0x0 // =0\n addvl\tx15, x10, #0x1\nKAI_ASM_LABEL(label_4)\n KAI_ASM_INST(0x8540c950) // ld1rw { z16.s }, p2/z, [x10]\n KAI_ASM_INST(0x8540c9f1) // ld1rw { z17.s }, p2/z, [x15]\n add\tx10, x10, #0x4\n add\tx15, x15, #0x4\n KAI_ASM_INST(0xc006440c)\t// \tmov\t{ z12.b - z15.b }, za0h.b[w14, 0x0:0x3]\n fmul\tz20.s, z17.s, z4.s\n fmul\tz21.s, z17.s, z5.s\n fmul\tz22.s, z17.s, z6.s\n fmul\tz23.s, z17.s, z7.s\n mla\t z12.s, p2/m, z16.s, z0.s\n mla\t z13.s, p2/m, z16.s, z1.s\n mla\t z14.s, p2/m, z16.s, z2.s\n mla\t z15.s, p2/m, z16.s, z3.s\n KAI_ASM_INST(0xc132e18c)\t// \tscvtf\t{ z12.s - z15.s }, { z12.s - z15.s }\n fmul\tz24.s, z20.s, z12.s\n fmul\tz25.s, z21.s, z13.s\n fmul\tz26.s, z22.s, z14.s\n fmul\tz27.s, z23.s, z15.s\n fadd\tz24.s, p2/m, z24.s, z8.s\n fadd\tz25.s, p2/m, z25.s, z9.s\n fadd\tz26.s, p2/m, z26.s, z10.s\n fadd\tz27.s, p2/m, z27.s, z11.s\n KAI_ASM_INST(0xc1bfcbd8) // fclamp\t{ z24.s - z27.s }, z30.s, z31.s\n KAI_ASM_INST(0xc120e31c) // fcvt z28.h, { z24.s - z25.s}\n KAI_ASM_INST(0xc120e35d) // fcvt z29.h, { z26.s - z27.s}\n KAI_ASM_INST(0xa0602e3c) // st1h\t{ z28.h - z29.h }, pn11, [x17]\n ldr\tx24, [x0, #0x18] // dst_stride_row\n add\tx17, x17, x24\n add\tx14, x14, #0x4\n cmp\tx14, x16\n b.lt label_4\n ldr\tx24, [x0, #0x38] // rhs_stride\n add\tx8, x8, x24\n addvl\tx9, x9, #0x2\n ldr\tx24, [x0, #0x40] // rhs_row_bytes\n add\tx24, x24, x8\n mov\tx11, x8\n KAI_ASM_INST(0x25784570)\t// \twhilelt\tpn8.h, x11, x24, vlx2\n addvl\tx11, x8, #0x2\n KAI_ASM_INST(0x25784572)\t// \twhilelt\tpn10.h, x11, x24, vlx2\n decb x13, all\n subs xzr, xzr, x13 // cmp xzr, x13\n b.mi\tlabel_2\n ldr\tx24, [x0, #0x30]\n add\tx20, x20, x24\n ldr\tx24, [x0, #0x50]\n add\tx19, x19, x24\n cntw\tx24\n sub\tx12, x12, x24\n whilelt\tp0.s, xzr, x12\n b.mi\tlabel_1\n KAI_ASM_INST(0xd503467f)\t// \tsmstop\n ldp d14, d15, [sp, 80]\n ldp d12, d13, [sp, 64]\n ldp d10, d11, [sp, 48]\n ldp d8, d9, [sp, 32]\n ldp x24, x25, [sp, 16]\n ldp x19, x20, [sp], 96\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f16_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_FP16_SCALAR_ARITHMETIC) || \\\n !defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_FP16.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qai8dxp_f16_neon.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#define FLT16_MAX 65504.0\n#define FLT16_MIN (-65504.0F)\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f16_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f16_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSUME((kr / sr == 8) || (kr / sr == 4));\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n float16_t const* src_ptr = (float16_t const*)lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n const size_t lhs_row_length = lhs_stride / sizeof(float16_t);\n\n const float16x8_t vmax = vdupq_n_f16((float16_t)FLT16_MIN);\n const float16x8_t vmin = vdupq_n_f16((float16_t)FLT16_MAX);\n\n // As we load 8-element vectors, limit vectorized loop to avoid reading out-of-bounds\n const int32_t blocks_lim_k = num_blocks_k - (8 / k_block_len);\n\n size_t row_idx = 0;\n\n // Improved performance with 4x loop unrolling where packing parameters allow\n if (mr == 4) {\n for (; row_idx + 3 < m; row_idx += 4) {\n // Find min/max for each channel\n int32_t k_idx = 0;\n float16x8_t vmax0 = vmax;\n float16x8_t vmin0 = vmin;\n float16x8_t vmax1 = vmax;\n float16x8_t vmin1 = vmin;\n float16x8_t vmax2 = vmax;\n float16x8_t vmin2 = vmin;\n float16x8_t vmax3 = vmax;\n float16x8_t vmin3 = vmin;\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float16x8_t src0 = vld1q_f16(src_ptr + k_idx);\n const float16x8_t src1 = vld1q_f16(src_ptr + k_idx + lhs_row_length);\n const float16x8_t src2 = vld1q_f16(src_ptr + k_idx + (2 * lhs_row_length));\n const float16x8_t src3 = vld1q_f16(src_ptr + k_idx + (3 * lhs_row_length));\n\n vmax0 = vmaxq_f16(src0, vmax0);\n vmax1 = vmaxq_f16(src1, vmax1);\n vmax2 = vmaxq_f16(src2, vmax2);\n vmax3 = vmaxq_f16(src3, vmax3);\n vmin0 = vminq_f16(src0, vmin0);\n vmin1 = vminq_f16(src1, vmin1);\n vmin2 = vminq_f16(src2, vmin2);\n vmin3 = vminq_f16(src3, vmin3);\n }\n\n float16_t max0 = vmaxvq_f16(vmax0);\n float16_t min0 = vminvq_f16(vmin0);\n float16_t max1 = vmaxvq_f16(vmax1);\n float16_t min1 = vminvq_f16(vmin1);\n float16_t max2 = vmaxvq_f16(vmax2);\n float16_t min2 = vminvq_f16(vmin2);\n float16_t max3 = vmaxvq_f16(vmax3);\n float16_t min3 = vminvq_f16(vmin3);\n // Process leftover elements with a scalar loop.\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float16_t src0 = *(src_ptr + (size_t)k_idx);\n max0 = vmaxh_f16(src0, max0);\n min0 = vminh_f16(src0, min0);\n const float16_t src1 = *(src_ptr + (size_t)k_idx + lhs_row_length);\n max1 = vmaxh_f16(src1, max1);\n min1 = vminh_f16(src1, min1);\n const float16_t src2 = *(src_ptr + (size_t)k_idx + (2 * lhs_row_length));\n max2 = vmaxh_f16(src2, max2);\n min2 = vminh_f16(src2, min2);\n const float16_t src3 = *(src_ptr + (size_t)k_idx + (3 * lhs_row_length));\n max3 = vmaxh_f16(src3, max3);\n min3 = vminh_f16(src3, min3);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n const float rmin1 = fminf(0.0F, min1);\n const float rmax1 = fmaxf(0.0F, max1);\n const float scale1 = rmin1 == rmax1 ? 1.F : (qmax - qmin) / (rmax1 - rmin1);\n const float rmin2 = fminf(0.0F, min2);\n const float rmax2 = fmaxf(0.0F, max2);\n const float scale2 = rmin2 == rmax2 ? 1.F : (qmax - qmin) / (rmax2 - rmin2);\n const float rmin3 = fminf(0.0F, min3);\n const float rmax3 = fmaxf(0.0F, max3);\n const float scale3 = rmin3 == rmax3 ? 1.F : (qmax - qmin) / (rmax3 - rmin3);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n const float recip_scale1 = scale1 ? 1.0F / scale1 : 0.0F;\n const float recip_scale2 = scale2 ? 1.0F / scale2 : 0.0F;\n const float recip_scale3 = scale3 ? 1.0F / scale3 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n const float descaled_min1 = rmin1 * scale1;\n const float descaled_max1 = rmax1 * scale1;\n const float descaled_min2 = rmin2 * scale2;\n const float descaled_max2 = rmax2 * scale2;\n const float descaled_min3 = rmin3 * scale3;\n const float descaled_max3 = rmax3 * scale3;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n const float zero_point_from_min_error1 = qmin + descaled_min1;\n const float zero_point_from_max_error1 = qmax + descaled_max1;\n const float zero_point_from_min_error2 = qmin + descaled_min2;\n const float zero_point_from_max_error2 = qmax + descaled_max2;\n const float zero_point_from_min_error3 = qmin + descaled_min3;\n const float zero_point_from_max_error3 = qmax + descaled_max3;\n\n float zero_point0 = (zero_point_from_min_error0 + zero_point_from_max_error0 > 0) ? qmin - descaled_min0\n : qmax - descaled_max0;\n float zero_point1 = (zero_point_from_min_error1 + zero_point_from_max_error1 > 0) ? qmin - descaled_min1\n : qmax - descaled_max1;\n float zero_point2 = (zero_point_from_min_error2 + zero_point_from_max_error2 > 0) ? qmin - descaled_min2\n : qmax - descaled_max2;\n float zero_point3 = (zero_point_from_min_error3 + zero_point_from_max_error3 > 0) ? qmin - descaled_min3\n : qmax - descaled_max3;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n zero_point1 = fmaxf(zero_point1, qmin);\n zero_point1 = fminf(zero_point1, qmax);\n zero_point2 = fmaxf(zero_point2, qmin);\n zero_point2 = fminf(zero_point2, qmax);\n zero_point3 = fmaxf(zero_point3, qmin);\n zero_point3 = fminf(zero_point3, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n const int32_t nudged_zero_point1 = (int32_t)rintf(zero_point1);\n const int32_t nudged_zero_point2 = (int32_t)rintf(zero_point2);\n const int32_t nudged_zero_point3 = (int32_t)rintf(zero_point3);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len);\n\n // Quantize the channels\n int32_t block_idx = 0;\n const int32_t block_incr = 8 / k_block_len;\n\n for (; block_idx <= blocks_lim_k; block_idx += block_incr) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x8_t src0 = vld1q_f16(src_ptr + k_idx_start);\n const float16x8_t src1 = vld1q_f16(src_ptr + k_idx_start + lhs_row_length);\n const float16x8_t src2 = vld1q_f16(src_ptr + k_idx_start + (2 * lhs_row_length));\n const float16x8_t src3 = vld1q_f16(src_ptr + k_idx_start + (3 * lhs_row_length));\n\n // Scale the values.\n const int32x4_t v0_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src0)), scale0));\n const int32x4_t v0_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src0), scale0));\n const int32x4_t v1_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src1)), scale1));\n const int32x4_t v1_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src1), scale1));\n const int32x4_t v2_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src2)), scale2));\n const int32x4_t v2_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src2), scale2));\n const int32x4_t v3_0_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src3)), scale3));\n const int32x4_t v3_1_s32 = vcvtq_s32_f32(vmulq_n_f32(vcvt_high_f32_f16(src3), scale3));\n\n const int16x4_t v0_0_s16 = vqmovn_s32(v0_0_s32);\n const int16x4_t v0_1_s16 = vqmovn_s32(v0_1_s32);\n const int16x4_t v1_0_s16 = vqmovn_s32(v1_0_s32);\n const int16x4_t v1_1_s16 = vqmovn_s32(v1_1_s32);\n const int16x4_t v2_0_s16 = vqmovn_s32(v2_0_s32);\n const int16x4_t v2_1_s16 = vqmovn_s32(v2_1_s32);\n const int16x4_t v3_0_s16 = vqmovn_s32(v3_0_s32);\n const int16x4_t v3_1_s16 = vqmovn_s32(v3_1_s32);\n\n int16x8_t v0_s16;\n int16x8_t v1_s16;\n int16x8_t v2_s16;\n int16x8_t v3_s16;\n if (k_block_len == 8) {\n v0_s16 = vcombine_s16(v0_0_s16, v0_1_s16);\n v1_s16 = vcombine_s16(v1_0_s16, v1_1_s16);\n v2_s16 = vcombine_s16(v2_0_s16, v2_1_s16);\n v3_s16 = vcombine_s16(v3_0_s16, v3_1_s16);\n } else { // k_block_len == 4\n v0_s16 = vcombine_s16(v0_0_s16, v1_0_s16);\n v1_s16 = vcombine_s16(v2_0_s16, v3_0_s16);\n v2_s16 = vcombine_s16(v0_1_s16, v1_1_s16);\n v3_s16 = vcombine_s16(v2_1_s16, v3_1_s16);\n }\n\n // Add zero points.\n const int16x8_t vnzp0 = vdupq_n_s16((int16_t)nudged_zero_point0);\n const int16x8_t vnzp1 = vdupq_n_s16((int16_t)nudged_zero_point1);\n const int16x8_t vnzp2 = vdupq_n_s16((int16_t)nudged_zero_point2);\n const int16x8_t vnzp3 = vdupq_n_s16((int16_t)nudged_zero_point3);\n\n v0_s16 = vaddq_s16(v0_s16, vnzp0);\n v0_s16 = vmaxq_s16(v0_s16, vdupq_n_s16(INT8_MIN));\n v0_s16 = vminq_s16(v0_s16, vdupq_n_s16(INT8_MAX));\n v1_s16 = vaddq_s16(v1_s16, vnzp1);\n v1_s16 = vmaxq_s16(v1_s16, vdupq_n_s16(INT8_MIN));\n v1_s16 = vminq_s16(v1_s16, vdupq_n_s16(INT8_MAX));\n v2_s16 = vaddq_s16(v2_s16, vnzp2);\n v2_s16 = vmaxq_s16(v2_s16, vdupq_n_s16(INT8_MIN));\n v2_s16 = vminq_s16(v2_s16, vdupq_n_s16(INT8_MAX));\n v3_s16 = vaddq_s16(v3_s16, vnzp3);\n v3_s16 = vmaxq_s16(v3_s16, vdupq_n_s16(INT8_MIN));\n v3_s16 = vminq_s16(v3_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v0_s16);\n int8x8_t v1_s8 = vqmovn_s16(v1_s16);\n int8x8_t v2_s8 = vqmovn_s16(v2_s16);\n int8x8_t v3_s8 = vqmovn_s16(v3_s16);\n\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n vst1_s8((int8_t*)(dst_ptr + sizeof(int8x8_t)), v1_s8);\n vst1_s8((int8_t*)(dst_ptr + 2 * sizeof(int8x8_t)), v2_s8);\n vst1_s8((int8_t*)(dst_ptr + 3 * sizeof(int8x8_t)), v3_s8);\n dst_ptr += block_incr * mr * k_block_len * sizeof(int8_t);\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index.\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0 = (float)(*(src_ptr + k_idx_start));\n const float src1 = (float)(*(src_ptr + k_idx_start + lhs_row_length));\n const float src2 = (float)(*(src_ptr + k_idx_start + (2 * lhs_row_length)));\n const float src3 = (float)(*(src_ptr + k_idx_start + (3 * lhs_row_length)));\n\n // Scale the value.\n int32_t d0_s32 = (int32_t)(roundf(src0 * scale0));\n int32_t d1_s32 = (int32_t)(roundf(src1 * scale1));\n int32_t d2_s32 = (int32_t)(roundf(src2 * scale2));\n int32_t d3_s32 = (int32_t)(roundf(src3 * scale3));\n\n d0_s32 = d0_s32 + nudged_zero_point0;\n d0_s32 = KAI_MAX(d0_s32, INT8_MIN);\n d0_s32 = KAI_MIN(d0_s32, INT8_MAX);\n\n d1_s32 = d1_s32 + nudged_zero_point1;\n d1_s32 = KAI_MAX(d1_s32, INT8_MIN);\n d1_s32 = KAI_MIN(d1_s32, INT8_MAX);\n\n d2_s32 = d2_s32 + nudged_zero_point2;\n d2_s32 = KAI_MAX(d2_s32, INT8_MIN);\n d2_s32 = KAI_MIN(d2_s32, INT8_MAX);\n\n d3_s32 = d3_s32 + nudged_zero_point3;\n d3_s32 = KAI_MAX(d3_s32, INT8_MIN);\n d3_s32 = KAI_MIN(d3_s32, INT8_MAX);\n\n *(int8_t*)dst_ptr = (int8_t)d0_s32;\n *(int8_t*)(dst_ptr + k_block_len * sizeof(int8_t)) = (int8_t)d1_s32;\n *(int8_t*)(dst_ptr + 2 * (k_block_len * sizeof(int8_t))) = (int8_t)d2_s32;\n *(int8_t*)(dst_ptr + 3 * (k_block_len * sizeof(int8_t))) = (int8_t)d3_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n uint8_t* dst_base = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr = dst_base + dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row.\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n *((int32_t*)(dst_ptr + kai_num_bytes_per_offset)) = -nudged_zero_point1;\n *((int32_t*)(dst_ptr + 2 * kai_num_bytes_per_offset)) = -nudged_zero_point2;\n *((int32_t*)(dst_ptr + 3 * kai_num_bytes_per_offset)) = -nudged_zero_point3;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier.\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params.\n *((float*)(dst_ptr)) = recip_scale0;\n *((float*)(dst_ptr + kai_num_bytes_per_multiplier)) = recip_scale1;\n *((float*)(dst_ptr + 2 * kai_num_bytes_per_multiplier)) = recip_scale2;\n *((float*)(dst_ptr + 3 * kai_num_bytes_per_multiplier)) = recip_scale3;\n\n // Update src_ptr. Note: now lhs contains fp16 values (2 bytes each).\n src_ptr += (4 * lhs_row_length);\n\n // Move to the next row as we have interleaved all Mr rows.\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n\n for (; row_idx < num_rows; ++row_idx) {\n // Find min/max for each channel\n int32_t k_idx = 0;\n float16x8_t vmax0 = vmax;\n float16x8_t vmin0 = vmin;\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float16x8_t src0_0 = vld1q_f16(src_ptr + (size_t)k_idx);\n vmax0 = vmaxq_f16(vmax0, src0_0);\n vmin0 = vminq_f16(vmin0, src0_0);\n }\n // Get the max/min\n float16_t max0 = vmaxvq_f16(vmax0);\n float16_t min0 = vminvq_f16(vmin0);\n\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float16_t src0 = *(src_ptr + (size_t)k_idx);\n max0 = vmaxh_f16(src0, max0);\n min0 = vminh_f16(src0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n if (k_block_len == 8) {\n for (; block_idx < blocks_lim_k; ++block_idx) {\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x8_t src_0 = vld1q_f16(src_ptr + k_idx_start);\n\n // Scale the values\n const float32x4_t v0_f32 = vmulq_n_f32(vcvt_f32_f16(vget_low_f16(src_0)), scale0);\n const float32x4_t v1_f32 = vmulq_n_f32(vcvt_high_f32_f16(src_0), scale0);\n const int32x4_t v0_s32 = vcvtnq_s32_f32(v0_f32);\n const int32x4_t v1_s32 = vcvtnq_s32_f32(v1_f32);\n\n const int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n const int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v_s8);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < blocks_lim_k; ++block_idx) {\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float16x4_t src_0 = vld1_f16(src_ptr + k_idx_start);\n\n // Scale the values\n const float32x4_t v0_f32 = vmulq_n_f32(vcvt_f32_f16(src_0), scale0);\n const int32x4_t v0_s32 = vcvtnq_s32_f32(v0_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n v0_s16 = vadd_s16(v0_s16, vnzp_s16);\n v0_s16 = vmax_s16(v0_s16, vdup_n_s16(INT8_MIN));\n v0_s16 = vmin_s16(v0_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v_s8 = vqmovn_s16(vcombine_s16(v0_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0 = (float)(*(src_ptr + k_idx_start));\n\n // Scale the values\n int32_t d0_s32 = (int32_t)(roundf(src0 * scale0));\n\n d0_s32 = d0_s32 + nudged_zero_point0;\n d0_s32 = KAI_MAX(d0_s32, INT8_MIN);\n d0_s32 = KAI_MIN(d0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)d0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += lhs_row_length;\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f16_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f16_neon(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f16_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f16_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n const size_t k_internal = kai_k_roundedup(k);\n\n return nr * (k_internal + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, const struct kai_rhs_pack_qsi8cx_params* params) {\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT(sr == 1);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n\n const int32_t lhs_zero_point = params->lhs_zero_point;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_num_bytes_per_row = nr * k_internal;\n const size_t rhs_stride = k;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n\n int32_t* sums = (int32_t*)(dst_row + nr * k_internal);\n\n // Initialize to zero the RHS reduction sums\n memset(sums, 0, nr * sizeof(int32_t));\n\n for (size_t dst_offset = 0; dst_offset < dst_num_bytes_per_row; dst_offset += kr) {\n const size_t block_idx = dst_offset / kr;\n const size_t nr_idx = block_idx % nr;\n const size_t super_block_idx = block_idx / nr;\n\n const size_t k0_idx = super_block_idx * kr;\n const size_t n0_idx = dst_row_idx * nr + nr_idx;\n\n // Clamp the index to avoid out-of-bound reads\n const size_t n0_valid_idx = KAI_MIN(n0_idx, n - 1);\n\n const size_t src_offset = n0_valid_idx * rhs_stride;\n\n int32_t partial_sum = 0;\n\n // Get the partial reduction sum\n for (size_t i = 0; i < kr; i++) {\n const size_t k0_valid_idx = k0_idx + i;\n int8_t v = 0;\n if (k0_valid_idx < k) {\n v = rhs[src_offset + k0_valid_idx];\n }\n ((int8_t*)dst_row)[i] = v;\n partial_sum += v;\n }\n\n sums[nr_idx] += partial_sum * lhs_zero_point;\n\n dst_row += kr;\n }\n\n // Adjust the reduction sums\n for (size_t i = 0; i < nr; ++i) {\n dst_row += sizeof(int32_t);\n }\n\n // Adjust the scales\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n *((float*)(dst_row)) = scale[src_row_idx];\n dst_row += sizeof(float);\n }\n\n // Set the bias\n if (bias == NULL) {\n memset(dst_row, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n ((float*)dst_row)[i] = bias[src_row_idx];\n }\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Get the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed).\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix, which contains the packed 8-bit quantized symmetric per-channel\n/// (qs8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of rows.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be an even value.\n/// @param[in] nr The number of N rows to interleave on the same output output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n/// @param[in] rhs The RHS matrix containing the 8-bit values.\n/// Size in bytes is expected to be equal to or greater than n * k * sizeof(uint8_t).\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_qsi8cx_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa against gemm_f16_qs8cx_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint16_t* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f16_neon.h\"\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f16_neon((size_t)M, (size_t)K, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qai8dxp_f16_neon((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(uint16_t), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q8_snap = nullptr;\n static size_t B_q8_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q8_snap, B_q8_snap_size, B_q8, (size_t)N*K)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qsi8cx_params params;\n params.lhs_zero_point = 1;\n params.scale_multiplier = 1.0f;\n kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q8, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n static uint16_t* tmp16 = nullptr;\n static size_t tmp16_cap = 0;\n if ((size_t)M * N > tmp16_cap) {\n std::free(tmp16);\n tmp16 = static_cast(std::malloc(sizeof(uint16_t) * (size_t)M * N));\n tmp16_cap = (size_t)M * N;\n if (tmp16 == nullptr) return -1;\n }\n kai_run_matmul_clamp_f16_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, tmp16, (size_t)N * sizeof(uint16_t), sizeof(uint16_t), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n // fp16 kernel result widened to the raw ABI's fp32 output (exact).\n widen_f16(tmp16, output, (size_t)M * N);\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..229c0c881b5184680f75befd59c2478606d1433d --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_f16act_qs4c32_sme2_n256_k512", + "definition": "gemm_f16act_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_f16act_qs4c32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2) || !defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)) && \\\n !defined(_M_ARM64)\n#error This file must be compiled for AArch64 and FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\ntypedef struct {\n float* dst; // 0\n const void* lhs_packed; // 0x8\n const void* rhs_packed; // 0x10\n const void* rhs_scales; // 0x18\n size_t dst_stride_row; // 0x20\n size_t lhs_packed_stride; // 0x28\n size_t rhs_packed_stride; // 0x30\n size_t m; // 0x38\n size_t n; // 0x40\n size_t k; // 0x48\n size_t bl; // 0x50\n const uint16_t* lut; // 0x58\n float min; // 0x60\n float max; // 0x64\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // Multiple of vector length\nstatic const size_t kai_n_step = 4; // Multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // Multiple of vector length\nstatic const size_t kai_nr = 4; // Multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 2;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_recip_num_bytes_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 2;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_bl = 32;\n\n// Look-up table used for int4->int8 convert\nstatic const uint16_t lut[] = {\n 0xc800, // = -8.0\n 0x0000, // = 0.0\n 0xc700, // = -7.0\n 0x0000, // = 0.0\n 0xc600, // = -6.0\n 0x0000, // = 0.0\n 0xc500, // = -5.0\n 0x0000, // = 0.0\n 0xc400, // = -4.0\n 0x0000, // = 0.0\n 0xc200, // = -3.0\n 0x0000, // = 0.0\n 0xc000, // = -2.0\n 0x0000, // = 0.0\n 0xbc00, // = -1.0\n 0x0000, // = 0.0\n 0x0000, // = 0.0\n 0x0000, // = 0.0\n 0x3c00, // = 1.0\n 0x0000, // = 0.0\n 0x4000, // = 2.0\n 0x0000, // = 0.0\n 0x4200, // = 3.0\n 0x0000, // = 0.0\n 0x4400, // = 4.0\n 0x0000, // = 0.0\n 0x4500, // = 5.0\n 0x0000, // = 0.0\n 0x4600, // = 6.0\n 0x0000, // = 0.0\n 0x4700, // = 7.0\n 0x0000, // = 0.0\n};\n\n#define KAI_LUT_NENTRIES (sizeof(lut) / sizeof(lut[0]))\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs);\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs = (bl / kai_recip_num_bytes_qvalue_rhs) + kai_num_bytes_multiplier_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME((k % kai_bl) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n return k / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME((k % kai_bl) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n const size_t nr = kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr * (num_bytes_per_block * num_blocks_per_row);\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % mr) == 0);\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t n_idx, size_t k, size_t bl) {\n const size_t nr = kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n const size_t m_step = kai_get_m_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n const size_t n_step = kai_get_n_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % m_step) == 0);\n KAI_ASSUME((n_idx % n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n KAI_UNUSED(dst_stride_col);\n\n const size_t num_blocks = kai_get_num_blocks_per_row(k, bl);\n\n const size_t nr = kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride(k, bl);\n\n KernelArgs args;\n const uint8_t* rhs_packed_p = rhs_packed;\n const uint8_t* rhs_scales = rhs_packed_p + rhs_packed_stride - (nr * num_blocks) * kai_num_bytes_multiplier_rhs;\n\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.rhs_scales = rhs_scales;\n args.dst_stride_row = dst_stride_row;\n args.lhs_packed_stride = kai_get_lhs_packed_stride(k, bl);\n args.rhs_packed_stride = rhs_packed_stride;\n args.m = m;\n args.n = n;\n args.k = k;\n args.bl = bl;\n\n args.lut = lut;\n args.min = scalar_min;\n args.max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n KAI_ASM_CODE(matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -128 ]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp d8, d9, [sp, 48]\n stp d10, d11, [sp, 64]\n stp d12, d13, [sp, 80]\n stp d14, d15, [sp, 96]\n KAI_ASM_INST(0xd503477f) // smstart\n cntw x14\n ptrue p2.b, all\n ldr x19, [x0, #0x58] // lut\n KAI_ASM_INST(0xe11f8260) //ldr zt0, [x19]\n mov x8, #0\n ldr x16, [x0, #0x10] // rhs_packed\n ldr x17, [x0, #0x18] // rhs_scales\n ldr x6, [x0, #0x40] // N\n KAI_ASM_INST(0x8558c81c) // ld1rw z28.s, p2/z, [x0, #0x60] // min\n KAI_ASM_INST(0x8559c81d) // ld1rw z29.s, p2/z, [x0, #0x64] // max\n\n KAI_ASM_INST(0x25664510) // whilelt pn8.h, x8, x6, VLx2\n KAI_ASM_INST(0x25a66511) // whilelt pn9.s, x8, x6, VLx4\n ldr x4, [x0] // dst\n b.eq label_9 // b.none label_9\nKAI_ASM_LABEL(label_1) // N loop\n ldr x9, [x0, #0x38] // M\n KAI_ASM_INST(0x25261501) // whilelt p1.b, x8, x6\n ldr x22, [x0, #0x8] // lhs_packed\n mov x24, x4 // dst\nKAI_ASM_LABEL(label_2) // M loop\n KAI_ASM_INST(0xc00800ff) // zero {za}\n KAI_ASM_INST(0x25a917e0)// whilelt p0.s, xzr, x9\n mov x23, x22\n mov x20, #0\n mov x21, #0\n ldr x10, [x0, #0x48] // K\n cmp x10, #0\n b.eq label_8\nKAI_ASM_LABEL(label_3) // K loop\n lsl x5, x21, 1\n KAI_ASM_INST(0xa0052220) // ld1h {z0.h - z1.h}, pn8/z, [x17, x5, lsl #1]\n KAI_ASM_INST(0xc160d018) // zip {z24.h - z25.h}, z0.h, z0.h\n KAI_ASM_INST(0xc161d03a) // zip {z26.h - z27.h}, z1.h, z1.h\n ldr x11, [x0, #0x50] //bl\nKAI_ASM_LABEL(label_4) // Block loop\n lsl x5, x20, 2\n KAI_ASM_INST(0xa425c604) // ld2b {z4.b, z5.b}, p1/z, [x16, x5]\n inch x20, all\n KAI_ASM_INST(0xa540a2e6)// ld1w {z6.s}, p0/z, [x23]\n KAI_ASM_INST(0xc08a9088) // luti4 {z8.h - z11.h}, zt0, z4[0]\n KAI_ASM_INST(0x65580908) // fmul z8.h, z8.h, z24.h\n KAI_ASM_INST(0x65590929) // fmul z9.h, z9.h, z25.h\n KAI_ASM_INST(0x655a094a) // fmul z10.h, z10.h, z26.h\n KAI_ASM_INST(0x655b096b) // fmul z11.h, z11.h, z27.h\n KAI_ASM_INST(0x81a848c0) // fmopa za0.s, p2/m, p2/m, z6.h, z8.h\n KAI_ASM_INST(0x81a948c1) // fmopa za1.s, p2/m, p2/m, z6.h, z9.h\n KAI_ASM_INST(0x81aa48c2) // fmopa za2.s, p2/m, p2/m, z6.h, z10.h\n KAI_ASM_INST(0x81ab48c3) // fmopa za3.s, p2/m, p2/m, z6.h, z11.h\n KAI_ASM_INST(0xa54e42e7) // ld1w {z7.s}, p0/z, [x23, x14, lsl 2]\n add x23, x23, x14, lsl 3\n KAI_ASM_INST(0xc08a90ac) // luti4 {z12.h - z15.h}, zt0, z5[0]\n KAI_ASM_INST(0x6558098c) // fmul z12.h, z12.h, z24.h\n KAI_ASM_INST(0x655909ad) // fmul z13.h, z13.h, z25.h\n KAI_ASM_INST(0x655a09ce) // fmul z14.h, z14.h, z26.h\n KAI_ASM_INST(0x655b09ef) // fmul z15.h, z15.h, z27.h\n KAI_ASM_INST(0x81ac48e0) // fmopa za0.s, p2/m, p2/m, z7.h, z12.h\n KAI_ASM_INST(0x81ad48e1) // fmopa za1.s, p2/m, p2/m, z7.h, z13.h\n KAI_ASM_INST(0x81ae48e2) // fmopa za2.s, p2/m, p2/m, z7.h, z14.h\n KAI_ASM_INST(0x81af48e3) // fmopa za3.s, p2/m, p2/m, z7.h, z15.h\n subs x11, x11, #4\n b.gt label_4\n ldr x5, [x0, #0x50] // bl\n subs x10, x10, x5\n inch x21, all\n b.gt label_3\nKAI_ASM_LABEL(label_8)\n cmp x9, x14\n csel x15, x9, x14, lo\n lsl x15, x15, #2\n mov w12, #0\nKAI_ASM_LABEL(label_5) // store tiles\n KAI_ASM_INST(0xc0060400) // mova {z0.b - z3.b}, za0h.b[w12, 0:3]\n KAI_ASM_INST(0xc1bdcb80) // fclamp { z0.s - z3.s}, z28.s, z29.s\n KAI_ASM_INST(0xa060c700) // st1w {z0.s - z3.s}, pn9, [x24]\n ldr x5, [x0, #0x20] // dst_stride_row\n add x24, x24, x5\n add w12, w12, #4\n cmp w12, w15\n blt label_5\n ldr x5, [x0, #0x28] // offset_stride_l\n add x22, x22, x5\n decw x9, all\n cmp x9, #0\n b.gt label_2\n incb x4, all, mul #4 // dst\n ldr x5, [x0, #0x30] // rhs_packed_stride\n add x16, x16, x5\n add x17, x17, x5\n incb x8, all\n KAI_ASM_INST(0x25664510) // whilelt pn8.h, x8, x6, VLx2\n KAI_ASM_INST(0x25a66511) // whilelt pn9.s, x8, x6, VLx4\n b.mi label_1 // b.first label_1\nKAI_ASM_LABEL(label_9)\n KAI_ASM_INST(0xd503467f) // smstop\n ldp d14, d15, [sp, 96]\n ldp d12, d13, [sp, 80]\n ldp d10, d11, [sp, 64]\n ldp d8, d9, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp],128\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_pack_f16pmrx2_f32_neon to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon to pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed fp16 values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of m_step.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 4-bit with per-block (32) quantization (qsi4c32) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of m_step.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Packed fp16 (f16pmrx2)\n/// RHS matrix: Quantized Symmetric Signed 4-bit with per-block (32) quantization (qsi4c32) and packed.\n/// Output tile: (rows x cols) = 1 VL x 4 VL (Vector Length)\n///\n/// Instruction used: SME2 (MOPA)\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] bl Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel dependencies list at the top of this file reports\n/// the available LHS packing functions for this micro-kernel.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel dependencies list at the top of this file reports\n/// the available RHS packing functions for this micro-kernel.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. Unused.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_pack_f16pmrx2_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @param[in] mr Number of rows to be interleaved.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_pack_f16pmrx2_f32_neon(size_t mr);\n\n/// Gets the offset in bytes to the data element in the LHS buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] lhs_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_offset_lhs_pack_f16pmrx2_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Number of kr splits.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_pack_f16pmrx2_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Number of kr splits.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_pack_f16pmrx2_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Runs the LHS packing function for matrix multiplication.\n///\n/// The pointer of each buffers (LHS and packed LHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * LHS: @ref kai_get_lhs_offset_lhs_pack_f16pmrx2_f32_neon.\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_lhs_pack_f16pmrx2_f32_neon.\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k Common dimension between the LHS and RHS matrix.\n/// @param[in] bl The block length. unused\n/// @param[in] mr Block size in M dimension.\n/// @param[in] kr Block size in K dimension. It must be 4.\n/// @param[in] sr Number of kr splits. It must be 2\n/// @param[in] m_idx_start Unused.\n/// @param[in] lhs LHS matrix data buffer.\n/// @param[in] lhs_stride Row stride in bytes of the LHS matrix. Currently unused.\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_pack_f16pmrx2_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs,\n size_t lhs_stride, void* lhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_pack_f16pmrx2_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// mrx2 => this function can take in generic mr values but the input is expected to have a block depth of 2\n// Block depth is calculated as kr / sr. The values of these parameters are defined in the matmul ukernel.\n\n#if ((!defined(__aarch64__) || !defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)) && !defined(_M_ARM64))\n#error This file must be compiled for AArch64\n#else // Architectural features check.\n\n#include \"kai_lhs_pack_f16pmrx2_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\ninline static size_t kai_num_bytes_per_block(size_t bl) {\n return bl * sizeof(uint16_t);\n}\n\ninline static size_t kai_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSERT((k % bl) == 0);\n return k / bl;\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t bl) {\n KAI_UNUSED(kr);\n\n return mr * kai_num_blocks_per_row(k, bl) * kai_num_bytes_per_block(bl);\n}\n\nsize_t kai_get_m_step_lhs_pack_f16pmrx2_f32_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_pack_f16pmrx2_f32_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_pack_f16pmrx2_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((m_idx % mr) == 0);\n\n KAI_UNUSED(sr);\n\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, bl);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_pack_f16pmrx2_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KAI_UNUSED(sr);\n\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return (num_rows * kai_lhs_packed_stride(k, mr, kr, bl));\n}\nvoid kai_run_lhs_pack_f16pmrx2_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs,\n size_t lhs_stride, void* lhs_packed) {\n KAI_ASSUME(sr == 2);\n\n KAI_UNUSED(bl);\n KAI_UNUSED(m_idx_start);\n KAI_UNUSED(lhs_stride);\n KAI_UNUSED(kr);\n\n // Pointer on a source matrix of the batch\n const float* lhs_ptr = lhs;\n\n // Pointer on a destination tranposed matrix of the batch\n uint16_t* lhs_packed_ptr = lhs_packed;\n\n for (uint64_t dst_row_idx = 0; dst_row_idx < m; dst_row_idx += mr) {\n // If rows left is more than mr, then calculate over mr as normal otherwise calculate over leftover rows\n uint64_t rows_in_mr = ((m - dst_row_idx) >= mr) ? mr : (m - dst_row_idx);\n for (uint64_t i = 0; (i < (rows_in_mr - (rows_in_mr % 4))); i += 4) {\n for (uint64_t j = 0; j < k; j += 16) {\n float32x4x4_t aa1 = vld4q_f32((lhs_ptr + i * k + j));\n float32x4x4_t aa2 = vld4q_f32((lhs_ptr + (i + 1) * k + j));\n float32x4x4_t aa3 = vld4q_f32((lhs_ptr + (i + 2) * k + j));\n float32x4x4_t aa4 = vld4q_f32((lhs_ptr + (i + 3) * k + j));\n\n float16x4_t a_1 = vcvt_f16_f32(aa1.val[0]);\n float16x4_t a_2 = vcvt_f16_f32(aa1.val[1]);\n float16x4_t a_3 = vcvt_f16_f32(aa2.val[0]);\n float16x4_t a_4 = vcvt_f16_f32(aa2.val[1]);\n float16x4x4_t a = {.val = {a_1, a_2, a_3, a_4}};\n a_1 = vcvt_f16_f32(aa1.val[2]);\n a_2 = vcvt_f16_f32(aa1.val[3]);\n a_3 = vcvt_f16_f32(aa2.val[2]);\n a_4 = vcvt_f16_f32(aa2.val[3]);\n float16x4x4_t a2 = {.val = {a_1, a_2, a_3, a_4}};\n a_1 = vcvt_f16_f32(aa3.val[0]);\n a_2 = vcvt_f16_f32(aa3.val[1]);\n a_3 = vcvt_f16_f32(aa4.val[0]);\n a_4 = vcvt_f16_f32(aa4.val[1]);\n float16x4x4_t a3 = {.val = {a_1, a_2, a_3, a_4}};\n a_1 = vcvt_f16_f32(aa3.val[2]);\n a_2 = vcvt_f16_f32(aa3.val[3]);\n a_3 = vcvt_f16_f32(aa4.val[2]);\n a_4 = vcvt_f16_f32(aa4.val[3]);\n float16x4x4_t a4 = {.val = {a_1, a_2, a_3, a_4}};\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + (j / 2) * mr * 2), a, 0);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + (j / 2) * mr * 2 + 4), a3, 0);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 1) * mr * 2), a2, 0);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 1) * mr * 2 + 4), a4, 0);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 2) * mr * 2), a, 1);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 2) * mr * 2 + 4), a3, 1);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 3) * mr * 2), a2, 1);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 3) * mr * 2 + 4), a4, 1);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 4) * mr * 2), a, 2);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 4) * mr * 2 + 4), a3, 2);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 5) * mr * 2), a2, 2);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 5) * mr * 2 + 4), a4, 2);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 6) * mr * 2), a, 3);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 6) * mr * 2 + 4), a3, 3);\n\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 7) * mr * 2), a2, 3);\n vst4_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 7) * mr * 2 + 4), a4, 3);\n }\n }\n for (uint64_t i = (rows_in_mr - (rows_in_mr % 4)); i < rows_in_mr; i++) {\n for (uint64_t j = 0; j < k; j += 16) {\n float32x4x4_t aa = vld4q_f32((lhs_ptr + i * k + j));\n\n float16x4_t a_1 = vcvt_f16_f32(aa.val[0]);\n float16x4_t a_2 = vcvt_f16_f32(aa.val[1]);\n float16x4_t a_3 = vcvt_f16_f32(aa.val[2]);\n float16x4_t a_4 = vcvt_f16_f32(aa.val[3]);\n\n float16x4x2_t p0 = {.val = {a_1, a_2}};\n float16x4x2_t p1 = {.val = {a_3, a_4}};\n\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 0) * mr * 2), p0, 0);\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 1) * mr * 2), p1, 0);\n\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 2) * mr * 2), p0, 1);\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 3) * mr * 2), p1, 1);\n\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 4) * mr * 2), p0, 2);\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 5) * mr * 2), p1, 2);\n\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 6) * mr * 2), p0, 3);\n vst2_lane_f16((void*)(lhs_packed_ptr + i * 2 + ((j / 2) + 7) * mr * 2), p1, 3);\n }\n }\n lhs_ptr += mr * k;\n lhs_packed_ptr += mr * k;\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_multiplier = sizeof(uint16_t);\nstatic const size_t kai_max_bl = KAI_SME_VEC_LENGTH_MAX_BYTES;\nstatic const size_t kai_nr_tile = 4;\nstatic const size_t kai_bl_multiple_of = 32;\n\n#if defined(_MSC_VER)\n#define KAI_ALIGNED_AS(N) __declspec(align(N))\n#elif defined(__GNUC__) || defined(__clang__)\n#define KAI_ALIGNED_AS(N) __attribute__((aligned(N)))\n#else\n#define KAI_ALIGNED_AS(N)\n#endif\n\nstatic inline void convert_chunk32_s1s0_s16s0(uint8_t* dst_lo, uint8_t* dst_hi, const uint8_t* src_ptr) {\n // Two sequential 128-bit loads followed by unzip have better throughput than a structured LD2.\n const uint8x16_t v0 = vld1q_u8(src_ptr);\n const uint8x16_t v1 = vld1q_u8(src_ptr + 16);\n\n const uint8x16_t even_bytes = vuzp1q_u8(v0, v1);\n const uint8x16_t odd_bytes = vuzp2q_u8(v0, v1);\n\n const uint8x16_t lo_pairs = vsliq_n_u8(even_bytes, odd_bytes, 4);\n const uint8x16_t hi_pairs = vsriq_n_u8(odd_bytes, even_bytes, 4);\n\n vst1q_u8(dst_lo, lo_pairs);\n vst1q_u8(dst_hi, hi_pairs);\n}\n\nstatic inline void convert_tail16_s1s0_s16s0(uint8_t* dst_lo, uint8_t* dst_hi, const uint8_t* src_ptr) {\n const uint8x16_t v0 = vld1q_u8(src_ptr);\n const uint8x16_t even_dup = vuzp1q_u8(v0, v0);\n const uint8x16_t odd_dup = vuzp2q_u8(v0, v0);\n\n const uint8x16_t lo_pairs_dup = vsliq_n_u8(even_dup, odd_dup, 4);\n const uint8x16_t hi_pairs_dup = vsriq_n_u8(odd_dup, even_dup, 4);\n const uint8x16_t packed = vcombine_u8(vget_low_u8(lo_pairs_dup), vget_low_u8(hi_pairs_dup));\n\n KAI_ALIGNED_AS(16) uint8_t tmp[16];\n vst1q_u8(tmp, packed);\n\n for (size_t i = 0; i < 8; ++i) {\n dst_lo[i] = tmp[i];\n dst_hi[i] = tmp[8 + i];\n }\n}\n\nstatic inline void convert_s1s0_s16s0_scalar(uint16_t* dst_blk, const uint8_t* src_blk, size_t bl) {\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n for (size_t bl4_idx = 0; bl4_idx < bl / 4; bl4_idx++) {\n const size_t byte_idx0 = bl4_idx * 2;\n const size_t byte_idx1 = byte_idx0 + 1;\n uint8_t packed0 = 0;\n uint8_t packed1 = 0;\n\n if (byte_idx0 < split) {\n // First half of byte0: pack low nibbles into sequential order.\n const size_t k0 = byte_idx0 * 2;\n packed0 = (src_blk[k0] & 0xF) | (src_blk[k0 + 1] << 4);\n } else {\n // Second half of byte0: pack high nibbles into sequential order.\n const size_t k0 = byte_idx0 * 2 - half;\n packed0 = (src_blk[k0] >> 4) | (src_blk[k0 + 1] & 0xF0);\n }\n // Repeated for byte1\n if (byte_idx1 < split) {\n const size_t k1 = byte_idx1 * 2;\n packed1 = (src_blk[k1] & 0xF) | (src_blk[k1 + 1] << 4);\n } else {\n const size_t k1 = byte_idx1 * 2 - half;\n packed1 = (src_blk[k1] >> 4) | (src_blk[k1 + 1] & 0xF0);\n }\n dst_blk[bl4_idx] = (uint16_t)packed0 | ((uint16_t)packed1 << 8);\n }\n}\n\nstatic inline void convert_s1s0_s16s0_neon(uint16_t* dst_blk, const uint8_t* src_blk, size_t bl) {\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n uint8_t* dst_bytes = (uint8_t*)dst_blk;\n uint8_t* dst_low = dst_bytes;\n uint8_t* dst_high = dst_bytes + split;\n\n // Special-case bl == 32 (half == 16) so that the whole block is\n // handled with a single 128-bit load and store.\n if (half == 16) {\n const uint8x16_t v0 = vld1q_u8(src_blk);\n const uint8x16_t even_dup = vuzp1q_u8(v0, v0);\n const uint8x16_t odd_dup = vuzp2q_u8(v0, v0);\n\n const uint8x16_t lo_pairs_dup = vsliq_n_u8(even_dup, odd_dup, 4);\n const uint8x16_t hi_pairs_dup = vsriq_n_u8(odd_dup, even_dup, 4);\n\n const uint8x16_t packed = vcombine_u8(vget_low_u8(lo_pairs_dup), vget_low_u8(hi_pairs_dup));\n vst1q_u8(dst_bytes, packed);\n return;\n }\n\n const uint8_t* src_ptr = src_blk;\n uint8_t* dst_low_ptr = dst_low;\n uint8_t* dst_high_ptr = dst_high;\n\n size_t remaining = half;\n\n // Process two 32-byte chunks per iteration when possible to reduce loop\n // overhead while keeping all loads and stores 128-bit wide.\n for (; remaining >= 64; remaining -= 64) {\n convert_chunk32_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n convert_chunk32_s1s0_s16s0(dst_low_ptr + 16, dst_high_ptr + 16, src_ptr + 32);\n\n src_ptr += 64;\n dst_low_ptr += 32;\n dst_high_ptr += 32;\n }\n for (; remaining >= 32; remaining -= 32) {\n convert_chunk32_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n\n src_ptr += 32;\n dst_low_ptr += 16;\n dst_high_ptr += 16;\n }\n\n // Handle the remaining 16 bytes (if any) using a single 128-bit load\n // and store to a temporary buffer, followed by scalar writes.\n if (remaining != 0) {\n convert_tail16_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n }\n}\n\nstatic inline void convert_s1s0_s16s0_neon_rows4(\n uint16_t* dst0, uint16_t* dst1, uint16_t* dst2, uint16_t* dst3, const uint8_t* src0, const uint8_t* src1,\n const uint8_t* src2, const uint8_t* src3, size_t bl) {\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n uint8_t* dst0_bytes = (uint8_t*)dst0;\n uint8_t* dst1_bytes = (uint8_t*)dst1;\n uint8_t* dst2_bytes = (uint8_t*)dst2;\n uint8_t* dst3_bytes = (uint8_t*)dst3;\n\n uint8_t* dst0_low = dst0_bytes;\n uint8_t* dst1_low = dst1_bytes;\n uint8_t* dst2_low = dst2_bytes;\n uint8_t* dst3_low = dst3_bytes;\n\n uint8_t* dst0_high = dst0_bytes + split;\n uint8_t* dst1_high = dst1_bytes + split;\n uint8_t* dst2_high = dst2_bytes + split;\n uint8_t* dst3_high = dst3_bytes + split;\n\n // bl == 32 (half == 16) is common and can be handled without a loop.\n if (half == 16) {\n const uint8x16_t r0 = vld1q_u8(src0);\n const uint8x16_t r1 = vld1q_u8(src1);\n const uint8x16_t r2 = vld1q_u8(src2);\n const uint8x16_t r3 = vld1q_u8(src3);\n\n const uint8x16_t r0_even = vuzp1q_u8(r0, r0);\n const uint8x16_t r0_odd = vuzp2q_u8(r0, r0);\n const uint8x16_t r1_even = vuzp1q_u8(r1, r1);\n const uint8x16_t r1_odd = vuzp2q_u8(r1, r1);\n const uint8x16_t r2_even = vuzp1q_u8(r2, r2);\n const uint8x16_t r2_odd = vuzp2q_u8(r2, r2);\n const uint8x16_t r3_even = vuzp1q_u8(r3, r3);\n const uint8x16_t r3_odd = vuzp2q_u8(r3, r3);\n\n const uint8x16_t r0_lo = vsliq_n_u8(r0_even, r0_odd, 4);\n const uint8x16_t r0_hi = vsriq_n_u8(r0_odd, r0_even, 4);\n const uint8x16_t r1_lo = vsliq_n_u8(r1_even, r1_odd, 4);\n const uint8x16_t r1_hi = vsriq_n_u8(r1_odd, r1_even, 4);\n const uint8x16_t r2_lo = vsliq_n_u8(r2_even, r2_odd, 4);\n const uint8x16_t r2_hi = vsriq_n_u8(r2_odd, r2_even, 4);\n const uint8x16_t r3_lo = vsliq_n_u8(r3_even, r3_odd, 4);\n const uint8x16_t r3_hi = vsriq_n_u8(r3_odd, r3_even, 4);\n\n const uint8x16_t r0_packed = vcombine_u8(vget_low_u8(r0_lo), vget_low_u8(r0_hi));\n const uint8x16_t r1_packed = vcombine_u8(vget_low_u8(r1_lo), vget_low_u8(r1_hi));\n const uint8x16_t r2_packed = vcombine_u8(vget_low_u8(r2_lo), vget_low_u8(r2_hi));\n const uint8x16_t r3_packed = vcombine_u8(vget_low_u8(r3_lo), vget_low_u8(r3_hi));\n\n vst1q_u8(dst0_bytes, r0_packed);\n vst1q_u8(dst1_bytes, r1_packed);\n vst1q_u8(dst2_bytes, r2_packed);\n vst1q_u8(dst3_bytes, r3_packed);\n return;\n }\n\n const uint8_t* src0_ptr = src0;\n const uint8_t* src1_ptr = src1;\n const uint8_t* src2_ptr = src2;\n const uint8_t* src3_ptr = src3;\n\n size_t remaining = half;\n\n for (; remaining >= 64; remaining -= 64) {\n convert_chunk32_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_chunk32_s1s0_s16s0(dst0_low + 16, dst0_high + 16, src0_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_chunk32_s1s0_s16s0(dst1_low + 16, dst1_high + 16, src1_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_chunk32_s1s0_s16s0(dst2_low + 16, dst2_high + 16, src2_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n convert_chunk32_s1s0_s16s0(dst3_low + 16, dst3_high + 16, src3_ptr + 32);\n\n src0_ptr += 64;\n src1_ptr += 64;\n src2_ptr += 64;\n src3_ptr += 64;\n\n dst0_low += 32;\n dst1_low += 32;\n dst2_low += 32;\n dst3_low += 32;\n\n dst0_high += 32;\n dst1_high += 32;\n dst2_high += 32;\n dst3_high += 32;\n }\n for (; remaining >= 32; remaining -= 32) {\n convert_chunk32_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_chunk32_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_chunk32_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_chunk32_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n\n src0_ptr += 32;\n src1_ptr += 32;\n src2_ptr += 32;\n src3_ptr += 32;\n\n dst0_low += 16;\n dst1_low += 16;\n dst2_low += 16;\n dst3_low += 16;\n\n dst0_high += 16;\n dst1_high += 16;\n dst2_high += 16;\n dst3_high += 16;\n }\n\n if (remaining != 0) {\n convert_tail16_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_tail16_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_tail16_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_tail16_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n }\n}\n\nstatic inline void interleave_rows4_u16(\n uint16_t* dst_row_base, size_t nr, const uint16_t* row0, const uint16_t* row1, const uint16_t* row2,\n const uint16_t* row3, size_t bl4) {\n uint16_t* dst_ptr = dst_row_base;\n\n const uint16_t* row0_ptr = row0;\n const uint16_t* row1_ptr = row1;\n const uint16_t* row2_ptr = row2;\n const uint16_t* row3_ptr = row3;\n\n size_t remaining = bl4;\n\n // Store two columns per iteration to reduce branch and address-generation\n // overhead while keeping all loads sequential.\n for (; remaining >= 2; remaining -= 2) {\n const uint64_t packed0 = (uint64_t)row0_ptr[0] | ((uint64_t)row1_ptr[0] << 16) | ((uint64_t)row2_ptr[0] << 32) |\n ((uint64_t)row3_ptr[0] << 48);\n const uint64_t packed1 = (uint64_t)row0_ptr[1] | ((uint64_t)row1_ptr[1] << 16) | ((uint64_t)row2_ptr[1] << 32) |\n ((uint64_t)row3_ptr[1] << 48);\n\n *((uint64_t*)dst_ptr) = packed0;\n *((uint64_t*)(dst_ptr + nr)) = packed1;\n\n row0_ptr += 2;\n row1_ptr += 2;\n row2_ptr += 2;\n row3_ptr += 2;\n dst_ptr += 2 * nr;\n }\n\n if (remaining != 0) {\n const uint64_t packed = (uint64_t)row0_ptr[0] | ((uint64_t)row1_ptr[0] << 16) | ((uint64_t)row2_ptr[0] << 32) |\n ((uint64_t)row3_ptr[0] << 48);\n *((uint64_t*)dst_ptr) = packed;\n }\n}\n\nstatic inline void store_row_strided_u16(\n uint16_t* dst_block_base, size_t row_idx, size_t nr, const uint16_t* src_vals, size_t bl4, size_t nr1, size_t nr2,\n size_t nr3, size_t dst_step) {\n const uint16_t* src_ptr = src_vals;\n uint16_t* dst_ptr = dst_block_base + row_idx;\n\n size_t remaining_bl4 = bl4;\n for (; remaining_bl4 >= 4; remaining_bl4 -= 4) {\n dst_ptr[0] = src_ptr[0];\n dst_ptr[nr1] = src_ptr[1];\n dst_ptr[nr2] = src_ptr[2];\n dst_ptr[nr3] = src_ptr[3];\n src_ptr += 4;\n dst_ptr += dst_step;\n }\n for (; remaining_bl4 != 0; --remaining_bl4) {\n *dst_ptr = *src_ptr;\n ++src_ptr;\n dst_ptr += nr;\n }\n}\n\ninline static size_t kai_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_num_bytes_per_block(size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n return (bl / 2) + kai_num_bytes_multiplier;\n}\n\ninline static size_t kai_rhs_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n\n return num_bytes_per_block * num_blocks_per_row;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n\n return nr * (num_bytes_per_block * num_blocks_per_row);\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % nr) == 0);\n\n // The scales are stored after all the nr packed quantized values\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t bl, const uint8_t* rhs,\n const float* bias, void* rhs_packed, size_t extra_bytes, const struct kai_rhs_pack_qs4cxs1s0_param* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME(bl <= kai_max_bl);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME(bias == NULL);\n KAI_ASSUME(extra_bytes == 0);\n\n KAI_ASSUME(kr == 4);\n KAI_ASSUME(sr == 2);\n KAI_ASSUME(kr >= 1 && kr <= 16);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(params != NULL);\n KAI_ASSUME(params->rhs_zero_point == 8);\n KAI_ASSUME(params->lhs_zero_point == 1);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t num_blocks = k / bl;\n const size_t rhs_stride = kai_rhs_stride(k, bl);\n const size_t rhs_packed_stride =\n kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n const size_t bl4 = bl / 4;\n const size_t block_stride_u16 = bl4 * nr;\n const size_t scales_offset = rhs_packed_stride - (nr * num_blocks * kai_num_bytes_multiplier);\n\n uint8_t* rhs_packed_ptr = rhs_packed;\n\n if (kr == 4 && sr == 2 && (nr % kai_nr_tile) == 0 && (bl % kai_bl_multiple_of) == 0) {\n // Reuse scratch buffers across all rows and blocks. Four buffers allow\n // row-block interleaving with wide stores across the contiguous row\n // dimension.\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_0[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_1[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_2[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_3[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n\n const size_t nr1 = nr;\n const size_t nr2 = nr1 + nr;\n const size_t nr3 = nr2 + nr;\n const size_t dst_step = nr3 + nr;\n\n for (size_t group_start = 0; group_start < n; group_start += nr, rhs_packed_ptr += rhs_packed_stride) {\n const size_t rows_in_group = KAI_MIN(n - group_start, nr);\n const uint8_t* rhs_group_base = rhs + group_start * rhs_stride;\n\n uint16_t* group_base_u16 = (uint16_t*)rhs_packed_ptr;\n uint16_t* rhs_packed_scales = (uint16_t*)(rhs_packed_ptr + scales_offset);\n\n const uint8_t* src_block_base = rhs_group_base;\n uint16_t* dst_block_base = group_base_u16;\n uint16_t* scales_block = rhs_packed_scales;\n\n for (size_t block_idx = 0; block_idx < num_blocks; ++block_idx) {\n size_t row_idx = 0;\n const uint8_t* src_row_block = src_block_base;\n\n for (; row_idx + kai_nr_tile <= rows_in_group;\n row_idx += kai_nr_tile, src_row_block += kai_nr_tile * rhs_stride) {\n const uint8_t* restrict src_row0 = src_row_block;\n const uint8_t* restrict src_row1 = src_row0 + rhs_stride;\n const uint8_t* restrict src_row2 = src_row1 + rhs_stride;\n const uint8_t* restrict src_row3 = src_row2 + rhs_stride;\n\n const uint16_t scale0 = *((const uint16_t*)src_row0);\n const uint16_t scale1 = *((const uint16_t*)src_row1);\n const uint16_t scale2 = *((const uint16_t*)src_row2);\n const uint16_t scale3 = *((const uint16_t*)src_row3);\n\n const uint64_t packed_scales = (uint64_t)scale0 | ((uint64_t)scale1 << 16) |\n ((uint64_t)scale2 << 32) | ((uint64_t)scale3 << 48);\n *((uint64_t*)(scales_block + row_idx)) = packed_scales;\n\n convert_s1s0_s16s0_neon_rows4(\n blk_s1s0_rows_0, blk_s1s0_rows_1, blk_s1s0_rows_2, blk_s1s0_rows_3,\n src_row0 + kai_num_bytes_multiplier, src_row1 + kai_num_bytes_multiplier,\n src_row2 + kai_num_bytes_multiplier, src_row3 + kai_num_bytes_multiplier, bl);\n\n interleave_rows4_u16(\n dst_block_base + row_idx, nr, blk_s1s0_rows_0, blk_s1s0_rows_1, blk_s1s0_rows_2,\n blk_s1s0_rows_3, bl4);\n }\n\n for (; row_idx < rows_in_group; ++row_idx, src_row_block += rhs_stride) {\n const uint16_t* blk_scale_ptr = (const uint16_t*)src_row_block;\n const uint8_t* blk_s16s0 = src_row_block + kai_num_bytes_multiplier;\n\n scales_block[row_idx] = *blk_scale_ptr;\n\n convert_s1s0_s16s0_neon(blk_s1s0_rows_0, blk_s16s0, bl);\n store_row_strided_u16(dst_block_base, row_idx, nr, blk_s1s0_rows_0, bl4, nr1, nr2, nr3, dst_step);\n }\n\n src_block_base += num_bytes_per_block;\n dst_block_base += block_stride_u16;\n scales_block += nr;\n }\n }\n return;\n }\n\n for (uint64_t n_idx = 0; n_idx < n; n_idx++) {\n uint16_t* rhs_packed_scales =\n (uint16_t*)(rhs_packed_ptr + rhs_packed_stride - (nr * num_blocks * kai_num_bytes_multiplier));\n\n for (size_t block_idx = 0; block_idx < num_blocks; block_idx++) {\n uint16_t blk_s1s0[KAI_SME_VEC_LENGTH_MAX_BYTES / 4];\n\n const uint16_t* blk_scale_ptr =\n (const uint16_t*)(rhs + (block_idx * num_bytes_per_block) + n_idx * rhs_stride);\n const uint8_t* blk_s16s0 = (const uint8_t*)blk_scale_ptr + kai_num_bytes_multiplier;\n\n convert_s1s0_s16s0_scalar(blk_s1s0, blk_s16s0, bl);\n\n for (size_t bl4_idx = 0; bl4_idx < bl / 4; bl4_idx++) {\n // Uint16 holds 4 int4 values\n ((uint16_t*)rhs_packed_ptr)[(block_idx * bl / 4 + bl4_idx) * nr + (n_idx % nr)] = blk_s1s0[bl4_idx];\n }\n\n // Num. block (rows) x Nr (cols)\n rhs_packed_scales[(n_idx % nr) + block_idx * nr] = *blk_scale_ptr;\n }\n\n if (((n_idx + 1) % nr) == 0) {\n rhs_packed_ptr += rhs_packed_stride;\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n///\n/// Two int4 K values are stored in one byte. These values are stored in blocks, where each block\n/// has it own scale factor. The scale factor is expected to be a f16 value and stored at the beginning of each block.\n/// The first byte in the block holds the K-index + 0 and K-index + 16 values.\n/// The K-index + 0 value is stored in the lower order part of the byte (low nibble) while\n/// the K-index + 16 value is stored in the higher order part (high nibble).\n/// For example, if the block length is 32, the values are stored in the following order:\n/// |byte(s16, s0),byte(s17, s1),byte(s18, s2),...,byte(s31, s15),float16(scale)|\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, //\n size_t rhs_stride); //\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl); //\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl); //\n\n/// Runs the RHS packing micro-kernel.\n///\n/// The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte. The lower order part of the byte (low) holds\n/// the first nibble (K-index + 0). The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] bias The biases.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n const float* bias, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_qs4cxs1s0_param* params); //\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa against gemm_f16act_qs4c32_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_pack_f16pmrx2_f32_neon.h\"\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n// Interleave B_q4 [N, K/2] and the raw f16 B_scales [N, K/32] into the per-block [scale f16][16 data bytes]\n// layout kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon expects.\nvoid interleave_qs4c32(const uint8_t* b_q4, const uint16_t* b_scales, uint8_t* dst) {\n const size_t nb = K / BL, data = BL / 2;\n for (size_t n = 0; n < (size_t)N; ++n)\n for (size_t b = 0; b < nb; ++b) {\n std::memcpy(dst, &b_scales[n * nb + b], sizeof(uint16_t));\n dst += sizeof(uint16_t);\n std::memcpy(dst, b_q4 + (n * nb + b) * data, data);\n dst += data;\n }\n}\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n // The kernel's LHS packer reads fp32 (it narrows to fp16 itself), so the fp16 activation is widened first (timed).\n static float* a32 = nullptr;\n static size_t a32_cap = 0;\n if ((size_t)M * K > a32_cap) {\n std::free(a32);\n a32 = static_cast(std::malloc(sizeof(float) * (size_t)M * K));\n a32_cap = (size_t)M * K;\n if (a32 == nullptr) return -1;\n }\n widen_f16(A, a32, (size_t)M * K);\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_pack_f16pmrx2_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_pack_f16pmrx2_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, a32, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(uint16_t)*N*(K/BL));\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon((size_t)N, (size_t)K, nr, kr, BL);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n const size_t nb = K / BL;\n uint8_t* inter = static_cast(std::malloc((size_t)N * nb * (BL / 2 + sizeof(uint16_t))));\n if (inter == nullptr) return -1;\n interleave_qs4c32(B_q4, B_scales, inter);\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(1, (size_t)N, (size_t)K, nr, kr, sr, BL, inter, nullptr, rhs_packed, 0, ¶ms);\n std::free(inter);\n }\n\n kai_run_matmul_clamp_f32_f16p1vlx2_qsi4c32p4vlx2_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f32_bf16_n512_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f32_bf16_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..0322ea6824a628bd281cb2b588168da5de72b03e --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f32_bf16_n512_k512.json @@ -0,0 +1,74 @@ +{ + "name": "baseline-kleidiai-arm_gemm_f32_bf16_n512_k512", + "definition": "gemm_f32_bf16_n512_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_f32_bf16_n512_k512: KleidiAI kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "i8mm" + ], + "compile_flags": [ + "-O3", + "-march=armv8.2-a+dotprod+i8mm+bf16" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// --------------------------------------------------\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets mr value.\n///\n/// This is the packing parameter which must be used to pack the LHS matrix.\n///\n/// @return The mr value.\nsize_t kai_get_mr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets nr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The nr value.\nsize_t kai_get_nr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets kr value.\n///\n/// This is the packing parameter which must be used to pack the LHS & RHS matrices.\n///\n/// @return The kr value.\nsize_t kai_get_kr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets sr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The sr value.\nsize_t kai_get_sr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS matrix buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] k Number of columns.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Row index.\n/// @param[in] k Number of columns.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] n_idx Column index.\n/// @param[in] stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(\n size_t m_idx, size_t n_idx, size_t stride);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.\n/// * Packed RHS: @ref kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.\n/// * Output: @ref kai_get_dst_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.\n///\n/// @param[in] m Number of output rows to be computed.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k Common dimension of the LHS and RHS operand.\n/// @param[in] lhs_packed Packed LHS buffer.\n/// @param[in] rhs_packed Packed RHS buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. For now, it must be sizeof(float)\n/// @param[in] clamp_min Minimum value to clamp the final result.\n/// @param[in] clamp_max Maximum value to clamp the final result.\nvoid kai_run_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(\n size_t m, size_t n, size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n void* dst, size_t dst_stride_row, size_t dst_stride_col, //\n float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// Do not flag up inline assembly blocks\n#pragma GCC diagnostic ignored \"-Woverlength-strings\"\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_BF16.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.h\"\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_mr = 8;\nstatic const size_t kai_nr = 12;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nsize_t kai_get_m_step_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_mr;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_nr;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t m_idx, size_t k) {\n KAI_ASSUME(m_idx % kai_mr == 0);\n\n return m_idx * kai_roundup(k, kai_kr) * sizeof(uint16_t);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t n_idx, size_t k) {\n KAI_ASSUME(n_idx % kai_nr == 0);\n\n return n_idx * (sizeof(float) + kai_roundup(k, kai_kr) * sizeof(uint16_t));\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(\n size_t m_idx, size_t n_idx, size_t stride) {\n KAI_ASSUME(m_idx % kai_mr == 0);\n KAI_ASSUME(n_idx % kai_nr == 0);\n\n return m_idx * stride + n_idx * sizeof(float);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(size_t m, size_t n) {\n return m * n * sizeof(float);\n}\n\nvoid kai_run_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla(\n size_t m, size_t n, size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n void* dst, size_t dst_stride_row, size_t dst_stride_col, //\n float clamp_min, float clamp_max) {\n KAI_ASSERT(dst_stride_col == sizeof(float));\n\n const void* Apanel = lhs_packed;\n void* Cpanel = dst;\n size_t ldc = dst_stride_row / sizeof(float);\n\n size_t M = m;\n\n typedef struct {\n float maxval;\n float minval;\n size_t N;\n size_t K;\n const void* Bpanel;\n void* output_ptr;\n } KernelArgs;\n\n KernelArgs ka;\n\n ka.N = n;\n ka.K = kai_roundup(k, kai_kr) / kai_kr - 1;\n\n ka.Bpanel = rhs_packed;\n\n // Direct output.\n ka.output_ptr = dst;\n\n // Clamping output.\n ka.maxval = clamp_max;\n ka.minval = clamp_min;\n\n __asm__ __volatile__(\n \"1:\" // Height loop\n \"add x11, %x[Cpanel], %x[ldc], LSL #2\\n\"\n \"add x10, %x[Cpanel], %x[ldc], LSL #1\\n\"\n \"add x9, x11, %x[ldc], LSL #1\\n\"\n \"cmp %x[M], #0x8\\n\"\n \"add x28, %x[Cpanel], %x[ldc], LSL #3\\n\"\n \"add x27, %x[Cpanel], %x[ldc]\\n\"\n \"add x26, x10, %x[ldc]\\n\"\n \"add x25, x11, %x[ldc]\\n\"\n \"add x24, x9, %x[ldc]\\n\"\n \"bge 2f\\n\"\n \"cmp %x[M], #0x2\\n\"\n \"mov x24, %x[Cpanel]\\n\"\n \"csel x27, x27, %x[Cpanel], GE\\n\"\n \"csel x10, x10, %x[Cpanel], GT\\n\"\n \"cmp %x[M], #0x4\\n\"\n \"csel x26, x26, %x[Cpanel], GE\\n\"\n \"csel x11, x11, %x[Cpanel], GT\\n\"\n \"cmp %x[M], #0x6\\n\"\n \"csel x25, x25, %x[Cpanel], GE\\n\"\n \"csel x9, x9, %x[Cpanel], GT\\n\"\n \"2:\" // all rows valid\n \"ldr x23, [%x[args_ptr], %[offsetof_N]]\\n\"\n \"ldr x22, [%x[args_ptr], %[offsetof_Bpanel]]\\n\"\n \"mov x21, %x[Apanel]\\n\"\n \"3:\" // Width loop\n \"ldr q4, [x22, #0x0]\\n\"\n \"ldr q5, [x22, #0x10]\\n\"\n \"mov %x[Apanel], x21\\n\"\n \"ldr q6, [x22, #0x20]\\n\"\n \"ldr x20, [%x[args_ptr], %[offsetof_K]]\\n\"\n \"add x22, x22, #0x30\\n\"\n \"ldr q7, [x22, #0x0]\\n\"\n \"ldr q0, [%x[Apanel], #0x0]\\n\"\n \"ldr q1, [%x[Apanel], #0x10]\\n\"\n \"zip1 v8.2d, v4.2d, v4.2d\\n\"\n \"ldr q2, [%x[Apanel], #0x20]\\n\"\n \"zip2 v11.2d, v4.2d, v4.2d\\n\"\n \"ldr q4, [x22, #0x10]\\n\"\n \"zip1 v9.2d, v5.2d, v5.2d\\n\"\n \"zip2 v12.2d, v5.2d, v5.2d\\n\"\n \"cmp x20, #0x2\\n\"\n \"zip1 v10.2d, v6.2d, v6.2d\\n\"\n \"zip2 v13.2d, v6.2d, v6.2d\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0x0]\\n\"\n \"mov v14.16b, v8.16b\\n\"\n \"mov v17.16b, v11.16b\\n\"\n \"prfm pldl1keep, [x22, #0x0]\\n\"\n \"mov v15.16b, v9.16b\\n\"\n \"mov v18.16b, v12.16b\\n\"\n \"prfm pldl1keep, [x22, #0x40]\\n\"\n \"mov v16.16b, v10.16b\\n\"\n \"mov v19.16b, v13.16b\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0x40]\\n\"\n \"mov v20.16b, v8.16b\\n\"\n \"mov v21.16b, v9.16b\\n\"\n \"prfm pldl1keep, [x22, #0x80]\\n\"\n \"mov v22.16b, v10.16b\\n\"\n \"mov v23.16b, v11.16b\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0x80]\\n\"\n \"mov v24.16b, v12.16b\\n\"\n \"mov v25.16b, v13.16b\\n\"\n \"prfm pldl1keep, [x22, #0xc0]\\n\"\n \"mov v26.16b, v8.16b\\n\"\n \"mov v27.16b, v9.16b\\n\"\n \"prfm pldl1keep, [x22, #0x100]\\n\"\n \"mov v28.16b, v10.16b\\n\"\n \"mov v29.16b, v11.16b\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0xc0]\\n\"\n \"mov v30.16b, v12.16b\\n\"\n \"mov v31.16b, v13.16b\\n\"\n \"prfm pldl1keep, [x22, #0x140]\\n\"\n \"add x22, x22, #0x20\\n\"\n \"add %x[Apanel], %x[Apanel], #0x30\\n\"\n \"blt 5f\\n\"\n \"4:\" // main loop head\n \"ldr q3, [%x[Apanel], #0x0]\\n\"\n \"ldr q5, [x22, #0x0]\\n\"\n \".inst 0x6e47ec08 // bfmmla v8.4s, v0.8h, v7.8h\\n\"\n \"ldr q6, [x22, #0x10]\\n\"\n \".inst 0x6e44ec0b // bfmmla v11.4s, v0.8h, v4.8h\\n\"\n \".inst 0x6e47ec2e // bfmmla v14.4s, v1.8h, v7.8h\\n\"\n \".inst 0x6e44ec31 // bfmmla v17.4s, v1.8h, v4.8h\\n\"\n \".inst 0x6e47ec54 // bfmmla v20.4s, v2.8h, v7.8h\\n\"\n \"sub x20, x20, #0x2\\n\"\n \".inst 0x6e44ec57 // bfmmla v23.4s, v2.8h, v4.8h\\n\"\n \".inst 0x6e47ec7a // bfmmla v26.4s, v3.8h, v7.8h\\n\"\n \"ldr q7, [x22, #0x20]\\n\"\n \".inst 0x6e44ec7d // bfmmla v29.4s, v3.8h, v4.8h\\n\"\n \"ldr q4, [x22, #0x30]\\n\"\n \".inst 0x6e45ec09 // bfmmla v9.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0c // bfmmla v12.4s, v0.8h, v6.8h\\n\"\n \".inst 0x6e45ec2f // bfmmla v15.4s, v1.8h, v5.8h\\n\"\n \"cmp x20, #0x2\\n\"\n \".inst 0x6e46ec32 // bfmmla v18.4s, v1.8h, v6.8h\\n\"\n \".inst 0x6e45ec55 // bfmmla v21.4s, v2.8h, v5.8h\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0x100]\\n\"\n \".inst 0x6e46ec58 // bfmmla v24.4s, v2.8h, v6.8h\\n\"\n \".inst 0x6e45ec7b // bfmmla v27.4s, v3.8h, v5.8h\\n\"\n \"ldr q5, [x22, #0x40]\\n\"\n \".inst 0x6e46ec7e // bfmmla v30.4s, v3.8h, v6.8h\\n\"\n \"ldr q6, [x22, #0x50]\\n\"\n \".inst 0x6e47ec0a // bfmmla v10.4s, v0.8h, v7.8h\\n\"\n \".inst 0x6e44ec0d // bfmmla v13.4s, v0.8h, v4.8h\\n\"\n \"ldr q0, [%x[Apanel], #0x10]\\n\"\n \".inst 0x6e47ec30 // bfmmla v16.4s, v1.8h, v7.8h\\n\"\n \".inst 0x6e44ec33 // bfmmla v19.4s, v1.8h, v4.8h\\n\"\n \"ldr q1, [%x[Apanel], #0x20]\\n\"\n \".inst 0x6e47ec56 // bfmmla v22.4s, v2.8h, v7.8h\\n\"\n \".inst 0x6e44ec59 // bfmmla v25.4s, v2.8h, v4.8h\\n\"\n \"ldr q2, [%x[Apanel], #0x30]\\n\"\n \".inst 0x6e47ec7c // bfmmla v28.4s, v3.8h, v7.8h\\n\"\n \"ldr q7, [x22, #0x60]\\n\"\n \".inst 0x6e44ec7f // bfmmla v31.4s, v3.8h, v4.8h\\n\"\n \"ldr q3, [%x[Apanel], #0x40]\\n\"\n \"ldr q4, [x22, #0x70]\\n\"\n \".inst 0x6e45ec08 // bfmmla v8.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0b // bfmmla v11.4s, v0.8h, v6.8h\\n\"\n \".inst 0x6e45ec2e // bfmmla v14.4s, v1.8h, v5.8h\\n\"\n \".inst 0x6e46ec31 // bfmmla v17.4s, v1.8h, v6.8h\\n\"\n \"prfm pldl1keep, [x22, #0x180]\\n\"\n \".inst 0x6e45ec54 // bfmmla v20.4s, v2.8h, v5.8h\\n\"\n \".inst 0x6e46ec57 // bfmmla v23.4s, v2.8h, v6.8h\\n\"\n \"prfm pldl1keep, [x22, #0x1c0]\\n\"\n \".inst 0x6e45ec7a // bfmmla v26.4s, v3.8h, v5.8h\\n\"\n \"ldr q5, [x22, #0x80]\\n\"\n \".inst 0x6e46ec7d // bfmmla v29.4s, v3.8h, v6.8h\\n\"\n \"ldr q6, [x22, #0x90]\\n\"\n \"prfm pldl1keep, [%x[Apanel], #0x140]\\n\"\n \".inst 0x6e47ec09 // bfmmla v9.4s, v0.8h, v7.8h\\n\"\n \"prfm pldl1keep, [x22, #0x200]\\n\"\n \".inst 0x6e44ec0c // bfmmla v12.4s, v0.8h, v4.8h\\n\"\n \".inst 0x6e47ec2f // bfmmla v15.4s, v1.8h, v7.8h\\n\"\n \".inst 0x6e44ec32 // bfmmla v18.4s, v1.8h, v4.8h\\n\"\n \".inst 0x6e47ec55 // bfmmla v21.4s, v2.8h, v7.8h\\n\"\n \".inst 0x6e44ec58 // bfmmla v24.4s, v2.8h, v4.8h\\n\"\n \".inst 0x6e47ec7b // bfmmla v27.4s, v3.8h, v7.8h\\n\"\n \"ldr q7, [x22, #0xa0]\\n\"\n \".inst 0x6e44ec7e // bfmmla v30.4s, v3.8h, v4.8h\\n\"\n \"ldr q4, [x22, #0xb0]\\n\"\n \".inst 0x6e45ec0a // bfmmla v10.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0d // bfmmla v13.4s, v0.8h, v6.8h\\n\"\n \"ldr q0, [%x[Apanel], #0x50]\\n\"\n \".inst 0x6e45ec30 // bfmmla v16.4s, v1.8h, v5.8h\\n\"\n \".inst 0x6e46ec33 // bfmmla v19.4s, v1.8h, v6.8h\\n\"\n \"ldr q1, [%x[Apanel], #0x60]\\n\"\n \".inst 0x6e45ec56 // bfmmla v22.4s, v2.8h, v5.8h\\n\"\n \".inst 0x6e46ec59 // bfmmla v25.4s, v2.8h, v6.8h\\n\"\n \"ldr q2, [%x[Apanel], #0x70]\\n\"\n \".inst 0x6e45ec7c // bfmmla v28.4s, v3.8h, v5.8h\\n\"\n \".inst 0x6e46ec7f // bfmmla v31.4s, v3.8h, v6.8h\\n\"\n \"add %x[Apanel], %x[Apanel], #0x80\\n\"\n \"add x22, x22, #0xc0\\n\"\n \"bge 4b\\n\"\n \"5:\" // main loop skip\n \"ldr q3, [%x[Apanel], #0x0]\\n\"\n \"ldr q5, [x22, #0x0]\\n\"\n \".inst 0x6e47ec08 // bfmmla v8.4s, v0.8h, v7.8h\\n\"\n \"ldr q6, [x22, #0x10]\\n\"\n \".inst 0x6e44ec0b // bfmmla v11.4s, v0.8h, v4.8h\\n\"\n \".inst 0x6e47ec2e // bfmmla v14.4s, v1.8h, v7.8h\\n\"\n \".inst 0x6e44ec31 // bfmmla v17.4s, v1.8h, v4.8h\\n\"\n \".inst 0x6e47ec54 // bfmmla v20.4s, v2.8h, v7.8h\\n\"\n \"add %x[Apanel], %x[Apanel], #0x10\\n\"\n \".inst 0x6e44ec57 // bfmmla v23.4s, v2.8h, v4.8h\\n\"\n \".inst 0x6e47ec7a // bfmmla v26.4s, v3.8h, v7.8h\\n\"\n \"ldr q7, [x22, #0x20]\\n\"\n \".inst 0x6e44ec7d // bfmmla v29.4s, v3.8h, v4.8h\\n\"\n \"ldr q4, [x22, #0x30]\\n\"\n \".inst 0x6e45ec09 // bfmmla v9.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0c // bfmmla v12.4s, v0.8h, v6.8h\\n\"\n \".inst 0x6e45ec2f // bfmmla v15.4s, v1.8h, v5.8h\\n\"\n \"add x22, x22, #0x40\\n\"\n \".inst 0x6e46ec32 // bfmmla v18.4s, v1.8h, v6.8h\\n\"\n \".inst 0x6e45ec55 // bfmmla v21.4s, v2.8h, v5.8h\\n\"\n \".inst 0x6e46ec58 // bfmmla v24.4s, v2.8h, v6.8h\\n\"\n \".inst 0x6e45ec7b // bfmmla v27.4s, v3.8h, v5.8h\\n\"\n \".inst 0x6e46ec7e // bfmmla v30.4s, v3.8h, v6.8h\\n\"\n \".inst 0x6e47ec0a // bfmmla v10.4s, v0.8h, v7.8h\\n\"\n \".inst 0x6e44ec0d // bfmmla v13.4s, v0.8h, v4.8h\\n\"\n \".inst 0x6e47ec30 // bfmmla v16.4s, v1.8h, v7.8h\\n\"\n \".inst 0x6e44ec33 // bfmmla v19.4s, v1.8h, v4.8h\\n\"\n \".inst 0x6e47ec56 // bfmmla v22.4s, v2.8h, v7.8h\\n\"\n \".inst 0x6e44ec59 // bfmmla v25.4s, v2.8h, v4.8h\\n\"\n \".inst 0x6e47ec7c // bfmmla v28.4s, v3.8h, v7.8h\\n\"\n \".inst 0x6e44ec7f // bfmmla v31.4s, v3.8h, v4.8h\\n\"\n \"cbz x20, 6f\\n\"\n \"ldr q5, [x22, #0x0]\\n\"\n \"ldr q0, [%x[Apanel], #0x0]\\n\"\n \"ldr q1, [%x[Apanel], #0x10]\\n\"\n \"ldr q6, [x22, #0x10]\\n\"\n \"ldr q2, [%x[Apanel], #0x20]\\n\"\n \"ldr q3, [%x[Apanel], #0x30]\\n\"\n \"add %x[Apanel], %x[Apanel], #0x40\\n\"\n \"ldr q7, [x22, #0x20]\\n\"\n \"ldr q4, [x22, #0x30]\\n\"\n \".inst 0x6e45ec08 // bfmmla v8.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0b // bfmmla v11.4s, v0.8h, v6.8h\\n\"\n \".inst 0x6e45ec2e // bfmmla v14.4s, v1.8h, v5.8h\\n\"\n \".inst 0x6e46ec31 // bfmmla v17.4s, v1.8h, v6.8h\\n\"\n \".inst 0x6e45ec54 // bfmmla v20.4s, v2.8h, v5.8h\\n\"\n \".inst 0x6e46ec57 // bfmmla v23.4s, v2.8h, v6.8h\\n\"\n \".inst 0x6e45ec7a // bfmmla v26.4s, v3.8h, v5.8h\\n\"\n \"ldr q5, [x22, #0x40]\\n\"\n \".inst 0x6e46ec7d // bfmmla v29.4s, v3.8h, v6.8h\\n\"\n \"ldr q6, [x22, #0x50]\\n\"\n \".inst 0x6e47ec09 // bfmmla v9.4s, v0.8h, v7.8h\\n\"\n \".inst 0x6e44ec0c // bfmmla v12.4s, v0.8h, v4.8h\\n\"\n \".inst 0x6e47ec2f // bfmmla v15.4s, v1.8h, v7.8h\\n\"\n \"add x22, x22, #0x60\\n\"\n \".inst 0x6e44ec32 // bfmmla v18.4s, v1.8h, v4.8h\\n\"\n \".inst 0x6e47ec55 // bfmmla v21.4s, v2.8h, v7.8h\\n\"\n \".inst 0x6e44ec58 // bfmmla v24.4s, v2.8h, v4.8h\\n\"\n \".inst 0x6e47ec7b // bfmmla v27.4s, v3.8h, v7.8h\\n\"\n \".inst 0x6e44ec7e // bfmmla v30.4s, v3.8h, v4.8h\\n\"\n \".inst 0x6e45ec0a // bfmmla v10.4s, v0.8h, v5.8h\\n\"\n \".inst 0x6e46ec0d // bfmmla v13.4s, v0.8h, v6.8h\\n\"\n \".inst 0x6e45ec30 // bfmmla v16.4s, v1.8h, v5.8h\\n\"\n \".inst 0x6e46ec33 // bfmmla v19.4s, v1.8h, v6.8h\\n\"\n \".inst 0x6e45ec56 // bfmmla v22.4s, v2.8h, v5.8h\\n\"\n \".inst 0x6e46ec59 // bfmmla v25.4s, v2.8h, v6.8h\\n\"\n \".inst 0x6e45ec7c // bfmmla v28.4s, v3.8h, v5.8h\\n\"\n \".inst 0x6e46ec7f // bfmmla v31.4s, v3.8h, v6.8h\\n\"\n \"6:\" // multiply loop done\n \"add x20, %x[args_ptr], %[offset_max]\\n\"\n \"uzp1 v7.2d, v8.2d, v11.2d\\n\"\n \"uzp2 v8.2d, v8.2d, v11.2d\\n\"\n \"ld1r { v1.4s }, [x20]\\n\"\n \"uzp1 v11.2d, v9.2d, v12.2d\\n\"\n \"uzp2 v9.2d, v9.2d, v12.2d\\n\"\n \"uzp1 v12.2d, v10.2d, v13.2d\\n\"\n \"uzp2 v10.2d, v10.2d, v13.2d\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v0.4s }, [x20]\\n\"\n \"uzp1 v13.2d, v14.2d, v17.2d\\n\"\n \"uzp2 v14.2d, v14.2d, v17.2d\\n\"\n \"uzp1 v17.2d, v15.2d, v18.2d\\n\"\n \"uzp2 v15.2d, v15.2d, v18.2d\\n\"\n \"cmp x23, #0xc\\n\"\n \"uzp1 v18.2d, v16.2d, v19.2d\\n\"\n \"uzp2 v16.2d, v16.2d, v19.2d\\n\"\n \"uzp1 v19.2d, v20.2d, v23.2d\\n\"\n \"uzp2 v20.2d, v20.2d, v23.2d\\n\"\n \"uzp1 v23.2d, v21.2d, v24.2d\\n\"\n \"uzp2 v21.2d, v21.2d, v24.2d\\n\"\n \"uzp1 v24.2d, v22.2d, v25.2d\\n\"\n \"uzp2 v22.2d, v22.2d, v25.2d\\n\"\n \"uzp1 v25.2d, v26.2d, v29.2d\\n\"\n \"uzp2 v26.2d, v26.2d, v29.2d\\n\"\n \"uzp1 v29.2d, v27.2d, v30.2d\\n\"\n \"uzp2 v27.2d, v27.2d, v30.2d\\n\"\n \"uzp1 v30.2d, v28.2d, v31.2d\\n\"\n \"uzp2 v28.2d, v28.2d, v31.2d\\n\"\n \"fmin v7.4s, v7.4s, v1.4s\\n\"\n \"fmin v11.4s, v11.4s, v1.4s\\n\"\n \"fmin v12.4s, v12.4s, v1.4s\\n\"\n \"fmin v8.4s, v8.4s, v1.4s\\n\"\n \"fmin v9.4s, v9.4s, v1.4s\\n\"\n \"fmin v10.4s, v10.4s, v1.4s\\n\"\n \"fmin v13.4s, v13.4s, v1.4s\\n\"\n \"fmin v17.4s, v17.4s, v1.4s\\n\"\n \"fmin v18.4s, v18.4s, v1.4s\\n\"\n \"fmin v14.4s, v14.4s, v1.4s\\n\"\n \"fmin v15.4s, v15.4s, v1.4s\\n\"\n \"fmin v16.4s, v16.4s, v1.4s\\n\"\n \"fmin v19.4s, v19.4s, v1.4s\\n\"\n \"fmin v23.4s, v23.4s, v1.4s\\n\"\n \"fmin v24.4s, v24.4s, v1.4s\\n\"\n \"fmin v20.4s, v20.4s, v1.4s\\n\"\n \"fmin v21.4s, v21.4s, v1.4s\\n\"\n \"fmin v22.4s, v22.4s, v1.4s\\n\"\n \"fmin v25.4s, v25.4s, v1.4s\\n\"\n \"fmin v29.4s, v29.4s, v1.4s\\n\"\n \"fmin v30.4s, v30.4s, v1.4s\\n\"\n \"fmin v26.4s, v26.4s, v1.4s\\n\"\n \"fmin v27.4s, v27.4s, v1.4s\\n\"\n \"fmin v28.4s, v28.4s, v1.4s\\n\"\n \"fmax v7.4s, v7.4s, v0.4s\\n\"\n \"fmax v11.4s, v11.4s, v0.4s\\n\"\n \"fmax v12.4s, v12.4s, v0.4s\\n\"\n \"fmax v8.4s, v8.4s, v0.4s\\n\"\n \"fmax v9.4s, v9.4s, v0.4s\\n\"\n \"fmax v10.4s, v10.4s, v0.4s\\n\"\n \"fmax v13.4s, v13.4s, v0.4s\\n\"\n \"fmax v17.4s, v17.4s, v0.4s\\n\"\n \"fmax v18.4s, v18.4s, v0.4s\\n\"\n \"fmax v14.4s, v14.4s, v0.4s\\n\"\n \"fmax v15.4s, v15.4s, v0.4s\\n\"\n \"fmax v16.4s, v16.4s, v0.4s\\n\"\n \"fmax v19.4s, v19.4s, v0.4s\\n\"\n \"fmax v23.4s, v23.4s, v0.4s\\n\"\n \"fmax v24.4s, v24.4s, v0.4s\\n\"\n \"fmax v20.4s, v20.4s, v0.4s\\n\"\n \"fmax v21.4s, v21.4s, v0.4s\\n\"\n \"fmax v22.4s, v22.4s, v0.4s\\n\"\n \"fmax v25.4s, v25.4s, v0.4s\\n\"\n \"fmax v29.4s, v29.4s, v0.4s\\n\"\n \"fmax v30.4s, v30.4s, v0.4s\\n\"\n \"fmax v26.4s, v26.4s, v0.4s\\n\"\n \"fmax v27.4s, v27.4s, v0.4s\\n\"\n \"fmax v28.4s, v28.4s, v0.4s\\n\"\n \"blt 7f\\n\"\n \"str q26, [x24, #0x0]\\n\"\n \"str q27, [x24, #0x10]\\n\"\n \"str q28, [x24, #0x20]\\n\"\n \"add x24, x24, #0x30\\n\"\n \"str q25, [x9, #0x0]\\n\"\n \"str q29, [x9, #0x10]\\n\"\n \"str q30, [x9, #0x20]\\n\"\n \"add x9, x9, #0x30\\n\"\n \"str q20, [x25, #0x0]\\n\"\n \"str q21, [x25, #0x10]\\n\"\n \"str q22, [x25, #0x20]\\n\"\n \"add x25, x25, #0x30\\n\"\n \"str q19, [x11, #0x0]\\n\"\n \"str q23, [x11, #0x10]\\n\"\n \"str q24, [x11, #0x20]\\n\"\n \"add x11, x11, #0x30\\n\"\n \"str q14, [x26, #0x0]\\n\"\n \"str q15, [x26, #0x10]\\n\"\n \"str q16, [x26, #0x20]\\n\"\n \"add x26, x26, #0x30\\n\"\n \"str q13, [x10, #0x0]\\n\"\n \"str q17, [x10, #0x10]\\n\"\n \"str q18, [x10, #0x20]\\n\"\n \"add x10, x10, #0x30\\n\"\n \"str q8, [x27, #0x0]\\n\"\n \"str q9, [x27, #0x10]\\n\"\n \"str q10, [x27, #0x20]\\n\"\n \"add x27, x27, #0x30\\n\"\n \"str q7, [%x[Cpanel], #0x0]\\n\"\n \"str q11, [%x[Cpanel], #0x10]\\n\"\n \"str q12, [%x[Cpanel], #0x20]\\n\"\n \"add %x[Cpanel], %x[Cpanel], #0x30\\n\"\n \"b 14f\\n\"\n \"7:\" // partial output\n \"tbz x23, #3, 9f\\n\"\n \"st1 { v26.4s }, [x24], #0x10\\n\"\n \"st1 { v27.4s }, [x24], #0x10\\n\"\n \"st1 { v25.4s }, [x9], #0x10\\n\"\n \"st1 { v29.4s }, [x9], #0x10\\n\"\n \"st1 { v20.4s }, [x25], #0x10\\n\"\n \"st1 { v21.4s }, [x25], #0x10\\n\"\n \"st1 { v19.4s }, [x11], #0x10\\n\"\n \"st1 { v23.4s }, [x11], #0x10\\n\"\n \"st1 { v14.4s }, [x26], #0x10\\n\"\n \"st1 { v15.4s }, [x26], #0x10\\n\"\n \"st1 { v13.4s }, [x10], #0x10\\n\"\n \"st1 { v17.4s }, [x10], #0x10\\n\"\n \"st1 { v8.4s }, [x27], #0x10\\n\"\n \"st1 { v9.4s }, [x27], #0x10\\n\"\n \"st1 { v7.4s }, [%x[Cpanel]], #0x10\\n\"\n \"st1 { v11.4s }, [%x[Cpanel]], #0x10\\n\"\n \"tbz x23, #1, 8f\\n\"\n \"str d28, [x24], #0x8\\n\"\n \"str d30, [x9], #0x8\\n\"\n \"str d22, [x25], #0x8\\n\"\n \"str d24, [x11], #0x8\\n\"\n \"str d16, [x26], #0x8\\n\"\n \"str d18, [x10], #0x8\\n\"\n \"str d10, [x27], #0x8\\n\"\n \"str d12, [%x[Cpanel]], #0x8\\n\"\n \"tbz x23, #0, 13f\\n\"\n \"st1 { v28.s }[2], [x24]\\n\"\n \"st1 { v30.s }[2], [x9]\\n\"\n \"st1 { v22.s }[2], [x25]\\n\"\n \"st1 { v24.s }[2], [x11]\\n\"\n \"st1 { v16.s }[2], [x26]\\n\"\n \"st1 { v18.s }[2], [x10]\\n\"\n \"st1 { v10.s }[2], [x27]\\n\"\n \"st1 { v12.s }[2], [%x[Cpanel]]\\n\"\n \"b 13f\\n\"\n \"8:\" // partial result store: partial_1_8\n \"tbz x23, #0, 13f\\n\"\n \"str s28, [x24, #0x0]\\n\"\n \"str s30, [x9, #0x0]\\n\"\n \"str s22, [x25, #0x0]\\n\"\n \"str s24, [x11, #0x0]\\n\"\n \"str s16, [x26, #0x0]\\n\"\n \"str s18, [x10, #0x0]\\n\"\n \"str s10, [x27, #0x0]\\n\"\n \"str s12, [%x[Cpanel], #0x0]\\n\"\n \"b 13f\\n\"\n \"9:\" // partial result store: partial_4_0\n \"tbz x23, #2, 11f\\n\"\n \"st1 { v26.4s }, [x24], #0x10\\n\"\n \"st1 { v25.4s }, [x9], #0x10\\n\"\n \"st1 { v20.4s }, [x25], #0x10\\n\"\n \"st1 { v19.4s }, [x11], #0x10\\n\"\n \"st1 { v14.4s }, [x26], #0x10\\n\"\n \"st1 { v13.4s }, [x10], #0x10\\n\"\n \"st1 { v8.4s }, [x27], #0x10\\n\"\n \"st1 { v7.4s }, [%x[Cpanel]], #0x10\\n\"\n \"tbz x23, #1, 10f\\n\"\n \"str d27, [x24], #0x8\\n\"\n \"str d29, [x9], #0x8\\n\"\n \"str d21, [x25], #0x8\\n\"\n \"str d23, [x11], #0x8\\n\"\n \"str d15, [x26], #0x8\\n\"\n \"str d17, [x10], #0x8\\n\"\n \"str d9, [x27], #0x8\\n\"\n \"str d11, [%x[Cpanel]], #0x8\\n\"\n \"tbz x23, #0, 13f\\n\"\n \"st1 { v27.s }[2], [x24]\\n\"\n \"st1 { v29.s }[2], [x9]\\n\"\n \"st1 { v21.s }[2], [x25]\\n\"\n \"st1 { v23.s }[2], [x11]\\n\"\n \"st1 { v15.s }[2], [x26]\\n\"\n \"st1 { v17.s }[2], [x10]\\n\"\n \"st1 { v9.s }[2], [x27]\\n\"\n \"st1 { v11.s }[2], [%x[Cpanel]]\\n\"\n \"b 13f\\n\"\n \"10:\" // partial result store: partial_1_4\n \"tbz x23, #0, 13f\\n\"\n \"str s27, [x24, #0x0]\\n\"\n \"str s29, [x9, #0x0]\\n\"\n \"str s21, [x25, #0x0]\\n\"\n \"str s23, [x11, #0x0]\\n\"\n \"str s15, [x26, #0x0]\\n\"\n \"str s17, [x10, #0x0]\\n\"\n \"str s9, [x27, #0x0]\\n\"\n \"str s11, [%x[Cpanel], #0x0]\\n\"\n \"b 13f\\n\"\n \"11:\" // partial result store: partial_2_0\n \"tbz x23, #1, 12f\\n\"\n \"str d26, [x24], #0x8\\n\"\n \"str d25, [x9], #0x8\\n\"\n \"str d20, [x25], #0x8\\n\"\n \"str d19, [x11], #0x8\\n\"\n \"str d14, [x26], #0x8\\n\"\n \"str d13, [x10], #0x8\\n\"\n \"str d8, [x27], #0x8\\n\"\n \"str d7, [%x[Cpanel]], #0x8\\n\"\n \"tbz x23, #0, 13f\\n\"\n \"st1 { v26.s }[2], [x24]\\n\"\n \"st1 { v25.s }[2], [x9]\\n\"\n \"st1 { v20.s }[2], [x25]\\n\"\n \"st1 { v19.s }[2], [x11]\\n\"\n \"st1 { v14.s }[2], [x26]\\n\"\n \"st1 { v13.s }[2], [x10]\\n\"\n \"st1 { v8.s }[2], [x27]\\n\"\n \"st1 { v7.s }[2], [%x[Cpanel]]\\n\"\n \"b 13f\\n\"\n \"12:\" // partial result store: partial_1_0\n \"str s26, [x24, #0x0]\\n\"\n \"str s25, [x9, #0x0]\\n\"\n \"str s20, [x25, #0x0]\\n\"\n \"str s19, [x11, #0x0]\\n\"\n \"str s14, [x26, #0x0]\\n\"\n \"str s13, [x10, #0x0]\\n\"\n \"str s8, [x27, #0x0]\\n\"\n \"str s7, [%x[Cpanel], #0x0]\\n\"\n \"13:\" // partial result store: Done\n \"14:\" // store done\n \"subs x23, x23, #0xc\\n\"\n \"bgt 3b\\n\"\n \"subs %x[M], %x[M], #0x8\\n\"\n \"mov %x[Cpanel], x28\\n\"\n \"bgt 1b\\n\"\n : [Apanel] \"+&r\"(Apanel), [Cpanel] \"+&r\"(Cpanel), [M] \"+&r\"(M)\n : [args_ptr] \"r\"(&ka), [ldc] \"r\"(ldc * sizeof(float)), [offset_max] \"I\"(offsetof(KernelArgs, maxval)),\n [offset_min] \"I\"(offsetof(KernelArgs, minval)), [offsetof_Bpanel] \"I\"(offsetof(KernelArgs, Bpanel)),\n [offsetof_K] \"I\"(offsetof(KernelArgs, K)), [offsetof_N] \"I\"(offsetof(KernelArgs, N))\n : \"cc\", \"memory\", \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\", \"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v13\", \"v14\",\n \"v15\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\",\n \"v30\", \"v31\", \"x9\", \"x10\", \"x11\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\", \"x27\", \"x28\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon to pack the RHS matrix.\n/// -# kai_lhs_quant_pack_bf16p1x4_f32_neon to pack the LHS matrix.\n\n/// --------------------------------------------------\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets mr value.\n///\n/// This is the packing parameter which must be used to pack the LHS matrix.\n///\n/// @return The mr value.\nsize_t kai_get_mr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets nr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The nr value.\nsize_t kai_get_nr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets kr value.\n///\n/// This is the packing parameter which must be used to pack the LHS and RHS matrices.\n///\n/// @return The kr value.\nsize_t kai_get_kr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets sr value.\n///\n/// This is the packing parameter which must be used to pack the LHS and RHS matrices.\n///\n/// @return The sr value.\nsize_t kai_get_sr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void);\n\n/// Gets the offset in bytes to the data element in the LHS matrix buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix and DST matrix.\n/// @param[in] k The common dimension between the LHS and RHS matrices (K)\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix and the DST matrix.\n/// @param[in] k The common dimension between the LHS and RHS matrices (K)\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] n_idx Column index.\n/// @param[in] dst_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.\n/// * Packed RHS: @ref kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.\n/// * Output: @ref kai_get_dst_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.\n///\n/// @param[in] m Number of output rows to be computed. This must be 1.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k Common dimension of the LHS and RHS matrices.\n/// @param[in] lhs_packed Packed LHS matrix buffer.\n/// @param[in] rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Row stride in bytes of the output matrix.\n/// @param[in] dst_stride_col Column stride in bytes of the output matrix. Currently, an unused parameter.\n/// @param[in] clamp_min Minimum value to clamp the final result.\n/// @param[in] clamp_max Maximum value to clamp the final result.\nvoid kai_run_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, void* dst, size_t dst_stride_row,\n size_t dst_stride_col, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// Do not flag up inline assembly blocks\n#pragma GCC diagnostic ignored \"-Woverlength-strings\"\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_BF16.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_nr = 12;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nstatic const size_t kai_m_step = 1;\nstatic const size_t kai_n_step = 36;\n\nsize_t kai_get_m_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t m_idx, size_t k) {\n KAI_ASSUME(m_idx == 0);\n\n return m_idx * kai_roundup(k, kai_kr) * sizeof(uint16_t);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t n_idx, size_t k) {\n KAI_ASSUME(n_idx % kai_get_nr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() == 0);\n return n_idx * (kai_roundup(k, kai_kr) * sizeof(uint16_t) + sizeof(float));\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME(m_idx % kai_get_m_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() == 0);\n KAI_ASSUME(n_idx % kai_get_n_step_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() == 0);\n\n return (m_idx * dst_stride) + (n_idx * sizeof(float));\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(size_t m, size_t n) {\n return m * n * sizeof(float);\n}\n\nvoid kai_run_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, void* dst, size_t dst_stride_row,\n size_t dst_stride_col, float clamp_min, float clamp_max) {\n KAI_UNUSED(dst_stride_row);\n KAI_UNUSED(dst_stride_col);\n\n KAI_ASSUME(m == 1);\n\n typedef struct {\n float maxval;\n float minval;\n } KernelArgs;\n\n KernelArgs ka;\n ka.maxval = clamp_max;\n ka.minval = clamp_min;\n\n size_t N = n;\n size_t K = k;\n\n const void* A_ptr = lhs_packed;\n const void* B_ptr = rhs_packed;\n void* output_ptr = dst;\n\n // Add clamping flag\n uint64_t flags = 0x2;\n\n __asm__ __volatile__(\n \"add x26, %x[K], #0x3\\n\"\n \"mov x20, #0xc\\n\"\n \"bic x26, x26, #0x3\\n\"\n \"add x25, %x[N], #0x3\\n\"\n \"lsr x25, x25, #0x2\\n\"\n \"lsl x26, x26, #0x1\\n\"\n \"add x26, x26, #0x4\\n\"\n \"mul x26, x26, x20\\n\"\n \"1:\" // Column loop\n \"cmp x25, #0x9\\n\"\n \"bge 89f\\n\"\n \"cmp x25, #0x7\\n\"\n \"bgt 78f\\n\"\n \"beq 67f\\n\"\n \"cmp x25, #0x5\\n\"\n \"bgt 56f\\n\"\n \"beq 45f\\n\"\n \"cmp x25, #0x3\\n\"\n \"bgt 34f\\n\"\n \"beq 23f\\n\"\n \"cmp x25, #0x1\\n\"\n \"bgt 12f\\n\"\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"mov x24, %x[K]\\n\"\n \"movi v16.16b, #0x0\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v15.4s, v14.4s, v16.4s\\n\"\n \"zip1 v14.4s, v14.4s, v16.4s\\n\"\n \"blt 4f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 3f\\n\"\n \"2:\" // Width 1: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"cmp x24, #0x8\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \"bge 2b\\n\"\n \"3:\" // Width 1: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q3, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q4, [%x[B_ptr], #0x10]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc6e // bfdot v14.4s, v3.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \".inst 0x6e40fc8f // bfdot v15.4s, v4.8h, v0.8h\\n\"\n \"4:\" // Width 1: Multiply loop: Main loop skip\n \"cbz x24, 7f\\n\"\n \"tbz x24, #1, 5f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 6f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 6f\\n\"\n \"5:\" // Width 1: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"6:\" // Width 1: Multiply loop: Ragged operand read: Done\n \"ldr q5, [%x[B_ptr], #0x0]\\n\"\n \"ldr q6, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \".inst 0x6e40fcae // bfdot v14.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fccf // bfdot v15.4s, v6.8h, v0.8h\\n\"\n \"7:\" // Width 1: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"tbz %x[flags], #1, 8f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v17.4s }, [x21]\\n\"\n \"ld1r { v16.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v17.4s\\n\"\n \"fmax v14.4s, v14.4s, v16.4s\\n\"\n \"8:\" // Width 1: No activation\n \"cmp %x[N], #0x4\\n\"\n \"blt 9f\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 11f\\n\"\n \"9:\" // Width 1: Partial writeback\n \"tbz %x[N], #1, 10f\\n\"\n \"str d14, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 11f\\n\"\n \"st1 { v14.s }[2], [%x[output_ptr]]\\n\"\n \"b 11f\\n\"\n \"10:\" // Width 1: Partial direct writeback: partial_1_0\n \"str s14, [%x[output_ptr], #0x0]\\n\"\n \"11:\" // Width 1: Writeback done\n \"b 100f\\n\"\n \"12:\" // Width 2\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"movi v18.16b, #0x0\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v17.4s, v15.4s, v18.4s\\n\"\n \"zip1 v16.4s, v15.4s, v18.4s\\n\"\n \"zip2 v15.4s, v14.4s, v18.4s\\n\"\n \"zip1 v14.4s, v14.4s, v18.4s\\n\"\n \"blt 15f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 14f\\n\"\n \"13:\" // Width 2: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \"bge 13b\\n\"\n \"14:\" // Width 2: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q5, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q6, [%x[B_ptr], #0x10]\\n\"\n \"ldr q7, [%x[B_ptr], #0x20]\\n\"\n \"ldr q8, [%x[B_ptr], #0x30]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fcae // bfdot v14.4s, v5.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fccf // bfdot v15.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf0 // bfdot v16.4s, v7.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \".inst 0x6e40fd11 // bfdot v17.4s, v8.8h, v0.8h\\n\"\n \"15:\" // Width 2: Multiply loop: Main loop skip\n \"cbz x24, 18f\\n\"\n \"tbz x24, #1, 16f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 17f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 17f\\n\"\n \"16:\" // Width 2: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"17:\" // Width 2: Multiply loop: Ragged operand read: Done\n \"ldr q9, [%x[B_ptr], #0x0]\\n\"\n \"ldr q10, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q11, [%x[B_ptr], #0x20]\\n\"\n \"ldr q12, [%x[B_ptr], #0x30]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \".inst 0x6e40fd2e // bfdot v14.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd4f // bfdot v15.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd70 // bfdot v16.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd91 // bfdot v17.4s, v12.8h, v0.8h\\n\"\n \"18:\" // Width 2: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"tbz %x[flags], #1, 19f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v17.4s }, [x21]\\n\"\n \"ld1r { v16.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v17.4s\\n\"\n \"fmin v15.4s, v15.4s, v17.4s\\n\"\n \"fmax v14.4s, v14.4s, v16.4s\\n\"\n \"fmax v15.4s, v15.4s, v16.4s\\n\"\n \"19:\" // Width 2: No activation\n \"cmp %x[N], #0x8\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"blt 20f\\n\"\n \"str q15, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 22f\\n\"\n \"20:\" // Width 2: Partial writeback\n \"tbz %x[N], #1, 21f\\n\"\n \"str d15, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 22f\\n\"\n \"st1 { v15.s }[2], [%x[output_ptr]]\\n\"\n \"b 22f\\n\"\n \"21:\" // Width 2: Partial direct writeback: partial_1_4\n \"tbz %x[N], #0, 22f\\n\"\n \"str s15, [%x[output_ptr], #0x0]\\n\"\n \"22:\" // Width 2: Writeback done\n \"b 100f\\n\"\n \"23:\" // Width 3\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"movi v20.16b, #0x0\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v17.4s, v15.4s, v20.4s\\n\"\n \"zip2 v19.4s, v16.4s, v20.4s\\n\"\n \"zip1 v18.4s, v16.4s, v20.4s\\n\"\n \"zip1 v16.4s, v15.4s, v20.4s\\n\"\n \"zip2 v15.4s, v14.4s, v20.4s\\n\"\n \"zip1 v14.4s, v14.4s, v20.4s\\n\"\n \"blt 26f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 25f\\n\"\n \"24:\" // Width 3: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 24b\\n\"\n \"25:\" // Width 3: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q7, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q8, [%x[B_ptr], #0x10]\\n\"\n \"ldr q9, [%x[B_ptr], #0x20]\\n\"\n \"ldr q10, [%x[B_ptr], #0x30]\\n\"\n \"ldr q11, [%x[B_ptr], #0x40]\\n\"\n \"ldr q12, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fcee // bfdot v14.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd0f // bfdot v15.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd30 // bfdot v16.4s, v9.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fd51 // bfdot v17.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd72 // bfdot v18.4s, v11.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fd93 // bfdot v19.4s, v12.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"26:\" // Width 3: Multiply loop: Main loop skip\n \"cbz x24, 29f\\n\"\n \"tbz x24, #1, 27f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 28f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 28f\\n\"\n \"27:\" // Width 3: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"28:\" // Width 3: Multiply loop: Ragged operand read: Done\n \"ldr q13, [%x[B_ptr], #0x0]\\n\"\n \"ldr q1, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q2, [%x[B_ptr], #0x20]\\n\"\n \"ldr q3, [%x[B_ptr], #0x30]\\n\"\n \"ldr q4, [%x[B_ptr], #0x40]\\n\"\n \"ldr q5, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \".inst 0x6e40fdae // bfdot v14.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc2f // bfdot v15.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc50 // bfdot v16.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc71 // bfdot v17.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc92 // bfdot v18.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb3 // bfdot v19.4s, v5.8h, v0.8h\\n\"\n \"29:\" // Width 3: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"tbz %x[flags], #1, 30f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v18.4s }, [x21]\\n\"\n \"ld1r { v17.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v18.4s\\n\"\n \"fmin v15.4s, v15.4s, v18.4s\\n\"\n \"fmin v16.4s, v16.4s, v18.4s\\n\"\n \"fmax v14.4s, v14.4s, v17.4s\\n\"\n \"fmax v15.4s, v15.4s, v17.4s\\n\"\n \"fmax v16.4s, v16.4s, v17.4s\\n\"\n \"30:\" // Width 3: No activation\n \"cmp %x[N], #0xc\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x20\\n\"\n \"blt 31f\\n\"\n \"str q16, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 33f\\n\"\n \"31:\" // Width 3: Partial writeback\n \"tbz %x[N], #1, 32f\\n\"\n \"str d16, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 33f\\n\"\n \"st1 { v16.s }[2], [%x[output_ptr]]\\n\"\n \"b 33f\\n\"\n \"32:\" // Width 3: Partial direct writeback: partial_1_8\n \"tbz %x[N], #0, 33f\\n\"\n \"str s16, [%x[output_ptr], #0x0]\\n\"\n \"33:\" // Width 3: Writeback done\n \"b 100f\\n\"\n \"34:\" // Width 4\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x20, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x20, #0x0]\\n\"\n \"movi v22.16b, #0x0\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v21.4s, v17.4s, v22.4s\\n\"\n \"zip1 v20.4s, v17.4s, v22.4s\\n\"\n \"zip2 v19.4s, v16.4s, v22.4s\\n\"\n \"zip1 v18.4s, v16.4s, v22.4s\\n\"\n \"zip2 v17.4s, v15.4s, v22.4s\\n\"\n \"zip1 v16.4s, v15.4s, v22.4s\\n\"\n \"zip2 v15.4s, v14.4s, v22.4s\\n\"\n \"zip1 v14.4s, v14.4s, v22.4s\\n\"\n \"blt 37f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 36f\\n\"\n \"35:\" // Width 4: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x20, #0x10]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 35b\\n\"\n \"36:\" // Width 4: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q9, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q10, [%x[B_ptr], #0x10]\\n\"\n \"ldr q11, [%x[B_ptr], #0x20]\\n\"\n \"ldr q12, [%x[B_ptr], #0x30]\\n\"\n \"ldr q13, [%x[B_ptr], #0x40]\\n\"\n \"ldr q1, [%x[B_ptr], #0x50]\\n\"\n \"ldr q2, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fd2e // bfdot v14.4s, v9.8h, v0.8h\\n\"\n \"ldr q3, [x20, #0x10]\\n\"\n \".inst 0x6e40fd4f // bfdot v15.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd70 // bfdot v16.4s, v11.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fd91 // bfdot v17.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdb2 // bfdot v18.4s, v13.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fc33 // bfdot v19.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc54 // bfdot v20.4s, v2.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fc75 // bfdot v21.4s, v3.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"37:\" // Width 4: Multiply loop: Main loop skip\n \"cbz x24, 40f\\n\"\n \"tbz x24, #1, 38f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 39f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 39f\\n\"\n \"38:\" // Width 4: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"39:\" // Width 4: Multiply loop: Ragged operand read: Done\n \"ldr q4, [%x[B_ptr], #0x0]\\n\"\n \"ldr q5, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q6, [%x[B_ptr], #0x20]\\n\"\n \"ldr q7, [%x[B_ptr], #0x30]\\n\"\n \"ldr q8, [%x[B_ptr], #0x40]\\n\"\n \"ldr q9, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q10, [x20, #0x0]\\n\"\n \"ldr q11, [x20, #0x10]\\n\"\n \".inst 0x6e40fc8e // bfdot v14.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcaf // bfdot v15.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd0 // bfdot v16.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf1 // bfdot v17.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd12 // bfdot v18.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd33 // bfdot v19.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd54 // bfdot v20.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd75 // bfdot v21.4s, v11.8h, v0.8h\\n\"\n \"40:\" // Width 4: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"tbz %x[flags], #1, 41f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v19.4s }, [x21]\\n\"\n \"ld1r { v18.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v19.4s\\n\"\n \"fmin v15.4s, v15.4s, v19.4s\\n\"\n \"fmin v16.4s, v16.4s, v19.4s\\n\"\n \"fmin v17.4s, v17.4s, v19.4s\\n\"\n \"fmax v14.4s, v14.4s, v18.4s\\n\"\n \"fmax v15.4s, v15.4s, v18.4s\\n\"\n \"fmax v16.4s, v16.4s, v18.4s\\n\"\n \"fmax v17.4s, v17.4s, v18.4s\\n\"\n \"41:\" // Width 4: No activation\n \"cmp %x[N], #0x10\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x30\\n\"\n \"blt 42f\\n\"\n \"str q17, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 44f\\n\"\n \"42:\" // Width 4: Partial writeback\n \"tbz %x[N], #1, 43f\\n\"\n \"str d17, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 44f\\n\"\n \"st1 { v17.s }[2], [%x[output_ptr]]\\n\"\n \"b 44f\\n\"\n \"43:\" // Width 4: Partial direct writeback: partial_1_12\n \"tbz %x[N], #0, 44f\\n\"\n \"str s17, [%x[output_ptr], #0x0]\\n\"\n \"44:\" // Width 4: Writeback done\n \"b 100f\\n\"\n \"45:\" // Width 5\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x20, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x20, #0x0]\\n\"\n \"movi v24.16b, #0x0\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"ldr q18, [x20, #0x10]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v21.4s, v17.4s, v24.4s\\n\"\n \"zip1 v20.4s, v17.4s, v24.4s\\n\"\n \"zip2 v19.4s, v16.4s, v24.4s\\n\"\n \"zip2 v17.4s, v15.4s, v24.4s\\n\"\n \"zip2 v23.4s, v18.4s, v24.4s\\n\"\n \"zip1 v22.4s, v18.4s, v24.4s\\n\"\n \"zip1 v18.4s, v16.4s, v24.4s\\n\"\n \"zip1 v16.4s, v15.4s, v24.4s\\n\"\n \"zip2 v15.4s, v14.4s, v24.4s\\n\"\n \"zip1 v14.4s, v14.4s, v24.4s\\n\"\n \"blt 48f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 47f\\n\"\n \"46:\" // Width 5: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x20, #0x10]\\n\"\n \"ldr q9, [x20, #0x20]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x20, #0x30]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd36 // bfdot v22.4s, v9.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fd57 // bfdot v23.4s, v10.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 46b\\n\"\n \"47:\" // Width 5: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q11, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q12, [%x[B_ptr], #0x10]\\n\"\n \"ldr q13, [%x[B_ptr], #0x20]\\n\"\n \"ldr q1, [%x[B_ptr], #0x30]\\n\"\n \"ldr q2, [%x[B_ptr], #0x40]\\n\"\n \"ldr q3, [%x[B_ptr], #0x50]\\n\"\n \"ldr q4, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fd6e // bfdot v14.4s, v11.8h, v0.8h\\n\"\n \"ldr q5, [x20, #0x10]\\n\"\n \"ldr q6, [x20, #0x20]\\n\"\n \".inst 0x6e40fd8f // bfdot v15.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdb0 // bfdot v16.4s, v13.8h, v0.8h\\n\"\n \"ldr q7, [x20, #0x30]\\n\"\n \".inst 0x6e40fc31 // bfdot v17.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc52 // bfdot v18.4s, v2.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fc73 // bfdot v19.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc94 // bfdot v20.4s, v4.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fcb5 // bfdot v21.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd6 // bfdot v22.4s, v6.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fcf7 // bfdot v23.4s, v7.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"48:\" // Width 5: Multiply loop: Main loop skip\n \"cbz x24, 51f\\n\"\n \"tbz x24, #1, 49f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 50f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 50f\\n\"\n \"49:\" // Width 5: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"50:\" // Width 5: Multiply loop: Ragged operand read: Done\n \"ldr q8, [%x[B_ptr], #0x0]\\n\"\n \"ldr q9, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q10, [%x[B_ptr], #0x20]\\n\"\n \"ldr q11, [%x[B_ptr], #0x30]\\n\"\n \"ldr q12, [%x[B_ptr], #0x40]\\n\"\n \"ldr q13, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q1, [x20, #0x0]\\n\"\n \"ldr q2, [x20, #0x10]\\n\"\n \".inst 0x6e40fd0e // bfdot v14.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd2f // bfdot v15.4s, v9.8h, v0.8h\\n\"\n \"ldr q3, [x20, #0x20]\\n\"\n \"ldr q4, [x20, #0x30]\\n\"\n \".inst 0x6e40fd50 // bfdot v16.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd71 // bfdot v17.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd92 // bfdot v18.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdb3 // bfdot v19.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc34 // bfdot v20.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc55 // bfdot v21.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc76 // bfdot v22.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc97 // bfdot v23.4s, v4.8h, v0.8h\\n\"\n \"51:\" // Width 5: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"faddp v18.4s, v22.4s, v23.4s\\n\"\n \"tbz %x[flags], #1, 52f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v20.4s }, [x21]\\n\"\n \"ld1r { v19.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v20.4s\\n\"\n \"fmin v15.4s, v15.4s, v20.4s\\n\"\n \"fmin v16.4s, v16.4s, v20.4s\\n\"\n \"fmin v17.4s, v17.4s, v20.4s\\n\"\n \"fmin v18.4s, v18.4s, v20.4s\\n\"\n \"fmax v14.4s, v14.4s, v19.4s\\n\"\n \"fmax v15.4s, v15.4s, v19.4s\\n\"\n \"fmax v16.4s, v16.4s, v19.4s\\n\"\n \"fmax v17.4s, v17.4s, v19.4s\\n\"\n \"fmax v18.4s, v18.4s, v19.4s\\n\"\n \"52:\" // Width 5: No activation\n \"cmp %x[N], #0x14\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"str q17, [%x[output_ptr], #0x30]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x40\\n\"\n \"blt 53f\\n\"\n \"str q18, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 55f\\n\"\n \"53:\" // Width 5: Partial writeback\n \"tbz %x[N], #1, 54f\\n\"\n \"str d18, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 55f\\n\"\n \"st1 { v18.s }[2], [%x[output_ptr]]\\n\"\n \"b 55f\\n\"\n \"54:\" // Width 5: Partial direct writeback: partial_1_16\n \"tbz %x[N], #0, 55f\\n\"\n \"str s18, [%x[output_ptr], #0x0]\\n\"\n \"55:\" // Width 5: Writeback done\n \"b 100f\\n\"\n \"56:\" // Width 6\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x20, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x20, #0x0]\\n\"\n \"movi v26.16b, #0x0\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"ldr q18, [x20, #0x10]\\n\"\n \"ldr q19, [x20, #0x20]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"cmp x24, #0x4\\n\"\n \"zip2 v21.4s, v17.4s, v26.4s\\n\"\n \"zip1 v20.4s, v17.4s, v26.4s\\n\"\n \"zip2 v17.4s, v15.4s, v26.4s\\n\"\n \"zip2 v25.4s, v19.4s, v26.4s\\n\"\n \"zip1 v24.4s, v19.4s, v26.4s\\n\"\n \"zip2 v23.4s, v18.4s, v26.4s\\n\"\n \"zip1 v22.4s, v18.4s, v26.4s\\n\"\n \"zip2 v19.4s, v16.4s, v26.4s\\n\"\n \"zip1 v18.4s, v16.4s, v26.4s\\n\"\n \"zip1 v16.4s, v15.4s, v26.4s\\n\"\n \"zip2 v15.4s, v14.4s, v26.4s\\n\"\n \"zip1 v14.4s, v14.4s, v26.4s\\n\"\n \"blt 59f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 58f\\n\"\n \"57:\" // Width 6: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x20, #0x10]\\n\"\n \"ldr q9, [x20, #0x20]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x20, #0x30]\\n\"\n \"ldr q11, [x20, #0x40]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"ldr q12, [x20, #0x50]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd36 // bfdot v22.4s, v9.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fd57 // bfdot v23.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd78 // bfdot v24.4s, v11.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fd99 // bfdot v25.4s, v12.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 57b\\n\"\n \"58:\" // Width 6: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q13, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q1, [%x[B_ptr], #0x10]\\n\"\n \"ldr q2, [%x[B_ptr], #0x20]\\n\"\n \"ldr q3, [%x[B_ptr], #0x30]\\n\"\n \"ldr q4, [%x[B_ptr], #0x40]\\n\"\n \"ldr q5, [%x[B_ptr], #0x50]\\n\"\n \"ldr q6, [x20, #0x0]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \".inst 0x6e40fdae // bfdot v14.4s, v13.8h, v0.8h\\n\"\n \"ldr q7, [x20, #0x10]\\n\"\n \"ldr q8, [x20, #0x20]\\n\"\n \".inst 0x6e40fc2f // bfdot v15.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc50 // bfdot v16.4s, v2.8h, v0.8h\\n\"\n \"ldr q9, [x20, #0x30]\\n\"\n \"ldr q10, [x20, #0x40]\\n\"\n \".inst 0x6e40fc71 // bfdot v17.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc92 // bfdot v18.4s, v4.8h, v0.8h\\n\"\n \"ldr q11, [x20, #0x50]\\n\"\n \".inst 0x6e40fcb3 // bfdot v19.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd4 // bfdot v20.4s, v6.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \".inst 0x6e40fcf5 // bfdot v21.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd16 // bfdot v22.4s, v8.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \".inst 0x6e40fd37 // bfdot v23.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd58 // bfdot v24.4s, v10.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \".inst 0x6e40fd79 // bfdot v25.4s, v11.8h, v0.8h\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"59:\" // Width 6: Multiply loop: Main loop skip\n \"cbz x24, 62f\\n\"\n \"tbz x24, #1, 60f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 61f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 61f\\n\"\n \"60:\" // Width 6: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"61:\" // Width 6: Multiply loop: Ragged operand read: Done\n \"ldr q12, [%x[B_ptr], #0x0]\\n\"\n \"ldr q13, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q1, [%x[B_ptr], #0x20]\\n\"\n \"ldr q2, [%x[B_ptr], #0x30]\\n\"\n \"ldr q3, [%x[B_ptr], #0x40]\\n\"\n \"ldr q4, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q5, [x20, #0x0]\\n\"\n \"ldr q6, [x20, #0x10]\\n\"\n \".inst 0x6e40fd8e // bfdot v14.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdaf // bfdot v15.4s, v13.8h, v0.8h\\n\"\n \"ldr q7, [x20, #0x20]\\n\"\n \"ldr q8, [x20, #0x30]\\n\"\n \".inst 0x6e40fc30 // bfdot v16.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc51 // bfdot v17.4s, v2.8h, v0.8h\\n\"\n \"ldr q9, [x20, #0x40]\\n\"\n \"ldr q10, [x20, #0x50]\\n\"\n \".inst 0x6e40fc72 // bfdot v18.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc93 // bfdot v19.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb4 // bfdot v20.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd5 // bfdot v21.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf6 // bfdot v22.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd17 // bfdot v23.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd38 // bfdot v24.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd59 // bfdot v25.4s, v10.8h, v0.8h\\n\"\n \"62:\" // Width 6: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"faddp v18.4s, v22.4s, v23.4s\\n\"\n \"faddp v19.4s, v24.4s, v25.4s\\n\"\n \"tbz %x[flags], #1, 63f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v21.4s }, [x21]\\n\"\n \"ld1r { v20.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v21.4s\\n\"\n \"fmin v15.4s, v15.4s, v21.4s\\n\"\n \"fmin v16.4s, v16.4s, v21.4s\\n\"\n \"fmin v17.4s, v17.4s, v21.4s\\n\"\n \"fmin v18.4s, v18.4s, v21.4s\\n\"\n \"fmin v19.4s, v19.4s, v21.4s\\n\"\n \"fmax v14.4s, v14.4s, v20.4s\\n\"\n \"fmax v15.4s, v15.4s, v20.4s\\n\"\n \"fmax v16.4s, v16.4s, v20.4s\\n\"\n \"fmax v17.4s, v17.4s, v20.4s\\n\"\n \"fmax v18.4s, v18.4s, v20.4s\\n\"\n \"fmax v19.4s, v19.4s, v20.4s\\n\"\n \"63:\" // Width 6: No activation\n \"cmp %x[N], #0x18\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"str q17, [%x[output_ptr], #0x30]\\n\"\n \"str q18, [%x[output_ptr], #0x40]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x50\\n\"\n \"blt 64f\\n\"\n \"str q19, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 66f\\n\"\n \"64:\" // Width 6: Partial writeback\n \"tbz %x[N], #1, 65f\\n\"\n \"str d19, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 66f\\n\"\n \"st1 { v19.s }[2], [%x[output_ptr]]\\n\"\n \"b 66f\\n\"\n \"65:\" // Width 6: Partial direct writeback: partial_1_20\n \"tbz %x[N], #0, 66f\\n\"\n \"str s19, [%x[output_ptr], #0x0]\\n\"\n \"66:\" // Width 6: Writeback done\n \"b 100f\\n\"\n \"67:\" // Width 7\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x21, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x21, #0x0]\\n\"\n \"add x20, %x[B_ptr], x26, LSL #1\\n\"\n \"movi v28.16b, #0x0\\n\"\n \"ldr q18, [x21, #0x10]\\n\"\n \"ldr q19, [x21, #0x20]\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"ldr q20, [x20, #0x0]\\n\"\n \"cmp x24, #0x4\\n\"\n \"add x21, x21, #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"zip2 v21.4s, v17.4s, v28.4s\\n\"\n \"zip2 v25.4s, v19.4s, v28.4s\\n\"\n \"zip1 v24.4s, v19.4s, v28.4s\\n\"\n \"zip2 v23.4s, v18.4s, v28.4s\\n\"\n \"zip2 v27.4s, v20.4s, v28.4s\\n\"\n \"zip1 v26.4s, v20.4s, v28.4s\\n\"\n \"zip1 v22.4s, v18.4s, v28.4s\\n\"\n \"zip1 v20.4s, v17.4s, v28.4s\\n\"\n \"zip2 v19.4s, v16.4s, v28.4s\\n\"\n \"zip1 v18.4s, v16.4s, v28.4s\\n\"\n \"zip2 v17.4s, v15.4s, v28.4s\\n\"\n \"zip1 v16.4s, v15.4s, v28.4s\\n\"\n \"zip2 v15.4s, v14.4s, v28.4s\\n\"\n \"zip1 v14.4s, v14.4s, v28.4s\\n\"\n \"blt 70f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 69f\\n\"\n \"68:\" // Width 7: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x21, #0x0]\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q8, [x21, #0x10]\\n\"\n \"ldr q9, [x21, #0x20]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x21, #0x30]\\n\"\n \"ldr q11, [x21, #0x40]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"ldr q12, [x21, #0x50]\\n\"\n \"ldr q13, [x20, #0x0]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"ldr q1, [x20, #0x10]\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd36 // bfdot v22.4s, v9.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fd57 // bfdot v23.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd78 // bfdot v24.4s, v11.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fd99 // bfdot v25.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdba // bfdot v26.4s, v13.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc3b // bfdot v27.4s, v1.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 68b\\n\"\n \"69:\" // Width 7: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q2, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q3, [%x[B_ptr], #0x10]\\n\"\n \"ldr q4, [%x[B_ptr], #0x20]\\n\"\n \"ldr q5, [%x[B_ptr], #0x30]\\n\"\n \"ldr q6, [%x[B_ptr], #0x40]\\n\"\n \"ldr q7, [%x[B_ptr], #0x50]\\n\"\n \"ldr q8, [x21, #0x0]\\n\"\n \".inst 0x6e40fc4e // bfdot v14.4s, v2.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q9, [x21, #0x10]\\n\"\n \"ldr q10, [x21, #0x20]\\n\"\n \".inst 0x6e40fc6f // bfdot v15.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc90 // bfdot v16.4s, v4.8h, v0.8h\\n\"\n \"ldr q11, [x21, #0x30]\\n\"\n \"ldr q12, [x21, #0x40]\\n\"\n \".inst 0x6e40fcb1 // bfdot v17.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd2 // bfdot v18.4s, v6.8h, v0.8h\\n\"\n \"ldr q13, [x21, #0x50]\\n\"\n \"ldr q1, [x20, #0x0]\\n\"\n \".inst 0x6e40fcf3 // bfdot v19.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd14 // bfdot v20.4s, v8.8h, v0.8h\\n\"\n \"ldr q2, [x20, #0x10]\\n\"\n \".inst 0x6e40fd35 // bfdot v21.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd56 // bfdot v22.4s, v10.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fd77 // bfdot v23.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd98 // bfdot v24.4s, v12.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fdb9 // bfdot v25.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc3a // bfdot v26.4s, v1.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc5b // bfdot v27.4s, v2.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"70:\" // Width 7: Multiply loop: Main loop skip\n \"cbz x24, 73f\\n\"\n \"tbz x24, #1, 71f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 72f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 72f\\n\"\n \"71:\" // Width 7: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"72:\" // Width 7: Multiply loop: Ragged operand read: Done\n \"ldr q3, [%x[B_ptr], #0x0]\\n\"\n \"ldr q4, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q5, [%x[B_ptr], #0x20]\\n\"\n \"ldr q6, [%x[B_ptr], #0x30]\\n\"\n \"ldr q7, [%x[B_ptr], #0x40]\\n\"\n \"ldr q8, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q9, [x21, #0x0]\\n\"\n \"ldr q10, [x21, #0x10]\\n\"\n \".inst 0x6e40fc6e // bfdot v14.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc8f // bfdot v15.4s, v4.8h, v0.8h\\n\"\n \"ldr q11, [x21, #0x20]\\n\"\n \"ldr q12, [x21, #0x30]\\n\"\n \".inst 0x6e40fcb0 // bfdot v16.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd1 // bfdot v17.4s, v6.8h, v0.8h\\n\"\n \"ldr q13, [x21, #0x40]\\n\"\n \"ldr q1, [x21, #0x50]\\n\"\n \".inst 0x6e40fcf2 // bfdot v18.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd13 // bfdot v19.4s, v8.8h, v0.8h\\n\"\n \"ldr q2, [x20, #0x0]\\n\"\n \"ldr q3, [x20, #0x10]\\n\"\n \".inst 0x6e40fd34 // bfdot v20.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd55 // bfdot v21.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd76 // bfdot v22.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd97 // bfdot v23.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdb8 // bfdot v24.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc39 // bfdot v25.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc5a // bfdot v26.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc7b // bfdot v27.4s, v3.8h, v0.8h\\n\"\n \"73:\" // Width 7: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"faddp v18.4s, v22.4s, v23.4s\\n\"\n \"faddp v19.4s, v24.4s, v25.4s\\n\"\n \"faddp v20.4s, v26.4s, v27.4s\\n\"\n \"tbz %x[flags], #1, 74f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v22.4s }, [x21]\\n\"\n \"ld1r { v21.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v22.4s\\n\"\n \"fmin v15.4s, v15.4s, v22.4s\\n\"\n \"fmin v16.4s, v16.4s, v22.4s\\n\"\n \"fmin v17.4s, v17.4s, v22.4s\\n\"\n \"fmin v18.4s, v18.4s, v22.4s\\n\"\n \"fmin v19.4s, v19.4s, v22.4s\\n\"\n \"fmin v20.4s, v20.4s, v22.4s\\n\"\n \"fmax v14.4s, v14.4s, v21.4s\\n\"\n \"fmax v15.4s, v15.4s, v21.4s\\n\"\n \"fmax v16.4s, v16.4s, v21.4s\\n\"\n \"fmax v17.4s, v17.4s, v21.4s\\n\"\n \"fmax v18.4s, v18.4s, v21.4s\\n\"\n \"fmax v19.4s, v19.4s, v21.4s\\n\"\n \"fmax v20.4s, v20.4s, v21.4s\\n\"\n \"74:\" // Width 7: No activation\n \"cmp %x[N], #0x1c\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"str q17, [%x[output_ptr], #0x30]\\n\"\n \"str q18, [%x[output_ptr], #0x40]\\n\"\n \"str q19, [%x[output_ptr], #0x50]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x60\\n\"\n \"blt 75f\\n\"\n \"str q20, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 77f\\n\"\n \"75:\" // Width 7: Partial writeback\n \"tbz %x[N], #1, 76f\\n\"\n \"str d20, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 77f\\n\"\n \"st1 { v20.s }[2], [%x[output_ptr]]\\n\"\n \"b 77f\\n\"\n \"76:\" // Width 7: Partial direct writeback: partial_1_24\n \"tbz %x[N], #0, 77f\\n\"\n \"str s20, [%x[output_ptr], #0x0]\\n\"\n \"77:\" // Width 7: Writeback done\n \"b 100f\\n\"\n \"78:\" // Width 8\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x21, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x21, #0x0]\\n\"\n \"add x20, %x[B_ptr], x26, LSL #1\\n\"\n \"movi v30.16b, #0x0\\n\"\n \"ldr q18, [x21, #0x10]\\n\"\n \"ldr q19, [x21, #0x20]\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"ldr q20, [x20, #0x0]\\n\"\n \"ldr q21, [x20, #0x10]\\n\"\n \"cmp x24, #0x4\\n\"\n \"add x21, x21, #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"zip2 v25.4s, v19.4s, v30.4s\\n\"\n \"zip1 v24.4s, v19.4s, v30.4s\\n\"\n \"zip2 v23.4s, v18.4s, v30.4s\\n\"\n \"zip1 v22.4s, v18.4s, v30.4s\\n\"\n \"zip2 v29.4s, v21.4s, v30.4s\\n\"\n \"zip1 v28.4s, v21.4s, v30.4s\\n\"\n \"zip2 v27.4s, v20.4s, v30.4s\\n\"\n \"zip1 v26.4s, v20.4s, v30.4s\\n\"\n \"zip2 v21.4s, v17.4s, v30.4s\\n\"\n \"zip1 v20.4s, v17.4s, v30.4s\\n\"\n \"zip2 v19.4s, v16.4s, v30.4s\\n\"\n \"zip1 v18.4s, v16.4s, v30.4s\\n\"\n \"zip2 v17.4s, v15.4s, v30.4s\\n\"\n \"zip1 v16.4s, v15.4s, v30.4s\\n\"\n \"zip2 v15.4s, v14.4s, v30.4s\\n\"\n \"zip1 v14.4s, v14.4s, v30.4s\\n\"\n \"blt 81f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 80f\\n\"\n \"79:\" // Width 8: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x21, #0x0]\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q8, [x21, #0x10]\\n\"\n \"ldr q9, [x21, #0x20]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x21, #0x30]\\n\"\n \"ldr q11, [x21, #0x40]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"ldr q12, [x21, #0x50]\\n\"\n \"ldr q13, [x20, #0x0]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"ldr q1, [x20, #0x10]\\n\"\n \"ldr q2, [x20, #0x20]\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd36 // bfdot v22.4s, v9.8h, v0.8h\\n\"\n \"ldr q3, [x20, #0x30]\\n\"\n \".inst 0x6e40fd57 // bfdot v23.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd78 // bfdot v24.4s, v11.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fd99 // bfdot v25.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdba // bfdot v26.4s, v13.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fc3b // bfdot v27.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc5c // bfdot v28.4s, v2.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fc7d // bfdot v29.4s, v3.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 79b\\n\"\n \"80:\" // Width 8: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q4, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q5, [%x[B_ptr], #0x10]\\n\"\n \"ldr q6, [%x[B_ptr], #0x20]\\n\"\n \"ldr q7, [%x[B_ptr], #0x30]\\n\"\n \"ldr q8, [%x[B_ptr], #0x40]\\n\"\n \"ldr q9, [%x[B_ptr], #0x50]\\n\"\n \"ldr q10, [x21, #0x0]\\n\"\n \".inst 0x6e40fc8e // bfdot v14.4s, v4.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q11, [x21, #0x10]\\n\"\n \"ldr q12, [x21, #0x20]\\n\"\n \".inst 0x6e40fcaf // bfdot v15.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcd0 // bfdot v16.4s, v6.8h, v0.8h\\n\"\n \"ldr q13, [x21, #0x30]\\n\"\n \"ldr q1, [x21, #0x40]\\n\"\n \".inst 0x6e40fcf1 // bfdot v17.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd12 // bfdot v18.4s, v8.8h, v0.8h\\n\"\n \"ldr q2, [x21, #0x50]\\n\"\n \"ldr q3, [x20, #0x0]\\n\"\n \".inst 0x6e40fd33 // bfdot v19.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd54 // bfdot v20.4s, v10.8h, v0.8h\\n\"\n \"ldr q4, [x20, #0x10]\\n\"\n \"ldr q5, [x20, #0x20]\\n\"\n \".inst 0x6e40fd75 // bfdot v21.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd96 // bfdot v22.4s, v12.8h, v0.8h\\n\"\n \"ldr q6, [x20, #0x30]\\n\"\n \".inst 0x6e40fdb7 // bfdot v23.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc38 // bfdot v24.4s, v1.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fc59 // bfdot v25.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc7a // bfdot v26.4s, v3.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fc9b // bfdot v27.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcbc // bfdot v28.4s, v5.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fcdd // bfdot v29.4s, v6.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"81:\" // Width 8: Multiply loop: Main loop skip\n \"cbz x24, 84f\\n\"\n \"tbz x24, #1, 82f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 83f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 83f\\n\"\n \"82:\" // Width 8: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"83:\" // Width 8: Multiply loop: Ragged operand read: Done\n \"ldr q7, [%x[B_ptr], #0x0]\\n\"\n \"ldr q8, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q9, [%x[B_ptr], #0x20]\\n\"\n \"ldr q10, [%x[B_ptr], #0x30]\\n\"\n \"ldr q11, [%x[B_ptr], #0x40]\\n\"\n \"ldr q12, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q13, [x21, #0x0]\\n\"\n \"ldr q1, [x21, #0x10]\\n\"\n \".inst 0x6e40fcee // bfdot v14.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd0f // bfdot v15.4s, v8.8h, v0.8h\\n\"\n \"ldr q2, [x21, #0x20]\\n\"\n \"ldr q3, [x21, #0x30]\\n\"\n \".inst 0x6e40fd30 // bfdot v16.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd51 // bfdot v17.4s, v10.8h, v0.8h\\n\"\n \"ldr q4, [x21, #0x40]\\n\"\n \"ldr q5, [x21, #0x50]\\n\"\n \".inst 0x6e40fd72 // bfdot v18.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd93 // bfdot v19.4s, v12.8h, v0.8h\\n\"\n \"ldr q6, [x20, #0x0]\\n\"\n \"ldr q7, [x20, #0x10]\\n\"\n \".inst 0x6e40fdb4 // bfdot v20.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc35 // bfdot v21.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x20, #0x20]\\n\"\n \"ldr q9, [x20, #0x30]\\n\"\n \".inst 0x6e40fc56 // bfdot v22.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc77 // bfdot v23.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc98 // bfdot v24.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb9 // bfdot v25.4s, v5.8h, v0.8h\\n\"\n \".inst 0x6e40fcda // bfdot v26.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcfb // bfdot v27.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd1c // bfdot v28.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd3d // bfdot v29.4s, v9.8h, v0.8h\\n\"\n \"84:\" // Width 8: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"faddp v18.4s, v22.4s, v23.4s\\n\"\n \"faddp v19.4s, v24.4s, v25.4s\\n\"\n \"faddp v20.4s, v26.4s, v27.4s\\n\"\n \"faddp v21.4s, v28.4s, v29.4s\\n\"\n \"tbz %x[flags], #1, 85f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v23.4s }, [x21]\\n\"\n \"ld1r { v22.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v23.4s\\n\"\n \"fmin v15.4s, v15.4s, v23.4s\\n\"\n \"fmin v16.4s, v16.4s, v23.4s\\n\"\n \"fmin v17.4s, v17.4s, v23.4s\\n\"\n \"fmin v18.4s, v18.4s, v23.4s\\n\"\n \"fmin v19.4s, v19.4s, v23.4s\\n\"\n \"fmin v20.4s, v20.4s, v23.4s\\n\"\n \"fmin v21.4s, v21.4s, v23.4s\\n\"\n \"fmax v14.4s, v14.4s, v22.4s\\n\"\n \"fmax v15.4s, v15.4s, v22.4s\\n\"\n \"fmax v16.4s, v16.4s, v22.4s\\n\"\n \"fmax v17.4s, v17.4s, v22.4s\\n\"\n \"fmax v18.4s, v18.4s, v22.4s\\n\"\n \"fmax v19.4s, v19.4s, v22.4s\\n\"\n \"fmax v20.4s, v20.4s, v22.4s\\n\"\n \"fmax v21.4s, v21.4s, v22.4s\\n\"\n \"85:\" // Width 8: No activation\n \"cmp %x[N], #0x20\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"str q17, [%x[output_ptr], #0x30]\\n\"\n \"str q18, [%x[output_ptr], #0x40]\\n\"\n \"str q19, [%x[output_ptr], #0x50]\\n\"\n \"str q20, [%x[output_ptr], #0x60]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x70\\n\"\n \"blt 86f\\n\"\n \"str q21, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 88f\\n\"\n \"86:\" // Width 8: Partial writeback\n \"tbz %x[N], #1, 87f\\n\"\n \"str d21, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 88f\\n\"\n \"st1 { v21.s }[2], [%x[output_ptr]]\\n\"\n \"b 88f\\n\"\n \"87:\" // Width 8: Partial direct writeback: partial_1_28\n \"tbz %x[N], #0, 88f\\n\"\n \"str s21, [%x[output_ptr], #0x0]\\n\"\n \"88:\" // Width 8: Writeback done\n \"b 100f\\n\"\n \"89:\" // Width 9\n \"ldr q14, [%x[B_ptr], #0x0]\\n\"\n \"ldr q15, [%x[B_ptr], #0x10]\\n\"\n \"mov x24, %x[K]\\n\"\n \"add x21, %x[B_ptr], x26\\n\"\n \"ldr q16, [%x[B_ptr], #0x20]\\n\"\n \"ldr q17, [x21, #0x0]\\n\"\n \"add x20, %x[B_ptr], x26, LSL #1\\n\"\n \"movi v0.16b, #0x0\\n\"\n \"ldr q18, [x21, #0x10]\\n\"\n \"ldr q19, [x21, #0x20]\\n\"\n \"mov x23, %x[A_ptr]\\n\"\n \"add x22, x20, x26\\n\"\n \"ldr q20, [x20, #0x0]\\n\"\n \"ldr q21, [x20, #0x10]\\n\"\n \"cmp x24, #0x4\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x30\\n\"\n \"ldr q22, [x20, #0x20]\\n\"\n \"add x21, x21, #0x30\\n\"\n \"add x20, x20, #0x30\\n\"\n \"zip2 v25.4s, v19.4s, v0.4s\\n\"\n \"zip1 v24.4s, v19.4s, v0.4s\\n\"\n \"zip2 v23.4s, v18.4s, v0.4s\\n\"\n \"zip2 v29.4s, v21.4s, v0.4s\\n\"\n \"zip1 v28.4s, v21.4s, v0.4s\\n\"\n \"zip2 v31.4s, v22.4s, v0.4s\\n\"\n \"zip1 v30.4s, v22.4s, v0.4s\\n\"\n \"zip2 v27.4s, v20.4s, v0.4s\\n\"\n \"zip1 v26.4s, v20.4s, v0.4s\\n\"\n \"zip1 v22.4s, v18.4s, v0.4s\\n\"\n \"zip2 v21.4s, v17.4s, v0.4s\\n\"\n \"zip1 v20.4s, v17.4s, v0.4s\\n\"\n \"zip2 v19.4s, v16.4s, v0.4s\\n\"\n \"zip1 v18.4s, v16.4s, v0.4s\\n\"\n \"zip2 v17.4s, v15.4s, v0.4s\\n\"\n \"zip1 v16.4s, v15.4s, v0.4s\\n\"\n \"zip2 v15.4s, v14.4s, v0.4s\\n\"\n \"zip1 v14.4s, v14.4s, v0.4s\\n\"\n \"blt 92f\\n\"\n \"cmp x24, #0x8\\n\"\n \"blt 91f\\n\"\n \"90:\" // Width 9: Multiply loop: Main loop head\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q1, [%x[B_ptr], #0x0]\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"add x23, x23, #0x8\\n\"\n \"ldr q2, [%x[B_ptr], #0x10]\\n\"\n \"ldr q3, [%x[B_ptr], #0x20]\\n\"\n \"cmp x24, #0x8\\n\"\n \"ldr q4, [%x[B_ptr], #0x30]\\n\"\n \"ldr q5, [%x[B_ptr], #0x40]\\n\"\n \"ldr q6, [%x[B_ptr], #0x50]\\n\"\n \"ldr q7, [x21, #0x0]\\n\"\n \".inst 0x6e40fc2e // bfdot v14.4s, v1.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q8, [x21, #0x10]\\n\"\n \"ldr q9, [x21, #0x20]\\n\"\n \".inst 0x6e40fc4f // bfdot v15.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc70 // bfdot v16.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x21, #0x30]\\n\"\n \"ldr q11, [x21, #0x40]\\n\"\n \".inst 0x6e40fc91 // bfdot v17.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb2 // bfdot v18.4s, v5.8h, v0.8h\\n\"\n \"ldr q12, [x21, #0x50]\\n\"\n \"ldr q13, [x20, #0x0]\\n\"\n \".inst 0x6e40fcd3 // bfdot v19.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf4 // bfdot v20.4s, v7.8h, v0.8h\\n\"\n \"ldr q1, [x20, #0x10]\\n\"\n \"ldr q2, [x20, #0x20]\\n\"\n \".inst 0x6e40fd15 // bfdot v21.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd36 // bfdot v22.4s, v9.8h, v0.8h\\n\"\n \"ldr q3, [x20, #0x30]\\n\"\n \"ldr q4, [x20, #0x40]\\n\"\n \".inst 0x6e40fd57 // bfdot v23.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd78 // bfdot v24.4s, v11.8h, v0.8h\\n\"\n \"ldr q5, [x20, #0x50]\\n\"\n \".inst 0x6e40fd99 // bfdot v25.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdba // bfdot v26.4s, v13.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fc3b // bfdot v27.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc5c // bfdot v28.4s, v2.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fc7d // bfdot v29.4s, v3.8h, v0.8h\\n\"\n \".inst 0x6e40fc9e // bfdot v30.4s, v4.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fcbf // bfdot v31.4s, v5.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"bge 90b\\n\"\n \"91:\" // Width 9: Multiply loop: Single iteration only\n \"ld1r { v0.2d }, [x23]\\n\"\n \"ldr q6, [%x[B_ptr], #0x0]\\n\"\n \"add x23, x23, #0x8\\n\"\n \"sub x24, x24, #0x4\\n\"\n \"ldr q7, [%x[B_ptr], #0x10]\\n\"\n \"ldr q8, [%x[B_ptr], #0x20]\\n\"\n \"ldr q9, [%x[B_ptr], #0x30]\\n\"\n \"ldr q10, [%x[B_ptr], #0x40]\\n\"\n \"ldr q11, [%x[B_ptr], #0x50]\\n\"\n \"ldr q12, [x21, #0x0]\\n\"\n \".inst 0x6e40fcce // bfdot v14.4s, v6.8h, v0.8h\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x60\\n\"\n \"ldr q13, [x21, #0x10]\\n\"\n \"ldr q1, [x21, #0x20]\\n\"\n \".inst 0x6e40fcef // bfdot v15.4s, v7.8h, v0.8h\\n\"\n \".inst 0x6e40fd10 // bfdot v16.4s, v8.8h, v0.8h\\n\"\n \"ldr q2, [x21, #0x30]\\n\"\n \"ldr q3, [x21, #0x40]\\n\"\n \".inst 0x6e40fd31 // bfdot v17.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd52 // bfdot v18.4s, v10.8h, v0.8h\\n\"\n \"ldr q4, [x21, #0x50]\\n\"\n \"ldr q5, [x20, #0x0]\\n\"\n \".inst 0x6e40fd73 // bfdot v19.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd94 // bfdot v20.4s, v12.8h, v0.8h\\n\"\n \"ldr q6, [x20, #0x10]\\n\"\n \"ldr q7, [x20, #0x20]\\n\"\n \".inst 0x6e40fdb5 // bfdot v21.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc36 // bfdot v22.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x20, #0x30]\\n\"\n \"ldr q9, [x20, #0x40]\\n\"\n \".inst 0x6e40fc57 // bfdot v23.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc78 // bfdot v24.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x20, #0x50]\\n\"\n \".inst 0x6e40fc99 // bfdot v25.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcba // bfdot v26.4s, v5.8h, v0.8h\\n\"\n \"add x21, x21, #0x60\\n\"\n \".inst 0x6e40fcdb // bfdot v27.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcfc // bfdot v28.4s, v7.8h, v0.8h\\n\"\n \"add x20, x20, #0x60\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x400]\\n\"\n \".inst 0x6e40fd1d // bfdot v29.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd3e // bfdot v30.4s, v9.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x440]\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x480]\\n\"\n \".inst 0x6e40fd5f // bfdot v31.4s, v10.8h, v0.8h\\n\"\n \"prfm pldl1keep, [%x[B_ptr], #0x4c0]\\n\"\n \"prfm pldl1keep, [x23, #0x80]\\n\"\n \"92:\" // Width 9: Multiply loop: Main loop skip\n \"cbz x24, 95f\\n\"\n \"tbz x24, #1, 93f\\n\"\n \"ldr s0, [x23], #0x4\\n\"\n \"tbz x24, #0, 94f\\n\"\n \"ld1 { v0.h }[2], [x23]\\n\"\n \"b 94f\\n\"\n \"93:\" // Width 9: Multiply loop: Ragged operand read: partial_1_0\n \"ldr h0, [x23, #0x0]\\n\"\n \"94:\" // Width 9: Multiply loop: Ragged operand read: Done\n \"ldr q11, [%x[B_ptr], #0x0]\\n\"\n \"ldr q12, [%x[B_ptr], #0x10]\\n\"\n \"dup v0.2d, v0.d[0]\\n\"\n \"ldr q13, [%x[B_ptr], #0x20]\\n\"\n \"ldr q1, [%x[B_ptr], #0x30]\\n\"\n \"ldr q2, [%x[B_ptr], #0x40]\\n\"\n \"ldr q3, [%x[B_ptr], #0x50]\\n\"\n \"add %x[B_ptr], %x[B_ptr], #0x90\\n\"\n \"ldr q4, [x21, #0x0]\\n\"\n \"ldr q5, [x21, #0x10]\\n\"\n \".inst 0x6e40fd6e // bfdot v14.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd8f // bfdot v15.4s, v12.8h, v0.8h\\n\"\n \"ldr q6, [x21, #0x20]\\n\"\n \"ldr q7, [x21, #0x30]\\n\"\n \".inst 0x6e40fdb0 // bfdot v16.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc31 // bfdot v17.4s, v1.8h, v0.8h\\n\"\n \"ldr q8, [x21, #0x40]\\n\"\n \"ldr q9, [x21, #0x50]\\n\"\n \".inst 0x6e40fc52 // bfdot v18.4s, v2.8h, v0.8h\\n\"\n \".inst 0x6e40fc73 // bfdot v19.4s, v3.8h, v0.8h\\n\"\n \"ldr q10, [x20, #0x0]\\n\"\n \"ldr q11, [x20, #0x10]\\n\"\n \".inst 0x6e40fc94 // bfdot v20.4s, v4.8h, v0.8h\\n\"\n \".inst 0x6e40fcb5 // bfdot v21.4s, v5.8h, v0.8h\\n\"\n \"ldr q12, [x20, #0x20]\\n\"\n \"ldr q13, [x20, #0x30]\\n\"\n \".inst 0x6e40fcd6 // bfdot v22.4s, v6.8h, v0.8h\\n\"\n \".inst 0x6e40fcf7 // bfdot v23.4s, v7.8h, v0.8h\\n\"\n \"ldr q1, [x20, #0x40]\\n\"\n \"ldr q2, [x20, #0x50]\\n\"\n \".inst 0x6e40fd18 // bfdot v24.4s, v8.8h, v0.8h\\n\"\n \".inst 0x6e40fd39 // bfdot v25.4s, v9.8h, v0.8h\\n\"\n \".inst 0x6e40fd5a // bfdot v26.4s, v10.8h, v0.8h\\n\"\n \".inst 0x6e40fd7b // bfdot v27.4s, v11.8h, v0.8h\\n\"\n \".inst 0x6e40fd9c // bfdot v28.4s, v12.8h, v0.8h\\n\"\n \".inst 0x6e40fdbd // bfdot v29.4s, v13.8h, v0.8h\\n\"\n \".inst 0x6e40fc3e // bfdot v30.4s, v1.8h, v0.8h\\n\"\n \".inst 0x6e40fc5f // bfdot v31.4s, v2.8h, v0.8h\\n\"\n \"95:\" // Width 9: Multiply loop: No odd multiplies\n \"prfm pstl1keep, [%x[output_ptr], #0x0]\\n\"\n \"faddp v14.4s, v14.4s, v15.4s\\n\"\n \"faddp v15.4s, v16.4s, v17.4s\\n\"\n \"faddp v16.4s, v18.4s, v19.4s\\n\"\n \"faddp v17.4s, v20.4s, v21.4s\\n\"\n \"faddp v18.4s, v22.4s, v23.4s\\n\"\n \"faddp v19.4s, v24.4s, v25.4s\\n\"\n \"faddp v20.4s, v26.4s, v27.4s\\n\"\n \"faddp v21.4s, v28.4s, v29.4s\\n\"\n \"faddp v22.4s, v30.4s, v31.4s\\n\"\n \"tbz %x[flags], #1, 96f\\n\"\n \"add x21, %x[args_ptr], %[offset_max]\\n\"\n \"add x20, %x[args_ptr], %[offset_min]\\n\"\n \"ld1r { v24.4s }, [x21]\\n\"\n \"ld1r { v23.4s }, [x20]\\n\"\n \"fmin v14.4s, v14.4s, v24.4s\\n\"\n \"fmin v15.4s, v15.4s, v24.4s\\n\"\n \"fmin v16.4s, v16.4s, v24.4s\\n\"\n \"fmin v17.4s, v17.4s, v24.4s\\n\"\n \"fmin v18.4s, v18.4s, v24.4s\\n\"\n \"fmin v19.4s, v19.4s, v24.4s\\n\"\n \"fmin v20.4s, v20.4s, v24.4s\\n\"\n \"fmin v21.4s, v21.4s, v24.4s\\n\"\n \"fmin v22.4s, v22.4s, v24.4s\\n\"\n \"fmax v14.4s, v14.4s, v23.4s\\n\"\n \"fmax v15.4s, v15.4s, v23.4s\\n\"\n \"fmax v16.4s, v16.4s, v23.4s\\n\"\n \"fmax v17.4s, v17.4s, v23.4s\\n\"\n \"fmax v18.4s, v18.4s, v23.4s\\n\"\n \"fmax v19.4s, v19.4s, v23.4s\\n\"\n \"fmax v20.4s, v20.4s, v23.4s\\n\"\n \"fmax v21.4s, v21.4s, v23.4s\\n\"\n \"fmax v22.4s, v22.4s, v23.4s\\n\"\n \"96:\" // Width 9: No activation\n \"cmp %x[N], #0x24\\n\"\n \"str q14, [%x[output_ptr], #0x0]\\n\"\n \"str q15, [%x[output_ptr], #0x10]\\n\"\n \"str q16, [%x[output_ptr], #0x20]\\n\"\n \"str q17, [%x[output_ptr], #0x30]\\n\"\n \"str q18, [%x[output_ptr], #0x40]\\n\"\n \"str q19, [%x[output_ptr], #0x50]\\n\"\n \"str q20, [%x[output_ptr], #0x60]\\n\"\n \"str q21, [%x[output_ptr], #0x70]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x80\\n\"\n \"blt 97f\\n\"\n \"str q22, [%x[output_ptr], #0x0]\\n\"\n \"add %x[output_ptr], %x[output_ptr], #0x10\\n\"\n \"b 99f\\n\"\n \"97:\" // Width 9: Partial writeback\n \"tbz %x[N], #1, 98f\\n\"\n \"str d22, [%x[output_ptr]], #0x8\\n\"\n \"tbz %x[N], #0, 99f\\n\"\n \"st1 { v22.s }[2], [%x[output_ptr]]\\n\"\n \"b 99f\\n\"\n \"98:\" // Width 9: Partial direct writeback: partial_1_32\n \"tbz %x[N], #0, 99f\\n\"\n \"str s22, [%x[output_ptr], #0x0]\\n\"\n \"99:\" // Width 9: Writeback done\n \"subs x25, x25, #0x9\\n\"\n \"mov %x[B_ptr], x22\\n\"\n \"sub %x[N], %x[N], #0x24\\n\"\n \"bgt 1b\\n\"\n \"100:\" // Exit\n : [B_ptr] \"+&r\"(B_ptr), [N] \"+&r\"(N), [output_ptr] \"+&r\"(output_ptr)\n : [A_ptr] \"r\"(A_ptr), [K] \"r\"(K), [args_ptr] \"r\"(&ka), [flags] \"r\"(flags),\n [offset_max] \"I\"(offsetof(KernelArgs, maxval)), [offset_min] \"I\"(offsetof(KernelArgs, minval))\n : \"cc\", \"memory\", \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\", \"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v13\", \"v14\",\n \"v15\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\",\n \"v30\", \"v31\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_bf16p8x4_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @param[in] mr Number of rows to be interleaved.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_quant_pack_bf16p8x4_f32_neon(size_t mr);\n\n/// Gets the offset in bytes to the data element in the LHS buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] lhs_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_offset_lhs_quant_pack_bf16p8x4_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_bf16p8x4_f32_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_bf16p8x4_f32_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Runs the LHS packing function for matrix multiplication.\n///\n/// The pointer of each buffers (LHS and packed LHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * LHS: @ref kai_get_lhs_offset_lhs_quant_pack_bf16p8x4_f32_neon.\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_lhs_quant_pack_bf16p8x4_f32_neon.\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k Common dimension between the LHS and RHS matrix.\n/// @param[in] mr Block size in M dimension. It must be 8.\n/// @param[in] kr Block size in K dimension. It must be 4.\n/// @param[in] sr Number of kr splits. It must be 1.\n/// @param[in] m_idx_start Unused. Must be 0.\n/// @param[in] lhs LHS matrix data buffer.\n/// @param[in] lhs_stride Row stride in bytes of the LHS matrix.\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_quant_pack_bf16p8x4_f32_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_bf16p8x4_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_BF16.\n#else // Architectural features check.\n\n#define MAX_MR 8\n\n#include \"kai_lhs_quant_pack_bf16p8x4_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_mr = 8;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nsize_t kai_get_m_step_lhs_quant_pack_bf16p8x4_f32_neon(size_t mr) {\n KAI_ASSUME(mr == kai_mr);\n return kai_mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_bf16p8x4_f32_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_bf16p8x4_f32_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(sr);\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(kr == kai_kr);\n KAI_ASSUME(sr == kai_sr);\n KAI_ASSUME(m_idx % mr == 0);\n\n return m_idx * kai_roundup(k, kr) * sizeof(uint16_t);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_bf16p8x4_f32_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(sr);\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(kr == kai_kr);\n KAI_ASSUME(sr == kai_sr);\n\n return kai_roundup(m, mr) * kai_roundup(k, kr) * sizeof(uint16_t);\n}\n\nvoid kai_run_lhs_quant_pack_bf16p8x4_f32_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed) {\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(sr == kai_sr);\n KAI_ASSUME(kr == kai_kr);\n KAI_UNUSED(sr);\n KAI_ASSUME(lhs != NULL);\n KAI_ASSUME(lhs_packed != NULL);\n\n KAI_ASSUME(m_idx_start == 0);\n KAI_ASSUME(mr <= MAX_MR);\n\n const size_t block_height = mr;\n const size_t row_offset = 0;\n\n const void* in[MAX_MR];\n\n for (size_t block_y = 0; block_y < m; block_y += block_height) {\n const size_t height = KAI_MIN(m - block_y, block_height);\n void* out = (char*)lhs_packed + block_y * kai_roundup(k, kr) * sizeof(uint16_t);\n size_t width = k;\n\n for (size_t y = 0; y < height; y++) {\n in[y] = (const char*)lhs + (block_y + y) * lhs_stride;\n }\n\n __asm__ __volatile__(\n \"ldr x28, [%x[in], #0x0]\\n\"\n \"ldr x27, [%x[in], #0x8]\\n\"\n \"cmp %x[height], #0x8\\n\"\n \"ldr x26, [%x[in], #0x10]\\n\"\n \"ldr x25, [%x[in], #0x18]\\n\"\n \"ldr x24, [%x[in], #0x20]\\n\"\n \"ldr x23, [%x[in], #0x28]\\n\"\n \"ldr x22, [%x[in], #0x30]\\n\"\n \"ldr x21, [%x[in], #0x38]\\n\"\n \"add x28, x28, %x[row_offset], LSL #2\\n\"\n \"add x27, x27, %x[row_offset], LSL #2\\n\"\n \"add x26, x26, %x[row_offset], LSL #2\\n\"\n \"add x25, x25, %x[row_offset], LSL #2\\n\"\n \"add x24, x24, %x[row_offset], LSL #2\\n\"\n \"add x23, x23, %x[row_offset], LSL #2\\n\"\n \"add x22, x22, %x[row_offset], LSL #2\\n\"\n \"add x21, x21, %x[row_offset], LSL #2\\n\"\n \"beq 1f\\n\"\n \"cmp %x[height], #0x2\\n\"\n \"mov x21, x28\\n\"\n \"csel x27, x27, x28, GE\\n\"\n \"csel x26, x26, x28, GT\\n\"\n \"cmp %x[height], #0x4\\n\"\n \"csel x25, x25, x28, GE\\n\"\n \"csel x24, x24, x28, GT\\n\"\n \"cmp %x[height], #0x6\\n\"\n \"csel x23, x23, x28, GE\\n\"\n \"csel x22, x22, x28, GT\\n\"\n \"1:\" // no_pointer_adj\n \"cmp %x[width], #0x4\\n\"\n \"prfm pldl1keep, [x28, #0x0]\\n\"\n \"prfm pldl1keep, [x27, #0x0]\\n\"\n \"prfm pldl1keep, [x26, #0x0]\\n\"\n \"prfm pldl1keep, [x25, #0x0]\\n\"\n \"prfm pldl1keep, [x24, #0x0]\\n\"\n \"prfm pldl1keep, [x23, #0x0]\\n\"\n \"prfm pldl1keep, [x22, #0x0]\\n\"\n \"prfm pldl1keep, [x21, #0x0]\\n\"\n \"prfm pldl1keep, [x28, #0x40]\\n\"\n \"prfm pldl1keep, [x27, #0x40]\\n\"\n \"prfm pldl1keep, [x26, #0x40]\\n\"\n \"prfm pldl1keep, [x25, #0x40]\\n\"\n \"prfm pldl1keep, [x24, #0x40]\\n\"\n \"prfm pldl1keep, [x23, #0x40]\\n\"\n \"prfm pldl1keep, [x22, #0x40]\\n\"\n \"prfm pldl1keep, [x21, #0x40]\\n\"\n \"blt 3f\\n\"\n \"2:\" // Main loop head\n \"ldr q19, [x28], #0x10\\n\"\n \"ldr q18, [x26], #0x10\\n\"\n \"subs %x[width], %x[width], #0x4\\n\"\n \"ldr q17, [x24], #0x10\\n\"\n \"ldr q16, [x22], #0x10\\n\"\n \"cmp %x[width], #0x4\\n\"\n \"ldr q23, [x27], #0x10\\n\"\n \"ldr q22, [x25], #0x10\\n\"\n \"ldr q21, [x23], #0x10\\n\"\n \"ldr q20, [x21], #0x10\\n\"\n \".inst 0x0ea16a73 // bfcvtn v19.4h, v19.4s\\n\"\n \".inst 0x0ea16a52 // bfcvtn v18.4h, v18.4s\\n\"\n \".inst 0x0ea16a31 // bfcvtn v17.4h, v17.4s\\n\"\n \".inst 0x0ea16a10 // bfcvtn v16.4h, v16.4s\\n\"\n \"prfm pldl1keep, [x28, #0x70]\\n\"\n \"prfm pldl1keep, [x27, #0x70]\\n\"\n \"prfm pldl1keep, [x26, #0x70]\\n\"\n \"prfm pldl1keep, [x25, #0x70]\\n\"\n \"prfm pldl1keep, [x24, #0x70]\\n\"\n \"prfm pldl1keep, [x23, #0x70]\\n\"\n \".inst 0x4ea16af3 // bfcvtn2 v19.8h, v23.4s\\n\"\n \".inst 0x4ea16ad2 // bfcvtn2 v18.8h, v22.4s\\n\"\n \"prfm pldl1keep, [x22, #0x70]\\n\"\n \"prfm pldl1keep, [x21, #0x70]\\n\"\n \".inst 0x4ea16ab1 // bfcvtn2 v17.8h, v21.4s\\n\"\n \".inst 0x4ea16a90 // bfcvtn2 v16.8h, v20.4s\\n\"\n \"str q19, [%x[out_ptr], #0x0]\\n\"\n \"str q18, [%x[out_ptr], #0x10]\\n\"\n \"str q17, [%x[out_ptr], #0x20]\\n\"\n \"str q16, [%x[out_ptr], #0x30]\\n\"\n \"add %x[out_ptr], %x[out_ptr], #0x40\\n\"\n \"bge 2b\\n\"\n \"3:\" // Main loop skip\n \"cbz %x[width], 6f\\n\"\n \"tbz %x[width], #1, 4f\\n\"\n \"ldr d19, [x28], #0x8\\n\"\n \"ldr d23, [x27], #0x8\\n\"\n \"mov x20, #0x1\\n\"\n \"ldr d18, [x26], #0x8\\n\"\n \"ldr d22, [x25], #0x8\\n\"\n \"ldr d17, [x24], #0x8\\n\"\n \"ldr d21, [x23], #0x8\\n\"\n \"ldr d16, [x22], #0x8\\n\"\n \"ldr d20, [x21], #0x8\\n\"\n \"tbz %x[width], #0, 5f\\n\"\n \"ld1 { v19.s }[2], [x28]\\n\"\n \"ld1 { v23.s }[2], [x27]\\n\"\n \"ld1 { v18.s }[2], [x26]\\n\"\n \"ld1 { v22.s }[2], [x25]\\n\"\n \"ld1 { v17.s }[2], [x24]\\n\"\n \"ld1 { v21.s }[2], [x23]\\n\"\n \"ld1 { v16.s }[2], [x22]\\n\"\n \"ld1 { v20.s }[2], [x21]\\n\"\n \"b 5f\\n\"\n \"4:\" // odd_loads_1_0\n \"ldr s19, [x28, #0x0]\\n\"\n \"ldr s23, [x27, #0x0]\\n\"\n \"mov x20, #0x1\\n\"\n \"ldr s18, [x26, #0x0]\\n\"\n \"ldr s22, [x25, #0x0]\\n\"\n \"ldr s17, [x24, #0x0]\\n\"\n \"ldr s21, [x23, #0x0]\\n\"\n \"ldr s16, [x22, #0x0]\\n\"\n \"ldr s20, [x21, #0x0]\\n\"\n \"5:\" // Odd load end\n \".inst 0x0ea16a73 // bfcvtn v19.4h, v19.4s\\n\"\n \".inst 0x0ea16a52 // bfcvtn v18.4h, v18.4s\\n\"\n \".inst 0x0ea16a31 // bfcvtn v17.4h, v17.4s\\n\"\n \".inst 0x0ea16a10 // bfcvtn v16.4h, v16.4s\\n\"\n \".inst 0x4ea16af3 // bfcvtn2 v19.8h, v23.4s\\n\"\n \".inst 0x4ea16ad2 // bfcvtn2 v18.8h, v22.4s\\n\"\n \".inst 0x4ea16ab1 // bfcvtn2 v17.8h, v21.4s\\n\"\n \".inst 0x4ea16a90 // bfcvtn2 v16.8h, v20.4s\\n\"\n \"str q19, [%x[out_ptr], #0x0]\\n\"\n \"str q18, [%x[out_ptr], #0x10]\\n\"\n \"str q17, [%x[out_ptr], #0x20]\\n\"\n \"str q16, [%x[out_ptr], #0x30]\\n\"\n \"add %x[out_ptr], %x[out_ptr], #0x40\\n\"\n \"6:\" // Odds skip\n : [out_ptr] \"+&r\"(out), [width] \"+&r\"(width)\n : [height] \"r\"(height), [in] \"r\"(in), [row_offset] \"r\"(row_offset)\n : \"cc\", \"memory\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\",\n \"x25\", \"x26\", \"x27\", \"x28\");\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_bf16p1x4_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @param[in] mr Number of rows to be interleaved.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_quant_pack_bf16p1x4_f32_neon(size_t mr);\n\n/// Gets the offset in bytes to the data element in the LHS buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] lhs_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_offset_lhs_quant_pack_bf16p1x4_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_bf16p1x4_f32_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Number of columns to be interleaved.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_bf16p1x4_f32_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Runs the LHS packing function for matrix multiplication.\n///\n/// The pointer of each buffers (LHS and packed LHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * LHS: @ref kai_get_lhs_offset_lhs_quant_pack_bf16p1x4_f32_neon.\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_lhs_quant_pack_bf16p1x4_f32_neon.\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k Common dimension between the LHS and RHS matrix.\n/// @param[in] mr Block size in M dimension. It must be 8.\n/// @param[in] kr Block size in K dimension. It must be 4.\n/// @param[in] sr Number of kr splits. It must be 1.\n/// @param[in] m_idx_start Unused. Must be 0.\n/// @param[in] lhs LHS matrix data buffer.\n/// @param[in] lhs_stride Row stride in bytes of the LHS matrix. Currently unused.\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_quant_pack_bf16p1x4_f32_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_bf16p1x4_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_BF16.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_bf16p1x4_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nsize_t kai_get_m_step_lhs_quant_pack_bf16p1x4_f32_neon(size_t mr) {\n KAI_ASSUME(mr == kai_mr);\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_bf16p1x4_f32_neon(size_t m_idx, size_t lhs_stride) {\n KAI_ASSUME(m_idx % kai_mr == 0);\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_bf16p1x4_f32_neon(\n size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(sr);\n KAI_ASSUME(m_idx == 0);\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(kr == kai_kr);\n KAI_ASSUME(sr == kai_sr);\n\n return m_idx * kai_roundup(k, kr) * sizeof(uint16_t);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_bf16p1x4_f32_neon(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(sr);\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(kr == kai_kr);\n KAI_ASSUME(sr == kai_sr);\n\n return kai_roundup(m, mr) * kai_roundup(k, kr) * sizeof(uint16_t);\n}\n\nvoid kai_run_lhs_quant_pack_bf16p1x4_f32_neon(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride,\n void* lhs_packed) {\n KAI_UNUSED(sr);\n KAI_UNUSED(lhs_stride);\n\n KAI_ASSUME(m == 1);\n KAI_ASSUME(mr == kai_mr);\n KAI_ASSUME(kr == kai_kr);\n KAI_ASSUME(sr == kai_sr);\n\n KAI_ASSUME(lhs != NULL);\n KAI_ASSUME(lhs_packed != NULL);\n\n KAI_ASSUME(m_idx_start == 0);\n\n const float* lhs_ptr = lhs;\n uint16_t* lhs_packed_ptr = lhs_packed;\n\n // Unroll two 256-bit loops\n size_t i = 0;\n for (; i + 16 <= k; i += 16) {\n const float32x4x4_t val = vld1q_f32_x4(lhs_ptr);\n bfloat16x8x2_t bf_val;\n\n bf_val.val[0] = vcvtq_low_bf16_f32(val.val[0]);\n bf_val.val[0] = vcvtq_high_bf16_f32(bf_val.val[0], val.val[1]);\n bf_val.val[1] = vcvtq_low_bf16_f32(val.val[2]);\n bf_val.val[1] = vcvtq_high_bf16_f32(bf_val.val[1], val.val[3]);\n vst1q_bf16_x2((bfloat16_t*)(lhs_packed_ptr), bf_val);\n\n lhs_ptr += 16;\n lhs_packed_ptr += 16;\n }\n\n // 1 load + 1 convert + 1 store\n for (; i + 8 <= k; i += 8) {\n const float32x4x2_t f32_val = vld1q_f32_x2(lhs_ptr);\n bfloat16x8_t bf_val = vcvtq_low_bf16_f32(f32_val.val[0]);\n bf_val = vcvtq_high_bf16_f32(bf_val, f32_val.val[1]);\n vst1q_bf16((bfloat16_t*)(lhs_packed_ptr), bf_val);\n\n lhs_ptr += 8;\n lhs_packed_ptr += 8;\n }\n\n for (; i + 4 <= k; i += 4) {\n const float32x4_t f32_val = vld1q_f32(lhs_ptr);\n bfloat16x4_t bf_val = vcvt_bf16_f32(f32_val);\n vst1_bf16((bfloat16_t*)(lhs_packed_ptr), bf_val);\n\n lhs_ptr += 4;\n lhs_packed_ptr += 4;\n }\n\n for (; i < k; ++i) {\n *lhs_packed_ptr = kai_cast_bf16_f32(*lhs_ptr);\n\n ++lhs_ptr;\n ++lhs_packed_ptr;\n }\n\n // Zero pad\n const size_t rounded_up_k = kai_roundup(k, kr);\n for (; i < rounded_up_k; ++i) {\n *lhs_packed_ptr = 0;\n ++lhs_packed_ptr;\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Gets n step value.\n///\n/// The starting row index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(void);\n\n/// Gets the offset in bytes to the data element in the RHS matrix buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the bias buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_bias_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the packed RHS buffer.\n///\n/// @param[in] n_idx Row index.\n/// @param[in] k Number of columns.\n/// @param[in] nr Block size in N dimension.\n/// @param[in] kr Block size in K dimension.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr);\n\n/// Gets the size in bytes of the packed RHS buffer.\n///\n/// @param[in] n Number of rows.\n/// @param[in] k Number of columns.\n/// @param[in] nr Block size in N dimension.\n/// @param[in] kr Block size in K dimension.\n///\n/// @return The size in bytes of the packed RHS buffer.\nsize_t kai_get_rhs_packed_size_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n, size_t k, size_t nr, size_t kr);\n\n/// Runs the RHS packing function for matrix multiplication.\n///\n/// The pointer of each buffers (RHS, bias and packed RHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * RHS: @ref kai_get_rhs_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.\n/// * Bias: @ref kai_get_bias_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.\n/// * Output: @ref kai_get_rhs_packed_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.\n///\n/// @param[in] num_groups Number of groups. It must be 1.\n/// @param[in] n Number of columns of the output matrix.\n/// @param[in] k Common dimension between the LHS and RHS matrix.\n/// @param[in] nr Block size in N dimension.\n/// @param[in] kr Block size in K dimension.\n/// @param[in] sr Number of kr splits. It must be 1.\n/// @param[in] rhs_stride Row stride in bytes of the RHS matrix.\n/// @param[in] rhs RHS matrix data buffer.\n/// @param[in] bias Bias matrix data buffer.\n/// @param[in] scale Scale data buffer. It must be NULL.\n/// @param[out] rhs_packed Packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix. It must be 0.\n/// @param[in] params Extra packing parameters. It must be NULL.\nvoid kai_run_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t rhs_stride, const void* rhs,\n const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes, const void* params);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// Do not flag up inline assembly blocks\n#pragma GCC diagnostic ignored \"-Woverlength-strings\"\n\n#if !defined(__aarch64__) || !defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC)\n#error This file must be compiled for AArch64, FEAT_BF16.\n#else // Architectural features check.\n\n#define MAX_NR 12\n\n#include \"kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.h\"\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_nr = 12;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nsize_t kai_get_n_step_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(void) {\n return kai_nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n_idx) {\n KAI_ASSUME(n_idx % kai_nr == 0);\n return n_idx * sizeof(float);\n}\n\nsize_t kai_get_bias_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n_idx) {\n KAI_ASSUME(n_idx % kai_nr == 0);\n return n_idx * sizeof(uint32_t);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr) {\n KAI_ASSUME(n_idx % nr == 0);\n KAI_ASSUME(kai_nr == nr);\n KAI_ASSUME(kai_kr == kr);\n\n return n_idx * (sizeof(uint32_t) + kai_roundup(k, kr) * sizeof(uint16_t));\n}\n\nsize_t kai_get_rhs_packed_size_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(size_t n, size_t k, size_t nr, size_t kr) {\n return kai_get_rhs_packed_offset_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(kai_roundup(n, nr), k, nr, kr);\n}\n\nvoid kai_run_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t rhs_stride, const void* rhs,\n const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes, const void* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME(kai_nr == nr);\n KAI_ASSUME(kai_kr == kr);\n KAI_ASSUME(kai_sr == sr);\n KAI_ASSUME(sr == 1);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(scale == NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(extra_bytes == 0);\n KAI_ASSUME(params == NULL);\n KAI_ASSUME(nr <= MAX_NR);\n\n size_t height = k;\n const size_t width = n;\n const void* in = rhs;\n void* out = rhs_packed;\n const size_t in_stride = rhs_stride;\n const float* pad_row = rhs;\n\n // Fill zeros if bias is nullptr\n size_t bias_step = nr * sizeof(float);\n uint8_t zero_bias[MAX_NR * sizeof(float)];\n\n if (bias == NULL) {\n memset(zero_bias, 0, MAX_NR * sizeof(float));\n bias_step = 0;\n }\n\n const void* bias_ptr = bias == NULL ? (const void*)zero_bias : bias;\n\n const size_t out_stride = nr * kai_roundup(height, kr) * sizeof(uint16_t) + nr * sizeof(uint32_t);\n\n __asm__ __volatile__(\n \"mov x22, %x[width]\\n\"\n \"mov x21, %x[out]\\n\"\n \"cmp x22, #0xc\\n\"\n \"blt 2f\\n\"\n \"1:\" // Bias: Full loop\n \"ldr q16, [%x[bias], #0x0]\\n\"\n \"ldr q26, [%x[bias], #0x10]\\n\"\n \"sub x22, x22, #0xc\\n\"\n \"ldr q8, [%x[bias], #0x20]\\n\"\n \"cmp x22, #0xc\\n\"\n \"add %x[bias], %x[bias], %x[bias_step]\\n\"\n \"str q16, [x21, #0x0]\\n\"\n \"str q26, [x21, #0x10]\\n\"\n \"str q8, [x21, #0x20]\\n\"\n \"add x21, x21, %x[out_stride]\\n\"\n \"bge 1b\\n\"\n \"cbz x22, 3f\\n\"\n \"2:\" // Bias: Tail loop\n \"ldr w20, [%x[bias], #0x0]\\n\"\n \"sub x22, x22, #0x1\\n\"\n \"add %x[bias], %x[bias], #0x4\\n\"\n \"cmp x22, #0x0\\n\"\n \"str w20, [x21]\\n\"\n \"add x21, x21, #0x4\\n\"\n \"bgt 2b\\n\"\n \"3:\" // Bias: Done\n \"cmp %x[height], #0x8\\n\"\n \"add %x[out], %x[out], #0x30\\n\"\n \"blt 12f\\n\"\n \"4:\" // Main row loop: Head\n \"mov x9, %x[in]\\n\"\n \"mov x28, %x[width]\\n\"\n \"mov x27, %x[out]\\n\"\n \"sub %x[height], %x[height], #0x8\\n\"\n \"add x26, x9, %x[in_stride]\\n\"\n \"add x25, x26, %x[in_stride]\\n\"\n \"add x24, x25, %x[in_stride]\\n\"\n \"cmp x28, #0xc\\n\"\n \"add x23, x24, %x[in_stride]\\n\"\n \"add x22, x23, %x[in_stride]\\n\"\n \"add x21, x22, %x[in_stride]\\n\"\n \"add x20, x21, %x[in_stride]\\n\"\n \"add %x[in], x20, %x[in_stride]\\n\"\n \"blt 6f\\n\"\n \"5:\" // Main row loop: Column loop\n \"ldr q28, [x9], #0x10\\n\"\n \"ldr q27, [x26], #0x10\\n\"\n \"sub x28, x28, #0xc\\n\"\n \"ldr q11, [x25], #0x10\\n\"\n \"ldr q5, [x24], #0x10\\n\"\n \"cmp x28, #0xc\\n\"\n \"ldr q14, [x23], #0x10\\n\"\n \"ldr q6, [x22], #0x10\\n\"\n \"ldr q2, [x21], #0x10\\n\"\n \"ldr q18, [x20], #0x10\\n\"\n \"ldr q1, [x9], #0x10\\n\"\n \"ldr q7, [x26], #0x10\\n\"\n \"zip1 v15.4s, v28.4s, v11.4s\\n\"\n \"zip1 v8.4s, v27.4s, v5.4s\\n\"\n \"ldr q3, [x25], #0x10\\n\"\n \"ldr q23, [x24], #0x10\\n\"\n \"zip2 v17.4s, v28.4s, v11.4s\\n\"\n \"zip2 v27.4s, v27.4s, v5.4s\\n\"\n \"ldr q5, [x23], #0x10\\n\"\n \"ldr q30, [x22], #0x10\\n\"\n \"zip1 v26.4s, v14.4s, v2.4s\\n\"\n \"zip1 v31.4s, v6.4s, v18.4s\\n\"\n \"ldr q20, [x21], #0x10\\n\"\n \"ldr q16, [x20], #0x10\\n\"\n \"zip2 v12.4s, v14.4s, v2.4s\\n\"\n \"zip2 v24.4s, v6.4s, v18.4s\\n\"\n \"ldr q29, [x9], #0x10\\n\"\n \"ldr q6, [x26], #0x10\\n\"\n \"zip1 v18.4s, v1.4s, v3.4s\\n\"\n \"zip1 v4.4s, v7.4s, v23.4s\\n\"\n \"ldr q22, [x25], #0x10\\n\"\n \"ldr q0, [x24], #0x10\\n\"\n \"zip2 v3.4s, v1.4s, v3.4s\\n\"\n \"zip2 v1.4s, v7.4s, v23.4s\\n\"\n \"ldr q2, [x23], #0x10\\n\"\n \"ldr q10, [x22], #0x10\\n\"\n \"zip1 v28.4s, v5.4s, v20.4s\\n\"\n \"zip1 v14.4s, v30.4s, v16.4s\\n\"\n \"ldr q9, [x21], #0x10\\n\"\n \"ldr q23, [x20], #0x10\\n\"\n \"zip2 v13.4s, v5.4s, v20.4s\\n\"\n \"zip2 v30.4s, v30.4s, v16.4s\\n\"\n \"zip1 v16.4s, v29.4s, v22.4s\\n\"\n \"zip1 v5.4s, v6.4s, v0.4s\\n\"\n \"zip2 v22.4s, v29.4s, v22.4s\\n\"\n \"zip2 v0.4s, v6.4s, v0.4s\\n\"\n \"zip1 v7.4s, v2.4s, v9.4s\\n\"\n \"zip1 v19.4s, v10.4s, v23.4s\\n\"\n \"zip2 v21.4s, v2.4s, v9.4s\\n\"\n \"zip2 v25.4s, v10.4s, v23.4s\\n\"\n \"zip1 v11.4s, v15.4s, v8.4s\\n\"\n \"zip1 v9.4s, v17.4s, v27.4s\\n\"\n \"zip1 v6.4s, v18.4s, v4.4s\\n\"\n \"zip1 v2.4s, v3.4s, v1.4s\\n\"\n \"zip1 v29.4s, v16.4s, v5.4s\\n\"\n \"zip1 v20.4s, v22.4s, v0.4s\\n\"\n \"zip1 v10.4s, v26.4s, v31.4s\\n\"\n \"zip1 v23.4s, v12.4s, v24.4s\\n\"\n \".inst 0x0ea1696b // bfcvtn v11.4h, v11.4s\\n\"\n \"zip2 v8.4s, v15.4s, v8.4s\\n\"\n \"zip1 v15.4s, v28.4s, v14.4s\\n\"\n \".inst 0x0ea16929 // bfcvtn v9.4h, v9.4s\\n\"\n \"zip2 v27.4s, v17.4s, v27.4s\\n\"\n \"zip1 v17.4s, v13.4s, v30.4s\\n\"\n \".inst 0x0ea168c6 // bfcvtn v6.4h, v6.4s\\n\"\n \"zip2 v4.4s, v18.4s, v4.4s\\n\"\n \"zip1 v18.4s, v7.4s, v19.4s\\n\"\n \".inst 0x0ea16842 // bfcvtn v2.4h, v2.4s\\n\"\n \"zip2 v1.4s, v3.4s, v1.4s\\n\"\n \"zip1 v3.4s, v21.4s, v25.4s\\n\"\n \".inst 0x0ea16bbd // bfcvtn v29.4h, v29.4s\\n\"\n \"zip2 v5.4s, v16.4s, v5.4s\\n\"\n \".inst 0x0ea16a94 // bfcvtn v20.4h, v20.4s\\n\"\n \"zip2 v0.4s, v22.4s, v0.4s\\n\"\n \".inst 0x0ea16956 // bfcvtn v22.4h, v10.4s\\n\"\n \"zip2 v31.4s, v26.4s, v31.4s\\n\"\n \".inst 0x0ea16aea // bfcvtn v10.4h, v23.4s\\n\"\n \"zip2 v26.4s, v12.4s, v24.4s\\n\"\n \".inst 0x0ea169ef // bfcvtn v15.4h, v15.4s\\n\"\n \"zip2 v12.4s, v28.4s, v14.4s\\n\"\n \".inst 0x0ea16a2e // bfcvtn v14.4h, v17.4s\\n\"\n \"zip2 v24.4s, v13.4s, v30.4s\\n\"\n \".inst 0x0ea16a57 // bfcvtn v23.4h, v18.4s\\n\"\n \"zip2 v18.4s, v7.4s, v19.4s\\n\"\n \".inst 0x0ea16871 // bfcvtn v17.4h, v3.4s\\n\"\n \"zip2 v16.4s, v21.4s, v25.4s\\n\"\n \".inst 0x4ea1690b // bfcvtn2 v11.8h, v8.4s\\n\"\n \".inst 0x4ea16b69 // bfcvtn2 v9.8h, v27.4s\\n\"\n \".inst 0x4ea16886 // bfcvtn2 v6.8h, v4.4s\\n\"\n \".inst 0x4ea16822 // bfcvtn2 v2.8h, v1.4s\\n\"\n \".inst 0x4ea168bd // bfcvtn2 v29.8h, v5.4s\\n\"\n \".inst 0x4ea16814 // bfcvtn2 v20.8h, v0.4s\\n\"\n \".inst 0x4ea16bf6 // bfcvtn2 v22.8h, v31.4s\\n\"\n \".inst 0x4ea16b4a // bfcvtn2 v10.8h, v26.4s\\n\"\n \"str q11, [x27, #0x0]\\n\"\n \".inst 0x4ea1698f // bfcvtn2 v15.8h, v12.4s\\n\"\n \".inst 0x4ea16b0e // bfcvtn2 v14.8h, v24.4s\\n\"\n \"str q9, [x27, #0x10]\\n\"\n \".inst 0x4ea16a57 // bfcvtn2 v23.8h, v18.4s\\n\"\n \".inst 0x4ea16a11 // bfcvtn2 v17.8h, v16.4s\\n\"\n \"str q6, [x27, #0x20]\\n\"\n \"str q2, [x27, #0x30]\\n\"\n \"str q29, [x27, #0x40]\\n\"\n \"str q20, [x27, #0x50]\\n\"\n \"str q22, [x27, #0x60]\\n\"\n \"str q10, [x27, #0x70]\\n\"\n \"str q15, [x27, #0x80]\\n\"\n \"str q14, [x27, #0x90]\\n\"\n \"str q23, [x27, #0xa0]\\n\"\n \"str q17, [x27, #0xb0]\\n\"\n \"add x27, x27, %x[out_stride]\\n\"\n \"bge 5b\\n\"\n \"6:\" // Main row loop: Column loop skip\n \"cbz x28, 11f\\n\"\n \"cmp x28, #0x4\\n\"\n \"movi v16.16b, #0x0\\n\"\n \"str q16, [x27, #0x0]\\n\"\n \"str q16, [x27, #0x10]\\n\"\n \"str q16, [x27, #0x20]\\n\"\n \"str q16, [x27, #0x30]\\n\"\n \"str q16, [x27, #0x40]\\n\"\n \"str q16, [x27, #0x50]\\n\"\n \"str q16, [x27, #0x60]\\n\"\n \"str q16, [x27, #0x70]\\n\"\n \"str q16, [x27, #0x80]\\n\"\n \"str q16, [x27, #0x90]\\n\"\n \"str q16, [x27, #0xa0]\\n\"\n \"str q16, [x27, #0xb0]\\n\"\n \"blt 8f\\n\"\n \"7:\" // Main row loop: width 4 loop: loop\n \"ldr q25, [x9], #0x10\\n\"\n \"ldr q24, [x26], #0x10\\n\"\n \"sub x28, x28, #0x4\\n\"\n \"ldr q21, [x25], #0x10\\n\"\n \"ldr q20, [x24], #0x10\\n\"\n \"cmp x28, #0x4\\n\"\n \"ldr q23, [x23], #0x10\\n\"\n \"ldr q19, [x22], #0x10\\n\"\n \"ldr q18, [x21], #0x10\\n\"\n \"ldr q17, [x20], #0x10\\n\"\n \"zip1 v22.4s, v25.4s, v21.4s\\n\"\n \"zip1 v16.4s, v24.4s, v20.4s\\n\"\n \"zip2 v21.4s, v25.4s, v21.4s\\n\"\n \"zip2 v20.4s, v24.4s, v20.4s\\n\"\n \"zip1 v27.4s, v23.4s, v18.4s\\n\"\n \"zip1 v26.4s, v19.4s, v17.4s\\n\"\n \"zip2 v25.4s, v23.4s, v18.4s\\n\"\n \"zip2 v24.4s, v19.4s, v17.4s\\n\"\n \"zip1 v19.4s, v22.4s, v16.4s\\n\"\n \"zip1 v18.4s, v21.4s, v20.4s\\n\"\n \"zip1 v17.4s, v27.4s, v26.4s\\n\"\n \"zip2 v23.4s, v22.4s, v16.4s\\n\"\n \"zip1 v16.4s, v25.4s, v24.4s\\n\"\n \"zip2 v22.4s, v21.4s, v20.4s\\n\"\n \".inst 0x0ea16a75 // bfcvtn v21.4h, v19.4s\\n\"\n \".inst 0x0ea16a54 // bfcvtn v20.4h, v18.4s\\n\"\n \".inst 0x0ea16a33 // bfcvtn v19.4h, v17.4s\\n\"\n \"zip2 v18.4s, v27.4s, v26.4s\\n\"\n \".inst 0x0ea16a11 // bfcvtn v17.4h, v16.4s\\n\"\n \"zip2 v16.4s, v25.4s, v24.4s\\n\"\n \".inst 0x4ea16af5 // bfcvtn2 v21.8h, v23.4s\\n\"\n \".inst 0x4ea16ad4 // bfcvtn2 v20.8h, v22.4s\\n\"\n \".inst 0x4ea16a53 // bfcvtn2 v19.8h, v18.4s\\n\"\n \".inst 0x4ea16a11 // bfcvtn2 v17.8h, v16.4s\\n\"\n \"str q21, [x27, #0x0]\\n\"\n \"str q20, [x27, #0x10]\\n\"\n \"str q19, [x27, #0x60]\\n\"\n \"str q17, [x27, #0x70]\\n\"\n \"add x27, x27, #0x20\\n\"\n \"bge 7b\\n\"\n \"8:\" // Main row loop: width 4 loop: skip\n \"cmp x28, #0x1\\n\"\n \"blt 10f\\n\"\n \"9:\" // Main row loop: width 1 loop: loop\n \"ldr s23, [x9], #0x4\\n\"\n \"ldr s22, [x26], #0x4\\n\"\n \"sub x28, x28, #0x1\\n\"\n \"ldr s19, [x25], #0x4\\n\"\n \"ldr s17, [x24], #0x4\\n\"\n \"cmp x28, #0x1\\n\"\n \"ldr s21, [x23], #0x4\\n\"\n \"ldr s20, [x22], #0x4\\n\"\n \"ldr s18, [x21], #0x4\\n\"\n \"ldr s16, [x20], #0x4\\n\"\n \"zip1 v19.4s, v23.4s, v19.4s\\n\"\n \"zip1 v17.4s, v22.4s, v17.4s\\n\"\n \"zip1 v18.4s, v21.4s, v18.4s\\n\"\n \"zip1 v16.4s, v20.4s, v16.4s\\n\"\n \"zip1 v17.4s, v19.4s, v17.4s\\n\"\n \"zip1 v16.4s, v18.4s, v16.4s\\n\"\n \".inst 0x0ea16a31 // bfcvtn v17.4h, v17.4s\\n\"\n \".inst 0x0ea16a10 // bfcvtn v16.4h, v16.4s\\n\"\n \"str d17, [x27, #0x0]\\n\"\n \"str d16, [x27, #0x60]\\n\"\n \"add x27, x27, #0x8\\n\"\n \"bge 9b\\n\"\n \"10:\" // Main row loop: width 1 loop: skip\n \"11:\" // Main row loop: odd col skip\n \"cmp %x[height], #0x8\\n\"\n \"add %x[out], %x[out], #0xc0\\n\"\n \"bge 4b\\n\"\n \"cbz %x[height], 21f\\n\"\n \"12:\" // Main loop skip\n \"13:\" // Tail row loop: Head\n \"mov x9, %x[in]\\n\"\n \"mov x20, %x[width]\\n\"\n \"cmp %x[height], #0x3\\n\"\n \"mov x27, %x[out]\\n\"\n \"add x26, x9, %x[in_stride]\\n\"\n \"add x25, x26, %x[in_stride]\\n\"\n \"add x24, x25, %x[in_stride]\\n\"\n \"csel x25, x25, %x[pad_row], GE\\n\"\n \"add %x[in], x24, %x[in_stride]\\n\"\n \"csel x24, x24, %x[pad_row], GT\\n\"\n \"cmp %x[height], #0x1\\n\"\n \"sub %x[height], %x[height], #0x4\\n\"\n \"csel x26, x26, %x[pad_row], GT\\n\"\n \"cmp x20, #0xc\\n\"\n \"blt 15f\\n\"\n \"14:\" // Tail row loop: Column loop\n \"ldr q24, [x9], #0x10\\n\"\n \"ldr q23, [x26], #0x10\\n\"\n \"sub x20, x20, #0xc\\n\"\n \"ldr q22, [x25], #0x10\\n\"\n \"ldr q16, [x24], #0x10\\n\"\n \"cmp x20, #0xc\\n\"\n \"ldr q28, [x9], #0x10\\n\"\n \"ldr q27, [x26], #0x10\\n\"\n \"ldr q21, [x25], #0x10\\n\"\n \"ldr q20, [x24], #0x10\\n\"\n \"ldr q19, [x9], #0x10\\n\"\n \"zip1 v26.4s, v24.4s, v22.4s\\n\"\n \"zip1 v25.4s, v23.4s, v16.4s\\n\"\n \"ldr q18, [x26], #0x10\\n\"\n \"ldr q17, [x25], #0x10\\n\"\n \"zip2 v24.4s, v24.4s, v22.4s\\n\"\n \"zip2 v23.4s, v23.4s, v16.4s\\n\"\n \"ldr q16, [x24], #0x10\\n\"\n \"zip1 v2.4s, v28.4s, v21.4s\\n\"\n \"zip1 v22.4s, v27.4s, v20.4s\\n\"\n \"zip2 v1.4s, v28.4s, v21.4s\\n\"\n \"zip2 v0.4s, v27.4s, v20.4s\\n\"\n \"zip1 v31.4s, v19.4s, v17.4s\\n\"\n \"zip1 v30.4s, v18.4s, v16.4s\\n\"\n \"zip2 v29.4s, v19.4s, v17.4s\\n\"\n \"zip2 v28.4s, v18.4s, v16.4s\\n\"\n \"zip1 v21.4s, v26.4s, v25.4s\\n\"\n \"zip1 v20.4s, v24.4s, v23.4s\\n\"\n \"zip1 v19.4s, v2.4s, v22.4s\\n\"\n \"zip1 v18.4s, v1.4s, v0.4s\\n\"\n \"zip1 v17.4s, v31.4s, v30.4s\\n\"\n \"zip1 v16.4s, v29.4s, v28.4s\\n\"\n \".inst 0x0ea16abb // bfcvtn v27.4h, v21.4s\\n\"\n \"zip2 v26.4s, v26.4s, v25.4s\\n\"\n \".inst 0x0ea16a99 // bfcvtn v25.4h, v20.4s\\n\"\n \"zip2 v24.4s, v24.4s, v23.4s\\n\"\n \".inst 0x0ea16a77 // bfcvtn v23.4h, v19.4s\\n\"\n \"zip2 v22.4s, v2.4s, v22.4s\\n\"\n \".inst 0x0ea16a55 // bfcvtn v21.4h, v18.4s\\n\"\n \"zip2 v20.4s, v1.4s, v0.4s\\n\"\n \".inst 0x0ea16a33 // bfcvtn v19.4h, v17.4s\\n\"\n \"zip2 v18.4s, v31.4s, v30.4s\\n\"\n \".inst 0x0ea16a11 // bfcvtn v17.4h, v16.4s\\n\"\n \"zip2 v16.4s, v29.4s, v28.4s\\n\"\n \".inst 0x4ea16b5b // bfcvtn2 v27.8h, v26.4s\\n\"\n \".inst 0x4ea16b19 // bfcvtn2 v25.8h, v24.4s\\n\"\n \".inst 0x4ea16ad7 // bfcvtn2 v23.8h, v22.4s\\n\"\n \".inst 0x4ea16a95 // bfcvtn2 v21.8h, v20.4s\\n\"\n \".inst 0x4ea16a53 // bfcvtn2 v19.8h, v18.4s\\n\"\n \".inst 0x4ea16a11 // bfcvtn2 v17.8h, v16.4s\\n\"\n \"str q27, [x27, #0x0]\\n\"\n \"str q25, [x27, #0x10]\\n\"\n \"str q23, [x27, #0x20]\\n\"\n \"str q21, [x27, #0x30]\\n\"\n \"str q19, [x27, #0x40]\\n\"\n \"str q17, [x27, #0x50]\\n\"\n \"add x27, x27, %x[out_stride]\\n\"\n \"bge 14b\\n\"\n \"15:\" // Tail row loop: Column loop skip\n \"cbz x20, 20f\\n\"\n \"cmp x20, #0x4\\n\"\n \"movi v16.16b, #0x0\\n\"\n \"str q16, [x27, #0x0]\\n\"\n \"str q16, [x27, #0x10]\\n\"\n \"str q16, [x27, #0x20]\\n\"\n \"str q16, [x27, #0x30]\\n\"\n \"str q16, [x27, #0x40]\\n\"\n \"str q16, [x27, #0x50]\\n\"\n \"blt 17f\\n\"\n \"16:\" // Tail row loop: width 4 loop: loop\n \"ldr q21, [x9], #0x10\\n\"\n \"ldr q20, [x26], #0x10\\n\"\n \"sub x20, x20, #0x4\\n\"\n \"ldr q19, [x25], #0x10\\n\"\n \"ldr q17, [x24], #0x10\\n\"\n \"cmp x20, #0x4\\n\"\n \"zip1 v18.4s, v21.4s, v19.4s\\n\"\n \"zip1 v16.4s, v20.4s, v17.4s\\n\"\n \"zip2 v21.4s, v21.4s, v19.4s\\n\"\n \"zip2 v20.4s, v20.4s, v17.4s\\n\"\n \"zip1 v17.4s, v18.4s, v16.4s\\n\"\n \"zip2 v19.4s, v18.4s, v16.4s\\n\"\n \"zip1 v16.4s, v21.4s, v20.4s\\n\"\n \".inst 0x0ea16a32 // bfcvtn v18.4h, v17.4s\\n\"\n \"zip2 v17.4s, v21.4s, v20.4s\\n\"\n \".inst 0x0ea16a10 // bfcvtn v16.4h, v16.4s\\n\"\n \".inst 0x4ea16a72 // bfcvtn2 v18.8h, v19.4s\\n\"\n \".inst 0x4ea16a30 // bfcvtn2 v16.8h, v17.4s\\n\"\n \"str q18, [x27, #0x0]\\n\"\n \"str q16, [x27, #0x10]\\n\"\n \"add x27, x27, #0x20\\n\"\n \"bge 16b\\n\"\n \"17:\" // Tail row loop: width 4 loop: skip\n \"cmp x20, #0x1\\n\"\n \"blt 19f\\n\"\n \"18:\" // Tail row loop: width 1 loop: loop\n \"ldr s19, [x9], #0x4\\n\"\n \"ldr s18, [x26], #0x4\\n\"\n \"sub x20, x20, #0x1\\n\"\n \"ldr s17, [x25], #0x4\\n\"\n \"ldr s16, [x24], #0x4\\n\"\n \"cmp x20, #0x1\\n\"\n \"zip1 v17.4s, v19.4s, v17.4s\\n\"\n \"zip1 v16.4s, v18.4s, v16.4s\\n\"\n \"zip1 v16.4s, v17.4s, v16.4s\\n\"\n \".inst 0x0ea16a10 // bfcvtn v16.4h, v16.4s\\n\"\n \"str d16, [x27, #0x0]\\n\"\n \"add x27, x27, #0x8\\n\"\n \"bge 18b\\n\"\n \"19:\" // Tail row loop: width 1 loop: skip\n \"20:\" // Tail row loop: odd col skip\n \"cmp %x[height], #0x1\\n\"\n \"add %x[out], %x[out], #0x60\\n\"\n \"bge 13b\\n\"\n \"21:\" // Done\n : [bias] \"+&r\"(bias_ptr), [height] \"+&r\"(height), [in] \"+&r\"(in), [out] \"+&r\"(out)\n : [bias_step] \"r\"(bias_step), [in_stride] \"r\"(in_stride), [out_stride] \"r\"(out_stride), [pad_row] \"r\"(pad_row),\n [width] \"r\"(width)\n : \"cc\", \"memory\", \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\", \"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v13\", \"v14\",\n \"v15\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\",\n \"v30\", \"v31\", \"x9\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\", \"x27\", \"x28\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla against gemm_f32_bf16_n512_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla.h\"\n#include \"kai_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot.h\"\n#include \"kai_lhs_quant_pack_bf16p8x4_f32_neon.h\"\n#include \"kai_lhs_quant_pack_bf16p1x4_f32_neon.h\"\n#include \"kai_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n // M == 1 runs the dedicated GEMV ukernel, as a KleidiAI user would pick it. Both variants\n // share one packed-RHS layout (same nr/kr/sr), so a single cached weight pack serves both.\n const bool gemv = (M == 1);\n const size_t nr = kai_get_nr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla();\n const size_t kr = kai_get_kr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla();\n const size_t sr = kai_get_sr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla();\n if (kai_get_nr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() != nr || kai_get_kr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() != kr ||\n kai_get_sr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() != sr) return -2;\n const size_t mr = gemv ? kai_get_mr_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot() : kai_get_mr_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = gemv ? (kai_get_lhs_packed_size_lhs_quant_pack_bf16p1x4_f32_neon((size_t)M, (size_t)K, mr, kr, sr)) : (kai_get_lhs_packed_size_lhs_quant_pack_bf16p8x4_f32_neon((size_t)M, (size_t)K, mr, kr, sr));\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n if (gemv) {\n kai_run_lhs_quant_pack_bf16p1x4_f32_neon((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n } else {\n kai_run_lhs_quant_pack_bf16p8x4_f32_neon((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_snap = nullptr;\n static size_t B_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_snap, B_snap_size, B, sizeof(float)*N*K)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon((size_t)N, (size_t)K, nr, kr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n kai_run_rhs_quant_pack_kxn_bf16p12x4biasf32_f32_neon(1, (size_t)N, (size_t)K, nr, kr, sr, (size_t)N * sizeof(float), B, bias, nullptr, rhs_packed, 0, nullptr);\n }\n\n if (gemv) {\n kai_run_matmul_clamp_f32_bf16p1x4_bf16p12x4b_1x36_neon_dot((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n } else {\n kai_run_matmul_clamp_f32_bf16p8x4_bf16p12x4b_8x12_neon_mmla((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n }\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_i32_u8_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_i32_u8_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..971434d02ddc27f06da827637ceebd123d7dc8c2 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_i32_u8_sme2_n256_k512.json @@ -0,0 +1,88 @@ +{ + "name": "baseline-kleidiai-arm_gemm_i32_u8_sme2_n256_k512", + "definition": "gemm_i32_u8_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_i32_u8_sme2_n256_k512: KleidiAI kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa (new-style uker API) with its x8p4vsx4 LHS/RHS packers; int32 result converted to float32.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// For micro-kernel naming and associated packing micro-kernel that goes with it, see:\n/// * docs/microkernel_tables.md\n/// * kai/ukernels/matmul/README.md\n/// This provides information such as the data type and packing format of the buffers.\n/// Any information that is not present in the above files is documented here.\n///\n/// Documentation conventions in this file:\n/// * Only required or conditionally required configuration parameters,\n/// operands, activation arguments, and flags are documented.\n/// * See the *_types.h file for the description of those argument types.\n/// * Accumulation data type matches the output data type by default. It is\n/// documented along with the API only when the data types differ.\n/// * Any argument not listed for a micro-kernel is unused and does not need\n/// to be populated.\n///\n\n/// Half-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst\n/// * rhs - rhs with per-n accumulator bias\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16p4vsx2_f16p4vsx2bf16_8vsx8vs_sme2_mopa(void);\n\n/// Single-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n/// * FEAT_FP16\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - f16p4vsx2 packed FP16 values.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to FP16 values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f16p4vsx2_qsi4c32p16vsx4s1s0sf16_f16p_4vsx16vs_sme2_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p1x4sf16 packed with per-block FP16 scale.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to 8-bit values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p1x4sf16_qsi4c32p16vsx4s1s0sf16_i8p_1x16vs_sme2_dot(void);\n\n/// Single-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst\n/// * rhs - rhs with per-n accumulator bias\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f32p4vsx1_f32p4vsx1bf32_8vsx8vs_sme2_mopa(void);\n\n/// Matrix multiplication with single-precision floating-point accumulation using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p4vsx4sf16 packed with per-block FP16 scale.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to 8-bit values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p4vsx4sf16_qsi4c32p16vsx4s1s0sf16_i8p_4vsx16vs_sme2_mopa(void);\n\n/// Matrix multiplication with 32-bit integer accumulation using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst, rhs\n/// * bias\n/// * acc_bias_m, acc_bias_n\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa(void);\n\n/// Matrix multiplication with 32-bit integer accumulation and FP32 output using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst, rhs\n/// * bias\n/// * acc_bias_m, acc_bias_n, scale_bias_n\n/// * scale\n/// * acc_scale_global\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Accumulation: I32, then converted to F32 using global scaling and per column bias\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamping output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication using SME2 MLA instruction.\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - rhs matrix and per-n accumulator bias vector.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f32_f32p4vsx1bf32_1x32vs_sme2_mla(void);\n\n/// Half-precision floating-point matrix multiplication using SVE2.1 FDOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SVE2p1\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Accumulation: F32, then converted to F16.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16_f16p16vsx2bf16_6x16vs_sve2p1_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi8cxp8x4_1x8_sve_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi8cxp32x4_1x32_sve_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp8x8_1x8_sve_dot(void);\n\n/// Half-precision floating-point vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - rhs matrix and per-n accumulator bias vector.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16_f16p4vsx2bf16_1x32vs_sme2_dot(void);\n\n/// Statically quantized INT8 matrix multiplication with INT4 RHS using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p8vsx4_qsi4cxp8vsx4sf32bi32_8vsx8vs_sme2_mopa(void);\n\n/// Statically quantized INT8 matrix multiplication using SME2 outer product (MOPA) and SME2.1 quarter tile outer\n/// product (MOP4A) instructions.\n///\n/// Required CPU features:\n/// * FEAT_SME2.1\n/// * FEAT_SME_MOP4\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p4vsx4_qsi8cxp4vsx4sf32bi32_8vsx8vs_sme2p1_mop4_mopa(void);\n\n/// Statically quantized INT8 matrix-vector multiplication with packed UINT2 RHS using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N destination-domain corrected bias and scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsu2cxp16vsx4sf32bi32_1x64vs_sme2_dot(void);\n\n/// Statically quantized INT8 matrix multiplication with packed UINT2 RHS using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N destination-domain corrected bias and scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p8vsx4_qsu2cxp16vsx4sf32bi32_8vsx16vs_sme2_mopa(void);\n\n/// Statically quantized INT8 matrix multiplication using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p4vsx4_qsi8cxp4vsx4bi32sf32_8vsx8vs_sme2_mopa(void);\n\n/// Statically quantized INT8 vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsi8cxp4vsx4bi32sf32_1x32vs_sme2_dot(void);\n\n/// Statically quantized INT8 vector-matrix multiplication with packed INT4 RHS using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - Packed RHS matrix with per-N bias and per-N scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsi4cxp8vsx4sf32bi32_1x64vs_sme2_dot(void);\n\n/// Matrix multiplication with FP16 packed LHS and QAI4C32P RHS with FP32 output using SME2 MOPA.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n/// * FEAT_FP16\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be 32.\n///\n/// Required operands:\n/// * lhs - FP16 data packed in 4vsx2 panels.\n/// * rhs - qai4c32p16vsx4s1s0sf16 packed with per-block FP16 offset and scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * clamp - FP32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f16p4vsx2_qai4c32p16vsx4s1s0sf16_4vsx16vs_sme2_mopa(void);\n\n/// Vector-matrix multiplication with dynamically quantized INT8 packed LHS and QAI4C32P RHS packed inputs with FP32\n/// output using SME2 DOT.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p1x4sf16 data packed with per-block FP16 sum and scale.\n/// * rhs - qai4c32p16vsx4s1s0sf16 packed with per-block FP16 offset and scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * clamp - FP32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p1x4_qai4c32p16vsx4s1s0sf16_1x16vs_sme2_dot(void);\n\n/// Single-precision floating-point matrix multiplication with statically-blockwise quantized unsigned INT4 RHS,\n/// using SME MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * dst\n/// * lhs - Dynamically quantized asymmetric per-row (qai8dxp) LHS, packed with @ref\n/// kai_lhs_quant_pack_qai8dxp_f32.\n/// * rhs - Packed RHS matrix, obtained with @ref kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme or\n/// @ref\n/// kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp4vsx4_qsi4c32p16vsx4_4vsx16vs_sme_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication with statically-blockwise quantized unsigned INT4\n/// RHS, using SME DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * dst\n/// * lhs - Dynamically quantized asymmetric per-row (qai8dxp) LHS, packed with @ref\n/// kai_lhs_quant_pack_qai8dxp_f32.\n/// * rhs - Packed RHS matrix, obtained with @ref kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme or\n/// @ref\n/// kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi4c32p16vsx4_1x16vs_sme_dot(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_format_config {\n size_t bl;\n};\n\n/// Micro-kernel configuration for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_config {\n struct kai_matmul_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_args {\n const void* ptr; ///< LHS buffer.\n struct kai_matmul_uker_lhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n};\n\n/// RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_args {\n const void* ptr; ///< RHS buffer.\n struct kai_matmul_uker_rhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Strides in bytes of the output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_stride_args {\n size_t m; ///< Strides in bytes in M dimension.\n};\n\n/// Output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_args {\n void* ptr; ///< Output buffer.\n struct kai_matmul_uker_dst_stride_args stride; ///< Strides in bytes.\n};\n\n//// Bias types ////\n///\n/// Bias can be applied at multiple stages:\n/// * `acc_bias` - Bias applied at the accumulation stage\n/// * `scale_bias` - Bias applied to the scaled accumulation stage\n///\n/// There are different kind of biases.\n/// * `global` - Scalar value applied to entire _stage_ for a global value shift\n/// * `m` - Scalar value applied to each row of _stage_ for a per row value shift\n/// * `n` - Scalar value applied to each column _stage_ for a per column value shift\n\n/// Accumulation stage ///\n\n/// Global accumulation bias parameters\nstruct kai_matmul_uker_acc_bias_global_args {\n const void* ptr; ///< Global accumulation bias value\n};\n\n/// Per-M accumulation bias\nstruct kai_matmul_uker_acc_bias_m_args {\n const void* ptr; ///< Per-M accumulation bias vector\n};\n\n/// Per-N accumulation bias\nstruct kai_matmul_uker_acc_bias_n_args {\n const void* ptr; ///< Per-N accumulation bias buffer.\n};\n\n/// Scaling stage ///\n\n/// Global scaled accumulation bias parameter\nstruct kai_matmul_uker_scale_bias_global_args {\n const void* ptr; ///< Scalar scaling bias parameter.\n};\n\n/// Per-M scaled accumulation bias\nstruct kai_matmul_uker_scale_bias_m_args {\n const void* ptr; ///< Per-M scaling bias buffer.\n};\n\n/// Per-N scaled accumulation bias\nstruct kai_matmul_uker_scale_bias_n_args {\n const void* ptr; ///< Per-N scaling bias buffer.\n};\n\n/// Bias parameters\nstruct kai_matmul_uker_bias_args {\n struct kai_matmul_uker_acc_bias_global_args acc_bias_global; ///< Accumulation bias, global\n struct kai_matmul_uker_acc_bias_m_args acc_bias_m; ///< Accumulation bias, per row\n struct kai_matmul_uker_acc_bias_n_args acc_bias_n; ///< Accumulation bias, per column\n struct kai_matmul_uker_scale_bias_global_args scale_bias_global; ///< Scale bias, scalar\n struct kai_matmul_uker_scale_bias_m_args scale_bias_m; ///< Scale bias, per row\n struct kai_matmul_uker_scale_bias_n_args scale_bias_n; ///< Scale bias, column\n};\n\n//// Scaling types ////\n///\n/// Scaling can be applied at multiple stages\n/// * `acc_scale` - Scaling applied to the biased accumulation stage\n///\n/// There are different kind of scaling.\n/// * `global` - Scalar value applied to entire _stage_ for a global scaling\n/// * `m` - Scalar value applied to each element in row of _stage_ for a per row scaling\n/// * `n` - Scalar value applied to each element in column of _stage_ for a per column scaling\n\n/// Global scale parameter for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_global_args {\n const void* ptr; ///< Global scale parameter.\n};\n\n/// Per-M accumulation scale buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_m_args {\n const void* ptr; ///< Per-M accumulation scale buffer.\n};\n\n/// Per-N accumulation scale buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_n_args {\n const void* ptr; ///< Per-N accumulation scale buffer.\n};\n\n/// Scale parameters\nstruct kai_matmul_uker_scale_args {\n struct kai_matmul_uker_acc_scale_global_args acc_scale_global; ///< Accumulation scale, scalar\n struct kai_matmul_uker_acc_scale_m_args acc_scale_m; ///< Accumulation scale, per row\n struct kai_matmul_uker_acc_scale_n_args acc_scale_n; ///< Accumulation scale, per column\n};\n\n//// Activation parameter types ////\n\n/// Clamping activation arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_clamp_args {\n const void* min_ptr; ///< Pointer to the minimum value.\n const void* max_ptr; ///< Pointer to the maximum value.\n};\n\n/// Activation function arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_activation_args {\n struct kai_matmul_uker_clamp_args clamp; ///< Output clamping function.\n};\n\n//// Lookup table parameter types ////\n\n/// Lookup table arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lut_args {\n const void* ptr; ///< Lookup table buffer.\n};\n\n//// Operand and high level argument types ////\n\n/// Operands for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_operand_args {\n struct kai_matmul_uker_dst_args dst; ///< Output buffer.\n struct kai_matmul_uker_lhs_args lhs; ///< LHS buffer.\n struct kai_matmul_uker_rhs_args rhs; ///< RHS buffer.\n struct kai_matmul_uker_bias_args bias; ///< Bias parameters\n struct kai_matmul_uker_scale_args scale; ///< Scale parameters\n struct kai_matmul_uker_lut_args lut; ///< Lookup table arguments.\n};\n\n/// Matrix multiplication micro-kernel run arguments.\nstruct kai_matmul_uker_args {\n uint64_t flags; ///< Control flags.\n struct kai_matmul_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_uker_operand_args operand; ///< Operands.\n struct kai_matmul_uker_activation_args activation; ///< Fused activation function.\n};\n\n/// Matrix multiplication micro-kernel run flags.\nenum kai_matmul_uker_flags_args {\n KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP = 0x10000, ///< Clamping output data.\n};\n\n/// Matrix multiplication micro-kernel API.\nstruct kai_matmul_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_uker_dim_args (*get_step)(const struct kai_matmul_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_uker_lhs_stride_args (*get_lhs_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* shape);\n\n /// Gets the offset in bytes of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* index,\n const struct kai_matmul_uker_lhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_uker_rhs_stride_args (*get_rhs_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* shape);\n\n /// Gets the offset in bytes of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* index,\n const struct kai_matmul_uker_rhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The stride in bytes.\n struct kai_matmul_uker_dst_stride_args (*get_dst_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape);\n\n /// Gets the offset in bytes of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the output data.\n ///\n /// @return The offset in bytes.\n size_t (*get_dst_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* index,\n const struct kai_matmul_uker_dst_stride_args* stride);\n\n /// Gets the size in bytes of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the output data.\n ///\n /// @return The size in bytes.\n size_t (*get_dst_size)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape,\n const struct kai_matmul_uker_dst_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_lhs.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Non-transposed LHS dynamic quantization and packing micro-kernel for FP32 data.\n///\n/// Required CPU features:\n/// * FEAT_AdvSIMD\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: qsi8d32p1x4sf16 data. Every 32-value block contains INT8 values followed by an FP16\n/// dequantized sum and an FP16 scale.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: FP32 data in MxK layout, where K must be a multiple of 32.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_qsi8d32p1x4sf16_f32_neon(void);\n\n/// Non-transposed LHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 8-bit data in 4vsx4 blocked format.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 8-bit data in plain format.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed LHS packing micro-kernel for 16-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 16-bit data in 4vsx2 blocked format.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 16-bit data in plain format.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x16p4vsx2_x16_sme(void);\n\n/// Non-transposed LHS packing micro-kernel for 32-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 32-bit data in MxK layout.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x32p4vsx1_x32_sme(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_lhs_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_format_config {\n size_t mr;\n size_t kr;\n size_t sr;\n};\n\n/// Micro-kernel configuration for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_config {\n struct kai_matmul_pack_lhs_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_args {\n const void* ptr; ///< LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// Packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_args {\n void* ptr; ///< Packed LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args stride; ///< Strides in bytes.\n};\n\n/// Operands for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_operand_args {\n struct kai_matmul_pack_lhs_uker_lhs_packed_args lhs_packed; ///< Packed LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_args lhs; ///< LHS buffer.\n};\n\n/// Matrix multiplication LHS packing micro-kernel arguments.\nstruct kai_matmul_pack_lhs_uker_args {\n uint64_t flags; ///< Control flags.\n\n struct kai_matmul_pack_lhs_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_pack_lhs_uker_operand_args operand; ///< Operands.\n};\n\n/// Matrix multiplication LHS packing micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_pack_lhs_uker_dim_args (*get_step)(const struct kai_matmul_pack_lhs_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_lhs_uker_lhs_stride_args (*get_lhs_stride)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_dim_args* shape);\n\n /// Gets the offset in bytes of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_offset)(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args (*get_lhs_packed_stride)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape);\n\n /// Gets the offset in bytes of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the packed LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_packed_offset)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride);\n\n /// Gets the size in bytes of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the packed LHS data.\n ///\n /// @return The size in bytes.\n size_t (*get_lhs_packed_size)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_rhs.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n// SPDX-FileCopyrightText: Copyright 2026 Meta Platforms, Inc. and affiliates.\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SVE\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 16vsx2 blocked layout.\n/// * Per-n bias vector: 16-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 16-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_rhs_pack_kxn_x16p16vsx2bx16_x16_x16_sve(void);\n\n/// Non-transposed RHS packing micro-kernel for 32-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * Per-n bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 32-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 32-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x32p4vsx1bx32_x32_x32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 4vsx2 blocked layout.\n/// * Per-n bias vector: 16-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 16-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x16p4vsx2bx16_x16_x16_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N 32-bit bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 8vsx2 blocked layout.\n/// * Per-N bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The optional per-N bias vector.\n/// * Per-N bias vector: 32-bit data. A null pointer packs zero bias.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x16p8vsx2bx32_x16_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 32-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * Per-n bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 32-bit data in NxK layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 32-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x32p4vsx1bx32_x32_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 16-bit data with per-N 32-bit bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 8vsx2 blocked layout.\n/// * Per-N bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in NxK layout.\n/// * bias_n - The optional per-N bias vector.\n/// * Per-N bias vector: 32-bit data. A null pointer packs zero bias.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x16p8vsx2bx32_x16_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 8-bit data in 4vsx4 blocked layout.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 8-bit data in NxK layout.\n/// * bias_n - Unused by this micro-kernel.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 8-bit data in 4vsx4 blocked layout.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 8-bit data in KxN layout.\n/// * bias_n - Unused by this micro-kernel.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized INT8 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * Per-N bias vector: INT32 data.\n/// * RHS matrix: INT8 data in 4vsx4 blocked format.\n/// * Per-N scale vector: FP32 data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: INT8 data in plain format, non-transposed.\n/// * bias_n - The per-N quantized bias vector.\n/// * Per-N bias vector: INT32 data.\n/// * k_sum_scale_global - The per-matrix row sum scale value.\n/// * Per-matrix row sum scale value: INT32 data.\n/// * scale_n - The per-N quantization scale vector.\n/// * Per-N scale vector: FP32 data.\n/// * scale_global - The per-matrix scale value.\n/// * Per-matrix scale value: FP32 data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi8cxp4vsx4bi32sf32_qsi8_i32_f32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized signed INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, non-transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4cxp8vsx4sf32bi32_qsi4cx_f32_i32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized unsigned INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, non-transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4cxp8vsx4sf32bi32_qsu4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized signed INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4cxp8vsx4sf32bi32_qsi4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized unsigned INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4cxp8vsx4sf32bi32_qsu4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized int4 data with block-wise quantization and super block meta\n/// data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: qai4c32p16vsx4s1s0sf16 data with 16vsx4-ordered per-block FP16 scale and offset metadata.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: qai4c32k256sf16s32s0 4-bit data in NxK layout, stored as 256-value super-blocks. K must be a\n/// multiple of 256\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qai4c32p16vsx4s1s0sf16_qai4c32k256sf16s32s0_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized UINT2 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, UINT2 RHS in 16vsx4 blocked format, and FP32 scale.\n/// * rhs - UINT2 data in plain format, non-transposed, with zero point 2.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - Negative LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsu2cxp16vsx4sf32bi32_qsu2cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized UINT2 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, UINT2 RHS in 16vsx4 blocked format, and FP32 scale.\n/// * rhs - UINT2 data in plain format, transposed, with zero point 2.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - Negative LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsu2cxp16vsx4sf32bi32_qsu2cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for statically-blockwise quantized unsigned INT4 data (fixed RHS zero point\n/// 8, fixed LHS zero point 1, BF16 block scales).\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * rhs_packed - Per-block INT4 RHS in s4s0 nrx4 blocked format, per-block BF16 scale, per-N FP32 row sum, and\n/// per-N FP32 bias.\n/// * rhs - INT4 data in plain format, transposed (N x K, two values packed per byte).\n/// * bias_n - Per-N FP32 bias.\n/// * scale_n - Per-block, per-N BF16 scale.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for statically-blockwise quantized unsigned INT4 data (fixed RHS zero\n/// point 8, fixed LHS zero point 1, BF16 block scales).\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * rhs_packed - Per-block INT4 RHS in s4s0 nrx4 blocked format, per-block BF16 scale, per-N FP32 row sum, and\n/// per-N FP32 bias.\n/// * rhs - INT4 data in plain format, non-transposed (K x N, two values packed per byte).\n/// * bias_n - Per-N FP32 bias.\n/// * scale_n - Per-block, per-N BF16 scale.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_rhs_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_format_config {\n size_t nr;\n size_t kr;\n size_t sr;\n size_t bl;\n};\n\n/// Micro-kernel configuration for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_config {\n struct kai_matmul_pack_rhs_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n size_t k; ///< Stride in bytes in K dimension.\n};\n\n/// RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_args {\n const void* ptr; ///< RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n};\n\n/// Packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_args {\n void* ptr; ///< Packed RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the per-N bias buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_bias_n_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Per-N bias buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_bias_n_args {\n const void* ptr; ///< Per-N bias buffer.\n};\n\n/// Per-matrix K sum scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_k_sum_scale_global_args {\n const void* ptr; ///< Per-matrix K sum scale buffer.\n};\n\n/// Dimensions of the per-N scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_n_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Per-N scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_n_args {\n const void* ptr; ///< Per-N scale buffer.\n};\n\n/// Dimensions of the per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_nk_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_nk_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n size_t k; ///< Stride in bytes in K dimension.\n};\n\n/// Per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel. Unlike `scale_n`, which holds a\n/// single value per N column, this operand holds one value per (N column, K block) pair and therefore requires\n/// explicit strides to locate an element, since the vector-buffer API used by `scale_n` cannot express a stride.\nstruct kai_matmul_pack_rhs_uker_scale_nk_args {\n const void* ptr; ///< Per-(N, K) scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_nk_stride_args stride; ///< Strides in bytes.\n};\n\n/// Per-matrix scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_global_args {\n const void* ptr; ///< Per-matrix scale buffer.\n};\n\n/// Operands for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_operand_args {\n struct kai_matmul_pack_rhs_uker_rhs_args rhs; ///< RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_packed_args rhs_packed; ///< Packed RHS buffer.\n struct kai_matmul_pack_rhs_uker_bias_n_args bias_n; ///< Per-N bias buffer.\n struct kai_matmul_pack_rhs_uker_k_sum_scale_global_args k_sum_scale_global; ///< Per-matrix K sum scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_n_args scale_n; ///< Per-N scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_global_args scale_global; ///< Per-matrix scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_nk_args scale_nk; ///< Per-(N, K) scale buffer.\n};\n\n/// Matrix multiplication RHS packing micro-kernel arguments.\nstruct kai_matmul_pack_rhs_uker_args {\n uint64_t flags; ///< Control flags.\n\n struct kai_matmul_pack_rhs_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_pack_rhs_uker_operand_args operand; ///< Operands.\n};\n\n/// Matrix multiplication RHS packing micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_pack_rhs_uker_dim_args (*get_step)(const struct kai_matmul_pack_rhs_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_rhs_stride_args (*get_rhs_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_dim_args* shape);\n\n /// Gets the offset in bytes of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args (*get_rhs_packed_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape);\n\n /// Gets the offset in bytes of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the packed RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_packed_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride);\n\n /// Gets the size in bytes of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the packed RHS data.\n ///\n /// @return The size in bytes.\n size_t (*get_rhs_packed_size)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride);\n\n /// Gets the offset in bytes of the per-N bias data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n ///\n /// @return The offset in bytes, or zero if `bias_n` is unused.\n size_t (*get_bias_n_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_bias_n_dim_args* index);\n\n /// Gets the offset in bytes of the per-N scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n ///\n /// @return The offset in bytes.\n size_t (*get_scale_n_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_n_dim_args* index);\n\n /// Gets the stride in bytes in each dimension of the per-(N, K) scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_scale_nk_stride_args (*get_scale_nk_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_nk_dim_args* shape);\n\n /// Gets the offset in bytes of the per-(N, K) scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the per-(N, K) scale data.\n ///\n /// @return The offset in bytes.\n size_t (*get_scale_nk_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_nk_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_scale_nk_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul.h\"\n#include \"kai/ukernels/matmul/kai_matmul_types.h\"\n\nenum {\n DST_ELEM_BYTES = 4,\n LHS_ELEM_BYTES = 1,\n RHS_ELEM_BYTES = 1,\n BIAS_ELEM_BYTES = 4,\n\n MR_VSCALE = 4,\n NR_VSCALE = 4,\n M_STEP_VSCALE = 8,\n N_STEP_VSCALE = 8,\n KR = 4,\n\n SUPPORTED_FLAGS = 0,\n};\n\ntypedef struct {\n uint64_t flags;\n size_t m;\n size_t n;\n size_t k;\n const void* lhs_ptr;\n size_t lhs_stride_row;\n const void* rhs_ptr;\n size_t rhs_stride_row;\n void* dst_ptr;\n size_t dst_stride_row;\n void* acc_ptr;\n const void* acc_bias_m_ptr;\n const void* acc_bias_n_ptr;\n const void* dst_bias_n_ptr;\n const void* dst_scale_1_ptr;\n const void* min_ptr;\n const void* max_ptr;\n} kai_matmul_uker_args_internal;\n\nvoid kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa(const kai_matmul_uker_args_internal* args);\n\nstatic size_t get_mr(void) {\n return MR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_nr(void) {\n return NR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_m_step(void) {\n return M_STEP_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_n_step(void) {\n return N_STEP_VSCALE * kai_get_sme_vscale();\n}\n\nstatic struct kai_matmul_uker_dim_args get_step(const struct kai_matmul_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_dim_args step = {\n .m = get_m_step(),\n .n = get_n_step(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_uker_lhs_stride_args get_lhs_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_lhs_stride_args stride = {\n .m = get_mr() * kai_roundup(shape->k, KR) * LHS_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* index,\n const struct kai_matmul_uker_lhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->m / get_mr() * stride->m;\n}\n\nstatic struct kai_matmul_uker_rhs_stride_args get_rhs_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_rhs_stride_args stride = {\n .n = get_nr() * (kai_roundup(shape->k, KR) * RHS_ELEM_BYTES),\n };\n return stride;\n}\n\nstatic size_t get_rhs_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* index,\n const struct kai_matmul_uker_rhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->n / get_nr() * stride->n;\n}\n\nstatic struct kai_matmul_uker_dst_stride_args get_dst_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_dst_stride_args stride = {\n .m = shape->n * DST_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_dst_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* index,\n const struct kai_matmul_uker_dst_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->n % get_nr() == 0);\n\n return index->m * stride->m + index->n * DST_ELEM_BYTES;\n}\n\nstatic size_t get_dst_size(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape,\n const struct kai_matmul_uker_dst_stride_args* stride) {\n KAI_UNUSED(config);\n\n return shape->m * stride->m;\n}\n\nstatic void run(const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_args* run_args) {\n KAI_UNUSED(config);\n KAI_ASSUME_MSG((run_args->flags & ~((size_t)SUPPORTED_FLAGS)) == 0, \"Only supported flags are accepted!\");\n\n KAI_ASSUME(run_args->operand.lhs.ptr != NULL);\n KAI_ASSUME(run_args->operand.rhs.ptr != NULL);\n KAI_ASSUME(run_args->operand.dst.ptr != NULL);\n\n kai_matmul_uker_args_internal args = {0};\n args.flags = run_args->flags;\n\n args.m = run_args->shape.m;\n args.n = run_args->shape.n;\n args.k = run_args->shape.k;\n\n args.lhs_ptr = run_args->operand.lhs.ptr;\n args.lhs_stride_row = run_args->operand.lhs.stride.m;\n\n args.rhs_ptr = run_args->operand.rhs.ptr;\n args.rhs_stride_row = run_args->operand.rhs.stride.n;\n\n args.dst_ptr = run_args->operand.dst.ptr;\n args.dst_stride_row = run_args->operand.dst.stride.m;\n\n args.acc_bias_m_ptr = run_args->operand.bias.acc_bias_m.ptr;\n args.acc_bias_n_ptr = run_args->operand.bias.acc_bias_n.ptr;\n args.dst_bias_n_ptr = NULL;\n args.dst_scale_1_ptr = NULL;\n\n args.min_ptr = NULL;\n args.max_ptr = NULL;\n\n kai_commit_za();\n kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa(&args);\n}\n\nstruct kai_matmul_uker_api kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa(void) {\n struct kai_matmul_uker_api api = {\n .run = run,\n .get_step = get_step,\n\n .get_lhs_stride = get_lhs_stride,\n .get_lhs_offset = get_lhs_offset,\n\n .get_rhs_stride = get_rhs_stride,\n .get_rhs_offset = get_rhs_offset,\n\n .get_dst_stride = get_dst_stride,\n .get_dst_offset = get_dst_offset,\n .get_dst_size = get_dst_size,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x5, [x0, #0x18]\n ptrue p0.b\n KAI_ASM_INST(0x25207814) // ptrue pn12.b\n ldr x6, [x0, #0x0]\n cntw x7\n ldr x8, [x0, #0x8]\n add x5, x5, #0x3\n ldr x17, [x0, #0x10]\n ldr x16, [x0, #0x20]\n lsr x5, x5, #0x2\n ldr x15, [x0, #0x28]\n ldr x14, [x0, #0x38]\n ldr x13, [x0, #0x58]\n ldr x11, [x0, #0x60]\n ldr x10, [x0, #0x48]\n tbz x6, #24, label_1\n ldr x22, [x0, #0x70]\n ldr x21, [x0, #0x78]\n ldr x20, [x0, #0x80]\n ldr x9, [x0, #0x68]\n KAI_ASM_INST(0x8540c2d7) // ld1rw { z23.s }, p0/Z, [x22]\n KAI_ASM_INST(0x8540c2b0) // ld1rw { z16.s }, p0/Z, [x21]\n KAI_ASM_INST(0x8540c296) // ld1rw { z22.s }, p0/Z, [x20]\nKAI_ASM_LABEL(label_1) // load_scale: skip\n mov x28, #0x0\nKAI_ASM_LABEL(label_2) // m_loop: body\n ldr x27, [x0, #0x40]\n KAI_ASM_INST(0x25a84790) // whilelt pn8.s, x28, x8, VLx2\n mov x26, #0x0\n KAI_ASM_INST(0xa01c41b4) // ld1w { z20.s-z21.s }, p8/Z, [x13, x28, LSL #2]\n ldr x25, [x0, #0x30]\n madd x27, x28, x10, x27\nKAI_ASM_LABEL(label_3) // m_loop: n_loop: body\n KAI_ASM_INST(0xc00800ff) // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n KAI_ASM_INST(0x25b14753) // whilelt pn11.s, x26, x17, VLx2\n mov x24, x16\n add x20, x28, x7\n KAI_ASM_INST(0xc0910280) // addva za0.s, p0/M, p0/M, z20.s\n KAI_ASM_INST(0xa01a4d62) // ld1w { z2.s-z3.s }, p11/Z, [x11, x26, LSL #2]\n add x23, x24, x15\n KAI_ASM_INST(0xc0910281) // addva za1.s, p0/M, p0/M, z20.s\n cmp x20, x8\n mov x22, x25\n KAI_ASM_INST(0xc09102a2) // addva za2.s, p0/M, p0/M, z21.s\n add x20, x26, x7\n csel x23, x23, x16, LT\n KAI_ASM_INST(0xc09102a3) // addva za3.s, p0/M, p0/M, z21.s\n cmp x20, x17\n add x21, x22, x14\n mov x20, x5\n csel x21, x21, x25, LT\n KAI_ASM_INST(0xc0900040) // addha za0.s, p0/M, p0/M, z2.s\n cmp x20, #0x4\n KAI_ASM_INST(0xc0900061) // addha za1.s, p0/M, p0/M, z3.s\n KAI_ASM_INST(0xc0900042) // addha za2.s, p0/M, p0/M, z2.s\n KAI_ASM_INST(0xc0900063) // addha za3.s, p0/M, p0/M, z3.s\n blt label_6\n sub x20, x20, #0x4\n KAI_ASM_INST(0xa040930c) // ld1b { z12.b-z15.b }, pn12.b/Z, [x24]\n addvl x24, x24, #4\n cmp x20, #0x4\n KAI_ASM_INST(0xa04092e8) // ld1b { z8.b-z11.b }, pn12.b/Z, [x23]\n addvl x23, x23, #4\n KAI_ASM_INST(0xa04092dc) // ld1b { z28.b-z31.b }, pn12.b/Z, [x22]\n addvl x22, x22, #4\n KAI_ASM_INST(0xa04092b8) // ld1b { z24.b-z27.b }, pn12.b/Z, [x21]\n addvl x21, x21, #4\n blt label_5\nKAI_ASM_LABEL(label_4) // m_loop: n_loop: k_loop_x4: body\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n sub x20, x20, #0x4\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n cmp x20, #0x4\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n KAI_ASM_INST(0xa1bd01a0) // umopa za0.s, p0/M, p0/M, z13.b, z29.b\n KAI_ASM_INST(0xa1b901a1) // umopa za1.s, p0/M, p0/M, z13.b, z25.b\n KAI_ASM_INST(0xa040130c) // ld1b { z12.b-z13.b }, pn12.b/Z, [x24]\n addvl x24, x24, #2\n KAI_ASM_INST(0xa1bd0122) // umopa za2.s, p0/M, p0/M, z9.b, z29.b\n KAI_ASM_INST(0xa04012dc) // ld1b { z28.b-z29.b }, pn12.b/Z, [x22]\n addvl x22, x22, #2\n KAI_ASM_INST(0xa1b90123) // umopa za3.s, p0/M, p0/M, z9.b, z25.b\n KAI_ASM_INST(0xa04012e8) // ld1b { z8.b-z9.b }, pn12.b/Z, [x23]\n addvl x23, x23, #2\n KAI_ASM_INST(0xa1be01c0) // umopa za0.s, p0/M, p0/M, z14.b, z30.b\n KAI_ASM_INST(0xa04012b8) // ld1b { z24.b-z25.b }, pn12.b/Z, [x21]\n addvl x21, x21, #2\n KAI_ASM_INST(0xa1ba01c1) // umopa za1.s, p0/M, p0/M, z14.b, z26.b\n KAI_ASM_INST(0xa1be0142) // umopa za2.s, p0/M, p0/M, z10.b, z30.b\n KAI_ASM_INST(0xa1ba0143) // umopa za3.s, p0/M, p0/M, z10.b, z26.b\n KAI_ASM_INST(0xa1bf01e0) // umopa za0.s, p0/M, p0/M, z15.b, z31.b\n KAI_ASM_INST(0xa1bb01e1) // umopa za1.s, p0/M, p0/M, z15.b, z27.b\n KAI_ASM_INST(0xa040130e) // ld1b { z14.b-z15.b }, pn12.b/Z, [x24]\n addvl x24, x24, #2\n KAI_ASM_INST(0xa1bf0162) // umopa za2.s, p0/M, p0/M, z11.b, z31.b\n KAI_ASM_INST(0xa04012de) // ld1b { z30.b-z31.b }, pn12.b/Z, [x22]\n addvl x22, x22, #2\n KAI_ASM_INST(0xa1bb0163) // umopa za3.s, p0/M, p0/M, z11.b, z27.b\n KAI_ASM_INST(0xa04012ea) // ld1b { z10.b-z11.b }, pn12.b/Z, [x23]\n addvl x23, x23, #2\n KAI_ASM_INST(0xa04012ba) // ld1b { z26.b-z27.b }, pn12.b/Z, [x21]\n addvl x21, x21, #2\n bge label_4\nKAI_ASM_LABEL(label_5) // m_loop: n_loop: k_loop_x4: tail\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n KAI_ASM_INST(0xa1bd01a0) // umopa za0.s, p0/M, p0/M, z13.b, z29.b\n KAI_ASM_INST(0xa1b901a1) // umopa za1.s, p0/M, p0/M, z13.b, z25.b\n KAI_ASM_INST(0xa1bd0122) // umopa za2.s, p0/M, p0/M, z9.b, z29.b\n KAI_ASM_INST(0xa1b90123) // umopa za3.s, p0/M, p0/M, z9.b, z25.b\n KAI_ASM_INST(0xa1be01c0) // umopa za0.s, p0/M, p0/M, z14.b, z30.b\n KAI_ASM_INST(0xa1ba01c1) // umopa za1.s, p0/M, p0/M, z14.b, z26.b\n KAI_ASM_INST(0xa1be0142) // umopa za2.s, p0/M, p0/M, z10.b, z30.b\n KAI_ASM_INST(0xa1ba0143) // umopa za3.s, p0/M, p0/M, z10.b, z26.b\n KAI_ASM_INST(0xa1bf01e0) // umopa za0.s, p0/M, p0/M, z15.b, z31.b\n KAI_ASM_INST(0xa1bb01e1) // umopa za1.s, p0/M, p0/M, z15.b, z27.b\n KAI_ASM_INST(0xa1bf0162) // umopa za2.s, p0/M, p0/M, z11.b, z31.b\n KAI_ASM_INST(0xa1bb0163) // umopa za3.s, p0/M, p0/M, z11.b, z27.b\nKAI_ASM_LABEL(label_6) // m_loop: n_loop: k_loop_x4: done\n cbz x20, label_9\n sub x20, x20, #0x1\n ld1b { z12.b }, p0/Z, [x24]\n addvl x24, x24, #1\n ld1b { z8.b }, p0/Z, [x23]\n addvl x23, x23, #1\n ld1b { z28.b }, p0/Z, [x22]\n addvl x22, x22, #1\n ld1b { z24.b }, p0/Z, [x21]\n addvl x21, x21, #1\n cbz x20, label_8\nKAI_ASM_LABEL(label_7) // m_loop: n_loop: k_loop_x1: body\n sub x20, x20, #0x1\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n ld1b { z12.b }, p0/Z, [x24]\n addvl x24, x24, #1\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n ld1b { z28.b }, p0/Z, [x22]\n addvl x22, x22, #1\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n ld1b { z8.b }, p0/Z, [x23]\n addvl x23, x23, #1\n ld1b { z24.b }, p0/Z, [x21]\n addvl x21, x21, #1\n cbnz x20, label_7\nKAI_ASM_LABEL(label_8) // m_loop: n_loop: k_loop_x1: tail\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\nKAI_ASM_LABEL(label_9) // m_loop: n_loop: k_loop_x1: done\n tbz x6, #24, label_11\n add x20, x28, x7\n add x21, x27, x26, LSL #2\n KAI_ASM_INST(0xa01a4d32) // ld1w { z18.s-z19.s }, p11/Z, [x9, x26, LSL #2]\n mov x12, #0x0\n whilelt p10.s, x28, x8\n whilelt p9.s, x20, x8\n madd x20, x7, x10, x21\nKAI_ASM_LABEL(label_10) // m_loop: n_loop: post_process_to_float: post_process_loop: body\n KAI_ASM_INST(0xc086040c) // mova { z12.s-z15.s }, za0h.s[x12]\n KAI_ASM_INST(0xc0860438) // mova { z24.s-z27.s }, za1h.s[x12]\n KAI_ASM_INST(0xc132e180) // scvtf { z0.s-z3.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc132e308) // scvtf { z8.s-z11.s }, { z24.s-z27.s }\n fmad z0.s, p0/M, z23.s, z18.s\n fmad z1.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0x25306d48) // psel p8.s, p11.s/Z, p10.s[w12]\n KAI_ASM_INST(0xc0860444) // mova { z4.s-z7.s }, za2h.s[x12]\n fmad z2.s, p0/M, z23.s, z18.s\n fmad z3.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0xc086047c) // mova { z28.s-z31.s }, za3h.s[x12]\n KAI_ASM_INST(0xc132e084) // scvtf { z4.s-z7.s }, { z4.s-z7.s }\n fmad z8.s, p0/M, z23.s, z19.s\n fmad z9.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc132e38c) // scvtf { z12.s-z15.s }, { z28.s-z31.s }\n fmad z10.s, p0/M, z23.s, z19.s\n fmad z11.s, p0/M, z23.s, z19.s\n fmad z4.s, p0/M, z23.s, z18.s\n fmad z5.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0xc1b6ca00) // fclamp { z0.s-z3.s }, z16.s, z22.s\n fmad z6.s, p0/M, z23.s, z18.s\n fmad z7.s, p0/M, z23.s, z18.s\n fmad z12.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc1b6ca08) // fclamp { z8.s-z11.s }, z16.s, z22.s\n fmad z13.s, p0/M, z23.s, z19.s\n fmad z14.s, p0/M, z23.s, z19.s\n fmad z15.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc1b6ca04) // fclamp { z4.s-z7.s }, z16.s, z22.s\n KAI_ASM_INST(0xa16042a0) // st1w { z0.s, z8.s }, p8, [x21]\n KAI_ASM_INST(0x25706d48) // psel p8.s, p11.s/Z, p10.s[w12, #1]\n add x21, x21, x10\n KAI_ASM_INST(0xc1b6ca0c) // fclamp { z12.s-z15.s }, z16.s, z22.s\n KAI_ASM_INST(0xa16042a1) // st1w { z1.s, z9.s }, p8, [x21]\n KAI_ASM_INST(0x25b06d48) // psel p8.s, p11.s/Z, p10.s[w12, #2]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a2) // st1w { z2.s, z10.s }, p8, [x21]\n KAI_ASM_INST(0x25f06d48) // psel p8.s, p11.s/Z, p10.s[w12, #3]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a3) // st1w { z3.s, z11.s }, p8, [x21]\n KAI_ASM_INST(0x25306d28) // psel p8.s, p11.s/Z, p9.s[w12]\n add x21, x21, x10\n KAI_ASM_INST(0xa1604284) // st1w { z4.s, z12.s }, p8, [x20]\n KAI_ASM_INST(0x25706d28) // psel p8.s, p11.s/Z, p9.s[w12, #1]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604285) // st1w { z5.s, z13.s }, p8, [x20]\n KAI_ASM_INST(0x25b06d28) // psel p8.s, p11.s/Z, p9.s[w12, #2]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604286) // st1w { z6.s, z14.s }, p8, [x20]\n KAI_ASM_INST(0x25f06d28) // psel p8.s, p11.s/Z, p9.s[w12, #3]\n add x12, x12, #0x4\n add x20, x20, x10\n cmp x12, x7\n KAI_ASM_INST(0xa1604287) // st1w { z7.s, z15.s }, p8, [x20]\n add x20, x20, x10\n blt label_10\n b label_13\nKAI_ASM_LABEL(label_11) // m_loop: n_loop: post_process_to_float: skip\n add x20, x28, x7\n add x21, x27, x26, LSL #2\n mov x12, #0x0\n whilelt p10.s, x28, x8\n whilelt p9.s, x20, x8\n madd x20, x7, x10, x21\nKAI_ASM_LABEL(label_12) // m_loop: n_loop: post_process_to_int: post_process_loop: body\n KAI_ASM_INST(0x25306d48) // psel p8.s, p11.s/Z, p10.s[w12]\n KAI_ASM_INST(0xc0860404) // mova { z4.s-z7.s }, za0h.s[x12]\n KAI_ASM_INST(0xc086042c) // mova { z12.s-z15.s }, za1h.s[x12]\n KAI_ASM_INST(0xc0860440) // mova { z0.s-z3.s }, za2h.s[x12]\n KAI_ASM_INST(0xc0860468) // mova { z8.s-z11.s }, za3h.s[x12]\n KAI_ASM_INST(0xa16042a4) // st1w { z4.s, z12.s }, p8, [x21]\n KAI_ASM_INST(0x25706d48) // psel p8.s, p11.s/Z, p10.s[w12, #1]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a5) // st1w { z5.s, z13.s }, p8, [x21]\n KAI_ASM_INST(0x25b06d48) // psel p8.s, p11.s/Z, p10.s[w12, #2]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a6) // st1w { z6.s, z14.s }, p8, [x21]\n KAI_ASM_INST(0x25f06d48) // psel p8.s, p11.s/Z, p10.s[w12, #3]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a7) // st1w { z7.s, z15.s }, p8, [x21]\n KAI_ASM_INST(0x25306d28) // psel p8.s, p11.s/Z, p9.s[w12]\n add x21, x21, x10\n KAI_ASM_INST(0xa1604280) // st1w { z0.s, z8.s }, p8, [x20]\n KAI_ASM_INST(0x25706d28) // psel p8.s, p11.s/Z, p9.s[w12, #1]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604281) // st1w { z1.s, z9.s }, p8, [x20]\n KAI_ASM_INST(0x25b06d28) // psel p8.s, p11.s/Z, p9.s[w12, #2]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604282) // st1w { z2.s, z10.s }, p8, [x20]\n KAI_ASM_INST(0x25f06d28) // psel p8.s, p11.s/Z, p9.s[w12, #3]\n add x12, x12, #0x4\n add x20, x20, x10\n cmp x12, x7\n KAI_ASM_INST(0xa1604283) // st1w { z3.s, z11.s }, p8, [x20]\n add x20, x20, x10\n blt label_12\nKAI_ASM_LABEL(label_13) // m_loop: n_loop: post_process_done\n incw x26, ALL, MUL #2\n add x25, x25, x14, LSL #1\n cmp x26, x17\n blt label_3\n incw x28, ALL, MUL #2\n add x16, x16, x15\n cmp x28, x8\n add x16, x16, x15\n blt label_2\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs_types.h\"\n\nenum {\n OUTPUT_ELEM_BYTES = 1,\n MR_VSCALE = 4,\n KR = 4,\n MAX_MR = MR_VSCALE * KAI_VSCALE_MAX,\n};\n\nvoid kai_matmul_pack_rows_x8p4vsx4_x8_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t get_mr(void) {\n return MR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_dim_args get_step(const struct kai_matmul_pack_lhs_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_lhs_uker_dim_args step = {\n .m = get_mr(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_lhs_stride_args get_lhs_stride(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args stride = {\n .m = shape->k * OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_offset(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->m * stride->m + index->k * OUTPUT_ELEM_BYTES;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args get_lhs_packed_stride(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args stride = {\n .m = mr * kai_roundup(shape->k, KR) * OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_packed_offset(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n const size_t mr = get_mr();\n return index->m / mr * stride->m + index->k * mr * OUTPUT_ELEM_BYTES;\n}\n\nstatic size_t get_lhs_packed_size(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n return div_ceil(shape->m, mr) * stride->m;\n}\nstatic void run(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_args* args) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n\n const size_t m = args->shape.m;\n const size_t width = args->shape.k;\n\n const uint8_t* lhs_ptr = args->operand.lhs.ptr;\n uint8_t* lhs_packed_ptr = args->operand.lhs_packed.ptr;\n\n const uint8_t* in[MAX_MR];\n kai_commit_za();\n\n for (size_t start_row = 0; start_row < m; start_row += mr) {\n const size_t height = KAI_MIN(m - start_row, mr);\n KAI_UNUSED(start_row);\n\n void* out = lhs_packed_ptr;\n lhs_packed_ptr += args->operand.lhs_packed.stride.m;\n\n for (size_t row = 0; row < height; ++row) {\n in[row] = lhs_ptr + row * args->operand.lhs.stride.m;\n }\n lhs_ptr += mr * args->operand.lhs.stride.m;\n\n // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n kai_matmul_pack_rows_x8p4vsx4_x8_sme(height, width, in, out);\n }\n}\n\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme(void) {\n struct kai_matmul_pack_lhs_uker_api api = {\n .run = run,\n\n .get_step = get_step,\n\n .get_lhs_stride = get_lhs_stride,\n .get_lhs_offset = get_lhs_offset,\n\n .get_lhs_packed_stride = get_lhs_packed_stride,\n .get_lhs_packed_offset = get_lhs_packed_offset,\n .get_lhs_packed_size = get_lhs_packed_size,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs_types.h\"\n\nenum {\n OUTPUT_ELEM_BYTES = 1,\n BIAS_ELEM_BYTES = 0,\n\n NR_VSCALE = 4,\n KR = 4,\n\n MAX_NR = NR_VSCALE * KAI_VSCALE_MAX,\n};\n\nvoid kai_matmul_pack_rows_x8p4vsx4_x8_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t get_nr(void) {\n return NR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_dim_args get_step(const struct kai_matmul_pack_rhs_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_rhs_uker_dim_args step = {\n .n = get_nr(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_rhs_stride_args get_rhs_stride(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args stride = {\n .n = shape->k * OUTPUT_ELEM_BYTES,\n .k = OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_rhs_offset(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->n * stride->n;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args get_rhs_packed_stride(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args stride = {\n .n = nr * (BIAS_ELEM_BYTES + kai_roundup(shape->k, KR) * OUTPUT_ELEM_BYTES),\n };\n\n return stride;\n}\n\nstatic size_t get_rhs_packed_offset(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n const size_t nr = get_nr();\n return index->n / nr * stride->n;\n}\n\nstatic size_t get_rhs_packed_size(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n return div_ceil(shape->n, nr) * stride->n;\n}\n\nstatic size_t get_bias_n_offset(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_bias_n_dim_args* index) {\n KAI_UNUSED(config);\n KAI_UNUSED(index);\n\n return 0;\n}\n\nstatic void run(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_args* args) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n\n const size_t n = args->shape.n;\n const size_t width = args->shape.k;\n\n const uint8_t* rhs_ptr = args->operand.rhs.ptr;\n uint8_t* rhs_packed_ptr = args->operand.rhs_packed.ptr;\n\n const uint8_t* in[MAX_NR];\n kai_commit_za();\n\n for (size_t start_row = 0; start_row < n; start_row += nr) {\n const size_t height = KAI_MIN(n - start_row, nr);\n\n void* out = rhs_packed_ptr;\n rhs_packed_ptr += args->operand.rhs_packed.stride.n;\n\n for (size_t row = 0; row < height; ++row) {\n in[row] = rhs_ptr + row * args->operand.rhs.stride.n;\n }\n rhs_ptr += nr * args->operand.rhs.stride.n;\n\n KAI_UNUSED(args->operand.bias_n.ptr);\n // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n kai_matmul_pack_rows_x8p4vsx4_x8_sme(height, width, in, out);\n }\n}\n\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme(void) {\n struct kai_matmul_pack_rhs_uker_api api = {\n .run = run,\n\n .get_step = get_step,\n\n .get_rhs_stride = get_rhs_stride,\n .get_rhs_offset = get_rhs_offset,\n\n .get_rhs_packed_stride = get_rhs_packed_stride,\n .get_rhs_packed_offset = get_rhs_packed_offset,\n .get_rhs_packed_size = get_rhs_packed_size,\n\n .get_bias_n_offset = get_bias_n_offset,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_pack_rows_x8p4vsx4_x8_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_pack_rows_x8p4vsx4_x8_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\nKAI_ASM_FUNCTION_LABEL(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x10, #0\n cntb x21\n mov x23, x1\n incb x23\n mov x20, x1\n sub x9, x21, #0x1\n cntw x28\n sub x23, x23, #0x1\n ands x9, x20, x9\n udiv x23, x23, x21 // n_passes = ceildiv(width, VL)\n csel x9, x9, x21, NE\n lsl x22, x0, #0x1 // height * 2\n lsl x21, x28, #0x1\n sub x20, x23, #0x1\n add x9, x9, #0x3\n sub x27, x28, #0x2\n whilelt p9.b, XZR, x22\n whilelt p8.b, x21, x22\n mov x26, #0\n mov x25, x2\n lsr x20, x20, #0x1 // n_loops = (n_passes - 1) / 2\n and x24, x23, #0x1 // odd_tail = bool(n_passes & 0x1)\n lsr x9, x9, #0x2\n ldr x23, [x25, #0]\n ptrue p11.s\n zip1 p10.b, p9.b, p8.b\n ldr x22, [x25, #0x8]\n mov x21, x10\n whilelt p9.b, x26, x1\n whilelt p8.b, x26, x1\n add x25, x25, #0x10\n mov x12, #0\n cbz x27, label_2\nKAI_ASM_LABEL(label_1) // K loop: Charge: Loop\n KAI_ASM_INST(0x25246141) // psel p1.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x25646140) // psel p0.b, p8.b/Z, p10.b[w12, #4]\n KAI_ASM_INST(0xe01506e0) // ld1b { za0h.b[x12] }, p1/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe01502c4) // ld1b { za0h.b[x12, #4] }, p0/Z, [x22, x21]\n add x12, x12, #0x8\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n cmp x12, x27, LSL #2\n blt label_1\nKAI_ASM_LABEL(label_2) // K loop: Charge: End\n KAI_ASM_INST(0x25246141) // psel p1.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x25646140) // psel p0.b, p8.b/Z, p10.b[w12, #4]\n mov x25, x2\n incb x26\n KAI_ASM_INST(0xe01506e0) // ld1b { za0h.b[x12] }, p1/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe01502c4) // ld1b { za0h.b[x12, #4] }, p0/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n cbz x20, label_8\n mov x20, x20\nKAI_ASM_LABEL(label_3) // K loop: Main loop\n whilelt p8.b, x26, x1\n mov x12, #0\n mov x14, #0\n cbz x27, label_5\nKAI_ASM_LABEL(label_4) // K loop: Main loop: First: Loop\n KAI_ASM_INST(0x25346143) // psel p3.b, p8.b/Z, p10.b[w12, #2]\n KAI_ASM_INST(0x25746142) // psel p2.b, p8.b/Z, p10.b[w12, #6]\n KAI_ASM_INST(0x25266d21) // psel p1.b, p11.b/Z, p9.b[w14]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n KAI_ASM_INST(0xe0150ee2) // ld1b { za0h.b[x12, #2] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe0150ac6) // ld1b { za0h.b[x12, #6] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n add x12, x12, #0x8\n KAI_ASM_INST(0xe0bfc460) // st1w { za0v.s[x14] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bcc061) // st1w { za0v.s[x14, #1] }, p0/Z, [x3, x28, LSL #2]\n add x14, x14, #0x2\n addvl x3, x3, #2\n cmp x14, x27\n blt label_4\nKAI_ASM_LABEL(label_5) // K loop: Main loop: First: Tail\n KAI_ASM_INST(0x25346143) // psel p3.b, p8.b/Z, p10.b[w12, #2]\n KAI_ASM_INST(0x25746142) // psel p2.b, p8.b/Z, p10.b[w12, #6]\n KAI_ASM_INST(0x25266d21) // psel p1.b, p11.b/Z, p9.b[w14]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n mov x25, x2\n whilelt p9.b, x26, x1\n KAI_ASM_INST(0xe0150ee2) // ld1b { za0h.b[x12, #2] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n incb x26\n mov x13, #0\n KAI_ASM_INST(0xe0150ac6) // ld1b { za0h.b[x12, #6] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n KAI_ASM_INST(0xe0bfc460) // st1w { za0v.s[x14] }, p1/Z, [x3, XZR, LSL #2]\n whilelt p8.b, x26, x1\n mov x12, #0\n KAI_ASM_INST(0xe0bcc061) // st1w { za0v.s[x14, #1] }, p0/Z, [x3, x28, LSL #2]\n addvl x3, x3, #2\n cbz x27, label_7\nKAI_ASM_LABEL(label_6) // K loop: Main loop: Second: Loop\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x25656142) // psel p2.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x25246d21) // psel p1.b, p11.b/Z, p9.b[w12]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n KAI_ASM_INST(0xe0152ee0) // ld1b { za0h.b[x13] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe0152ac4) // ld1b { za0h.b[x13, #4] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n add x13, x13, #0x8\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bc8069) // st1w { za2v.s[x12, #1] }, p0/Z, [x3, x28, LSL #2]\n add x12, x12, #0x2\n addvl x3, x3, #2\n cmp x12, x27\n blt label_6\nKAI_ASM_LABEL(label_7) // K loop: Main loop: Second: Tail\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x25656142) // psel p2.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x25246d21) // psel p1.b, p11.b/Z, p9.b[w12]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n mov x25, x2\n whilelt p9.b, x26, x1\n KAI_ASM_INST(0xe0152ee0) // ld1b { za0h.b[x13] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n subs x20, x20, #0x1\n incb x26\n KAI_ASM_INST(0xe0152ac4) // ld1b { za0h.b[x13, #4] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bc8069) // st1w { za2v.s[x12, #1] }, p0/Z, [x3, x28, LSL #2]\n addvl x3, x3, #2\n bgt label_3\nKAI_ASM_LABEL(label_8) // K loop: Tails\n cbnz x24, label_11\n mov x25, x2\n whilelt p8.b, x26, x1\n mov x13, #0\n mov x12, #0\nKAI_ASM_LABEL(label_9) // K loop: Tails: Even: First\n KAI_ASM_INST(0x25306d21) // psel p1.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25356140) // psel p0.b, p8.b/Z, p10.b[w13, #2]\n KAI_ASM_INST(0xe0bf8460) // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n ldr x20, [x25, #0]\n cmp x12, x28\n add x25, x25, #0x8\n KAI_ASM_INST(0xe0152282) // ld1b { za0h.b[x13, #2] }, p0/Z, [x20, x21]\n add x13, x13, #0x4\n blt label_9\n whilelt p9.b, x26, x1\n whilelt p8.b, x26, x1\n mov x20, #0\n mov x12, #0\nKAI_ASM_LABEL(label_10) // K loop: Tails: Even: Second\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n add x20, x20, #0x4\n KAI_ASM_INST(0xe0bf8068) // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n cmp x12, x9\n blt label_10\n whilelt p8.b, x26, x1\n b label_13\nKAI_ASM_LABEL(label_11) // K loop: Tails: Odd\n mov x12, #0\nKAI_ASM_LABEL(label_12) // K loop: Tails: Odd: Loop\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0xe0bf8060) // st1w { za0v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n cmp x12, x9\n blt label_12\nKAI_ASM_LABEL(label_13) // K loop: End\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_pack_cols_x8p4vsx4_x8_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_pack_cols_x8p4vsx4_x8_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\nKAI_ASM_FUNCTION_LABEL(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x20, [x0, #0x8]\n ptrue p1.b\n ldr x2, [x0, #0]\n ldr x3, [x0, #0x10]\n mov x4, x20\n ldr x5, [x0, #0x18]\n cmp x4, #0x10\n ldr x6, [x0, #0x20]\n ldr x7, [x0, #0x28]\n ldr x8, [x0, #0x30]\n blt label_4\nKAI_ASM_LABEL(label_1) // Main row loop: Head\n mov x17, x6\n mov x16, x7\n add x15, x17, x3\n sub x4, x4, #0x10\n add x14, x15, x3\n mov x13, x2\n add x12, x14, x3\n add x11, x12, x3\n add x10, x11, x3\n add x9, x10, x3\n add x28, x9, x3\n add x27, x28, x3\n add x26, x27, x3\n add x25, x26, x3\n add x24, x25, x3\n add x23, x24, x3\n add x22, x23, x3\n add x21, x22, x3\n add x20, x21, x3\n add x6, x20, x3\nKAI_ASM_LABEL(label_2) // Main row loop: Column loop\n whilelt p0.b, XZR, x13\n decw x13\n ld1b { z20.b }, p0/Z, [x17]\n cmp x13, #0\n incd x17, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x15]\n incd x15, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x14]\n incd x14, ALL, MUL #2\n ld1b { z16.b }, p0/Z, [x12]\n incd x12, ALL, MUL #2\n ld1b { z22.b }, p0/Z, [x11]\n incd x11, ALL, MUL #2\n ld1b { z19.b }, p0/Z, [x10]\n zip1 z21.b, z20.b, z17.b\n incd x10, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x9]\n zip1 z20.b, z18.b, z16.b\n incd x9, ALL, MUL #2\n ld1b { z16.b }, p0/Z, [x28]\n incd x28, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x27]\n incd x27, ALL, MUL #2\n ld1b { z25.b }, p0/Z, [x26]\n zip1 z24.b, z22.b, z17.b\n incd x26, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x25]\n zip1 z19.b, z19.b, z16.b\n incd x25, ALL, MUL #2\n zip1 z23.b, z21.b, z20.b\n ld1b { z16.b }, p0/Z, [x24]\n incd x24, ALL, MUL #2\n ld1b { z22.b }, p0/Z, [x23]\n incd x23, ALL, MUL #2\n ld1b { z21.b }, p0/Z, [x22]\n zip1 z20.b, z18.b, z17.b\n incd x22, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x21]\n zip1 z17.b, z25.b, z16.b\n incd x21, ALL, MUL #2\n zip1 z19.b, z24.b, z19.b\n ld1b { z16.b }, p0/Z, [x20]\n incd x20, ALL, MUL #2\n st1b { z23.b }, p1, [x16]\n zip1 z18.b, z22.b, z18.b\n zip1 z16.b, z21.b, z16.b\n zip1 z17.b, z20.b, z17.b\n st1b { z19.b }, p1, [x16, #1, MUL VL]\n zip1 z16.b, z18.b, z16.b\n st1b { z17.b }, p1, [x16, #2, MUL VL]\n st1b { z16.b }, p1, [x16, #3, MUL VL]\n add x16, x16, x5\n bgt label_2\n cmp x4, #0x10\n addvl x7, x7, #4\n bge label_1\n cbz x4, label_8\nKAI_ASM_LABEL(label_4) // Main loop skip\nKAI_ASM_LABEL(label_5) // Tail row loop: Head\n mov x17, x6\n cmp x4, #0x3\n add x15, x17, x3\n cntw x24\n add x14, x15, x3\n csel x23, x24, XZR, GT\n add x12, x14, x3\n csel x22, x24, XZR, GE\n add x6, x12, x3\n mov x16, x7\n csel x6, x6, x12, GT\n csel x12, x12, x8, GT\n csel x6, x6, x14, GE\n csel x14, x14, x8, GE\n cmp x4, #0x1\n sub x4, x4, #0x4\n csel x6, x6, x15, GT\n csel x15, x15, x8, GT\n csel x21, x24, XZR, GT\n mov x20, x2\nKAI_ASM_LABEL(label_6) // Tail row loop: Column loop\n whilelt p0.b, XZR, x20\n decw x20\n ld1b { z19.b }, p0/Z, [x17]\n cmp x20, #0\n add x17, x17, x24\n ld1b { z18.b }, p0/Z, [x15]\n add x15, x15, x21\n ld1b { z17.b }, p0/Z, [x14]\n add x14, x14, x22\n ld1b { z16.b }, p0/Z, [x12]\n add x12, x12, x23\n zip1 z17.b, z19.b, z17.b\n zip1 z16.b, z18.b, z16.b\n zip1 z16.b, z17.b, z16.b\n st1b { z16.b }, p1, [x16]\n add x16, x16, x5\n bgt label_6\n cmp x4, #0x1\n addvl x7, x7, #1\n bge label_5\nKAI_ASM_LABEL(label_8) // Done\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa (new-style\n// kai_matmul_uker API) against gemm_i32_u8_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, int M)\n// C[m,n] = sum_k A[m,k] * B[n,k], exact int32 accumulation in the kernel, converted to float32 at the end.\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, int M)\n{\n const kai_matmul_uker_api mm = kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa();\n const kai_matmul_pack_lhs_uker_api pl = kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme();\n const kai_matmul_pack_rhs_uker_api pr = kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme();\n const kai_matmul_uker_config mm_cfg{};\n const kai_matmul_pack_lhs_uker_config pl_cfg{};\n const kai_matmul_pack_rhs_uker_config pr_cfg{};\n\n // LHS: packed on EVERY call into a grow-only scratch buffer (activation-side work).\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n const kai_matmul_pack_lhs_uker_lhs_dim_args lhs_dim{(size_t)M, (size_t)K};\n const kai_matmul_pack_lhs_uker_lhs_stride_args lhs_stride = pl.get_lhs_stride(&pl_cfg, &lhs_dim);\n const kai_matmul_pack_lhs_uker_lhs_packed_dim_args lhs_pdim{(size_t)M, (size_t)K};\n const kai_matmul_pack_lhs_uker_lhs_packed_stride_args lhs_pstride = pl.get_lhs_packed_stride(&pl_cfg, &lhs_pdim);\n {\n const size_t sz = pl.get_lhs_packed_size(&pl_cfg, &lhs_pdim, &lhs_pstride);\n if (sz > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(sz);\n lhs_cap = sz;\n if (lhs_packed == nullptr) return -1;\n }\n kai_matmul_pack_lhs_uker_args a{};\n a.shape = {(size_t)M, (size_t)K};\n a.operand.lhs.ptr = A;\n a.operand.lhs.stride = lhs_stride;\n a.operand.lhs_packed.ptr = lhs_packed;\n a.operand.lhs_packed.stride = lhs_pstride;\n pl.run(&pl_cfg, &a);\n }\n\n // RHS: weight pack, cached while B is unchanged.\n static uint8_t* B_snap = nullptr;\n static size_t B_snap_size = 0;\n static void* rhs_packed = nullptr;\n const kai_matmul_pack_rhs_uker_rhs_dim_args rhs_dim{(size_t)N, (size_t)K};\n const kai_matmul_pack_rhs_uker_rhs_stride_args rhs_stride = pr.get_rhs_stride(&pr_cfg, &rhs_dim);\n const kai_matmul_pack_rhs_uker_rhs_packed_dim_args rhs_pdim{(size_t)N, (size_t)K};\n const kai_matmul_pack_rhs_uker_rhs_packed_stride_args rhs_pstride = pr.get_rhs_packed_stride(&pr_cfg, &rhs_pdim);\n if (refresh_cache(B_snap, B_snap_size, B, (size_t)N * K)) {\n std::free(rhs_packed);\n const size_t sz = pr.get_rhs_packed_size(&pr_cfg, &rhs_pdim, &rhs_pstride);\n rhs_packed = std::malloc(sz);\n if (rhs_packed == nullptr) return -1;\n kai_matmul_pack_rhs_uker_args a{};\n a.shape = {(size_t)N, (size_t)K};\n a.operand.rhs.ptr = B;\n a.operand.rhs.stride = rhs_stride;\n a.operand.rhs_packed.ptr = rhs_packed;\n a.operand.rhs_packed.stride = rhs_pstride;\n pr.run(&pr_cfg, &a);\n }\n\n // Matmul into an int32 scratch, then convert to the raw ABI's float32 output.\n static int32_t* acc = nullptr;\n static size_t acc_cap = 0;\n const kai_matmul_uker_dst_dim_args dst_dim{(size_t)M, (size_t)N};\n const kai_matmul_uker_dst_stride_args dst_stride = mm.get_dst_stride(&mm_cfg, &dst_dim);\n const size_t dst_size = mm.get_dst_size(&mm_cfg, &dst_dim, &dst_stride);\n if (dst_size > acc_cap) {\n std::free(acc);\n acc = static_cast(std::malloc(dst_size));\n acc_cap = dst_size;\n if (acc == nullptr) return -1;\n }\n const kai_matmul_uker_lhs_dim_args mm_lhs_dim{(size_t)M, (size_t)K};\n const kai_matmul_uker_rhs_dim_args mm_rhs_dim{(size_t)N, (size_t)K};\n // The kernel reads the accumulation-bias pointers (per M and per N) unconditionally, so a\n // \"no bias\" call still has to pass zero-filled int32 arrays.\n static int32_t* zero_m = nullptr;\n static size_t zero_m_cap = 0;\n static int32_t* zero_n = nullptr;\n if ((size_t)M > zero_m_cap) {\n std::free(zero_m);\n zero_m = static_cast(std::calloc((size_t)M, sizeof(int32_t)));\n zero_m_cap = (size_t)M;\n if (zero_m == nullptr) return -1;\n }\n if (zero_n == nullptr) {\n zero_n = static_cast(std::calloc((size_t)N, sizeof(int32_t)));\n if (zero_n == nullptr) return -1;\n }\n kai_matmul_uker_args args{};\n args.flags = 0;\n args.operand.bias.acc_bias_m.ptr = zero_m;\n args.operand.bias.acc_bias_n.ptr = zero_n;\n args.shape = {(size_t)M, (size_t)N, (size_t)K};\n args.operand.lhs.ptr = lhs_packed;\n args.operand.lhs.stride = mm.get_lhs_stride(&mm_cfg, &mm_lhs_dim);\n args.operand.rhs.ptr = rhs_packed;\n args.operand.rhs.stride = mm.get_rhs_stride(&mm_cfg, &mm_rhs_dim);\n args.operand.dst.ptr = acc;\n args.operand.dst.stride = dst_stride;\n mm.run(&mm_cfg, &args);\n\n const size_t total = (size_t)M * N;\n size_t i = 0;\n for (; i + 4 <= total; i += 4) vst1q_f32(output + i, vcvtq_f32_s32(vld1q_s32(acc + i)));\n for (; i < total; ++i) output[i] = (float)acc[i];\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..b02bfba8890cceee5301c9e5395b72cd408f460f --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_n256_k512.json @@ -0,0 +1,75 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qai4c32_n256_k512", + "definition": "gemm_qai4c32_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qai4c32_n256_k512: KleidiAI kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "dotprod", + "i8mm" + ], + "compile_flags": [ + "-O3", + "-march=armv8.2-a+dotprod+i8mm" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon to dynamically quantize and pack the LHS matrix in a single\n/// step.\n/// -# @ref kai_run_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon to pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32)\n/// values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of m_step.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32)\n/// values.\n///\n/// @param[in] n_idx Col index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of m_step.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32) and packed.\n/// RHS matrix: Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32) and packed.\n/// Output tile: (rows x cols) = m_step x n_step.\n///\n/// Note: Please refer to the get functions for m_step and n_step for the exact values.\n///\n/// Features used: i8mm\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(__ARM_FEATURE_MATMUL_INT8) && !defined(_M_ARM64)\n#error \"I8mm extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm.h\"\n\n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n float* dst;\n const void* lhs_packed;\n const void* rhs_packed;\n const float* clamp_vals;\n size_t dst_stride_row;\n size_t m;\n size_t n;\n size_t num_blocks;\n size_t num_subblocks;\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 8;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 4;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 16;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_sum_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_offset_rhs = 4;\n\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_bl = 32;\n\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs + kai_num_bytes_sum_lhs;\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs =\n (bl / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n return kai_mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n\n size_t rhs_packed_stride = kai_nr * (num_bytes_per_block * num_blocks_per_row);\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += kai_nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m_idx, size_t k, size_t bl) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t n_idx, size_t k, size_t bl) {\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl) == 0);\n\n if (m == 0) {\n return;\n }\n const size_t num_subblocks = bl / kai_bl;\n const size_t num_blocks = kai_get_num_blocks_per_row(k, bl);\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n KernelArgs args;\n\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.clamp_vals = clamp_vals;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.num_blocks = num_blocks;\n args.num_subblocks = num_subblocks;\n\n kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d10, d11, [sp, 72]\n stp d12, d13, [sp, 88]\n stp d14, d15, [sp, 104]\n stp d8, d9, [sp, 120]\n mov x21, #0x20\n movi v12.16b, #0xf0\n mov x6, #0x80\n ldr x20, [x0, #0x28]\n ldr x7, [x0, #0x40]\n ldr x8, [x0, #0x38]\n ldr x17, [x0, #0x8]\n ldr x16, [x0, #0x10]\n ldr x15, [x0, #0x30]\n mov x14, x20\n madd x6, x7, x6, x21\n ldr x13, [x0, #0x0]\n ldr x12, [x0, #0x20]\n ldr x11, [x0, #0x18]\n cmp x14, #0x8\n mul x6, x8, x6\n blt label_11\nKAI_ASM_LABEL(label_1) // Row loop\n mov x10, x16\n mov x9, x15\n add x28, x13, x12, LSL #3\nKAI_ASM_LABEL(label_2) // Column loop\n mov x23, x17\n movi v13.16b, #0x0\n movi v18.16b, #0x0\n mov x22, x8\n movi v29.16b, #0x0\n movi v14.16b, #0x0\n movi v15.16b, #0x0\n movi v11.16b, #0x0\n movi v4.16b, #0x0\n movi v6.16b, #0x0\n add x21, x23, x6\nKAI_ASM_LABEL(label_3) // Block loop\n movi v25.4s, #0x0\n movi v7.4s, #0x0\n mov x20, x7\n movi v10.4s, #0x0\n movi v17.4s, #0x0\n movi v3.4s, #0x0\n movi v8.4s, #0x0\n movi v9.4s, #0x0\n movi v27.4s, #0x0\nKAI_ASM_LABEL(label_4) // Sub block loop\n ldr q20, [x10, #0x0]\n ldr q23, [x10, #0x10]\n subs x20, x20, #0x1\n ldr q31, [x23, #0x0]\n ldr q22, [x23, #0x10]\n ldr q19, [x21, #0x0]\n ldr q28, [x21, #0x10]\n ldr q5, [x10, #0x20]\n ldr q16, [x10, #0x30]\n shl v26.16b, v20.16b, #0x4\n shl v0.16b, v23.16b, #0x4\n ldr q1, [x23, #0x20]\n ldr q21, [x23, #0x30]\n and v20.16b, v20.16b, v12.16b\n and v23.16b, v23.16b, v12.16b\n ldr q30, [x21, #0x20]\n ldr q24, [x21, #0x30]\n add x10, x10, #0x40\n ldr q2, [x23, #0x40]\n KAI_ASM_INST(0x4e9aa7f9) // smmla v25.4s, v31.16b, v26.16b\n KAI_ASM_INST(0x4e80a7e7) // smmla v7.4s, v31.16b, v0.16b\n ldr q31, [x23, #0x50]\n KAI_ASM_INST(0x4e9aa6ca) // smmla v10.4s, v22.16b, v26.16b\n KAI_ASM_INST(0x4e80a6d1) // smmla v17.4s, v22.16b, v0.16b\n ldr q22, [x21, #0x40]\n KAI_ASM_INST(0x4e9aa663) // smmla v3.4s, v19.16b, v26.16b\n KAI_ASM_INST(0x4e80a668) // smmla v8.4s, v19.16b, v0.16b\n ldr q19, [x21, #0x50]\n KAI_ASM_INST(0x4e9aa789) // smmla v9.4s, v28.16b, v26.16b\n ldr q26, [x23, #0x60]\n KAI_ASM_INST(0x4e80a79b) // smmla v27.4s, v28.16b, v0.16b\n ldr q0, [x23, #0x70]\n shl v28.16b, v5.16b, #0x4\n and v5.16b, v5.16b, v12.16b\n add x23, x23, #0x80\n KAI_ASM_INST(0x4e9ca439) // smmla v25.4s, v1.16b, v28.16b\n KAI_ASM_INST(0x4e9ca6aa) // smmla v10.4s, v21.16b, v28.16b\n KAI_ASM_INST(0x4e9ca7c3) // smmla v3.4s, v30.16b, v28.16b\n KAI_ASM_INST(0x4e9ca709) // smmla v9.4s, v24.16b, v28.16b\n ldr q28, [x21, #0x60]\n KAI_ASM_INST(0x4e94a459) // smmla v25.4s, v2.16b, v20.16b\n KAI_ASM_INST(0x4e94a7ea) // smmla v10.4s, v31.16b, v20.16b\n KAI_ASM_INST(0x4e94a6c3) // smmla v3.4s, v22.16b, v20.16b\n KAI_ASM_INST(0x4e94a669) // smmla v9.4s, v19.16b, v20.16b\n ldr q20, [x21, #0x70]\n add x21, x21, #0x80\n KAI_ASM_INST(0x4e85a759) // smmla v25.4s, v26.16b, v5.16b\n KAI_ASM_INST(0x4e85a40a) // smmla v10.4s, v0.16b, v5.16b\n KAI_ASM_INST(0x4e85a783) // smmla v3.4s, v28.16b, v5.16b\n KAI_ASM_INST(0x4e85a689) // smmla v9.4s, v20.16b, v5.16b\n shl v5.16b, v16.16b, #0x4\n and v16.16b, v16.16b, v12.16b\n KAI_ASM_INST(0x4e85a427) // smmla v7.4s, v1.16b, v5.16b\n KAI_ASM_INST(0x4e85a6b1) // smmla v17.4s, v21.16b, v5.16b\n KAI_ASM_INST(0x4e85a7c8) // smmla v8.4s, v30.16b, v5.16b\n KAI_ASM_INST(0x4e85a71b) // smmla v27.4s, v24.16b, v5.16b\n KAI_ASM_INST(0x4e97a447) // smmla v7.4s, v2.16b, v23.16b\n KAI_ASM_INST(0x4e97a7f1) // smmla v17.4s, v31.16b, v23.16b\n KAI_ASM_INST(0x4e97a6c8) // smmla v8.4s, v22.16b, v23.16b\n KAI_ASM_INST(0x4e97a67b) // smmla v27.4s, v19.16b, v23.16b\n KAI_ASM_INST(0x4e90a747) // smmla v7.4s, v26.16b, v16.16b\n KAI_ASM_INST(0x4e90a411) // smmla v17.4s, v0.16b, v16.16b\n KAI_ASM_INST(0x4e90a788) // smmla v8.4s, v28.16b, v16.16b\n KAI_ASM_INST(0x4e90a69b) // smmla v27.4s, v20.16b, v16.16b\n bgt label_4\n ldr q30, [x10, #0x0]\n ld1 { v31.4s }, [x23]\n add x23, x23, #0x10\n uzp1 v23.2d, v25.2d, v7.2d\n ldr q26, [x10, #0x10]\n ldr q16, [x23, #0x0]\n uzp2 v24.2d, v25.2d, v7.2d\n uzp1 v21.2d, v10.2d, v17.2d\n uzp2 v20.2d, v10.2d, v17.2d\n add x10, x10, #0x20\n add x23, x23, #0x10\n fmla v13.4s, v30.4s, v31.s[0]\n fmla v18.4s, v30.4s, v31.s[1]\n fmla v29.4s, v30.4s, v31.s[2]\n scvtf v23.4s, v23.4s\n fmla v14.4s, v30.4s, v31.s[3]\n fmul v19.4s, v26.4s, v16.s[0]\n fmul v1.4s, v26.4s, v16.s[1]\n scvtf v24.4s, v24.4s\n fmul v22.4s, v26.4s, v16.s[2]\n scvtf v21.4s, v21.4s\n fmul v16.4s, v26.4s, v16.s[3]\n scvtf v20.4s, v20.4s\n fmla v13.4s, v23.4s, v19.4s\n fmla v18.4s, v24.4s, v1.4s\n fmla v29.4s, v21.4s, v22.4s\n fmla v14.4s, v20.4s, v16.4s\n ld1 { v7.4s }, [x21]\n add x21, x21, #0x10\n uzp1 v23.2d, v3.2d, v8.2d\n uzp2 v22.2d, v3.2d, v8.2d\n ldr q16, [x21, #0x0]\n uzp1 v21.2d, v9.2d, v27.2d\n uzp2 v20.2d, v9.2d, v27.2d\n add x21, x21, #0x10\n fmla v15.4s, v30.4s, v7.s[0]\n fmla v11.4s, v30.4s, v7.s[1]\n fmla v4.4s, v30.4s, v7.s[2]\n fmla v6.4s, v30.4s, v7.s[3]\n scvtf v23.4s, v23.4s\n fmul v19.4s, v26.4s, v16.s[0]\n fmul v8.4s, v26.4s, v16.s[1]\n scvtf v22.4s, v22.4s\n fmul v30.4s, v26.4s, v16.s[2]\n scvtf v21.4s, v21.4s\n fmul v16.4s, v26.4s, v16.s[3]\n scvtf v20.4s, v20.4s\n fmla v15.4s, v23.4s, v19.4s\n fmla v11.4s, v22.4s, v8.4s\n fmla v4.4s, v21.4s, v30.4s\n fmla v6.4s, v20.4s, v16.4s\n subs x22, x22, #0x1\n bgt label_3\n ldr q21, [x10, #0x0]\n ld1r { v7.4s }, [x11]\n add x20, x11, #0x4\n cmp x9, #0x4\n ld1r { v16.4s }, [x20]\n add x10, x10, #0x10\n fadd v13.4s, v13.4s, v21.4s\n fadd v18.4s, v18.4s, v21.4s\n fadd v29.4s, v29.4s, v21.4s\n fadd v14.4s, v14.4s, v21.4s\n fadd v15.4s, v15.4s, v21.4s\n fadd v11.4s, v11.4s, v21.4s\n fadd v4.4s, v4.4s, v21.4s\n fadd v6.4s, v6.4s, v21.4s\n fmax v13.4s, v13.4s, v7.4s\n fmax v18.4s, v18.4s, v7.4s\n fmax v29.4s, v29.4s, v7.4s\n fmax v14.4s, v14.4s, v7.4s\n fmax v15.4s, v15.4s, v7.4s\n fmax v11.4s, v11.4s, v7.4s\n fmax v4.4s, v4.4s, v7.4s\n fmax v6.4s, v6.4s, v7.4s\n fmin v13.4s, v13.4s, v16.4s\n fmin v18.4s, v18.4s, v16.4s\n fmin v29.4s, v29.4s, v16.4s\n fmin v14.4s, v14.4s, v16.4s\n fmin v15.4s, v15.4s, v16.4s\n fmin v11.4s, v11.4s, v16.4s\n fmin v4.4s, v4.4s, v16.4s\n fmin v6.4s, v6.4s, v16.4s\n blt label_7\n mov x20, x13\n str q13, [x20, #0x0]\n add x20, x20, x12\n str q18, [x20, #0x0]\n add x20, x20, x12\n str q29, [x20, #0x0]\n add x20, x20, x12\n str q14, [x20, #0x0]\n add x20, x20, x12\n str q15, [x20, #0x0]\n add x20, x20, x12\n str q11, [x20, #0x0]\n add x20, x20, x12\n str q4, [x20, #0x0]\n add x20, x20, x12\n str q6, [x20, #0x0]\n b label_10\nKAI_ASM_LABEL(label_7) // Partial output\n mov x27, x13\n add x26, x27, x12, LSL #2\n add x25, x26, x12, LSL #1\n add x24, x26, x12\n add x23, x25, x12\n add x22, x27, x12, LSL #1\n add x21, x27, x12\n add x20, x22, x12\n tbz x9, #1, label_8\n st1 { v6.d }[0], [x23], #0x8\n st1 { v4.d }[0], [x25], #0x8\n st1 { v11.d }[0], [x24], #0x8\n st1 { v15.d }[0], [x26], #0x8\n st1 { v14.d }[0], [x20], #0x8\n st1 { v29.d }[0], [x22], #0x8\n st1 { v18.d }[0], [x21], #0x8\n st1 { v13.d }[0], [x27], #0x8\n tbz x9, #0, label_9\n st1 { v6.s }[2], [x23]\n st1 { v4.s }[2], [x25]\n st1 { v11.s }[2], [x24]\n st1 { v15.s }[2], [x26]\n st1 { v14.s }[2], [x20]\n st1 { v29.s }[2], [x22]\n st1 { v18.s }[2], [x21]\n st1 { v13.s }[2], [x27]\n b label_9\nKAI_ASM_LABEL(label_8) // Output block 0: partial_1_0\n st1 { v6.s }[0], [x23]\n st1 { v4.s }[0], [x25]\n st1 { v11.s }[0], [x24]\n st1 { v15.s }[0], [x26]\n st1 { v14.s }[0], [x20]\n st1 { v29.s }[0], [x22]\n st1 { v18.s }[0], [x21]\n st1 { v13.s }[0], [x27]\nKAI_ASM_LABEL(label_9) // Output block 0: Done\nKAI_ASM_LABEL(label_10) // Output stage exit\n subs x9, x9, #0x4\n add x13, x13, #0x10\n bgt label_2\n mov x20, #0x2\n sub x14, x14, #0x8\n cmp x14, #0x8\n mov x13, x28\n madd x17, x20, x6, x17\n bge label_1\nKAI_ASM_LABEL(label_11) // Row loop skip\n cbz x14, label_21\nKAI_ASM_LABEL(label_12) // Row tail: Row loop\n mov x26, x16\n mov x25, x15\n add x24, x13, x12, LSL #2\nKAI_ASM_LABEL(label_13) // Row tail: Column loop\n movi v13.16b, #0x0\n movi v18.16b, #0x0\n mov x23, x17\n mov x21, x8\n movi v29.16b, #0x0\n movi v14.16b, #0x0\nKAI_ASM_LABEL(label_14) // Row tail: Block loop\n movi v25.4s, #0x0\n movi v7.4s, #0x0\n mov x20, x7\n movi v10.4s, #0x0\n movi v17.4s, #0x0\nKAI_ASM_LABEL(label_15) // Row tail: Sub block loop\n ldr q0, [x26, #0x0]\n ldr q31, [x26, #0x10]\n subs x20, x20, #0x1\n ldr q30, [x23, #0x0]\n ldr q28, [x23, #0x10]\n ldr q27, [x26, #0x20]\n ldr q26, [x26, #0x30]\n add x26, x26, #0x40\n ldr q6, [x23, #0x20]\n ldr q24, [x23, #0x30]\n shl v23.16b, v0.16b, #0x4\n shl v22.16b, v31.16b, #0x4\n ldr q21, [x23, #0x40]\n ldr q20, [x23, #0x50]\n and v0.16b, v0.16b, v12.16b\n and v31.16b, v31.16b, v12.16b\n ldr q19, [x23, #0x60]\n ldr q2, [x23, #0x70]\n shl v11.16b, v27.16b, #0x4\n shl v16.16b, v26.16b, #0x4\n KAI_ASM_INST(0x4e97a7d9) // smmla v25.4s, v30.16b, v23.16b\n KAI_ASM_INST(0x4e96a7c7) // smmla v7.4s, v30.16b, v22.16b\n and v27.16b, v27.16b, v12.16b\n add x23, x23, #0x80\n KAI_ASM_INST(0x4e97a78a) // smmla v10.4s, v28.16b, v23.16b\n KAI_ASM_INST(0x4e96a791) // smmla v17.4s, v28.16b, v22.16b\n and v26.16b, v26.16b, v12.16b\n KAI_ASM_INST(0x4e8ba4d9) // smmla v25.4s, v6.16b, v11.16b\n KAI_ASM_INST(0x4e90a4c7) // smmla v7.4s, v6.16b, v16.16b\n KAI_ASM_INST(0x4e8ba70a) // smmla v10.4s, v24.16b, v11.16b\n KAI_ASM_INST(0x4e90a711) // smmla v17.4s, v24.16b, v16.16b\n KAI_ASM_INST(0x4e80a6b9) // smmla v25.4s, v21.16b, v0.16b\n KAI_ASM_INST(0x4e9fa6a7) // smmla v7.4s, v21.16b, v31.16b\n KAI_ASM_INST(0x4e80a68a) // smmla v10.4s, v20.16b, v0.16b\n KAI_ASM_INST(0x4e9fa691) // smmla v17.4s, v20.16b, v31.16b\n KAI_ASM_INST(0x4e9ba679) // smmla v25.4s, v19.16b, v27.16b\n KAI_ASM_INST(0x4e9aa667) // smmla v7.4s, v19.16b, v26.16b\n KAI_ASM_INST(0x4e9ba44a) // smmla v10.4s, v2.16b, v27.16b\n KAI_ASM_INST(0x4e9aa451) // smmla v17.4s, v2.16b, v26.16b\n bgt label_15\n ldr q6, [x26, #0x0]\n ld1 { v3.4s }, [x23]\n add x23, x23, #0x10\n uzp1 v24.2d, v25.2d, v7.2d\n ldr q23, [x26, #0x10]\n ldr q16, [x23, #0x0]\n uzp2 v22.2d, v25.2d, v7.2d\n uzp1 v21.2d, v10.2d, v17.2d\n uzp2 v20.2d, v10.2d, v17.2d\n add x26, x26, #0x20\n add x23, x23, #0x10\n fmla v13.4s, v6.4s, v3.s[0]\n fmla v18.4s, v6.4s, v3.s[1]\n fmla v29.4s, v6.4s, v3.s[2]\n scvtf v24.4s, v24.4s\n fmla v14.4s, v6.4s, v3.s[3]\n fmul v19.4s, v23.4s, v16.s[0]\n fmul v31.4s, v23.4s, v16.s[1]\n scvtf v22.4s, v22.4s\n fmul v17.4s, v23.4s, v16.s[2]\n scvtf v21.4s, v21.4s\n fmul v16.4s, v23.4s, v16.s[3]\n scvtf v20.4s, v20.4s\n fmla v13.4s, v24.4s, v19.4s\n fmla v18.4s, v22.4s, v31.4s\n fmla v29.4s, v21.4s, v17.4s\n fmla v14.4s, v20.4s, v16.4s\n subs x21, x21, #0x1\n bgt label_14\n ldr q20, [x26, #0x0]\n ld1r { v17.4s }, [x11]\n add x20, x11, #0x4\n cmp x25, #0x4\n ld1r { v16.4s }, [x20]\n add x26, x26, #0x10\n fadd v13.4s, v13.4s, v20.4s\n fadd v18.4s, v18.4s, v20.4s\n fadd v29.4s, v29.4s, v20.4s\n fadd v14.4s, v14.4s, v20.4s\n fmax v13.4s, v13.4s, v17.4s\n fmax v18.4s, v18.4s, v17.4s\n fmax v29.4s, v29.4s, v17.4s\n fmax v14.4s, v14.4s, v17.4s\n fmin v13.4s, v13.4s, v16.4s\n fmin v18.4s, v18.4s, v16.4s\n fmin v29.4s, v29.4s, v16.4s\n fmin v14.4s, v14.4s, v16.4s\n blt label_17\n mov x20, x13\n cmp x14, #0x1\n str q13, [x20, #0x0]\n add x20, x20, x12\n ble label_20\n cmp x14, #0x2\n str q18, [x20, #0x0]\n add x20, x20, x12\n ble label_20\n cmp x14, #0x3\n str q29, [x20, #0x0]\n add x20, x20, x12\n ble label_20\n str q14, [x20, #0x0]\n b label_20\nKAI_ASM_LABEL(label_17) // Row tail: Partial output\n mov x23, x13\n cmp x14, #0x1\n add x22, x23, x12\n csel x22, x22, x23, GT\n cmp x14, #0x2\n add x21, x23, x12, LSL #1\n csel x21, x21, x22, GT\n cmp x14, #0x3\n add x20, x21, x12\n csel x20, x20, x21, GT\n tbz x25, #1, label_18\n st1 { v14.d }[0], [x20], #0x8\n st1 { v29.d }[0], [x21], #0x8\n st1 { v18.d }[0], [x22], #0x8\n st1 { v13.d }[0], [x23], #0x8\n tbz x25, #0, label_19\n st1 { v14.s }[2], [x20]\n st1 { v29.s }[2], [x21]\n st1 { v18.s }[2], [x22]\n st1 { v13.s }[2], [x23]\n b label_19\nKAI_ASM_LABEL(label_18) // Row tail: Output block 0: partial_1_0\n st1 { v14.s }[0], [x20]\n st1 { v29.s }[0], [x21]\n st1 { v18.s }[0], [x22]\n st1 { v13.s }[0], [x23]\nKAI_ASM_LABEL(label_19) // Row tail: Output block 0: Done\nKAI_ASM_LABEL(label_20) // Row tail: Output stage exit\n subs x25, x25, #0x4\n add x13, x13, #0x10\n bgt label_13\n subs x14, x14, #0x4\n add x17, x17, x6\n mov x13, x24\n bgt label_12\nKAI_ASM_LABEL(label_21) // Row tail: Row loop skip\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d10, d11, [sp, 72]\n ldp d12, d13, [sp, 88]\n ldp d14, d15, [sp, 104]\n ldp d8, d9, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon to dynamically quantize and pack the LHS matrix in a single\n/// step.\n/// -# @ref kai_run_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon to pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32)\n/// values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be 1.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32)\n/// values.\n///\n/// @param[in] n_idx Col index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be 1.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Symmetric Signed 8-bit with per-block (multiple of 32) quantization (qsi8d32) and packed.\n/// RHS matrix: Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32) and packed.\n/// Output tile: (rows x cols) = m_step x n_step.\n///\n/// Note: Please refer to the get functions for m_step and n_step for the exact values.\n///\n/// Features used: dotprod\n///\n/// @param[in] m The number of output rows written. It must be 1.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(__ARM_FEATURE_DOTPROD) && !defined(_M_ARM64)\n#error \"Dotprod extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod.h\"\n\n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n float* dst;\n const void* lhs_packed;\n const void* rhs_packed;\n const float* clamp_vals;\n size_t dst_stride_row;\n size_t m;\n size_t n;\n size_t num_blocks;\n size_t num_subblocks;\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 16;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_sum_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_offset_rhs = 4;\n\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_bl = 32;\n\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs + kai_num_bytes_sum_lhs;\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs =\n (bl / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n return kai_mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n\n size_t rhs_packed_stride = kai_nr * (num_bytes_per_block * num_blocks_per_row);\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += kai_nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m_idx, size_t k, size_t bl) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t n_idx, size_t k, size_t bl) {\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME(m == 1);\n\n if (m == 0) {\n return;\n }\n const size_t num_subblocks = bl / kai_bl;\n const size_t num_blocks = kai_get_num_blocks_per_row(k, bl);\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n KernelArgs args;\n\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.clamp_vals = clamp_vals;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.num_blocks = num_blocks;\n args.num_subblocks = num_subblocks;\n\n kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod)\n stp x20, x21, [sp, -80]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n mov x21, #0x8\n movi v31.16b, #0xf0\n mov x15, #0x20\n ldr x14, [x0, #0x40]\n ldr x13, [x0, #0x38]\n ldr x20, [x0, #0x28]\n ldr x12, [x0, #0x8]\n ldr x11, [x0, #0x10]\n ldr x10, [x0, #0x30]\n madd x15, x14, x15, x21\n ldr x9, [x0, #0x0]\n ldr x28, [x0, #0x20]\n ldr x27, [x0, #0x18]\n mov x26, x20\n mul x15, x13, x15\nKAI_ASM_LABEL(label_1) // Row loop\n mov x25, x11\n mov x24, x10\n add x23, x9, x28\nKAI_ASM_LABEL(label_2) // Column loop\n mov x22, x12\n movi v30.16b, #0x0\n mov x21, x13\nKAI_ASM_LABEL(label_3) // Block loop\n movi v29.4s, #0x0\n movi v28.4s, #0x0\n mov x20, x14\nKAI_ASM_LABEL(label_4) // Sub block loop\n ldr q27, [x25, #0x0]\n ldr q26, [x25, #0x10]\n subs x20, x20, #0x1\n ld1r { v25.2d }, [x22], #0x8\n ldr q24, [x25, #0x20]\n ldr q23, [x25, #0x30]\n add x25, x25, #0x40\n ld1r { v22.2d }, [x22], #0x8\n ld1r { v21.2d }, [x22], #0x8\n shl v20.16b, v27.16b, #0x4\n shl v19.16b, v26.16b, #0x4\n ld1r { v18.2d }, [x22], #0x8\n shl v17.16b, v24.16b, #0x4\n and v27.16b, v27.16b, v31.16b\n shl v16.16b, v23.16b, #0x4\n and v26.16b, v26.16b, v31.16b\n KAI_ASM_INST(0x4e99969d) // sdot v29.4s, v20.16b, v25.16b\n KAI_ASM_INST(0x4e99967c) // sdot v28.4s, v19.16b, v25.16b\n and v24.16b, v24.16b, v31.16b\n and v23.16b, v23.16b, v31.16b\n KAI_ASM_INST(0x4e96963d) // sdot v29.4s, v17.16b, v22.16b\n KAI_ASM_INST(0x4e96961c) // sdot v28.4s, v16.16b, v22.16b\n KAI_ASM_INST(0x4e95977d) // sdot v29.4s, v27.16b, v21.16b\n KAI_ASM_INST(0x4e95975c) // sdot v28.4s, v26.16b, v21.16b\n KAI_ASM_INST(0x4e92971d) // sdot v29.4s, v24.16b, v18.16b\n KAI_ASM_INST(0x4e9296fc) // sdot v28.4s, v23.16b, v18.16b\n bgt label_4\n ldr q19, [x25, #0x0]\n ld1r { v18.4s }, [x22]\n add x22, x22, #0x4\n addp v29.4s, v29.4s, v28.4s\n ld1r { v17.4s }, [x22]\n ldr q16, [x25, #0x10]\n sub x21, x21, #0x1\n add x22, x22, #0x4\n add x25, x25, #0x20\n fmla v30.4s, v19.4s, v18.s[0]\n scvtf v29.4s, v29.4s\n fmul v16.4s, v16.4s, v17.4s\n fmla v30.4s, v29.4s, v16.4s\n cbnz x21, label_3\n ldr q18, [x25, #0x0]\n ld1r { v17.4s }, [x27]\n add x20, x27, #0x4\n cmp x24, #0x4\n ld1r { v16.4s }, [x20]\n add x25, x25, #0x10\n fadd v30.4s, v30.4s, v18.4s\n fmax v30.4s, v30.4s, v17.4s\n fmin v30.4s, v30.4s, v16.4s\n blt label_5\n str q30, [x9, #0x0]\n b label_8\nKAI_ASM_LABEL(label_5) // Partial output\n mov x20, x9\n tbz x24, #1, label_6\n st1 { v30.d }[0], [x20], #0x8\n tbz x24, #0, label_7\n st1 { v30.s }[2], [x20]\n b label_7\nKAI_ASM_LABEL(label_6) // Output block 0: partial_1_0\n st1 { v30.s }[0], [x20]\nKAI_ASM_LABEL(label_7) // Output block 0: Done\nKAI_ASM_LABEL(label_8) // Stores done\n subs x24, x24, #0x4\n add x9, x9, #0x10\n bgt label_2\n subs x26, x26, #0x1\n add x12, x12, x15\n mov x9, x23\n bgt label_1\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp x20, x21, [sp], 80\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized symmetric per-block (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of mr.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be\n/// a multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h\"\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return bl * sizeof(int8_t) + kai_num_bytes_multiplier + kai_num_bytes_sum;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSERT((k % bl) == 0);\n return k / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t bl) {\n KAI_UNUSED(kr);\n\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block(bl);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((m_idx % mr) == 0);\n\n KAI_UNUSED(sr);\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, mr, kr, bl);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KAI_UNUSED(sr);\n\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return (num_rows * kai_get_lhs_packed_stride(k, mr, kr, bl));\n}\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(((kr / sr) == 8) || ((kr / sr) == 4));\n\n if (m == 0) {\n return;\n }\n const size_t lhs_packed_stride = kai_get_lhs_packed_stride(k, mr, kr, bl);\n const size_t num_rows = m;\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n const size_t mr_block_size = mr * num_bytes_per_block;\n\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n const float* row_src_ptr = (const float*)((const uint8_t*)lhs + (row_idx + m_idx_start) * lhs_stride);\n const size_t dst_idx = ((row_idx + m_idx_start) % mr);\n\n for (size_t blk_idx = 0; blk_idx < num_blocks_per_row; ++blk_idx) {\n const float* src_ptr = row_src_ptr + blk_idx * bl;\n int8_t* dst_ptr = (int8_t*)lhs_packed + dst_idx * k_block_len * sizeof(int8_t) + blk_idx * mr_block_size;\n int8_t* param_ptr = (int8_t*)lhs_packed + blk_idx * mr_block_size + bl * mr + dst_idx * kai_num_bytes_sum;\n\n // Find absmax for each block\n float absmax = -FLT_MAX;\n int32_t k_idx = 0;\n float32x4_t vabsmax = vdupq_n_f32(-FLT_MAX);\n for (; k_idx < ((int32_t)bl); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n // Calculate the max\n vabsmax = vmaxq_f32(vabsq_f32(src0_0), vmaxq_f32(vabsmax, vabsq_f32(src0_1)));\n }\n // Get the absmax\n absmax = vmaxvq_f32(vabsmax);\n\n // Maximum/minimum int8 values\n const float qmax = (float)INT8_MAX;\n\n // Get the scale and reciprocal to quantize\n const float scale0 = absmax == 0.0F ? 0.0F : qmax / absmax;\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n int32_t qsum = 0;\n // Quantize the blocks\n for (k_idx = 0; k_idx <= (int32_t)bl - k_block_len; k_idx += k_block_len) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)k_idx, k - 1);\n if (k_block_len == 8) {\n const float32x4_t vsrc_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t vsrc_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(vsrc_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(vsrc_1, scale0);\n\n int16x4_t v0_s16 = vqmovn_s32(vcvtnq_s32_f32(v0_f32));\n int16x4_t v1_s16 = vqmovn_s32(vcvtnq_s32_f32(v1_f32));\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n // Update the sum\n qsum += vaddvq_s16(v_s16);\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8(dst_ptr, v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n } else if (k_block_len == 4) {\n const float32x2_t vsrc_0 = vld1_f32(src_ptr + k_idx_start);\n const float32x2_t vsrc_1 = vld1_f32(src_ptr + k_idx_start + 2);\n\n // Scale the values\n float32x2_t v0_f32 = vmul_n_f32(vsrc_0, scale0);\n float32x2_t v1_f32 = vmul_n_f32(vsrc_1, scale0);\n\n int32x2_t v0_s32 = vcvtn_s32_f32(v0_f32);\n int32x2_t v1_s32 = vcvtn_s32_f32(v1_f32);\n int16x4_t v_s16 = vqmovn_s32(vcombine_s32(v0_s32, v1_s32));\n\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n // Update the sum\n qsum += vaddv_s16(v_s16);\n\n dst_ptr[0] = vqmovnh_s16(vget_lane_s16(v_s16, 0));\n dst_ptr[1] = vqmovnh_s16(vget_lane_s16(v_s16, 1));\n dst_ptr[2] = vqmovnh_s16(vget_lane_s16(v_s16, 2));\n dst_ptr[3] = vqmovnh_s16(vget_lane_s16(v_s16, 3));\n dst_ptr += 4 * sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n *((float*)(param_ptr)) = ((float)qsum) * recip_scale0;\n param_ptr += mr * kai_num_bytes_sum;\n *((float*)(param_ptr)) = recip_scale0;\n }\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((int8_t*)lhs_packed + lhs_packed_stride);\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qai4c32p_params\n#define kai_rhs_pack_nxk_qai4c32p_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 K values are stored in one byte. These values are stored in blocks\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t n_idx, //\n size_t rhs_stride); //\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] nr The number of N rows to interleave on the same output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] zero The zero point.\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n const void* zero, //\n const void* bias, //\n const void* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_nxk_qai4c32p_params* params);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n#include \"kai_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_offset_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return (bl / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n return nr * (num_bytes_per_block * num_blocks_per_row + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % nr) == 0);\n KAI_UNUSED(kr);\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_UNUSED(kr);\n const size_t num_rows = kai_roundup(n, nr) / nr;\n return num_rows * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nvoid kai_run_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t bl, const uint8_t* rhs,\n const void* zero, const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qai4c32p_params* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME(extra_bytes == 0);\n\n KAI_ASSUME(sr == 2);\n KAI_ASSUME(kr >= 1 && kr <= 16);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(zero != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(params != NULL);\n KAI_ASSUME(params->rhs_zero_point == 8);\n KAI_ASSUME(params->lhs_zero_point == 1);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t num_blocks_per_row = k / bl;\n const size_t rhs_stride = k;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride(k, nr, kr, bl);\n\n const size_t dst_packed_block_size = kai_get_num_bytes_per_block(bl) * nr;\n const size_t dst_block_data_size = (bl / 2) * nr;\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_bias_offset = num_blocks_per_row * dst_packed_block_size;\n const size_t k_block_length_in_bytes = kr / sr;\n const size_t k_interleaved_v = 16U;\n\n const size_t rhs_zero_point = params->rhs_zero_point;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n float* dst_row_bias = (float*)(dst_row + dst_bias_offset);\n\n for (size_t block_idx = 0; block_idx < num_blocks_per_row; block_idx++) {\n uint8_t* block_dst_row = dst_row + block_idx * dst_packed_block_size;\n float* block_dst_zp = (float*)(block_dst_row + dst_block_data_size);\n float* block_dst_scale = block_dst_zp + nr;\n\n for (size_t block_byte_idx = 0; block_byte_idx < dst_block_data_size; ++block_byte_idx) {\n const size_t dst_byte_idx = block_byte_idx;\n const size_t k_block_idx = dst_byte_idx / k_block_length_in_bytes;\n const size_t k_block_byte_idx = dst_byte_idx % k_block_length_in_bytes;\n const size_t super_k_block_idx = k_block_idx / nr;\n const size_t nr_idx = k_block_idx % nr;\n\n const size_t k_adjustment =\n ((k_block_byte_idx + super_k_block_idx * k_block_length_in_bytes) / k_interleaved_v) *\n k_interleaved_v;\n const size_t k0_idx = k_block_byte_idx + super_k_block_idx * k_block_length_in_bytes + k_adjustment;\n const size_t k1_idx = k0_idx + k_interleaved_v;\n const size_t n0_idx = dst_row_idx * nr + nr_idx;\n\n // Clamp the index to avoid out-of-bound reads\n const size_t n0_valid_idx = KAI_MIN(n0_idx, n - 1);\n\n const size_t src_addr_byte0 = (k0_idx + n0_valid_idx * rhs_stride + block_idx * bl) / 2;\n const size_t src_addr_byte1 = (k1_idx + n0_valid_idx * rhs_stride + block_idx * bl) / 2;\n\n uint8_t byte0 = rhs_zero_point | rhs_zero_point << 4;\n uint8_t byte1 = rhs_zero_point | rhs_zero_point << 4;\n\n if (k0_idx < k) {\n byte0 = rhs[src_addr_byte0];\n }\n if (k1_idx < k) {\n byte1 = rhs[src_addr_byte1];\n }\n\n const size_t shift_right_x0 = (k0_idx % 2 == 0) ? 4 : 0;\n const size_t shift_right_x1 = (k1_idx % 2 == 0) ? 4 : 0;\n\n const uint8_t src_x0_lo = (byte0 >> shift_right_x0) & 0x0F;\n const uint8_t src_x0_hi = (byte1 >> shift_right_x1) & 0x0F;\n\n const uint8_t dst_qs0 = src_x0_lo | (src_x0_hi << 4);\n\n *block_dst_row = dst_qs0 ^ 0x88;\n block_dst_row += sizeof(uint8_t);\n }\n\n // Adjust the zero points and scales\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n\n const float* block_zero = (const float*)zero + num_blocks_per_row * src_row_idx;\n const float* block_scale = (const float*)scale + num_blocks_per_row * src_row_idx;\n\n *block_dst_zp = block_zero[block_idx];\n *block_dst_scale = block_scale[block_idx] * 0.0625F;\n\n block_dst_zp++;\n block_dst_scale++;\n }\n }\n // Set the bias\n if (bias == NULL) {\n memset(dst_row_bias, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n\n dst_row_bias[i] = *((const float*)bias + src_row_idx);\n }\n }\n }\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm against gemm_qai4c32_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm.h\"\n#include \"kai_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod.h\"\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h\"\n#include \"kai_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n // M == 1 runs the dedicated GEMV ukernel, as a KleidiAI user would pick it. Both variants\n // share one packed-RHS layout (same nr/kr/sr), so a single cached weight pack serves both.\n const bool gemv = (M == 1);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm();\n if (kai_get_nr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod() != nr || kai_get_kr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod() != kr ||\n kai_get_sr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod() != sr) return -2;\n const size_t mr = gemv ? kai_get_mr_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod() : kai_get_mr_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = gemv ? (kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr)) : (kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr));\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n if (gemv) {\n kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n } else {\n kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* B_zeros_snap = nullptr;\n static size_t B_zeros_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N*(K/BL))\n | refresh_cache(B_zeros_snap, B_zeros_snap_size, B_zeros, sizeof(float)*N*(K/BL))\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon((size_t)N, (size_t)K, nr, kr, BL);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n // This packer takes the s0s1 nibble order (high nibble = first element); the definition stores the low nibble first.\n const size_t q4_bytes = (size_t)N * K / 2;\n uint8_t* B_q4_s0s1 = static_cast(std::malloc(q4_bytes));\n if (B_q4_s0s1 == nullptr) return -1;\n for (size_t i = 0; i < q4_bytes; ++i) B_q4_s0s1[i] = (uint8_t)((B_q4[i] << 4) | (B_q4[i] >> 4));\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qai4c32p_qau4c32s0s1_f32_f32_f32_neon(1, (size_t)N, (size_t)K, nr, kr, sr, BL, B_q4_s0s1, B_zeros, bias, B_scales, rhs_packed, 0, ¶ms);\n std::free(B_q4_s0s1);\n }\n\n if (gemv) {\n kai_run_matmul_clamp_f32_qsi8d32p1x8_qai4c32p4x8_1x4_neon_dotprod((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n } else {\n kai_run_matmul_clamp_f32_qsi8d32p4x8_qai4c32p4x8_8x4_neon_i8mm((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n }\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..c536d93e477a090280d7e0e5bd8b546c6f35359c --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai4c32_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qai4c32_sme2_n256_k512", + "definition": "gemm_qai4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qai4c32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon to dynamically quantize and pack the LHS matrix in a single\n/// step.\n/// -# @ref kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon or @ref\n/// kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s0s1_f32_f32_f32_neon pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-block (32) quantization (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of m_step.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 4-bit with per-block (multiple of 32) quantization (qai4c32)\n/// values.\n///\n/// @param[in] n_idx Col index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of m_step.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Symmetric Signed 8-bit with per-block (32) quantization (qsi8d32) and packed\n/// RHS matrix: Quantized Asymmetric Signed 4-bit with per-block (32) quantization (qai4c32) and packed.\n/// Output tile: (rows x cols) = 1 VL x 4 VL (Vector Length)\n///\n/// Instruction used: SME2 (MOPA)\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// It must be a multiple of the block length (bl).\n/// @param[in] bl Block length. Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n KAI_ASM_CODE(matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -128 ]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp x25, x26, [sp, 48]\n stp d8, d9, [sp, 64]\n stp d10, d11, [sp, 80]\n stp d12, d13, [sp, 96]\n stp d14, d15, [sp, 112]\n KAI_ASM_INST(0xd503477f) // smstart\n cntw x14\n ptrue p0.b, all\n KAI_ASM_INST(0x25a07810) // ptrue pn8.s\n cntw x5 //mr\n lsl x5, x5, #2\n whilelt p4.b, xzr, x5\n ldr x6, [x0, #0x58] // lut\n KAI_ASM_INST(0xe11f80c0) // ldr zt0, [x6]\n ldr x19, [x0, #0x10] // rhs_packed\n KAI_ASM_INST(0x8558c009) // ld1rw z9.s, p0/z, [x0, #0x60]\n KAI_ASM_INST(0x8559c00a) // ld1rw z10.s, p0/z, [x0, #0x64]\n ldr x4, [x0, #0x50] // bl\n ldr x21, [x0, #0x18] // dst_stride_row\n ldr x20, [x0] // dst\n mov x8, #0\n ldr x13, [x0, #0x40] // n\n ldr x23, [x0, #0x48] // k\n KAI_ASM_INST(0x25ad6511) // whilelt pn9.s, x8, x13, VLx4\n b.eq label_9 // b.none label_9\nKAI_ASM_LABEL(label_1) // N Loop\n ldr x9, [x0, #0x38] // m\n ldr x22, [x0, #0x8] // lhs_packed\n mov x24, x20\nKAI_ASM_LABEL(label_2) // M Loop\n mov x26, x19\n mov x3, x22\n cmp x9, x14\n csel x15, x9, x14, lo\n lsl x15, x15, #2\n ldr x10, [x0, #0x48] // k\n cmp x10, #0\n b.eq label_8\nKAI_ASM_LABEL(label_3) // K Loop\n KAI_ASM_INST(0xc00800ff) // zero {za}\n mov x11, x4\nKAI_ASM_LABEL(label_4) // Block Loop\n KAI_ASM_INST(0xa0404342) //ld1w {z2.s - z3.s}, pn8/z, [x26]\n addvl x26, x26, #2\n ld1h {z8.h}, p0/z, [x3]\n addvl x3, x3, #1\n KAI_ASM_INST(0xc08a4044) // luti4 {z4.b - z5.b}, zt0, z2[0]\n KAI_ASM_INST(0xc08a4066) // luti4 {z6.b - z7.b}, zt0, z3[0]\n KAI_ASM_INST(0xa0840100) // smopa za0.s, p0/m, p0/m, z8.b, z4.b\n KAI_ASM_INST(0xa0850101) // smopa za1.s, p0/m, p0/m, z8.b, z5.b\n KAI_ASM_INST(0xa0860102) // smopa za2.s, p0/m, p0/m, z8.b, z6.b\n KAI_ASM_INST(0xa0870103) // smopa za3.s, p0/m, p0/m, z8.b, z7.b\n subs x11, x11, #4\n b.gt label_4\n mov w12, #0\n mov x25, x24\n ld1b {z17.b}, p4/z, [x3] // lhs sum\n ld1b {z16.b}, p4/z, [x3, #1, mul vl] // lhs scale\n addvl x3, x3, #2\n KAI_ASM_INST(0xa040c354) // ld1w { z20.s - z23.s }, pn8/z, [x26] // rhs zp\n KAI_ASM_INST(0xa041c340) // ld1w { z0.s - z3.s }, pn8/z, [x26, #4, mul vl ] // rhs scale\n addvl x26, x26, #8\n pfalse p3.b\nKAI_ASM_LABEL(label_5)\n pnext p3.s, p0, p3.s\n clastb z19.s, p3, z19.s, z16.s\n clastb z18.s, p3, z18.s, z17.s\n KAI_ASM_INST(0xc006041c) // mova {z28.b-z31.b}, za0h.b[w12, 0:3]\n add w12, w12, #4\n fmul z4.s, z0.s, z19.s\n fmul z5.s, z1.s, z19.s\n fmul z6.s, z2.s, z19.s\n fmul z7.s, z3.s, z19.s\n KAI_ASM_INST(0xc132e39c) // scvtf {z28.s-z31.s}, {z28.s-z31.s}\n cmp x10, x23\n b.ne label_6\n fmul z24.s, z20.s, z18.s\n fmul z25.s, z21.s, z18.s\n fmul z26.s, z22.s, z18.s\n fmul z27.s, z23.s, z18.s\n fmla z24.s, p0/m, z4.s, z28.s\n fmla z25.s, p0/m, z5.s, z29.s\n fmla z26.s, p0/m, z6.s, z30.s\n fmla z27.s, p0/m, z7.s, z31.s\n b label_7\nKAI_ASM_LABEL(label_6)\n KAI_ASM_INST(0xa040c738) // ld1w {z24.s-z27.s}, pn9/z, [x25]\n fmla z24.s, p0/m, z20.s, z18.s\n fmla z25.s, p0/m, z21.s, z18.s\n fmla z26.s, p0/m, z22.s, z18.s\n fmla z27.s, p0/m, z23.s, z18.s\n fmla z24.s, p0/m, z4.s, z28.s\n fmla z25.s, p0/m, z5.s, z29.s\n fmla z26.s, p0/m, z6.s, z30.s\n fmla z27.s, p0/m, z7.s, z31.s\nKAI_ASM_LABEL(label_7)\n KAI_ASM_INST(0xa060c738) // st1w {z24.s-z27.s}, pn9, [x25]\n add x25, x25, x21\n cmp x12, x15\n blt label_5\n subs x10, x10, x4\n b.gt label_3\nKAI_ASM_LABEL(label_8)\n ldr x5, [x0,0x30]\n add x5, x5, x19\n KAI_ASM_INST(0xa040c0ac) // ld1w {z12.s - z15.s}, pn8/z, [x5]\n mov x5, x24\n mov x12, 0\nKAI_ASM_LABEL(label_10) // Bias loop\n KAI_ASM_INST(0xa040c718) // ld1w {z24.s-z27.s}, pn9/z, [x24]\n fadd z24.s, p0/m, z24.s, z12.s\n fadd z25.s, p0/m, z25.s, z13.s\n fadd z26.s, p0/m, z26.s, z14.s\n fadd z27.s, p0/m, z27.s, z15.s\n KAI_ASM_INST(0xc1aac938) // fclamp { z24.s - z27.s }, z9.s, z10.s\n KAI_ASM_INST(0xa060c718) // st1w {z24.s-z27.s}, pn9, [x24]\n add x24, x24, x21\n add x12, x12, #4\n cmp x12, x15\n blt label_10\n mov x24, x5\n ldr\tx5, [x0, #0x20]\n add x22, x22, x5\n mov x24, x25\n decw x9, all\n cmp x9, #0\n b.gt label_2\n incb x20, all, mul #4\n ldr x5, [x0, #0x28] // rhs_packed_stride\n add x19, x19, x5\n incb x8, all\n KAI_ASM_INST(0x25ad6511) // whilelt pn9.s, x8, x13, VLx4\n b.mi label_1 // b.first label_1\nKAI_ASM_LABEL(label_9)\n KAI_ASM_INST(0xd503467f) // smstop\n ldp d14, d15, [sp, 112]\n ldp d12, d13, [sp, 96]\n ldp d10, d11, [sp, 80]\n ldp d8, d9, [sp, 64]\n ldp x25, x26, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp],128\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\ntypedef struct {\n float* dst; // 0\n const void* lhs_packed; // 0x8\n const void* rhs_packed; // 0x10\n size_t dst_stride_row; // 0x18\n size_t lhs_packed_stride; // 0x20\n size_t rhs_packed_stride; // 0x28\n size_t bias; // 0x30\n size_t m; // 0x38\n size_t n; // 0x40\n size_t k; // 0x48\n size_t bl; // 0x50\n const int32_t* lut; // 0x58\n float min; // 0x60\n float max; // 0x64\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n// Compute args\nstatic const size_t kai_m_step = 1; // Multiple of vector length\nstatic const size_t kai_n_step = 4; // Multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // Multiple of vector length\nstatic const size_t kai_nr = 4; // Multiple of vector length\nstatic const size_t kai_kr = 8;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_sum_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_offset_rhs = 4;\n\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_bl = 32;\n\n// Look-up table used for int4->int8 convert\nstatic const int32_t lut[16] = {-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};\n\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs + kai_num_bytes_sum_lhs;\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs =\n (bl / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME(bl % kai_bl == 0);\n KAI_ASSUME((k % kai_bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr * (num_bytes_per_block * num_blocks_per_row);\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((m_idx % mr) == 0);\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, size_t k, size_t bl) {\n KAI_ASSUME((k % bl) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n const size_t m_step = kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t n_step = kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % m_step) == 0);\n KAI_ASSUME((n_idx % n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.lhs_packed_stride = kai_get_lhs_packed_stride(k, bl);\n args.rhs_packed_stride = kai_get_rhs_packed_stride(k, bl);\n args.bias = args.rhs_packed_stride - nr * kai_num_bytes_bias;\n args.m = m;\n args.n = n;\n args.k = k;\n args.bl = bl;\n args.lut = lut;\n args.min = scalar_min;\n args.max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h\"\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return bl * sizeof(int8_t) + kai_num_bytes_multiplier + kai_num_bytes_sum;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSERT((k % bl) == 0);\n return k / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t bl) {\n KAI_UNUSED(kr);\n\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block(bl);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((m_idx % mr) == 0);\n\n KAI_UNUSED(sr);\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, mr, kr, bl);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KAI_UNUSED(sr);\n\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return (num_rows * kai_get_lhs_packed_stride(k, mr, kr, bl));\n}\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(((kr / sr) == 8) || ((kr / sr) == 4));\n\n if (m == 0) {\n return;\n }\n const size_t lhs_packed_stride = kai_get_lhs_packed_stride(k, mr, kr, bl);\n const size_t num_rows = m;\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n const size_t mr_block_size = mr * num_bytes_per_block;\n\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n const float* row_src_ptr = (const float*)((const uint8_t*)lhs + (row_idx + m_idx_start) * lhs_stride);\n const size_t dst_idx = ((row_idx + m_idx_start) % mr);\n\n for (size_t blk_idx = 0; blk_idx < num_blocks_per_row; ++blk_idx) {\n const float* src_ptr = row_src_ptr + blk_idx * bl;\n int8_t* dst_ptr = (int8_t*)lhs_packed + dst_idx * k_block_len * sizeof(int8_t) + blk_idx * mr_block_size;\n int8_t* param_ptr = (int8_t*)lhs_packed + blk_idx * mr_block_size + bl * mr + dst_idx * kai_num_bytes_sum;\n\n // Find absmax for each block\n float absmax = -FLT_MAX;\n int32_t k_idx = 0;\n float32x4_t vabsmax = vdupq_n_f32(-FLT_MAX);\n for (; k_idx < ((int32_t)bl); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n // Calculate the max\n vabsmax = vmaxq_f32(vabsq_f32(src0_0), vmaxq_f32(vabsmax, vabsq_f32(src0_1)));\n }\n // Get the absmax\n absmax = vmaxvq_f32(vabsmax);\n\n // Maximum/minimum int8 values\n const float qmax = (float)INT8_MAX;\n\n // Get the scale and reciprocal to quantize\n const float scale0 = absmax == 0.0F ? 0.0F : qmax / absmax;\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n int32_t qsum = 0;\n // Quantize the blocks\n for (k_idx = 0; k_idx <= (int32_t)bl - k_block_len; k_idx += k_block_len) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)k_idx, k - 1);\n if (k_block_len == 8) {\n const float32x4_t vsrc_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t vsrc_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(vsrc_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(vsrc_1, scale0);\n\n int16x4_t v0_s16 = vqmovn_s32(vcvtnq_s32_f32(v0_f32));\n int16x4_t v1_s16 = vqmovn_s32(vcvtnq_s32_f32(v1_f32));\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n // Update the sum\n qsum += vaddvq_s16(v_s16);\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8(dst_ptr, v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n } else if (k_block_len == 4) {\n const float32x2_t vsrc_0 = vld1_f32(src_ptr + k_idx_start);\n const float32x2_t vsrc_1 = vld1_f32(src_ptr + k_idx_start + 2);\n\n // Scale the values\n float32x2_t v0_f32 = vmul_n_f32(vsrc_0, scale0);\n float32x2_t v1_f32 = vmul_n_f32(vsrc_1, scale0);\n\n int32x2_t v0_s32 = vcvtn_s32_f32(v0_f32);\n int32x2_t v1_s32 = vcvtn_s32_f32(v1_f32);\n int16x4_t v_s16 = vqmovn_s32(vcombine_s32(v0_s32, v1_s32));\n\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n // Update the sum\n qsum += vaddv_s16(v_s16);\n\n dst_ptr[0] = vqmovnh_s16(vget_lane_s16(v_s16, 0));\n dst_ptr[1] = vqmovnh_s16(vget_lane_s16(v_s16, 1));\n dst_ptr[2] = vqmovnh_s16(vget_lane_s16(v_s16, 2));\n dst_ptr[3] = vqmovnh_s16(vget_lane_s16(v_s16, 3));\n dst_ptr += 4 * sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n *((float*)(param_ptr)) = ((float)qsum) * recip_scale0;\n param_ptr += mr * kai_num_bytes_sum;\n *((float*)(param_ptr)) = recip_scale0;\n }\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((int8_t*)lhs_packed + lhs_packed_stride);\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized symmetric per-block (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of mr.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be\n/// a multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n#include \"kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_offset_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\nstatic const size_t kai_bl_multiple_of = 32;\nstatic const size_t kai_nr_multiple_of = 4;\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_get_num_bytes_per_block(size_t bl) {\n return (bl / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_offset_rhs;\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl);\n return nr * (num_bytes_per_block * num_blocks_per_row + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % nr) == 0);\n KAI_UNUSED(kr);\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_UNUSED(kr);\n const size_t num_rows = kai_roundup(n, nr) / nr;\n return num_rows * kai_get_rhs_packed_stride(k, nr, kr, bl);\n}\n\nvoid kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t bl, const uint8_t* rhs,\n const void* zero, const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qai4c32p_params* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n KAI_ASSUME((nr % kai_nr_multiple_of) == 0);\n KAI_ASSUME(extra_bytes == 0);\n\n KAI_ASSUME(sr == 2);\n KAI_ASSUME(kr / sr == 4);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(zero != NULL);\n KAI_ASSUME(scale != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(params != NULL);\n KAI_ASSUME(params->rhs_zero_point == 8);\n KAI_ASSUME(params->lhs_zero_point == 1);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t block_length = kr / sr;\n const size_t num_blocks_per_row = k / bl;\n const size_t rhs_stride = k / 2;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride(k, nr, kr, bl);\n\n const size_t dst_packed_block_size = kai_get_num_bytes_per_block(bl) * nr;\n const size_t dst_block_data_size = bl / 2;\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_bias_offset = num_blocks_per_row * dst_packed_block_size;\n const size_t k_block_length_in_bytes = (block_length * sizeof(uint8_t)) / 2;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n float* dst_row_bias = (float*)(dst_row + dst_bias_offset);\n size_t row_idx = dst_row_idx * nr;\n size_t rows_left = n - row_idx;\n for (size_t block_idx = 0; block_idx < num_blocks_per_row; block_idx++) {\n uint8_t* block_dst_row = dst_row + block_idx * dst_packed_block_size;\n float* block_dst_zp = (float*)(block_dst_row + nr * dst_block_data_size);\n float* block_dst_scale = block_dst_zp + nr;\n size_t k_idx = block_idx * bl;\n for (size_t dst_byte_idx = 0; dst_byte_idx < dst_block_data_size; dst_byte_idx += 8) {\n for (size_t nr_idx = 0; nr_idx <= nr - 4; nr_idx += 4) {\n const size_t n0_idx = KAI_MIN(dst_row_idx * nr + nr_idx, n - 1);\n const size_t n1_idx = KAI_MIN(n0_idx + 1, n - 1);\n const size_t n2_idx = KAI_MIN(n0_idx + 2, n - 1);\n const size_t n3_idx = KAI_MIN(n0_idx + 3, n - 1);\n const uint8_t* src_addr_byte = rhs + (k_idx / 2) + dst_byte_idx;\n\n const uint8x8_t vec0_u8 = vld1_u8(src_addr_byte + n0_idx * rhs_stride);\n const uint8x8_t vec1_u8 = vld1_u8(src_addr_byte + n1_idx * rhs_stride);\n const uint8x8_t vec2_u8 = vld1_u8(src_addr_byte + n2_idx * rhs_stride);\n const uint8x8_t vec3_u8 = vld1_u8(src_addr_byte + n3_idx * rhs_stride);\n\n const uint16x4_t vec0_u16 = vreinterpret_u16_u8(vec0_u8);\n const uint16x4_t vec1_u16 = vreinterpret_u16_u8(vec1_u8);\n const uint16x4_t vec2_u16 = vreinterpret_u16_u8(vec2_u8);\n const uint16x4_t vec3_u16 = vreinterpret_u16_u8(vec3_u8);\n\n const uint16x4_t vec01_lo_u16 = vzip1_u16(vec0_u16, vec1_u16);\n const uint16x4_t vec01_hi_u16 = vzip2_u16(vec0_u16, vec1_u16);\n const uint16x4_t vec23_lo_u16 = vzip1_u16(vec2_u16, vec3_u16);\n const uint16x4_t vec23_hi_u16 = vzip2_u16(vec2_u16, vec3_u16);\n\n const uint32x2_t vec01_lo_u32 = vreinterpret_u32_u16(vec01_lo_u16);\n const uint32x2_t vec01_hi_u32 = vreinterpret_u32_u16(vec01_hi_u16);\n const uint32x2_t vec23_lo_u32 = vreinterpret_u32_u16(vec23_lo_u16);\n const uint32x2_t vec23_hi_u32 = vreinterpret_u32_u16(vec23_hi_u16);\n\n const uint32x2_t vin0_u32 = vzip1_u32(vec01_lo_u32, vec23_lo_u32);\n const uint32x2_t vin1_u32 = vzip2_u32(vec01_lo_u32, vec23_lo_u32);\n const uint32x2_t vin2_u32 = vzip1_u32(vec01_hi_u32, vec23_hi_u32);\n const uint32x2_t vin3_u32 = vzip2_u32(vec01_hi_u32, vec23_hi_u32);\n\n const uint8x8_t vin0_u8 = vreinterpret_u8_u32(vin0_u32);\n const uint8x8_t vin1_u8 = vreinterpret_u8_u32(vin1_u32);\n const uint8x8_t vin2_u8 = vreinterpret_u8_u32(vin2_u32);\n const uint8x8_t vin3_u8 = vreinterpret_u8_u32(vin3_u32);\n\n uint8_t* dst_row_offset = block_dst_row + nr_idx * k_block_length_in_bytes;\n vst1_u8(dst_row_offset, vin0_u8);\n vst1_u8(dst_row_offset + nr * k_block_length_in_bytes, vin1_u8);\n vst1_u8(dst_row_offset + 2 * (nr * k_block_length_in_bytes), vin2_u8);\n vst1_u8(dst_row_offset + 3 * (nr * k_block_length_in_bytes), vin3_u8);\n }\n block_dst_row += nr * sizeof(uint8x8_t);\n }\n\n // Adjust the zero points and scales\n for (size_t i = 0; i < nr; ++i) {\n const size_t src_row_idx = KAI_MIN(row_idx + i, n - 1);\n const size_t src_idx = src_row_idx * num_blocks_per_row + block_idx;\n\n block_dst_scale[i] = ((const float*)scale)[src_idx];\n block_dst_zp[i] = ((const float*)zero)[src_idx];\n }\n }\n // Set the bias\n if (bias == NULL) {\n memset(dst_row_bias, 0, nr * kai_num_bytes_bias);\n } else {\n if (rows_left >= nr) {\n memcpy(dst_row_bias, &((const float*)bias)[row_idx], nr * kai_num_bytes_bias);\n } else {\n // Fill remaining values\n memcpy(dst_row_bias, &((const float*)bias)[row_idx], rows_left * kai_num_bytes_bias);\n // Set leftover to 0\n memset(&dst_row_bias[rows_left], 0, (nr - rows_left) * kai_num_bytes_bias);\n }\n }\n }\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qai4c32p_params\n#define kai_rhs_pack_nxk_qai4c32p_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 K values are stored in one byte. These values are stored in blocks\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, //\n size_t rhs_stride); //\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl //\n);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte.\n/// nrx4 => this function can take in generic nr values but the input is expected to have a block depth of 4\n/// Block depth is calculated as kr / sr. The values of these parameters are defined in the matmul ukernel.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] nr The number of N rows to interleave on the same output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] zero The zero point.\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n const void* zero, //\n const void* bias, //\n const void* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_nxk_qai4c32p_params* params);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa against gemm_qai4c32_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qsi8d32pscalef32_f32_neon.h\"\n#include \"kai_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qsi8d32pscalef32_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* B_zeros_snap = nullptr;\n static size_t B_zeros_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N*(K/BL))\n | refresh_cache(B_zeros_snap, B_zeros_snap_size, B_zeros, sizeof(float)*N*(K/BL))\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon((size_t)N, (size_t)K, nr, kr, BL);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qai4c32ps1s0nrx4_qau4c32s1s0_f32_f32_f32_neon(1, (size_t)N, (size_t)K, nr, kr, sr, BL, B_q4, B_zeros, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qai4c32p4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..1a2d247f9c33c4e0fc150710262594ccb4f8c83d --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json @@ -0,0 +1,76 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qai8_qsi8cx_sme2_n256_k512", + "definition": "gemm_qai8_qsi8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qai8_qsi8cx_sme2_n256_k512: KleidiAI kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa with its x8p2vlx4 LHS and kxn qsi8cxp RHS packers; scales and bias folded into the kernel's static requantization parameters.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_pack_x8p2vlx4_x8_sme to pack the LHS matrix.\n/// -# kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme to pack the RHS matrix.\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets mr value.\n///\n/// This is the packing parameter which must be used to pack the LHS matrix.\n///\n/// @return The mr value.\nsize_t kai_get_mr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets nr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The nr value.\nsize_t kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets kr value.\n///\n/// This is the packing parameter which must be used to pack the LHS and RHS matrix.\n///\n/// @return The kr value.\nsize_t kai_get_kr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets sr value.\n///\n/// This is the packing parameter which must be used to pack the LHS and RHS matrix.\n///\n/// @return The sr value.\nsize_t kai_get_sr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS matrix buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix. Must be a multiple of `m_step`.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of `n_step`.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be a multiple of `m_step`.\n/// @param[in] n_idx Column index. Must be a multiple of `n_step`.\n/// @param[in] dst_stride_row Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride_row);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.\n/// * Packed RHS: @ref kai_get_rhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.\n/// * Output: @ref kai_get_dst_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.\n///\n/// @param[in] m Number of output rows to be computed.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] lhs_packed Packed LHS matrix buffer.\n/// @param[in] rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Row stride in bytes of the output matrix.\n/// @param[in] dst_stride_col Column stride in bytes of the output matrix. Unused\n/// @param[in] params Requantization and clamp parameters.\nvoid kai_run_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, void* dst, size_t dst_stride_row,\n size_t dst_stride_col, const struct kai_matmul_requantize32_params* params);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n#include \"kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n const void* A;\n const void* B;\n void* C;\n uint64_t ldcb;\n uint64_t M;\n uint64_t N;\n uint64_t K;\n int32_t min;\n int32_t max;\n int32_t result_zero_point;\n void* accumulator_buffer;\n uint64_t flags;\n} KernelArgs;\n\nstatic const size_t kai_mr = 2;\nstatic const size_t kai_nr = 2;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n\nvoid kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(KernelArgs* args);\n\n// Returns a constant value specific to this kernel that's relative to vector length\nstatic size_t kai_get_kernel_vec_length_constant(void) {\n const size_t kernel_vec_length_constant = kai_get_sme_vector_length_u8() / kai_kr;\n return kernel_vec_length_constant;\n}\n\nsize_t kai_get_m_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_mr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_n_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_nr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_mr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_mr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_nr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_kr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSUME(m_idx % kai_get_mr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa() == 0);\n return m_idx * kai_roundup(k, kai_kr) * sizeof(int8_t);\n}\n\nstatic size_t kai_get_rhs_packed_stride_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t k) {\n return kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa() *\n (sizeof(int32_t) + kai_roundup(k, kai_kr) * sizeof(int8_t) + sizeof(float));\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t n_idx, size_t k) {\n KAI_ASSUME(n_idx % kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa() == 0);\n const size_t block_idx = n_idx / kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa();\n return block_idx * kai_get_rhs_packed_stride_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride_row) {\n KAI_ASSUME(m_idx % kai_get_m_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa() == 0);\n KAI_ASSUME(n_idx % kai_get_n_step_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa() == 0);\n\n return m_idx * dst_stride_row + n_idx * sizeof(int8_t);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(size_t m, size_t n) {\n return m * n * sizeof(int8_t);\n}\n\nvoid kai_run_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, void* dst, size_t dst_stride_row,\n size_t dst_stride_col, const struct kai_matmul_requantize32_params* params) {\n KAI_UNUSED(dst_stride_col);\n KernelArgs args;\n\n args.A = lhs_packed;\n args.B = rhs_packed;\n args.C = dst;\n args.ldcb = dst_stride_row;\n args.M = m;\n args.N = n;\n args.K = k;\n args.min = params->min_value;\n args.max = params->max_value;\n args.result_zero_point = params->output_zero_point;\n args.accumulator_buffer = NULL;\n args.flags = 0;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x15, #0x0\n ldr x14, [x0, #0x30]\n ptrue p1.b\n KAI_ASM_INST(0x25207810) // ptrue pn8.b\n ldr w13, [x0, #0x20]\n mov x11, #0x0\n ldr w10, [x0, #0x28]\n add x14, x14, #0x3\n ldr x9, [x0, #0x0]\n lsr x14, x14, #0x2\nKAI_ASM_LABEL(label_1) // M loop\n ldr x28, [x0, #0x8]\nKAI_ASM_LABEL(label_2) // N loop\n KAI_ASM_INST(0xa0404382) // ld1w { z2.s-z3.s }, pn8.b/Z, [x28]\n KAI_ASM_INST(0xc00800ff) // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n mov x27, x9\n addvl x28, x28, #2\n KAI_ASM_INST(0xc0902440) // addha za0.s, p1/M, p1/M, z2.s\n KAI_ASM_INST(0xc0902461) // addha za1.s, p1/M, p1/M, z3.s\n KAI_ASM_INST(0xc0902442) // addha za2.s, p1/M, p1/M, z2.s\n KAI_ASM_INST(0xc0902463) // addha za3.s, p1/M, p1/M, z3.s\n lsr x21, x14, #0x2\n and x20, x14, #0x3\n cbz x21, label_6\n subs x21, x21, #0x1\n KAI_ASM_INST(0xa1408362) // ld1b { z2.b, z6.b, z10.b, z14.b }, pn8.b/Z, [x27]\n KAI_ASM_INST(0xa1418360) // ld1b { z0.b, z4.b, z8.b, z12.b }, pn8.b/Z, [x27, #0x4, MUL VL]\n addvl x27, x27, #8\n KAI_ASM_INST(0xa0408390) // ld1b { z16.b-z19.b }, pn8.b/Z, [x28]\n KAI_ASM_INST(0xa041839c) // ld1b { z28.b-z31.b }, pn8.b/Z, [x28, #0x4, MUL VL]\n addvl x28, x28, #8\n ble label_5\nKAI_ASM_LABEL(label_4) // K loop\n KAI_ASM_INST(0xa0902440) // smopa za0.s, p1/M, p1/M, z2.b, z16.b\n subs x21, x21, #0x1\n KAI_ASM_INST(0xa0912441) // smopa za1.s, p1/M, p1/M, z2.b, z17.b\n KAI_ASM_INST(0xa09024c2) // smopa za2.s, p1/M, p1/M, z6.b, z16.b\n KAI_ASM_INST(0xa09124c3) // smopa za3.s, p1/M, p1/M, z6.b, z17.b\n KAI_ASM_INST(0xa0922540) // smopa za0.s, p1/M, p1/M, z10.b, z18.b\n KAI_ASM_INST(0xa0932541) // smopa za1.s, p1/M, p1/M, z10.b, z19.b\n KAI_ASM_INST(0xa09225c2) // smopa za2.s, p1/M, p1/M, z14.b, z18.b\n KAI_ASM_INST(0xa09325c3) // smopa za3.s, p1/M, p1/M, z14.b, z19.b\n KAI_ASM_INST(0xa1408362) // ld1b { z2.b, z6.b, z10.b, z14.b }, pn8.b/Z, [x27]\n KAI_ASM_INST(0xa09c2400) // smopa za0.s, p1/M, p1/M, z0.b, z28.b\n KAI_ASM_INST(0xa0408390) // ld1b { z16.b-z19.b }, pn8.b/Z, [x28]\n KAI_ASM_INST(0xa09d2401) // smopa za1.s, p1/M, p1/M, z0.b, z29.b\n KAI_ASM_INST(0xa09c2482) // smopa za2.s, p1/M, p1/M, z4.b, z28.b\n KAI_ASM_INST(0xa09d2483) // smopa za3.s, p1/M, p1/M, z4.b, z29.b\n KAI_ASM_INST(0xa09e2500) // smopa za0.s, p1/M, p1/M, z8.b, z30.b\n KAI_ASM_INST(0xa09f2501) // smopa za1.s, p1/M, p1/M, z8.b, z31.b\n KAI_ASM_INST(0xa09e2582) // smopa za2.s, p1/M, p1/M, z12.b, z30.b\n KAI_ASM_INST(0xa09f2583) // smopa za3.s, p1/M, p1/M, z12.b, z31.b\n KAI_ASM_INST(0xa1418360) // ld1b { z0.b, z4.b, z8.b, z12.b }, pn8.b/Z, [x27, #0x4, MUL VL]\n addvl x27, x27, #8\n KAI_ASM_INST(0xa041839c) // ld1b { z28.b-z31.b }, pn8.b/Z, [x28, #0x4, MUL VL]\n addvl x28, x28, #8\n bgt label_4\nKAI_ASM_LABEL(label_5) // K loop tail\n KAI_ASM_INST(0xa0902440) // smopa za0.s, p1/M, p1/M, z2.b, z16.b\n KAI_ASM_INST(0xa0912441) // smopa za1.s, p1/M, p1/M, z2.b, z17.b\n KAI_ASM_INST(0xa09024c2) // smopa za2.s, p1/M, p1/M, z6.b, z16.b\n KAI_ASM_INST(0xa09124c3) // smopa za3.s, p1/M, p1/M, z6.b, z17.b\n KAI_ASM_INST(0xa0922540) // smopa za0.s, p1/M, p1/M, z10.b, z18.b\n KAI_ASM_INST(0xa0932541) // smopa za1.s, p1/M, p1/M, z10.b, z19.b\n KAI_ASM_INST(0xa09225c2) // smopa za2.s, p1/M, p1/M, z14.b, z18.b\n KAI_ASM_INST(0xa09325c3) // smopa za3.s, p1/M, p1/M, z14.b, z19.b\n KAI_ASM_INST(0xa09c2400) // smopa za0.s, p1/M, p1/M, z0.b, z28.b\n KAI_ASM_INST(0xa09d2401) // smopa za1.s, p1/M, p1/M, z0.b, z29.b\n KAI_ASM_INST(0xa09c2482) // smopa za2.s, p1/M, p1/M, z4.b, z28.b\n KAI_ASM_INST(0xa09d2483) // smopa za3.s, p1/M, p1/M, z4.b, z29.b\n KAI_ASM_INST(0xa09e2500) // smopa za0.s, p1/M, p1/M, z8.b, z30.b\n KAI_ASM_INST(0xa09f2501) // smopa za1.s, p1/M, p1/M, z8.b, z31.b\n KAI_ASM_INST(0xa09e2582) // smopa za2.s, p1/M, p1/M, z12.b, z30.b\n KAI_ASM_INST(0xa09f2583) // smopa za3.s, p1/M, p1/M, z12.b, z31.b\nKAI_ASM_LABEL(label_6) // K oddments\n cbz x20, label_8\nKAI_ASM_LABEL(label_7) // K oddments: Loop\n KAI_ASM_INST(0xa0400370) // ld1b { z16.b-z17.b }, pn8.b/Z, [x27]\n subs x20, x20, #0x1\n addvl x27, x27, #2\n KAI_ASM_INST(0xa1400385) // ld1b { z5.b, z13.b }, pn8.b/Z, [x28]\n addvl x28, x28, #2\n KAI_ASM_INST(0xa0852600) // smopa za0.s, p1/M, p1/M, z16.b, z5.b\n KAI_ASM_INST(0xa08d2601) // smopa za1.s, p1/M, p1/M, z16.b, z13.b\n KAI_ASM_INST(0xa0852622) // smopa za2.s, p1/M, p1/M, z17.b, z5.b\n KAI_ASM_INST(0xa08d2623) // smopa za3.s, p1/M, p1/M, z17.b, z13.b\n bgt label_7\nKAI_ASM_LABEL(label_8) // K oddments: End\n ldr x26, [x0, #0x10]\n sub x25, x13, x15\n cntw x24\n KAI_ASM_INST(0x854ec41a) // ld1rw { z26.s }, p1/Z, [x0, #56]\n ldr x23, [x0, #0x18]\n whilelt p0.h, x11, x10\n cmp x25, x24\n KAI_ASM_INST(0x854fc417) // ld1rw { z23.s }, p1/Z, [x0, #60]\n csel x22, x25, x24, LT\n KAI_ASM_INST(0x8550c400) // ld1rw { z0.s }, p1/Z, [x0, #64]\n mov x12, #0x0\n add x26, x26, x11 // C += n\n lsr x21, x22, #0x2\n KAI_ASM_INST(0xa0404382) // ld1w { z2.s-z3.s }, pn8.b/Z, [x28]\n madd x26, x15, x23, x26 // C += m * ldc\n addvl x28, x28, #2\n and x20, x22, #0x3\n cbz x21, label_11\nKAI_ASM_LABEL(label_10) // Store to output array: Accumulator row 0 loop\n KAI_ASM_INST(0xc0860408) // mova { z8.s-z11.s }, za0h.s[x12]\n KAI_ASM_INST(0xc0860430) // mova { z16.s-z19.s }, za1h.s[x12]\n KAI_ASM_INST(0xc132e108) // scvtf { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc132e210) // scvtf { z16.s-z19.s }, { z16.s-z19.s }\n fmul z8.s, z8.s, z2.s\n fmul z9.s, z9.s, z2.s\n add x12, x12, #0x4\n fmul z10.s, z10.s, z2.s\n fmul z11.s, z11.s, z2.s\n cmp x12, x21, LSL #2\n fmul z16.s, z16.s, z3.s\n fmul z17.s, z17.s, z3.s\n fmul z18.s, z18.s, z3.s\n fmul z19.s, z19.s, z3.s\n KAI_ASM_INST(0xc1b8e108) // frintn { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc131e108) // fcvtzs { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc1b8e210) // frintn { z16.s-z19.s }, { z16.s-z19.s }\n KAI_ASM_INST(0xc1a0ab08) // add { z8.s-z11.s }, { z8.s-z11.s }, z0.s\n KAI_ASM_INST(0xc131e210) // fcvtzs { z16.s-z19.s }, { z16.s-z19.s }\n KAI_ASM_INST(0xc1a0ab10) // add { z16.s-z19.s }, { z16.s-z19.s }, z0.s\n KAI_ASM_INST(0xc1b7cf48) // sclamp { z8.s-z11.s }, z26.s, z23.s\n KAI_ASM_INST(0xc1b7cf50) // sclamp { z16.s-z19.s }, z26.s, z23.s\n uzp1 z5.h, z8.h, z16.h\n uzp1 z14.h, z9.h, z17.h\n uzp1 z17.h, z10.h, z18.h\n uzp1 z16.h, z11.h, z19.h\n st1b { z5.h }, p0, [x26]\n add x26, x26, x23\n st1b { z14.h }, p0, [x26]\n add x26, x26, x23\n st1b { z17.h }, p0, [x26]\n add x26, x26, x23\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n blt label_10\nKAI_ASM_LABEL(label_11) // Store to output array: Accumulator row 0 oddments\n cbz x20, label_12\n KAI_ASM_INST(0xc0860408) // mova { z8.s-z11.s }, za0h.s[x12]\n KAI_ASM_INST(0xc086042c) // mova { z12.s-z15.s }, za1h.s[x12]\n KAI_ASM_INST(0xc132e108) // scvtf { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc132e18c) // scvtf { z12.s-z15.s }, { z12.s-z15.s }\n fmul z8.s, z8.s, z2.s\n fmul z9.s, z9.s, z2.s\n subs x20, x20, #0x1\n fmul z10.s, z10.s, z2.s\n fmul z11.s, z11.s, z2.s\n fmul z12.s, z12.s, z3.s\n fmul z13.s, z13.s, z3.s\n fmul z14.s, z14.s, z3.s\n fmul z15.s, z15.s, z3.s\n KAI_ASM_INST(0xc1b8e108) // frintn { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc131e108) // fcvtzs { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc1b8e18c) // frintn { z12.s-z15.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc1a0ab08) // add { z8.s-z11.s }, { z8.s-z11.s }, z0.s\n KAI_ASM_INST(0xc131e18c) // fcvtzs { z12.s-z15.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc1a0ab0c) // add { z12.s-z15.s }, { z12.s-z15.s }, z0.s\n KAI_ASM_INST(0xc1b7cf48) // sclamp { z8.s-z11.s }, z26.s, z23.s\n KAI_ASM_INST(0xc1b7cf4c) // sclamp { z12.s-z15.s }, z26.s, z23.s\n uzp1 z16.h, z8.h, z12.h\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n beq label_12\n subs x20, x20, #0x1\n uzp1 z16.h, z9.h, z13.h\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n beq label_12\n uzp1 z16.h, z10.h, z14.h\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\nKAI_ASM_LABEL(label_12) // Store to output array: Accumulator row 0 oddments: End\n subs x25, x25, x22\n beq label_16\n cmp x25, x24\n mov x12, #0x0\n csel x20, x25, x24, LT\n lsr x21, x20, #0x2\n and x20, x20, #0x3\n cbz x21, label_14\nKAI_ASM_LABEL(label_13) // Store to output array: Accumulator row 1 loop\n KAI_ASM_INST(0xc0860448) // mova { z8.s-z11.s }, za2h.s[x12]\n KAI_ASM_INST(0xc0860470) // mova { z16.s-z19.s }, za3h.s[x12]\n KAI_ASM_INST(0xc132e108) // scvtf { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc132e210) // scvtf { z16.s-z19.s }, { z16.s-z19.s }\n fmul z8.s, z8.s, z2.s\n fmul z9.s, z9.s, z2.s\n add x12, x12, #0x4\n fmul z10.s, z10.s, z2.s\n fmul z11.s, z11.s, z2.s\n cmp x12, x21, LSL #2\n fmul z16.s, z16.s, z3.s\n fmul z17.s, z17.s, z3.s\n fmul z18.s, z18.s, z3.s\n fmul z19.s, z19.s, z3.s\n KAI_ASM_INST(0xc1b8e108) // frintn { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc131e108) // fcvtzs { z8.s-z11.s }, { z8.s-z11.s }\n KAI_ASM_INST(0xc1b8e210) // frintn { z16.s-z19.s }, { z16.s-z19.s }\n KAI_ASM_INST(0xc1a0ab08) // add { z8.s-z11.s }, { z8.s-z11.s }, z0.s\n KAI_ASM_INST(0xc131e210) // fcvtzs { z16.s-z19.s }, { z16.s-z19.s }\n KAI_ASM_INST(0xc1a0ab10) // add { z16.s-z19.s }, { z16.s-z19.s }, z0.s\n KAI_ASM_INST(0xc1b7cf48) // sclamp { z8.s-z11.s }, z26.s, z23.s\n KAI_ASM_INST(0xc1b7cf50) // sclamp { z16.s-z19.s }, z26.s, z23.s\n uzp1 z21.h, z8.h, z16.h\n uzp1 z20.h, z9.h, z17.h\n uzp1 z17.h, z10.h, z18.h\n uzp1 z16.h, z11.h, z19.h\n st1b { z21.h }, p0, [x26]\n add x26, x26, x23\n st1b { z20.h }, p0, [x26]\n add x26, x26, x23\n st1b { z17.h }, p0, [x26]\n add x26, x26, x23\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n blt label_13\nKAI_ASM_LABEL(label_14) // Store to output array: Accumulator row 1 oddments\n cbz x20, label_15\n KAI_ASM_INST(0xc086044c) // mova { z12.s-z15.s }, za2h.s[x12]\n KAI_ASM_INST(0xc0860464) // mova { z4.s-z7.s }, za3h.s[x12]\n KAI_ASM_INST(0xc132e18c) // scvtf { z12.s-z15.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc132e084) // scvtf { z4.s-z7.s }, { z4.s-z7.s }\n fmul z12.s, z12.s, z2.s\n fmul z13.s, z13.s, z2.s\n subs x20, x20, #0x1\n fmul z14.s, z14.s, z2.s\n fmul z15.s, z15.s, z2.s\n fmul z4.s, z4.s, z3.s\n fmul z5.s, z5.s, z3.s\n fmul z6.s, z6.s, z3.s\n fmul z7.s, z7.s, z3.s\n KAI_ASM_INST(0xc1b8e18c) // frintn { z12.s-z15.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc131e18c) // fcvtzs { z12.s-z15.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc1b8e084) // frintn { z4.s-z7.s }, { z4.s-z7.s }\n KAI_ASM_INST(0xc1a0ab0c) // add { z12.s-z15.s }, { z12.s-z15.s }, z0.s\n KAI_ASM_INST(0xc131e084) // fcvtzs { z4.s-z7.s }, { z4.s-z7.s }\n KAI_ASM_INST(0xc1a0ab04) // add { z4.s-z7.s }, { z4.s-z7.s }, z0.s\n KAI_ASM_INST(0xc1b7cf4c) // sclamp { z12.s-z15.s }, z26.s, z23.s\n KAI_ASM_INST(0xc1b7cf44) // sclamp { z4.s-z7.s }, z26.s, z23.s\n uzp1 z16.h, z12.h, z4.h\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n beq label_15\n subs x20, x20, #0x1\n uzp1 z16.h, z13.h, z5.h\n st1b { z16.h }, p0, [x26]\n add x26, x26, x23\n beq label_15\n uzp1 z16.h, z14.h, z6.h\n st1b { z16.h }, p0, [x26]\nKAI_ASM_LABEL(label_15) // Store to output array: Accumulator row 1 oddments: End\nKAI_ASM_LABEL(label_16) // Store to output array: End\n incw x11, ALL, MUL #2\n cmp x11, x10\n blt label_2\n incw x15, ALL, MUL #2\n mov x11, #0x0\n cmp x15, x13\n mov x9, x27\n blt label_1\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_pack_x8p2vlx4_x8_sme.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @param[in] mr Number of rows to be interleaved.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_pack_x8p2vlx4_x8_sme(size_t mr);\n\n/// Gets the offset in bytes to the data element in the LHS buffer.\n///\n/// @param[in] m_idx Row index.\n/// @param[in] lhs_stride_row Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_offset_lhs_pack_x8p2vlx4_x8_sme(size_t m_idx, size_t lhs_stride_row);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Unused. Must be 4.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_pack_x8p2vlx4_x8_sme(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Number of rows to be interleaved.\n/// @param[in] kr Unused. Must be 4.\n/// @param[in] sr Unused. Must be 1.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_pack_x8p2vlx4_x8_sme(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Runs the LHS packing function for matrix multiplication.\n///\n/// The pointer of each buffers (LHS and packed LHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * LHS: @ref kai_get_lhs_offset_lhs_pack_x8p2vlx4_x8_sme.\n/// * Packed LHS: @ref kai_get_lhs_packed_offset_lhs_pack_x8p2vlx4_x8_sme.\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k Number of columns in the unpacked LHS matrix.\n/// @param[in] mr Block size in M dimension. It must be kai_get_m_step_lhs_pack_x8p2vlx4_x8_sme().\n/// @param[in] kr Block size in K dimension. It must be 4.\n/// @param[in] sr Number of kr splits. It must be 1.\n/// @param[in] m_idx_start Unused. Must be 0.\n/// @param[in] lhs LHS matrix data buffer.\n/// @param[in] lhs_stride_row Row stride in bytes of the LHS matrix.\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_pack_x8p2vlx4_x8_sme(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride_row,\n void* lhs_packed);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_pack_x8p2vlx4_x8_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n#include \"kai_lhs_pack_x8p2vlx4_x8_sme.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nenum {\n MR = 2,\n KR = 4,\n MAX_M_STEP = MR * (KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(int8_t)) / KR,\n SR = 1,\n};\n\nvoid kai_kernel_lhs_pack_x8p2vlx4_x8_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t kai_get_mr_lhs_pack_x8p2vlx4_x8_sme(void) {\n return MR * kai_get_sme_vector_length_u8() / KR;\n}\n\nsize_t kai_get_m_step_lhs_pack_x8p2vlx4_x8_sme(size_t mr) {\n KAI_ASSUME(mr == kai_get_mr_lhs_pack_x8p2vlx4_x8_sme());\n KAI_UNUSED(mr);\n return kai_get_mr_lhs_pack_x8p2vlx4_x8_sme();\n}\n\nsize_t kai_get_lhs_offset_lhs_pack_x8p2vlx4_x8_sme(size_t m_idx, size_t lhs_stride_row) {\n KAI_ASSUME(m_idx % kai_get_mr_lhs_pack_x8p2vlx4_x8_sme() == 0);\n\n return m_idx * lhs_stride_row;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_pack_x8p2vlx4_x8_sme(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME(m_idx % kai_get_m_step_lhs_pack_x8p2vlx4_x8_sme(mr) == 0);\n KAI_ASSUME(mr == kai_get_mr_lhs_pack_x8p2vlx4_x8_sme());\n KAI_ASSUME(kr == KR);\n KAI_ASSUME(sr == SR);\n\n KAI_UNUSED(mr);\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n return m_idx * kai_roundup(k, KR) * sizeof(int8_t);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_pack_x8p2vlx4_x8_sme(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME(mr == kai_get_mr_lhs_pack_x8p2vlx4_x8_sme());\n KAI_ASSUME(kr == KR);\n KAI_ASSUME(sr == SR);\n\n KAI_UNUSED(mr);\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n return kai_roundup(m, kai_get_mr_lhs_pack_x8p2vlx4_x8_sme()) * kai_roundup(k, KR) * sizeof(int8_t);\n}\n\nvoid kai_run_lhs_pack_x8p2vlx4_x8_sme(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const void* lhs, size_t lhs_stride_row,\n void* lhs_packed) {\n KAI_ASSUME(mr == kai_get_mr_lhs_pack_x8p2vlx4_x8_sme());\n KAI_ASSUME(kr == KR);\n KAI_ASSUME(sr == SR);\n KAI_ASSUME(m_idx_start == 0);\n KAI_ASSUME(lhs != NULL);\n KAI_ASSUME(lhs_packed != NULL);\n\n const size_t m_step = kai_get_mr_lhs_pack_x8p2vlx4_x8_sme();\n const size_t width = k;\n\n KAI_ASSERT(m_step <= MAX_M_STEP);\n const uint8_t* in[MAX_M_STEP];\n\n uint8_t* out_base = lhs_packed;\n const uint8_t* lhs_ptr = lhs;\n\n kai_commit_za();\n\n for (size_t i_m = 0; i_m < m; i_m += m_step) {\n const size_t height = KAI_MIN(m - i_m, m_step);\n void* out = out_base;\n out_base += m_step * kai_roundup(k, KR) * sizeof(int8_t);\n\n for (size_t y = 0; y < height; y++) {\n in[y] = lhs_ptr + (i_m + y) * lhs_stride_row;\n }\n\n kai_kernel_lhs_pack_x8p2vlx4_x8_sme(\n height, width, in, out); // NOLINT(bugprone-multi-level-implicit-pointer-conversion)\n }\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_pack_x8p2vlx4_x8_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(lhs_pack_x8p2vlx4_x8_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_lhs_pack_x8p2vlx4_x8_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_lhs_pack_x8p2vlx4_x8_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_lhs_pack_x8p2vlx4_x8_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x12, #0x0\n cntb x21\n mov x23, x1\n incb x23\n mov x20, x1\n sub x8, x21, #0x1\n cntw x17\n sub x23, x23, #0x1\n ands x8, x20, x8\n udiv x23, x23, x21 // n_passes = ceildiv(width, VL)\n csel x8, x8, x21, NE\n lsl x22, x0, #0x1 // height * 2\n lsl x21, x17, #0x1\n sub x20, x23, #0x1\n add x8, x8, #0x3\n sub x16, x17, #0x2\n whilelt p9.b, XZR, x22\n whilelt p8.b, x21, x22\n mov x11, #0x0\n mov x10, x2\n add x9, x2, x17, LSL #3\n cntw x28, ALL, MUL #2\n cntw x27, ALL, MUL #3\n ldr x26, [x10, #0x0]\n lsr x20, x20, #0x1 // n_loops = (n_passes - 1) / 2\n and x25, x23, #0x1 // odd_tail = bool(n_passes & 0x1)\n ldr x24, [x9, #0x0]\n lsr x8, x8, #0x2\n ptrue p11.s\n ldr x23, [x10, #0x8]\n zip1 p10.b, p9.b, p8.b\n mov x22, x12\n ldr x21, [x9, #0x8]\n whilelt p9.b, x11, x1\n whilelt p8.b, x11, x1\n add x10, x10, #0x10\n add x9, x9, #0x10\n mov x12, #0x0\n cbz x16, label_2\nKAI_ASM_LABEL(label_1) // K loop: Charge: Loop\n KAI_ASM_INST(0x25246143) // psel p3.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x252c6142) // psel p2.b, p8.b/Z, p10.b[w12, #1]\n KAI_ASM_INST(0x25646141) // psel p1.b, p8.b/Z, p10.b[w12, #4]\n KAI_ASM_INST(0x256c6140) // psel p0.b, p8.b/Z, p10.b[w12, #5]\n KAI_ASM_INST(0xe0160f40) // ld1b { za0h.b[x12] }, p3/Z, [x26, x22]\n ldr x26, [x10, #0x0]\n KAI_ASM_INST(0xe0160b01) // ld1b { za0h.b[x12, #1] }, p2/Z, [x24, x22]\n ldr x24, [x9, #0x0]\n KAI_ASM_INST(0xe01606e4) // ld1b { za0h.b[x12, #4] }, p1/Z, [x23, x22]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01602a5) // ld1b { za0h.b[x12, #5] }, p0/Z, [x21, x22]\n add x12, x12, #0x8\n ldr x21, [x9, #0x8]\n add x9, x9, #0x10\n cmp x12, x16, LSL #2\n blt label_1\nKAI_ASM_LABEL(label_2) // K loop: Charge: End\n KAI_ASM_INST(0x25246143) // psel p3.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x252c6142) // psel p2.b, p8.b/Z, p10.b[w12, #1]\n KAI_ASM_INST(0x25646141) // psel p1.b, p8.b/Z, p10.b[w12, #4]\n KAI_ASM_INST(0x256c6140) // psel p0.b, p8.b/Z, p10.b[w12, #5]\n mov x10, x2\n add x9, x2, x17, LSL #3\n KAI_ASM_INST(0xe0160f40) // ld1b { za0h.b[x12] }, p3/Z, [x26, x22]\n ldr x26, [x10, #0x0]\n incb x11\n KAI_ASM_INST(0xe0160b01) // ld1b { za0h.b[x12, #1] }, p2/Z, [x24, x22]\n ldr x24, [x9, #0x0]\n KAI_ASM_INST(0xe01606e4) // ld1b { za0h.b[x12, #4] }, p1/Z, [x23, x22]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01602a5) // ld1b { za0h.b[x12, #5] }, p0/Z, [x21, x22]\n ldr x21, [x9, #0x8]\n add x9, x9, #0x10\n incb x22\n cbz x20, label_8\n mov x20, x20\nKAI_ASM_LABEL(label_3) // K loop: Main loop\n whilelt p8.b, x11, x1\n mov x15, #0x0\n mov x14, #0x0\n cbz x16, label_5\nKAI_ASM_LABEL(label_4) // K loop: Main loop: First: Loop\n KAI_ASM_INST(0x25376143) // psel p3.b, p8.b/Z, p10.b[w15, #2]\n KAI_ASM_INST(0x253f6142) // psel p2.b, p8.b/Z, p10.b[w15, #3]\n KAI_ASM_INST(0x25776141) // psel p1.b, p8.b/Z, p10.b[w15, #6]\n KAI_ASM_INST(0x257f6140) // psel p0.b, p8.b/Z, p10.b[w15, #7]\n KAI_ASM_INST(0xe0166f42) // ld1b { za0h.b[x15, #2] }, p3/Z, [x26, x22]\n KAI_ASM_INST(0x25266d23) // psel p3.b, p11.b/Z, p9.b[w14]\n ldr x26, [x10, #0x0]\n KAI_ASM_INST(0xe0166b03) // ld1b { za0h.b[x15, #3] }, p2/Z, [x24, x22]\n KAI_ASM_INST(0x25266d22) // psel p2.b, p11.b/Z, p9.b[w14]\n ldr x24, [x9, #0x0]\n KAI_ASM_INST(0xe01666e6) // ld1b { za0h.b[x15, #6] }, p1/Z, [x23, x22]\n KAI_ASM_INST(0x252e6d21) // psel p1.b, p11.b/Z, p9.b[w14, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01662a7) // ld1b { za0h.b[x15, #7] }, p0/Z, [x21, x22]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0bfcc60) // st1w { za0v.s[x14] }, p3/Z, [x3, XZR, LSL #2]\n add x15, x15, #0x8\n KAI_ASM_INST(0xe0b1c864) // st1w { za1v.s[x14] }, p2/Z, [x3, x17, LSL #2]\n KAI_ASM_INST(0xe0bcc461) // st1w { za0v.s[x14, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0bbc065) // st1w { za1v.s[x14, #1] }, p0/Z, [x3, x27, LSL #2]\n add x14, x14, #0x2\n addvl x3, x3, #4\n cmp x14, x16\n blt label_4\nKAI_ASM_LABEL(label_5) // K loop: Main loop: First: Tail\n KAI_ASM_INST(0x25376143) // psel p3.b, p8.b/Z, p10.b[w15, #2]\n KAI_ASM_INST(0x253f6142) // psel p2.b, p8.b/Z, p10.b[w15, #3]\n KAI_ASM_INST(0x25776141) // psel p1.b, p8.b/Z, p10.b[w15, #6]\n KAI_ASM_INST(0x257f6140) // psel p0.b, p8.b/Z, p10.b[w15, #7]\n mov x10, x2\n add x9, x2, x17, LSL #3\n KAI_ASM_INST(0xe0166f42) // ld1b { za0h.b[x15, #2] }, p3/Z, [x26, x22]\n KAI_ASM_INST(0x25266d23) // psel p3.b, p11.b/Z, p9.b[w14]\n ldr x26, [x10, #0x0]\n mov x13, #0x0\n KAI_ASM_INST(0xe0166b03) // ld1b { za0h.b[x15, #3] }, p2/Z, [x24, x22]\n KAI_ASM_INST(0x25266d22) // psel p2.b, p11.b/Z, p9.b[w14]\n ldr x24, [x9, #0x0]\n mov x12, #0x0\n KAI_ASM_INST(0xe01666e6) // ld1b { za0h.b[x15, #6] }, p1/Z, [x23, x22]\n KAI_ASM_INST(0x252e6d21) // psel p1.b, p11.b/Z, p9.b[w14, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01662a7) // ld1b { za0h.b[x15, #7] }, p0/Z, [x21, x22]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n whilelt p9.b, x11, x1\n KAI_ASM_INST(0xe0bfcc60) // st1w { za0v.s[x14] }, p3/Z, [x3, XZR, LSL #2]\n incb x11\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0b1c864) // st1w { za1v.s[x14] }, p2/Z, [x3, x17, LSL #2]\n incb x22\n whilelt p8.b, x11, x1\n KAI_ASM_INST(0xe0bcc461) // st1w { za0v.s[x14, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0bbc065) // st1w { za1v.s[x14, #1] }, p0/Z, [x3, x27, LSL #2]\n addvl x3, x3, #4\n cbz x16, label_7\nKAI_ASM_LABEL(label_6) // K loop: Main loop: Second: Loop\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x252d6142) // psel p2.b, p8.b/Z, p10.b[w13, #1]\n KAI_ASM_INST(0x25656141) // psel p1.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x256d6140) // psel p0.b, p8.b/Z, p10.b[w13, #5]\n KAI_ASM_INST(0xe0162f40) // ld1b { za0h.b[x13] }, p3/Z, [x26, x22]\n KAI_ASM_INST(0x25246d23) // psel p3.b, p11.b/Z, p9.b[w12]\n ldr x26, [x10, #0x0]\n KAI_ASM_INST(0xe0162b01) // ld1b { za0h.b[x13, #1] }, p2/Z, [x24, x22]\n KAI_ASM_INST(0x25246d22) // psel p2.b, p11.b/Z, p9.b[w12]\n ldr x24, [x9, #0x0]\n KAI_ASM_INST(0xe01626e4) // ld1b { za0h.b[x13, #4] }, p1/Z, [x23, x22]\n KAI_ASM_INST(0x252c6d21) // psel p1.b, p11.b/Z, p9.b[w12, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01622a5) // ld1b { za0h.b[x13, #5] }, p0/Z, [x21, x22]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0bf8c68) // st1w { za2v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n add x13, x13, #0x8\n KAI_ASM_INST(0xe0b1886c) // st1w { za3v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n KAI_ASM_INST(0xe0bc8469) // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0bb806d) // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x27, LSL #2]\n add x12, x12, #0x2\n addvl x3, x3, #4\n cmp x12, x16\n blt label_6\nKAI_ASM_LABEL(label_7) // K loop: Main loop: Second: Tail\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x252d6142) // psel p2.b, p8.b/Z, p10.b[w13, #1]\n KAI_ASM_INST(0x25656141) // psel p1.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x256d6140) // psel p0.b, p8.b/Z, p10.b[w13, #5]\n mov x10, x2\n add x9, x2, x17, LSL #3\n KAI_ASM_INST(0xe0162f40) // ld1b { za0h.b[x13] }, p3/Z, [x26, x22]\n KAI_ASM_INST(0x25246d23) // psel p3.b, p11.b/Z, p9.b[w12]\n ldr x26, [x10, #0x0]\n KAI_ASM_INST(0xe0162b01) // ld1b { za0h.b[x13, #1] }, p2/Z, [x24, x22]\n KAI_ASM_INST(0x25246d22) // psel p2.b, p11.b/Z, p9.b[w12]\n ldr x24, [x9, #0x0]\n KAI_ASM_INST(0xe01626e4) // ld1b { za0h.b[x13, #4] }, p1/Z, [x23, x22]\n KAI_ASM_INST(0x252c6d21) // psel p1.b, p11.b/Z, p9.b[w12, #1]\n ldr x23, [x10, #0x8]\n add x10, x10, #0x10\n KAI_ASM_INST(0xe01622a5) // ld1b { za0h.b[x13, #5] }, p0/Z, [x21, x22]\n ldr x21, [x9, #0x8]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n whilelt p9.b, x11, x1\n KAI_ASM_INST(0xe0bf8c68) // st1w { za2v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n subs x20, x20, #0x1\n add x9, x9, #0x10\n KAI_ASM_INST(0xe0b1886c) // st1w { za3v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n incb x11\n incb x22\n KAI_ASM_INST(0xe0bc8469) // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n KAI_ASM_INST(0xe0bb806d) // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x27, LSL #2]\n addvl x3, x3, #4\n bgt label_3\nKAI_ASM_LABEL(label_8) // K loop: Tails\n cbnz x25, label_11\n mov x10, x2\n whilelt p8.b, x11, x1\n mov x13, #0x0\n mov x12, #0x0\nKAI_ASM_LABEL(label_9) // K loop: Tails: Even: First\n KAI_ASM_INST(0x25306d23) // psel p3.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25306d22) // psel p2.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25356141) // psel p1.b, p8.b/Z, p10.b[w13, #2]\n KAI_ASM_INST(0x253d6140) // psel p0.b, p8.b/Z, p10.b[w13, #3]\n KAI_ASM_INST(0xe0bf8c60) // st1w { za0v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b18864) // st1w { za1v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #2\n ldr x21, [x10, #0x0]\n cmp x12, x17\n ldr x20, [x10, x17, LSL #0x3]\n add x10, x10, #0x8\n KAI_ASM_INST(0xe01626a2) // ld1b { za0h.b[x13, #2] }, p1/Z, [x21, x22]\n KAI_ASM_INST(0xe0162283) // ld1b { za0h.b[x13, #3] }, p0/Z, [x20, x22]\n add x13, x13, #0x4\n blt label_9\n whilelt p9.b, x11, x1\n whilelt p8.b, x11, x1\n mov x20, #0x0\n mov x12, #0x0\nKAI_ASM_LABEL(label_10) // K loop: Tails: Even: Second\n KAI_ASM_INST(0x25306d21) // psel p1.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n add x20, x20, #0x4\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b1806c) // st1w { za3v.s[x12] }, p0/Z, [x3, x17, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #2\n cmp x12, x8\n blt label_10\n whilelt p8.b, x11, x1\n b label_13\nKAI_ASM_LABEL(label_11) // K loop: Tails: Odd\n mov x12, #0x0\nKAI_ASM_LABEL(label_12) // K loop: Tails: Odd: Loop\n KAI_ASM_INST(0x25306d21) // psel p1.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0xe0bf8460) // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0b18064) // st1w { za1v.s[x12] }, p0/Z, [x3, x17, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #2\n cmp x12, x8\n blt label_12\nKAI_ASM_LABEL(label_13) // K loop: End\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_lhs_pack_x8p2vlx4_x8_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(void);\n\n/// Gets the offset in bytes to the data element in the RHS matrix buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the bias buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_bias_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx);\n\n/// Gets row stride in bytes of the packed RHS matrix.\n///\n/// @param[in] k Number of rows.\n///\n/// @return Row stride in bytes.\nsize_t kai_get_rhs_packed_stride_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t k);\n\n/// Gets the offset in bytes to the data element in the scale buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_scale_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the packed RHS buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n/// @param[in] k Number of rows.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx, size_t k);\n\n/// Gets the size in bytes of the packed RHS buffer.\n///\n/// @param[in] n Number of columns.\n/// @param[in] k Number of rows.\n///\n/// @return The size in bytes of the packed RHS buffer.\nsize_t kai_get_rhs_packed_size_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n, size_t k);\n\n/// Runs the RHS packing function for matrix multiplication.\n///\n/// The pointer of each buffer (RHS, bias and packed RHS) needs to be added with offset\n/// calculated using the following functions:\n///\n/// * RHS: @ref kai_get_rhs_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.\n/// * Bias: @ref kai_get_bias_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.\n/// * Scale: @ref kai_get_scale_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.\n/// * Output: @ref kai_get_rhs_packed_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.\n///\n/// @param[in] num_groups Number of groups. It must be 1.\n/// @param[in] n Number of columns of the output matrix.\n/// @param[in] k Number of rows.\n/// @param[in] nr Block size in N dimension. It must be `get_n_step`\n/// @param[in] kr Block size in K dimension. It must be 4.\n/// @param[in] sr Number of kr splits. It must be 1.\n/// @param[in] rhs_stride_row Row stride in bytes of the RHS matrix.\n/// @param[in] rhs RHS matrix data buffer.\n/// @param[in] bias Bias matrix data buffer.\n/// @param[in] scale Scale data buffer.\n/// @param[out] rhs_packed Packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix. It must be 0.\n/// @param[in] params Extra quantization packing parameters.\nvoid kai_run_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t rhs_stride_row, const void* rhs,\n const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_qsi8cx_params* params);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nenum {\n NR = 2,\n KR = 4,\n MAX_N_STEP = NR * ((KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(uint8_t)) / KR),\n};\n\ntypedef struct {\n const void* bias_ptr;\n const void* scale_ptr;\n int32_t input_zero_point;\n float scale_multiplier;\n size_t width;\n size_t height;\n size_t in_stride;\n size_t out_stride;\n const void* in;\n void* out;\n const void* pad_row;\n} KernelArgs;\n\nstatic const size_t kai_num_bytes_input = sizeof(uint8_t);\nstatic const size_t kai_num_bytes_output = sizeof(uint8_t);\nstatic const size_t kai_num_bytes_bias = sizeof(int32_t);\nstatic const size_t kai_num_bytes_scale = sizeof(float);\n\nvoid kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(const KernelArgs* args_ptr);\n\nsize_t kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(void) {\n return NR * kai_get_sme_vector_length_u8() / KR;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx) {\n KAI_ASSUME(n_idx % kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme() == 0);\n\n return n_idx * kai_num_bytes_input;\n}\n\nsize_t kai_get_bias_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx) {\n return n_idx * kai_num_bytes_bias;\n}\n\nsize_t kai_get_scale_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx) {\n return n_idx * kai_num_bytes_scale;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t k) {\n return kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme() *\n (kai_num_bytes_bias + kai_roundup(k, KR) * kai_num_bytes_output + kai_num_bytes_scale);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n_idx, size_t k) {\n KAI_ASSUME(n_idx % kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme() == 0);\n\n const size_t block_idx = n_idx / kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme();\n return block_idx * kai_get_rhs_packed_stride_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(k);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(size_t n, size_t k) {\n const size_t n_nr_blocks = kai_roundup(n, kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme());\n return kai_get_rhs_packed_offset_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(n_nr_blocks, k);\n}\n\nvoid kai_run_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t rhs_stride_row, const void* rhs,\n const void* bias, const void* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_qsi8cx_params* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME(nr == kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme());\n KAI_ASSUME(kr == KR);\n KAI_ASSUME(sr == 1);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(bias != NULL);\n KAI_ASSUME(scale != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(extra_bytes == 0);\n KAI_ASSUME(params != NULL);\n\n KAI_ASSERT(kai_get_n_step_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme() <= MAX_N_STEP);\n static const uint8_t pad_row[MAX_N_STEP] = {0};\n\n KernelArgs args;\n args.bias_ptr = bias;\n args.scale_ptr = scale;\n args.height = k;\n args.width = n;\n args.in = rhs;\n args.out = rhs_packed;\n args.in_stride = rhs_stride_row;\n args.out_stride = kai_get_rhs_packed_stride_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(args.height);\n args.input_zero_point = params->lhs_zero_point;\n args.scale_multiplier = params->scale_multiplier;\n args.pad_row = pad_row;\n\n kai_commit_za();\n\n kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x4, [x0, #0x20]\n ptrue p2.b\n ldr x5, [x0, #0x40]\n ldr x6, [x0, #0x0]\n mov x7, x4\n ldr x8, [x0, #0x8]\n cmp x7, #0x8\n ldr w17, [x0, #0x10]\n mov x16, x5\n ldr w15, [x0, #0x14]\n incb x5, ALL, MUL #2\n ldr x14, [x0, #0x18]\n ldr x13, [x0, #0x28]\n ldr x12, [x0, #0x30]\n ldr x11, [x0, #0x38]\n ldr x10, [x0, #0x48]\n blt label_4\nKAI_ASM_LABEL(label_1) // Main row loop: Head\n mov x9, x11\n mov x28, x5\n add x27, x9, x13\n sub x7, x7, #0x8\n add x26, x27, x13\n mov x24, x14\n add x25, x26, x13\n add x23, x25, x13\n add x22, x23, x13\n add x21, x22, x13\n add x20, x21, x13\n add x11, x20, x13\nKAI_ASM_LABEL(label_2) // Main row loop: Column loop\n whilelt p0.b, XZR, x24\n decw x24, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x9]\n cmp x24, #0x0\n incd x9, ALL, MUL #4\n ld1b { z22.b }, p0/Z, [x27]\n incd x27, ALL, MUL #4\n ld1b { z17.b }, p0/Z, [x26]\n incd x26, ALL, MUL #4\n ld1b { z16.b }, p0/Z, [x25]\n incd x25, ALL, MUL #4\n ld1b { z20.b }, p0/Z, [x23]\n incd x23, ALL, MUL #4\n ld1b { z19.b }, p0/Z, [x22]\n zip1 z21.b, z18.b, z17.b\n incd x22, ALL, MUL #4\n ld1b { z18.b }, p0/Z, [x21]\n zip1 z17.b, z22.b, z16.b\n incd x21, ALL, MUL #4\n ld1b { z16.b }, p0/Z, [x20]\n incd x20, ALL, MUL #4\n zip1 z20.b, z20.b, z18.b\n zip1 z16.b, z19.b, z16.b\n zip1 z19.b, z21.b, z17.b\n zip2 z18.b, z21.b, z17.b\n zip1 z17.b, z20.b, z16.b\n zip2 z16.b, z20.b, z16.b\n st1b { z19.b }, p2, [x28]\n st1b { z18.b }, p2, [x28, #1, MUL VL]\n st1b { z17.b }, p2, [x28, #2, MUL VL]\n st1b { z16.b }, p2, [x28, #3, MUL VL]\n add x28, x28, x12\n bgt label_2\n cmp x7, #0x8\n addvl x5, x5, #4\n bge label_1\n cbz x7, label_8\nKAI_ASM_LABEL(label_4) // Main loop skip\nKAI_ASM_LABEL(label_5) // Tail row loop: Head\n mov x9, x11\n cmp x7, #0x3\n add x27, x9, x13\n cntw x24, ALL, MUL #2\n add x26, x27, x13\n csel x23, x24, XZR, GT\n add x25, x26, x13\n csel x22, x24, XZR, GE\n add x11, x25, x13\n mov x28, x5\n csel x11, x11, x25, GT\n csel x25, x25, x10, GT\n csel x11, x11, x26, GE\n csel x26, x26, x10, GE\n cmp x7, #0x1\n sub x7, x7, #0x4\n csel x11, x11, x27, GT\n csel x27, x27, x10, GT\n csel x21, x24, XZR, GT\n mov x20, x14\nKAI_ASM_LABEL(label_6) // Tail row loop: Column loop\n whilelt p0.b, XZR, x20\n decw x20, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x9]\n cmp x20, #0x0\n add x9, x9, x24\n ld1b { z19.b }, p0/Z, [x27]\n add x27, x27, x21\n ld1b { z17.b }, p0/Z, [x26]\n add x26, x26, x22\n ld1b { z16.b }, p0/Z, [x25]\n add x25, x25, x23\n zip1 z18.b, z18.b, z17.b\n zip1 z16.b, z19.b, z16.b\n zip1 z17.b, z18.b, z16.b\n zip2 z16.b, z18.b, z16.b\n st1b { z17.b }, p2, [x28]\n st1b { z16.b }, p2, [x28, #1, MUL VL]\n add x28, x28, x12\n bgt label_6\n cmp x7, #0x1\n addvl x5, x5, #2\n bge label_5\nKAI_ASM_LABEL(label_8) // Done\n mov x22, x5\n mov x21, x14\n dup z18.s, w15\n cbz x8, label_10\nKAI_ASM_LABEL(label_9) // Scale: Full loop\n mov x20, x21\n decw x21, ALL, MUL #2\n whilelt p1.s, XZR, x20\n decw x20\n whilelt p0.s, XZR, x20\n ld1w { z17.s }, p1/Z, [x8]\n cmp x21, #0x0\n ld1w { z16.s }, p0/Z, [x8, #1, MUL VL]\n incb x8, ALL, MUL #2\n fmul z17.s, z17.s, z18.s\n fmul z16.s, z16.s, z18.s\n st1w { z17.s }, p2, [x22]\n st1w { z16.s }, p2, [x22, #1, MUL VL]\n add x22, x22, x12\n bgt label_9\nKAI_ASM_LABEL(label_10) // Scale: Done\n cbz x14, label_13\n cbz x4, label_13\n dup z21.s, w17\n add x25, x4, #0x3\n cntw x24, ALL, MUL #2\n mov z20.b, #0x1\n lsr x25, x25, #0x2\n mov x23, x14\n addvl x22, x16, #2\n neg z21.s, p2/M, z21.s\nKAI_ASM_LABEL(label_11) // Bias: N loop\n mov x21, x22\n mov x20, x25\n mov z19.s, #0x0\n mov z18.s, #0x0\nKAI_ASM_LABEL(label_12) // Bias: K loop\n ld1b { z17.b }, p2/Z, [x21]\n subs x20, x20, #0x1\n ld1b { z16.b }, p2/Z, [x21, #1, MUL VL]\n addvl x21, x21, #2\n sdot z19.s, z17.b, z20.b\n sdot z18.s, z16.b, z20.b\n bgt label_12\n mov x20, x23\n add x22, x22, x12\n whilelt p1.s, XZR, x20\n decw x20\n whilelt p0.s, XZR, x20\n ld1w { z17.s }, p1/Z, [x6]\n subs x23, x23, x24\n ld1w { z16.s }, p0/Z, [x6, #1, MUL VL]\n addvl x6, x6, #2\n mla z17.s, p2/M, z19.s, z21.s\n mla z16.s, p2/M, z18.s, z21.s\n st1w { z17.s }, p2, [x16]\n st1w { z16.s }, p2, [x16, #1, MUL VL]\n add x16, x16, x12\n bgt label_11\nKAI_ASM_LABEL(label_13) // Bias: Done\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa against gemm_qai8_qsi8cx_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const int8_t* A, float* output, const float* A_scale, const int8_t* B_q8, const float* B_scales, const float* bias, const float* C_scale, int M)\n//\n// Statically-quantized int8 GEMM. The kernel computes, per output element,\n// dst = clamp(round_to_nearest_even((acc_i32 + bias_i32[n]) * scale[n] * scale_multiplier) + out_zp, min, max)\n// so the definition's float quantities are folded into the kernel's parameters:\n// scale[n] = B_scales[n]\n// scale_multiplier = A_scale[0] / C_scale[0]\n// bias_i32[n] = rint(bias[n] / (A_scale[0] * B_scales[n])) (bias expressed in accumulator units)\n// out_zp = 0, lhs_zp = 0, clamp = [-128, 127]\n// bias is therefore quantized to the accumulator grid; the definition's tolerance (abs_tol 1 LSB of the int8\n// output) covers that rounding and round-half-even ties.\n// The kernel's weight-side packer only has a kxn variant, so B_q8 [N,K] is transposed to [K,N] once per weight.\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa.h\"\n#include \"kai_lhs_pack_x8p2vlx4_x8_sme.h\"\n#include \"kai_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const float* A_scale, const int8_t* B_q8, const float* B_scales, const float* bias, const float* C_scale, int M)\n{\n const size_t mr = kai_get_mr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa();\n\n // LHS: the int8 activation is (re)packed on EVERY call into a grow-only scratch buffer.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t sz = kai_get_lhs_packed_size_lhs_pack_x8p2vlx4_x8_sme((size_t)M, (size_t)K, mr, kr, sr);\n if (sz > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(sz);\n lhs_cap = sz;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_pack_x8p2vlx4_x8_sme((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K, lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged. A_scale and C_scale only\n // enter through scale_multiplier, so they are part of the cache key too.\n static uint8_t* B_snap = nullptr; static size_t B_snap_size = 0;\n static uint8_t* Bs_snap = nullptr; static size_t Bs_snap_size = 0;\n static uint8_t* bias_snap = nullptr; static size_t bias_snap_size = 0;\n static uint8_t* As_snap = nullptr; static size_t As_snap_size = 0;\n static uint8_t* Cs_snap = nullptr; static size_t Cs_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_snap, B_snap_size, B_q8, (size_t)N * K)\n | refresh_cache(Bs_snap, Bs_snap_size, B_scales, sizeof(float) * N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float) * N)\n | refresh_cache(As_snap, As_snap_size, A_scale, sizeof(float))\n | refresh_cache(Cs_snap, Cs_snap_size, C_scale, sizeof(float));\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_size = kai_get_rhs_packed_size_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme((size_t)N, (size_t)K);\n rhs_packed = std::malloc(rhs_size);\n int8_t* b_kxn = static_cast(std::malloc((size_t)N * K));\n int32_t* bias_i32 = static_cast(std::malloc(sizeof(int32_t) * N));\n if (rhs_packed == nullptr || b_kxn == nullptr || bias_i32 == nullptr) {\n std::free(b_kxn);\n std::free(bias_i32);\n return -1;\n }\n for (int n = 0; n < N; ++n) {\n for (int k = 0; k < K; ++k) b_kxn[(size_t)k * N + n] = B_q8[(size_t)n * K + k];\n bias_i32[n] = (int32_t)std::nearbyintf(bias[n] / (A_scale[0] * B_scales[n]));\n }\n struct kai_rhs_pack_qsi8cx_params params;\n params.lhs_zero_point = 0;\n params.scale_multiplier = A_scale[0] / C_scale[0];\n kai_run_rhs_pack_kxn_qsi8cxp2vlx4sb_qs8cx_f32_i32_sme(\n 1, (size_t)N, (size_t)K, nr, kr, sr, (size_t)N, b_kxn, bias_i32, B_scales, rhs_packed, 0, ¶ms);\n std::free(b_kxn);\n std::free(bias_i32);\n }\n\n // int8 result into a grow-only scratch, then widened to the raw ABI's float32 output (exact).\n static int8_t* out8 = nullptr;\n static size_t out8_cap = 0;\n const size_t total = (size_t)M * N;\n if (total > out8_cap) {\n std::free(out8);\n out8 = static_cast(std::malloc(total));\n out8_cap = total;\n if (out8 == nullptr) return -1;\n }\n struct kai_matmul_requantize32_params rq;\n rq.min_value = -128;\n rq.max_value = 127;\n rq.output_zero_point = 0;\n kai_run_matmul_clamp_qai8_qai8p2vlx4_qsi8cxpsb2vlx4_2vlx2vl_sme2_mopa(\n (size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, out8, (size_t)N * sizeof(int8_t), sizeof(int8_t), &rq);\n\n size_t i = 0;\n for (; i + 8 <= total; i += 8) {\n const int16x8_t w = vmovl_s8(vld1_s8(out8 + i));\n vst1q_f32(output + i, vcvtq_f32_s32(vmovl_s16(vget_low_s16(w))));\n vst1q_f32(output + i + 4, vcvtq_f32_s32(vmovl_s16(vget_high_s16(w))));\n }\n for (; i < total; ++i) output[i] = (float)out8[i];\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..24dfe0da7f56177ee878809fd77498347e6e9ab6 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qai8dxp_qs4c32_sme2_n256_k512", + "definition": "gemm_qai8dxp_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qai8dxp_qs4c32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa with its qai8dxp LHS and qsi4c32p RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon and kai_rhs_pack_kxn_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon\n/// to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix with\n/// the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k);\n\n/**\n * Gets the offset in bytes for the packed RHS matrix,\n * which contains the packed 4-bit quantized symmetric per-block (32) values (qsi4c32p).\n *\n * @param[in] n_idx Row index in the RHS matrix (not packed).\n * @param[in] k The common dimension between the LHS and RHS matrix (K).\n * @param[in] bl Block length along K. It must be a multiple of 32, and K must be a multiple of bl.\n *\n * @return the offset in bytes to the packed RHS matrix\n */\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, size_t k, size_t bl);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n);\n\n///\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed\n/// RHS matrix: Signed 4-bit quantized symmetric per-block (32) (qsi4c32p) and packed.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] bl Block length along K. It must be a multiple of 32, and K must be a multiple of bl.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS packed matrix, which is obtained by calling @ref\n/// kai_run_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, size_t n, size_t k, size_t bl, const void* lhs_packed, const void* rhs_packed, float* dst,\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 64\n\n/// Lut to be indexed by i4 resulting in its value in i8 (i.e. -2 = 1110 -> 1111 1110).\nstatic const int8_t lut[KAI_LUT_NENTRIES] = {\n // clang-format off\n 0, 0, 0, 0,\n 1, 0, 0, 0,\n 2, 0, 0, 0,\n 3, 0, 0, 0,\n 4, 0, 0, 0,\n 5, 0, 0, 0,\n 6, 0, 0, 0,\n 7, 0, 0, 0,\n -8, 0, 0, 0,\n -7, 0, 0, 0,\n -6, 0, 0, 0,\n -5, 0, 0, 0,\n -4, 0, 0, 0,\n -3, 0, 0, 0,\n -2, 0, 0, 0,\n -1, 0, 0, 0\n // clang-format on\n};\n\ntypedef struct {\n float* dst; // 0 (0x00)\n const void* lhs_packed; // 8 (0x08)\n const void* rhs_packed; // 16 (0x10)\n size_t dst_stride_row; // 24 (0x18)\n size_t lhs_stride; // 32 (0x20)\n size_t rhs_stride; // 40 (0x28)\n size_t m; // 48 (0x30)\n size_t n; // 56 (0x38)\n size_t k; // 64 (0x40)\n size_t bl; // 72 (0x48)\n const int8_t* lut; // 80 (0x50)\n float scalar_max; // 88 (0x58)\n float scalar_min; // 92 (0x5C)\n} KernelArgs;\n\nextern void kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // multiple of vector length\nstatic const size_t kai_n_step = 4; // multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // multiple of vector length\nstatic const size_t kai_nr = 4; // multiple of vector length\nstatic const size_t kai_kr = 8;\nstatic const size_t kai_sr = 2;\n// LHS format args\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\n// RHS format args\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(uint16_t);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias_rhs = sizeof(float);\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_k_multiple_of = 32;\nstatic const size_t kai_bl = 32;\n\nstatic size_t kai_k_roundedup(const size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nstatic size_t kai_get_num_bytes_per_block_rhs(const size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n const size_t num_bytes_per_block_rhs = (bl / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs;\n return num_bytes_per_block_rhs;\n}\n\nstatic size_t kai_get_num_blocks_per_row(const size_t k, const size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\nstatic size_t kai_get_lhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n return mr * (k_internal * kai_num_bytes_qvalue_lhs + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\nstatic size_t kai_get_rhs_packed_stride(const size_t k, const size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME((k % kai_bl) == 0);\n\n const size_t k_internal = kai_k_roundedup(k);\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k_internal, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr * (num_blocks_per_row * num_bytes_per_block);\n rhs_packed_stride += nr * kai_num_bytes_sum_rhs; // per-column rsum\n rhs_packed_stride += nr * kai_num_bytes_bias_rhs; // per-column bias\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa()) == 0);\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n return (m_idx / mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n const size_t n_idx, const size_t k, const size_t bl) {\n KAI_ASSUME((n_idx % kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa()) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n const size_t m_idx, const size_t n_idx, const size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa()) == 0);\n KAI_ASSUME((n_idx % kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa()) == 0);\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(const size_t m, const size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n const size_t m, //\n const size_t n, //\n const size_t k, //\n const size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n const size_t dst_stride_row, //\n const size_t dst_stride_col, //\n const float scalar_min, //\n const float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME(m > 0);\n KAI_ASSUME(n > 0);\n KAI_ASSUME(k > 0);\n KAI_ASSUME((bl % kai_k_multiple_of) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.k = kai_k_roundedup(k);\n args.bl = bl;\n args.lhs_stride = kai_get_lhs_packed_stride(k);\n args.rhs_stride = kai_get_rhs_packed_stride(k, bl);\n args.scalar_max = scalar_max;\n args.scalar_min = scalar_min;\n args.lut = lut;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa)\n\n // -----------------------------------------------------------------------------\n // Args (x0 = args_ptr)\n // 0 (0x00)\n // 8 (0x08)\n // 16 (0x10)\n // 24 (0x18)\n // 32 (0x20)\n // 40 (0x28)\n // 48 (0x30)\n // 56 (0x38)\n // 64 (0x40)\n // 72 (0x48)\n // 80 (0x50)\n // 88 (0x58)\n // 92 (0x5C)\n // -----------------------------------------------------------------------------\n // GPR usage\n // x0/x16 args_ptr\n // x19 dst base\n // x20 lhs_packed\n // x8/x11 rhs_packed\n // x6 k\n // x7 lut_ptr (\u2192 zt0)\n // x12 m loop counter\n // x13 n loop counter\n // x14/x15 row loop index / bound\n // x9/x17 dst working ptrs\n // x21\u2013x22 store pointers\n // x25 k-loop counter\n // x5 stride / bl loads\n // x23\u2013x28 saved / scratch regs\n // -----------------------------------------------------------------------------\n // Z / ZA usage\n // zt0 lut descriptor\n // z0\u2013z1 rhs nibble inputs\n // z4 lhs bytes\n // z8\u2013z11 rhs expanded bytes\n // za0\u2013za3 accumulators\n // z12\u2013z15 ZA extracts\n // z18\u2013z19 scalar_min / scalar_max\n // z24\u2013z27 rhs scales or temps\n // z28\u2013z31 post-accum results\n // -----------------------------------------------------------------------------\n // Predicates\n // p0.s m active\n // p2.b all true\n // pn8.h n active (vlx2)\n // pn9.s n active (vlx4)\n // -----------------------------------------------------------------------------\n // Loop structure\n // m_loop: M tiles (cntw VL)\n // n_loop: N tiles (vlx4)\n // k_loop: K in blocks of 'bl'\n // zero ZA\n // ld1w LHS, ld1h RHS, luti4 expand\n // smopa accumulate\n // load RHS scale (lsl#16)\n // extract ZA \u2192 f32\n // scale, bias, clamp, store\n // -----------------------------------------------------------------------------\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, #-144]!\n stp x21, x22, [sp, #16]\n stp x23, x24, [sp, #32]\n stp x25, x26, [sp, #112]\n stp x27, x28, [sp, #128]\n stp d8, d9, [sp, #48]\n stp d10, d11, [sp, #64]\n stp d12, d13, [sp, #80]\n stp d14, d15, [sp, #96]\n\n mov x16, x0 // args_ptr\n\n KAI_ASM_INST(0xd503477f) // smstart\n mov x16, x0 // save args_ptr\n ldr x19, [x16, #0x00] // dst\n ldr x6, [x16, #0x40] // k\n ldr x20, [x16, #0x08] // lhs_packed\n ldr x7, [x16, #0x50] // lut\n KAI_ASM_INST(0xe11f80e0) // ldr zt0, [x7]\n cntw x7 // m_step = VL\n ptrue p2.b\n KAI_ASM_INST(0x8557ca12) // ld1rw {z18.s}, p2/z, [x16, #0x5C] - scalar_min\n KAI_ASM_INST(0x8556ca13) // ld1rw {z19.s}, p2/z, [x16, #0x58] - scalar_max\n\n ldr x12, [x16, #0x30] // M loop count\n KAI_ASM_INST(0x25ac17e0) // whilelt p0.s, xzr, x12\nKAI_ASM_LABEL(m_loop)\n ldr x8, [x16, #0x10] // rhs_packed\n mov x9, x19 // working dst\n ldr x13, [x16, #0x38] // N loop count\n cmp x7, x12 // m_step vs M loop count\n csel x15, x7, x12, lt //\n lsl x15, x15, #2 // rows in this M block * 4 ( loop bound for row)\n\n KAI_ASM_INST(0x256d47f0) // whilelt pn8.h, xzr, x13, vlx2\nKAI_ASM_LABEL(n_loop)\n mov x10, x20 // lhs_ptr\n mov x11, x8 // rhs_ptr\n mov x17, x9 // dst_ptr\n KAI_ASM_INST(0x25ad67f1) // whilelt pn9.s, xzr, x13, vlx4\n mov x25, x6 // k-loop counter\n\nKAI_ASM_LABEL(k_loop)\n KAI_ASM_INST(0xc00800ff) // zero {za}\n ldr x5, [x16, #0x48] // bl\nKAI_ASM_LABEL(k_block_loop)\n KAI_ASM_INST(0xa540a144) // ld1w { z4.s }, p0/z, [x10]\n addvl x10, x10, #1\n KAI_ASM_INST(0xa0402160) // ld1h { z0.h-z1.h }, pn8/z, [x11]\n addvl x11, x11, #2\n KAI_ASM_INST(0xc08a4008) // luti4 { z8.b - z9.b }, zt0, z0[0]\n KAI_ASM_INST(0xc08a402a) // luti4 { z10.b - z11.b }, zt0, z1[0]\n KAI_ASM_INST(0xa0884880) // smopa za0.s, p2/m, p2/m, z4.b, z8.b\n KAI_ASM_INST(0xa0894881) // smopa za1.s, p2/m, p2/m, z4.b, z9.b\n KAI_ASM_INST(0xa08a4882) // smopa za2.s, p2/m, p2/m, z4.b, z10.b\n KAI_ASM_INST(0xa08b4883) // smopa za3.s, p2/m, p2/m, z4.b, z11.b\n subs x5, x5, #4\n b.gt k_block_loop\n\n // Load per-output-vector RHS fixed-point scales (s16), then lsl #16 \u2192 Q15 in s32 lanes\n // Used to scale float accumulators after scvtf.\n ld1h z24.s, p2/z, [x11]\n ld1h z25.s, p2/z, [x11, #1, MUL VL]\n ld1h z26.s, p2/z, [x11, #2, MUL VL]\n ld1h z27.s, p2/z, [x11, #3, MUL VL]\n addvl x11, x11, #2 // advance rhs_ptr past 4 halfword vectors (scales)\n\n\n mov x14, #0 // store loop index\n mov x22, x17 // dst store pointer\n lsl z24.s, z24.s, #16\n lsl z25.s, z25.s, #16\n lsl z26.s, z26.s, #16\n lsl z27.s, z27.s, #16\n\nKAI_ASM_LABEL(accum_loop)\n // Extract 4 output vectors from ZA row w14 (low half), map to N columns 0..3\n // of this tile\n KAI_ASM_INST(0xc006440c) // mova { z12.b-z15.b }, za0h.b[w14, 0:3]\n add x14, x14, #4\n KAI_ASM_INST(0xc132e18c) // scvtf { z12.s-z15.s }, { z12.s-z15.s }\n\n // First K tile? (x25==x6 only on the first tile). If yes: write = accum * scale.\n // Else: C += accum * scale (FMLA into previous partial result).\n cmp x25, x6\n b.ne accum_fallback\n\n fmul z28.s, z12.s, z24.s\n fmul z29.s, z13.s, z25.s\n fmul z30.s, z14.s, z26.s\n fmul z31.s, z15.s, z27.s\n b post_accum\n\nKAI_ASM_LABEL(accum_fallback)\n KAI_ASM_INST(0xa040c6dc) // ld1w { z28.s - z31.s }, pn9/z, [x22]\n fmla z28.s, p2/m, z12.s, z24.s\n fmla z29.s, p2/m, z13.s, z25.s\n fmla z30.s, p2/m, z14.s, z26.s\n fmla z31.s, p2/m, z15.s, z27.s\n\nKAI_ASM_LABEL(post_accum)\n KAI_ASM_INST(0xa060c6dc) // st1w { z28.s - z31.s }, pn9, [x22]\n ldr x5, [x16, #0x18] // dst_stride_row\n add x22, x22, x5\n cmp x14, x15 // M tile loop: x15 = rows*4, x14 += 4 per row\n b.lt accum_loop\n ldr x5, [x16, #0x48] // bl\n subs x25, x25, x5\n b.gt k_loop\n\n // RHS row sums and bias\n KAI_ASM_INST(0xa040c560) // ld1w { z0.s-z3.s }, pn9/z, [x11]\n KAI_ASM_INST(0xa041c568) // ld1w { z8.s-z11.s }, pn9/z, [x11, #4, mul vl]\n addvl x11, x11, #8\n\n mov x14, #0\n addvl x21, x10, #1\n\nKAI_ASM_LABEL(postprocess_loop)\n // Load LHS row offset and scale factor\n KAI_ASM_INST(0x8540c950) // ld1rw {z16.s}, p2/z, [x10]\n KAI_ASM_INST(0x8540cab1) // ld1rw {z17.s}, p2/z, [x21]\n add x10, x10, #4\n add x21, x21, #4\n scvtf z16.s, p2/m, z16.s\n\n KAI_ASM_INST(0xa040c63c) // ld1w { z28.s - z31.s }, pn9/z, [x17]\n // facc + offset * row sum\n fmla z28.s, p2/m, z16.s, z0.s\n fmla z29.s, p2/m, z16.s, z1.s\n fmla z30.s, p2/m, z16.s, z2.s\n fmla z31.s, p2/m, z16.s, z3.s\n\n // Apply LHS scale factor\n fmul z24.s, z28.s, z17.s\n fmul z25.s, z29.s, z17.s\n fmul z26.s, z30.s, z17.s\n fmul z27.s, z31.s, z17.s\n\n // Add bias\n fadd z24.s, z24.s, z8.s\n fadd z25.s, z25.s, z9.s\n fadd z26.s, z26.s, z10.s\n fadd z27.s, z27.s, z11.s\n\n // Clamp and store\n KAI_ASM_INST(0xc1b3ca58) // fclamp { z24.s-z27.s }, z18.s, z19.s\n KAI_ASM_INST(0xa060c638) // st1w { z24.s-z27.s }, pn9, [x17]\n\n ldr x5, [x16, #0x18] // dst_stride_row\n add x17, x17, x5\n add x14, x14, #4\n cmp x14, x15\n b.lt postprocess_loop\n\n // N loop tail\n ldr x5, [x16, #0x28] // rhs_stride\n add x8, x8, x5\n addvl x9, x9, #4\n decb x13, all\n KAI_ASM_INST(0x256d47f0) // whilelt pn8.h, xzr, x13, vlx2\n b.mi n_loop\n\n // M loop tail\n ldr x5, [x16, #0x20] // lhs_stride\n add x20, x20, x5\n ldr x5, [x16, #0x18] // dst_stride_row\n mul x5, x5, x7\n add x19, x19, x5\n sub x12, x12, x7\n whilelt p0.s, xzr, x12\n b.mi m_loop\n\n KAI_ASM_INST(0xd503467f) // smstop\n\n ldp d14, d15, [sp, #96]\n ldp d12, d13, [sp, #80]\n ldp d10, d11, [sp, #64]\n ldp d8, d9, [sp, #48]\n ldp x27, x28, [sp, #128]\n ldp x25, x26, [sp, #112]\n ldp x23, x24, [sp, #32]\n ldp x21, x22, [sp, #16]\n ldp x19, x20, [sp], #144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Get the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n///\n/// Two int4 values are stored in one byte.\n/// The lower order part of the byte (low) holds the first nibble (K-index + 0).\n/// The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n size_t n_idx, //\n size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] scale_dt Block scale data type\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n enum kai_datatype scale_dt);\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] scale_dt Block scale data type\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n enum kai_datatype scale_dt);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n/// @param[in] scale_dt Block scale data type\n///\n/// @return the packed RHS matrix size in bytes\n// clang-format off\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n enum kai_datatype scale_dt);\n// clang-format on\n\n/// Runs the RHS packing micro-kernel.\n///\n/// The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte. The lower order part of the byte (low) holds\n/// the first nibble (K-index + 0). The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] num_groups The number of groups. It must be 1. Currently unused.\n/// @param[in] n The number of rows in the RHS matrix (not packed).\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel. It must be a multiple of 4.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] rhs_stride The number of bytes per row in bytes of the RHS matrix\n/// @param[in] bias The biases.\n/// @param[in] scale The per-block quantization scales.\n/// The scale data type must be provided with the params object.\n/// Supported scale data types are FP32, FP16 and BF16.\n/// @param[in] scale_stride The number of bytes per row in bytes of the scale matrix\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix. Currently unused.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n size_t rhs_stride, //\n const float* bias, //\n const void* scale, //\n size_t scale_stride, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// nrx4 => this function can take in generic nr values but the input is expected to have a block depth of 4.\n// Block depth is calculated as kr / sr. The values of these parameters are defined in the matmul ukernel.\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon.h\"\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\nstatic const size_t kai_nr_multiple_of = 4;\nstatic const size_t kai_bl_multiple_of = 32;\n\nstatic size_t kai_get_num_blocks_per_row(const size_t k, const size_t bl) {\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\nstatic size_t kai_get_num_bytes_per_block(const size_t bl, const size_t num_bytes_multiplier_rhs) {\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n return (bl / 2) + num_bytes_multiplier_rhs;\n}\n\nstatic size_t kai_get_rhs_packed_offset_end_of_all_blocks(\n // clang-format off\n const size_t k,\n const size_t nr,\n const size_t kr,\n const size_t bl,\n const size_t num_bytes_multiplier_rhs) {\n // clang-format on\n KAI_ASSERT((bl % kr) == 0);\n KAI_ASSERT((nr % kai_nr_multiple_of) == 0);\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl, num_bytes_multiplier_rhs);\n\n return (nr * num_bytes_per_block * num_blocks_per_row);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(const size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(const size_t n_idx, const size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n // clang-format off\n const size_t k,\n const size_t nr,\n const size_t kr,\n const size_t sr,\n const size_t bl,\n const enum kai_datatype scale_dt) {\n // clang-format on\n KAI_ASSERT((k % bl) == 0);\n KAI_ASSERT((bl % kr) == 0);\n KAI_ASSERT((nr % kai_nr_multiple_of) == 0);\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(scale_dt == kai_dt_bf16);\n\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t num_bytes_multiplier_rhs = kai_get_datatype_size_in_bytes(scale_dt);\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block(bl, num_bytes_multiplier_rhs);\n\n return nr * ((num_bytes_per_block * num_blocks_per_row) + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\n// clang-format off\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n const size_t n_idx,\n const size_t k,\n const size_t nr,\n const size_t kr,\n const size_t sr,\n const size_t bl,\n const enum kai_datatype scale_dt) {\n // clang-format on\n KAI_ASSERT((n_idx % nr) == 0);\n KAI_ASSERT((k % bl) == 0);\n KAI_ASSERT((bl % kr) == 0);\n KAI_ASSERT((nr % kai_nr_multiple_of) == 0);\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(scale_dt == kai_dt_bf16);\n\n return (n_idx / nr) *\n kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(k, nr, kr, sr, bl, scale_dt);\n}\n\n// clang-format off\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n const size_t n, //\n const size_t k, //\n const size_t nr, //\n const size_t kr, //\n const size_t sr, //\n const size_t bl, //\n const enum kai_datatype scale_dt) {\n // clang-format on\n KAI_ASSERT((k % bl) == 0);\n KAI_ASSERT((bl % kr) == 0);\n KAI_ASSERT((nr % kai_nr_multiple_of) == 0);\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(scale_dt == kai_dt_bf16);\n\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows *\n kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(k, nr, kr, sr, bl, scale_dt);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n // clang-format off\n const size_t num_groups,\n const size_t n,\n const size_t k,\n const size_t nr,\n const size_t kr,\n const size_t sr,\n const size_t bl,\n const uint8_t* rhs,\n const size_t rhs_stride,\n const float* bias,\n const void* scale,\n const size_t scale_stride,\n void* rhs_packed,\n const size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params* params) {\n // clang-format on\n KAI_UNUSED(num_groups);\n KAI_UNUSED(extra_bytes);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n KAI_ASSERT(params->rhs_zero_point == 8);\n KAI_ASSERT(params->lhs_zero_point == 1);\n\n KAI_ASSERT((k % bl) == 0);\n KAI_ASSERT((bl % kr) == 0);\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSERT((nr % kai_nr_multiple_of) == 0);\n KAI_ASSERT((bl % kai_bl_multiple_of) == 0);\n KAI_ASSERT(params->scale_dt == kai_dt_bf16);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n const size_t block_length = kr / sr;\n KAI_ASSERT(block_length == 4);\n const enum kai_datatype scale_dt = params->scale_dt;\n const size_t num_bytes_multiplier_rhs = kai_get_datatype_size_in_bytes(scale_dt);\n const size_t rhs_packed_offset_end_of_all_blocks =\n kai_get_rhs_packed_offset_end_of_all_blocks(k, nr, kr, bl, num_bytes_multiplier_rhs);\n const size_t num_qblocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block_k = bl / 2;\n const size_t dst_num_rows = kai_roundup(n, nr);\n const size_t block_length_in_bytes = block_length / 2;\n\n const int8x16_t rhs_zero_point = vdupq_n_s8(8);\n const uint8x16_t low_mask = vdupq_n_u8(0x0F);\n const size_t num_bytes_processed = 16;\n\n uint8_t* dst_row = (uint8_t*)rhs_packed;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; dst_row_idx += nr) {\n float* sums = (float*)(dst_row + rhs_packed_offset_end_of_all_blocks);\n\n // Initialize the RHS reduction sums to zero\n memset(sums, 0, nr * kai_num_bytes_sum_rhs);\n\n // Iterate over the quantized blocks\n for (size_t dst_qblock_idx = 0; dst_qblock_idx < num_qblocks_per_row; ++dst_qblock_idx) {\n // Store the scales after packing all K values in the block\n uint8_t* rhs_packed_scale = dst_row + num_bytes_per_block_k * nr;\n const uint8_t* scale_ptr = (const uint8_t*)scale + dst_qblock_idx * num_bytes_multiplier_rhs;\n\n for (size_t i = 0; i < nr; ++i) {\n const size_t src_row_idx = KAI_MIN(dst_row_idx + i, n - 1);\n const void* src_scales_ptr = scale_ptr + src_row_idx * scale_stride;\n void* dst_scales_ptr = rhs_packed_scale + i * num_bytes_multiplier_rhs;\n\n memcpy(\n dst_scales_ptr, //\n src_scales_ptr, //\n num_bytes_multiplier_rhs); //\n }\n\n size_t k0_idx_i = dst_qblock_idx * bl;\n\n for (size_t dst_byte_idx = 0; dst_byte_idx < num_bytes_per_block_k; dst_byte_idx += num_bytes_processed) {\n for (size_t nr_idx = 0; nr_idx < nr; nr_idx += 4) {\n // Clamp the indices to avoid out-of-bound reads\n const size_t n0_idx = KAI_MIN(dst_row_idx + nr_idx, n - 1);\n const size_t n1_idx = KAI_MIN(n0_idx + 1, n - 1);\n const size_t n2_idx = KAI_MIN(n0_idx + 2, n - 1);\n const size_t n3_idx = KAI_MIN(n0_idx + 3, n - 1);\n\n // Load scales\n const float d0 = kai_cast_f32_bf16(((uint16_t*)rhs_packed_scale)[nr_idx + 0]);\n const float d1 = kai_cast_f32_bf16(((uint16_t*)rhs_packed_scale)[nr_idx + 1]);\n const float d2 = kai_cast_f32_bf16(((uint16_t*)rhs_packed_scale)[nr_idx + 2]);\n const float d3 = kai_cast_f32_bf16(((uint16_t*)rhs_packed_scale)[nr_idx + 3]);\n\n // Initialize partial sum\n int32_t partial_sum0 = 0;\n int32_t partial_sum1 = 0;\n int32_t partial_sum2 = 0;\n int32_t partial_sum3 = 0;\n\n const uint8_t* src_block_base = rhs + ((k0_idx_i / 2) + dst_byte_idx);\n const uint8x16_t vsrc0_0 = vld1q_u8(src_block_base + n0_idx * rhs_stride);\n const uint8x16_t vsrc1_0 = vld1q_u8(src_block_base + n1_idx * rhs_stride);\n const uint8x16_t vsrc2_0 = vld1q_u8(src_block_base + n2_idx * rhs_stride);\n const uint8x16_t vsrc3_0 = vld1q_u8(src_block_base + n3_idx * rhs_stride);\n\n // Get the lower and higher nibble and apply zero-points\n const int8x16_t vsrc0_0_lo =\n vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vsrc0_0, low_mask)), rhs_zero_point);\n const int8x16_t vsrc0_0_hi = vsubq_s8(vreinterpretq_s8_u8(vshrq_n_u8(vsrc0_0, 4)), rhs_zero_point);\n const int8x16_t vsrc1_0_lo =\n vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vsrc1_0, low_mask)), rhs_zero_point);\n const int8x16_t vsrc1_0_hi = vsubq_s8(vreinterpretq_s8_u8(vshrq_n_u8(vsrc1_0, 4)), rhs_zero_point);\n const int8x16_t vsrc2_0_lo =\n vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vsrc2_0, low_mask)), rhs_zero_point);\n const int8x16_t vsrc2_0_hi = vsubq_s8(vreinterpretq_s8_u8(vshrq_n_u8(vsrc2_0, 4)), rhs_zero_point);\n const int8x16_t vsrc3_0_lo =\n vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vsrc3_0, low_mask)), rhs_zero_point);\n const int8x16_t vsrc3_0_hi = vsubq_s8(vreinterpretq_s8_u8(vshrq_n_u8(vsrc3_0, 4)), rhs_zero_point);\n\n // Calculate and store row sums\n partial_sum0 += vaddlvq_s16(vaddl_s8(\n vadd_s8(vget_low_s8(vsrc0_0_lo), vget_high_s8(vsrc0_0_lo)),\n vadd_s8(vget_low_s8(vsrc0_0_hi), vget_high_s8(vsrc0_0_hi))));\n partial_sum1 += vaddlvq_s16(vaddl_s8(\n vadd_s8(vget_low_s8(vsrc1_0_lo), vget_high_s8(vsrc1_0_lo)),\n vadd_s8(vget_low_s8(vsrc1_0_hi), vget_high_s8(vsrc1_0_hi))));\n partial_sum2 += vaddlvq_s16(vaddl_s8(\n vadd_s8(vget_low_s8(vsrc2_0_lo), vget_high_s8(vsrc2_0_lo)),\n vadd_s8(vget_low_s8(vsrc2_0_hi), vget_high_s8(vsrc2_0_hi))));\n partial_sum3 += vaddlvq_s16(vaddl_s8(\n vadd_s8(vget_low_s8(vsrc3_0_lo), vget_high_s8(vsrc3_0_lo)),\n vadd_s8(vget_low_s8(vsrc3_0_hi), vget_high_s8(vsrc3_0_hi))));\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n sums[nr_idx + 0] += (float)partial_sum0 * d0;\n sums[nr_idx + 1] += (float)partial_sum1 * d1;\n sums[nr_idx + 2] += (float)partial_sum2 * d2;\n sums[nr_idx + 3] += (float)partial_sum3 * d3;\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n\n const uint8x16_t vdst_u8_0 = vorrq_u8(\n vandq_u8(vreinterpretq_u8_s8(vsrc0_0_lo), low_mask),\n vshlq_n_u8(vreinterpretq_u8_s8(vsrc0_0_hi), 4));\n const uint8x16_t vdst_u8_1 = vorrq_u8(\n vandq_u8(vreinterpretq_u8_s8(vsrc1_0_lo), low_mask),\n vshlq_n_u8(vreinterpretq_u8_s8(vsrc1_0_hi), 4));\n const uint8x16_t vdst_u8_2 = vorrq_u8(\n vandq_u8(vreinterpretq_u8_s8(vsrc2_0_lo), low_mask),\n vshlq_n_u8(vreinterpretq_u8_s8(vsrc2_0_hi), 4));\n const uint8x16_t vdst_u8_3 = vorrq_u8(\n vandq_u8(vreinterpretq_u8_s8(vsrc3_0_lo), low_mask),\n vshlq_n_u8(vreinterpretq_u8_s8(vsrc3_0_hi), 4));\n\n // Reorder to interleave nr rows\n const uint16x8_t vdst_u16_0 = vreinterpretq_u16_u8(vdst_u8_0);\n const uint16x8_t vdst_u16_1 = vreinterpretq_u16_u8(vdst_u8_1);\n const uint16x8_t vdst_u16_2 = vreinterpretq_u16_u8(vdst_u8_2);\n const uint16x8_t vdst_u16_3 = vreinterpretq_u16_u8(vdst_u8_3);\n\n const uint32x4_t vdst_u32_0 = vreinterpretq_u32_u16(vzip1q_u16(vdst_u16_0, vdst_u16_1));\n const uint32x4_t vdst_u32_1 = vreinterpretq_u32_u16(vzip1q_u16(vdst_u16_2, vdst_u16_3));\n const uint32x4_t vdst_u32_2 = vreinterpretq_u32_u16(vzip2q_u16(vdst_u16_0, vdst_u16_1));\n const uint32x4_t vdst_u32_3 = vreinterpretq_u32_u16(vzip2q_u16(vdst_u16_2, vdst_u16_3));\n\n const uint32x4_t vdst0_0 = vzip1q_u32(vdst_u32_0, vdst_u32_1);\n const uint32x4_t vdst1_0 = vzip2q_u32(vdst_u32_0, vdst_u32_1);\n const uint32x4_t vdst2_0 = vzip1q_u32(vdst_u32_2, vdst_u32_3);\n const uint32x4_t vdst3_0 = vzip2q_u32(vdst_u32_2, vdst_u32_3);\n\n // Store packed values\n vst1_u32((uint32_t*)dst_row, vget_low_u32(vdst0_0));\n vst1_u32((uint32_t*)(dst_row + nr * block_length_in_bytes), vget_high_u32(vdst0_0));\n vst1_u32((uint32_t*)(dst_row + (2 * nr * block_length_in_bytes)), vget_low_u32(vdst1_0));\n\n vst1_u32((uint32_t*)(dst_row + (3 * nr * block_length_in_bytes)), vget_high_u32(vdst1_0));\n vst1_u32((uint32_t*)(dst_row + (4 * nr * block_length_in_bytes)), vget_low_u32(vdst2_0));\n vst1_u32((uint32_t*)(dst_row + (5 * nr * block_length_in_bytes)), vget_high_u32(vdst2_0));\n vst1_u32((uint32_t*)(dst_row + (6 * nr * block_length_in_bytes)), vget_low_u32(vdst3_0));\n vst1_u32((uint32_t*)(dst_row + (7 * nr * block_length_in_bytes)), vget_high_u32(vdst3_0));\n\n dst_row += (4 * block_length_in_bytes);\n }\n // Skip to end of qblock\n dst_row += 7 * nr * block_length_in_bytes;\n }\n\n // Move the pointer after scales\n dst_row += num_bytes_multiplier_rhs * nr;\n }\n\n // Move the pointer after the row sum\n dst_row += kai_num_bytes_sum_rhs * nr;\n\n // Set the bias\n if (bias == NULL) {\n memset(dst_row, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx + i, n - 1);\n ((float*)dst_row)[i] = bias[src_row_idx];\n }\n }\n\n // Move the pointer after the row sum\n dst_row += kai_num_bytes_bias * nr;\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa against gemm_qai8dxp_qs4c32_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, const float* bias, int M)\n// C = A @ dequant(B_q4, B_scales)^T + bias, activations dynamically quantized per row to asymmetric int8.\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, const float* bias, int M)\n{\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n // LHS: (re)quantized and packed on EVERY call into a grow-only scratch buffer (activation-side work).\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t sz = kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr);\n if (sz > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(sz);\n lhs_cap = sz;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qai8dxp_f32(\n (size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_snap = nullptr; static size_t B_snap_size = 0;\n static uint8_t* Bs_snap = nullptr; static size_t Bs_snap_size = 0;\n static uint8_t* bias_snap = nullptr; static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_snap, B_snap_size, B_q4, (size_t)N * K / 2)\n | refresh_cache(Bs_snap, Bs_snap_size, B_scales, sizeof(uint16_t) * N * (K / BL))\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float) * N);\n if (stale) {\n std::free(rhs_packed);\n const size_t sz = kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon((size_t)N, (size_t)K, nr, kr, sr, BL, kai_dt_bf16);\n rhs_packed = std::malloc(sz);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n params.scale_dt = kai_dt_bf16;\n kai_run_rhs_pack_nxk_qsi4c32ps1s0nrx4_qsu4c32s1s0_neon(\n 1, (size_t)N, (size_t)K, nr, kr, sr, BL, B_q4, /*rhs_stride=*/(size_t)K / 2, bias, B_scales,\n /*scale_stride=*/sizeof(uint16_t) * (K / BL), rhs_packed, 0, ¶ms);\n }\n\n kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n (size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float),\n -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..6e299bc677827d4b4d3f11fd716e6457c00fb147 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4c32_sme2_n256_k512.json @@ -0,0 +1,64 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qs4c32_sme2_n256_k512", + "definition": "gemm_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qs4c32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) || !(defined(__ARM_FEATURE_SVE2) || defined(__ARM_FEATURE_SME2))\n#error This file must be compiled for AArch64, FEAT_SVE2 or FEAT_SME2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n// Compute args\nstatic const size_t kai_m_step = 1; // Multiple of vector length\nstatic const size_t kai_n_step = 4; // Multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // Multiple of vector length\nstatic const size_t kai_nr = 4; // Multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 2;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 2;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_recip_num_bytes_qvalue_rhs = 2;\nstatic const size_t kai_num_bytes_multiplier_rhs = 2;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_bl = 32;\n\n// Look-up table used for int4->int8 convert\nstatic const int32_t lut[16] = {-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};\n\ninline static size_t kai_get_num_bytes_per_block_lhs(size_t bl) {\n return (bl * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs;\n}\n\ninline static size_t kai_get_num_bytes_per_block_rhs(size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n size_t num_bytes_per_block_rhs = (bl / kai_recip_num_bytes_qvalue_rhs) + kai_num_bytes_multiplier_rhs;\n return num_bytes_per_block_rhs;\n}\n\ninline static size_t kai_get_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n return k / bl;\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n return mr * kai_get_num_blocks_per_row(k, bl) * kai_get_num_bytes_per_block_lhs(bl);\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % kai_bl) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_get_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_get_num_bytes_per_block_rhs(bl);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr * (num_bytes_per_block * num_blocks_per_row);\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t k, size_t bl) {\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % mr) == 0);\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, size_t k, size_t bl) {\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n KAI_ASSUME((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k, bl);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n const size_t m_step = kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t n_step = kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n KAI_ASSUME((m_idx % m_step) == 0);\n KAI_ASSUME((n_idx % n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME((bl % kai_bl) == 0);\n\n if (m == 0) {\n return;\n }\n\n typedef struct {\n size_t lhs_packed_stride;\n size_t rhs_packed_stride;\n size_t mr;\n size_t bl;\n float scalar_min;\n float scalar_max;\n uint32_t is_clamp_valid;\n } KernelArgs;\n\n KernelArgs ka;\n\n const size_t num_blocks = kai_get_num_blocks_per_row(k, bl);\n\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n\n ka.mr = mr;\n ka.lhs_packed_stride = kai_get_lhs_packed_stride(k, bl);\n ka.rhs_packed_stride = kai_get_rhs_packed_stride(k, bl);\n ka.bl = bl;\n ka.scalar_min = scalar_min;\n ka.scalar_max = scalar_max;\n\n const uint16_t* lhs_scales = (const uint16_t*)((const int8_t*)lhs_packed + ka.lhs_packed_stride -\n (mr * num_blocks) * kai_num_bytes_multiplier_lhs);\n const uint16_t* rhs_scales = (const uint16_t*)((const uint8_t*)rhs_packed + ka.rhs_packed_stride -\n (nr * num_blocks) * kai_num_bytes_multiplier_rhs);\n\n ka.is_clamp_valid = ((scalar_min > -FLT_MAX) && (scalar_max < FLT_MAX)) ? 1 : 0;\n\n kai_commit_za();\n\n __asm__ volatile(\n // Switch to streaming mode with ZA enabling\n \" .inst 0xd503477f // smstart \\n\"\n\n // Constants\n // - SVLs\n \" cntw x14 \\n\"\n // - ptrue\n \" ptrue p0.b, all \\n\"\n \" .inst 0x25a07810 // ptrue pn8.s \\n\"\n\n // Predicate for loading fp16 scaling factors\n \" ldr x5, [%x[args_ptr], %[offset_mr]]\\n\"\n \" lsl x5, x5, #1 \\n\"\n \" whilelt p4.b, xzr, x5 \\n\"\n\n // Initialize ZT0 (Lookup table)\n \" mov x6, %[lut]\\n\"\n \" .inst 0xe11f80c0 // ldr zt0, [x6] \\n\"\n\n // Initialize the RHS packes and scale pointers\n \" mov x16, %[rhs_packed] \\n\"\n \" mov x17, %[rhs_scales] \\n\"\n\n // Load clamp min/max from KernelArgs\n \" ld1rw z15.s, p0/z, [%x[args_ptr], %[offset_min]] \\n\" // min\n \" ld1rw z17.s, p0/z, [%x[args_ptr], %[offset_max]] \\n\" // max\n\n // Iterate over n (x8)\n // e.g. for(n_idx = 0; n_idx < n; n_idx+=n_step)\n \" mov x8, #0 \\n\"\n \" mov x0, %[N] \\n\"\n \" .inst 0x25a06511 // whilelt pn9.s, x8, x0, VLx4 \\n\"\n\n \" b.none 9f // .LOOP_N_END%= \\n\"\n\n \" 1: // .LOOP_N_START%=: \\n\"\n\n // Iterate over m (x9)\n // e.g. for(n_idx = 0; n_idx < n; n_idx+=n_step)\n \" mov x9, %[M] \\n\"\n\n // Initialize the LHS packed and scale pointers\n \" mov x22, %[lhs_packed] \\n\"\n \" mov x23, %[lhs_scales] \\n\"\n\n // Initialize the DST pointer\n \" mov x24, %[dst] \\n\"\n\n \" 2: // .LOOP_M_START%=: \\n\"\n\n // Address offset for the left and right quantized values\n \" mov x20, #0 \\n\"\n \" mov x21, #0 \\n\"\n\n // Number of output rows to store -> min(SVLh, loop M index)\n \" cmp x9, x14 \\n\"\n \" csel x15, x9, x14, lo \\n\"\n \" lsl x15, x15, #2 \\n\"\n\n // Iterate over all K values\n // e.g. for(k_idx = 0; k_idx < k; k_idx += bl)\n \" mov x10, %[K] \\n\"\n\n // Skip processing if K=0\n \" cmp x10, #0 \\n\"\n \" b.eq 8f // .LOOP_K_END%= \\n\"\n\n \" 3: // .LOOP_K_START%=: \\n\"\n\n // Zeroing of ZA accumulator\n \" .inst 0xc00800ff // zero {za} \\n\"\n\n // Load the fp16 scaling factors for the right matrix block\n \" .inst 0xa0154220 // ld1w {z0.s - z1.s}, pn8/z, [x17], x21, lsl #2] \\n\"\n \" .inst 0xc161d000 // zip {z0.h - z1.h}, z0.h, z1.h \\n\"\n\n // Iterate over all values in the block\n // k_blk_idx = bl\n // e.g. while(k_blk_idx > 0) {... k_blk_idx -= 4}\n \" ldr x5, [%x[args_ptr], %[bl]] \\n\"\n \" mov x11, x5\\n\"\n\n \" 4: // .LOOP_BL_START%=: \\n\"\n\n // Load right matrix row\n \" .inst 0xa0144202 // ld1w {z2.s - z3.s}, pn8/z, [x16], x20, lsl #2] \\n\"\n\n // Load left matrix column\n \" ld1h {z8.h}, p0/z, [x22, x20, lsl #1] \\n\"\n \" inch x20, all \\n\"\n\n // Convert Int4 -> Int8\n \" .inst 0xc08a4044 // luti4 {z4.b - z5.b}, zt0, z2[0] \\n\"\n \" .inst 0xc08a4066 // luti4 {z6.b - z7.b}, zt0, z3[0] \\n\"\n\n // Outer-products\n \" .inst 0xa0840100 // smopa za0.s, p0/m, p0/m, z8.b, z4.b \\n\"\n \" .inst 0xa0850101 // smopa za1.s, p0/m, p0/m, z8.b, z5.b \\n\"\n \" .inst 0xa0860102 // smopa za2.s, p0/m, p0/m, z8.b, z6.b \\n\"\n \" .inst 0xa0870103 // smopa za3.s, p0/m, p0/m, z8.b, z7.b \\n\"\n\n // Decrement the block loop index\n \" subs x11, x11, #4 \\n\"\n\n \" b.gt 4b // .LOOP_BL_START%= \\n\"\n\n // === End of the block loop ===\n\n // Store loop index\n \" mov w12, #0 \\n\"\n\n // Copy destination pointer for store loop\n \" mov x25, x24 \\n\"\n\n // Load the fp16 scaling factors for the left matrix block\n \" ld1b {z16.b}, p4/z, [x23, x21] \\n\"\n \" inch x21, all \\n\"\n\n // Predicate for the selection of a scaling among the vector\n \" pfalse p3.b \\n\"\n\n \" 5: // .LOOP_ZA%=: \\n\"\n\n // Select and replicate scaling factor for the right block\n \" pnext p3.h, p0, p3.h \\n\"\n \" clastb z19.h, p3, z19.h, z16.h \\n\"\n\n // Get data from za\n \" .inst 0xc006041c // mova {z28.b-z31.b}, za0h.b[w12, 0:3] \\n\"\n \" add w12, w12, #4 \\n\"\n\n // Convert from int32 to fp32\n \" .inst 0xc132e39c // scvtf {z28.s-z31.s}, {z28.s-z31.s} \\n\"\n\n // Multiply left and right scaling factors\n \" movprfx z8, z18 \\n\"\n \" fmlalb z8.s, z19.h, z0.h \\n\"\n \" movprfx z9, z18 \\n\"\n \" fmlalb z9.s, z19.h, z1.h \\n\"\n \" movprfx z10, z18 \\n\"\n \" fmlalt z10.s, z19.h, z0.h \\n\"\n \" movprfx z11, z18 \\n\"\n \" fmlalt z11.s, z19.h, z1.h \\n\"\n\n \" cmp x10, %[K] \\n\"\n \" b.ne 6f // .ACCUMULATE%= \\n\"\n\n // Applying combined scaling factors to processed block\n \" fmul z24.s, z8.s, z28.s \\n\"\n \" fmul z25.s, z9.s, z29.s \\n\"\n \" fmul z26.s, z10.s, z30.s \\n\"\n \" fmul z27.s, z11.s, z31.s \\n\"\n\n \"b 7f // .STORE%= \\n\"\n\n \" 6: // .ACCUMULATE%=: \\n\"\n // Load intermediate result\n \" .inst 0xa040c738 // ld1w {z24.s-z27.s}, pn9/z, [x25] \\n\"\n\n // Multiply the intermediate results by LHS_SCALE x RHS_SCALE\n // and store in the main floating-point accumulator\n \" fmla z24.s, p0/m, z8.s, z28.s \\n\"\n \" fmla z25.s, p0/m, z9.s, z29.s \\n\"\n \" fmla z26.s, p0/m, z10.s, z30.s \\n\"\n \" fmla z27.s, p0/m, z11.s, z31.s \\n\"\n\n \"7: // .STORE%=: \\n\"\n // Store the results into memory\n \" .inst 0xa060c738 // st1w {z24.s-z27.s}, pn9, [x25] \\n\"\n \" add x25, x25, %[stride] \\n\"\n\n \" cmp x12, x15 \\n\"\n \" blt 5b // .LOOP_ZA%= \\n\"\n\n // Decrement K loop index by bl\n \" ldr x5, [%x[args_ptr], %[bl]] \\n\"\n \" subs x10, x10, x5 \\n\"\n\n \" b.gt 3b // .LOOP_K_START%= \\n\"\n\n \" 8: // .LOOP_K_END%=: \\n\"\n\n // === End of the K loop ===\n \" ldr x5, [%x[args_ptr], %[is_clamp_valid]]\\n\"\n \" cbz x5, 11f \\n\"\n \" mov x5, x24 \\n\"\n \" mov x12, 0 \\n\"\n\n // Clamp loop\n \" 10: // .LOOP_CLAMP%=: \\n\"\n \" .inst 0xa040c718 // ld1w {z24.s-z27.s}, pn9/z, [x24] \\n\"\n // Apply clamp\n \" .inst 0xc1b1c9f8 // fclamp { z24.s - z27.s }, z15.s, z17.s \\n\"\n // Store results into memory\n \" .inst 0xa060c718 // st1w {z24.s-z27.s}, pn9, [x24] \\n\"\n\n \" add x24, x24, %[stride] \\n\"\n \" add x12, x12, #4 \\n\"\n \" cmp x12, x15 \\n\"\n\n \" blt 10b // .LOOP_CLAMP%=: \\n\"\n\n \" mov x24, x5 \\n\"\n \" 11: // .LOOP_CLAMP_END%=: \\n\"\n \" ldr x5, [%x[args_ptr], %[offset_stride_l]] \\n\"\n\n // Increment pointer to the quantized values of the right matrix\n \" add x22, x22, x5\\n\"\n\n // Increment pointer to the scaling factors of the right matrix\n \" add x23, x23, x5 \\n\"\n\n // Update destination pointer\n \" mov x24, x25 \\n\"\n\n // Decrement M loop index\n \" decw x9, all \\n\"\n\n \" cmp x9, #0 \\n\"\n \" b.gt 2b // .LOOP_M_START%= \\n\"\n\n // === End of M loop ===\n\n // Increment output pointer\n \" incb %[dst], all, mul #4 \\n\"\n\n \" ldr x5, [%x[args_ptr], %[offset_stride_r]]\\n\"\n\n \" add x16, x16, x5 \\n\"\n \" add x17, x17, x5 \\n\"\n\n // Increment N loop index\n \" incb x8, all \\n\"\n\n \" .inst 0x25a06511 // whilelt pn9.s, x8, %[N], VLx4 \\n\"\n\n \" b.first 1b // .LOOP_N_START%= \\n\"\n\n \" 9: // .LOOP_N_END%=: \\n\"\n\n // === End of N loop ===\n\n // Exit streaming mode\n \" .inst 0xd503467f // smstop \\n\"\n : [dst] \"+r\"(dst), [rhs_packed] \"+r\"(rhs_packed), [rhs_scales] \"+r\"(rhs_scales)\n : [M] \"r\"(m), [N] \"r\"(n), [K] \"r\"(k), [lhs_packed] \"r\"(lhs_packed), [lhs_scales] \"r\"(lhs_scales),\n [stride] \"r\"(dst_stride_row), [lut] \"r\"(lut), [args_ptr] \"r\"(&ka),\n [offset_stride_l] \"I\"(offsetof(KernelArgs, lhs_packed_stride)),\n [offset_stride_r] \"I\"(offsetof(KernelArgs, rhs_packed_stride)), [offset_mr] \"I\"(offsetof(KernelArgs, mr)),\n [bl] \"I\"(offsetof(KernelArgs, bl)), [is_clamp_valid] \"I\"(offsetof(KernelArgs, is_clamp_valid)),\n [offset_min] \"I\"(offsetof(KernelArgs, scalar_min)), [offset_max] \"I\"(offsetof(KernelArgs, scalar_max))\n : \"p0\", \"p1\", \"p3\", \"p4\", \"p5\", \"p6\", \"p7\", \"p8\", \"p9\", \"p10\", \"p11\", \"p12\", \"p13\", \"p14\", \"p15\", \"z0\", \"z1\",\n \"z2\", \"z3\", \"z4\", \"z5\", \"z6\", \"z7\", \"z8\", \"z9\", \"z10\", \"z11\", \"z12\", \"z13\", \"z14\", \"z15\", \"z16\", \"z17\", \"z18\",\n \"z19\", \"z20\", \"z21\", \"z22\", \"z23\", \"z24\", \"z25\", \"z26\", \"z27\", \"z28\", \"z29\", \"z30\", \"z31\", \"x0\", \"x5\", \"x6\",\n \"x8\", \"x9\", \"x10\", \"x11\", \"x12\", \"x14\", \"x15\", \"x16\", \"x17\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\", \"x25\",\n \"memory\", \"cc\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qsi8d32p_f32_neon to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon to pack the RHS NxK matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-block (32) quantization (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of m_step.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 4-bit with per-block (32) quantization (qsi4c32) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] bl Block length. It must be a multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t n_idx, //\n size_t k, //\n size_t bl); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of m_step.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of n_step.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Symmetric Signed 8-bit with per-block (32) quantization (qsi8d32) and packed\n/// RHS matrix: Quantized Symmetric Signed 4-bit with per-block (32) quantization (qsi4c32) and packed.\n/// Output tile: (rows x cols) = 1 VL x 4 VL (Vector Length)\n///\n/// Instruction used: SME2 (MOPA)\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] bl Block length. It must be a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel dependencies list at the top of this file reports\n/// the available\n/// LHS packing functions for this micro-kernel.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel dependencies list at the top of this file reports\n/// the available\n/// RHS packing functions for this micro-kernel.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n size_t bl, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32p_f32_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32p_f32_neon(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32p_f32_neon(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized symmetric per-block (qsi8d32) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of mr.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be\n/// a multiple of 32.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qsi8d32p_f32_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_lhs_quant_pack_qsi8d32p_f32_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_multiplier = sizeof(uint16_t);\n\ninline static size_t kai_num_bytes_per_block(size_t bl) {\n return bl * sizeof(int8_t) + kai_num_bytes_multiplier;\n}\n\ninline static size_t kai_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSERT((k % bl) == 0);\n return k / bl;\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t bl) {\n KAI_UNUSED(kr);\n\n return mr * kai_num_blocks_per_row(k, bl) * kai_num_bytes_per_block(bl);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qsi8d32p_f32_neon(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qsi8d32p_f32_neon(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m_idx, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((m_idx % mr) == 0);\n\n KAI_UNUSED(sr);\n KAI_UNUSED(kr);\n\n // The scales are stored after all the mr packed quantized values\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, bl);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr) {\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n KAI_UNUSED(sr);\n KAI_UNUSED(kr);\n\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return (num_rows * kai_lhs_packed_stride(k, mr, kr, bl));\n}\n\nvoid kai_run_lhs_quant_pack_qsi8d32p_f32_neon(\n size_t m, size_t k, size_t bl, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs,\n size_t lhs_stride, void* lhs_packed) {\n KAI_ASSUME((bl % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME(kr == 4);\n KAI_ASSUME((bl % 32) == 0);\n KAI_UNUSED(sr);\n KAI_UNUSED(m_idx_start);\n KAI_UNUSED(lhs_stride);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_blocks = kai_num_blocks_per_row(k, bl);\n const size_t lhs_packed_stride = kai_lhs_packed_stride(k, mr, kr, bl);\n\n const float* lhs_ptr = lhs;\n int8_t* lhs_packed_start_ptr = lhs_packed;\n\n for (size_t m_idx = 0; m_idx < m; m_idx++) {\n int8_t* lhs_packed_ptr = lhs_packed_start_ptr;\n uint16_t* lhs_packed_scales =\n (uint16_t*)(lhs_packed_ptr + lhs_packed_stride - ((mr * num_blocks) * kai_num_bytes_multiplier));\n\n lhs_packed_ptr += (m_idx % mr) * kr;\n lhs_packed_scales += (m_idx % mr);\n\n for (size_t block_idx = 0; block_idx < num_blocks; block_idx++) {\n // Maximum absolute value of the block elements\n float amax = 0.0F;\n\n for (size_t bl_idx = 0; bl_idx < bl; bl_idx++) {\n amax = KAI_MAX(amax, fabsf(lhs_ptr[bl_idx]));\n }\n\n const float sf = amax / ((1 << 7) - 1);\n\n const float sf_inv = sf ? 1.0F / sf : 0.0F;\n\n for (size_t bl_idx = 0; bl_idx < bl; bl_idx += kr) {\n for (size_t kr_idx = 0; kr_idx < kr; ++kr_idx) {\n int32_t v0_s32 = (int32_t)(roundf(lhs_ptr[kr_idx] * sf_inv));\n lhs_packed_ptr[kr_idx] = (int8_t)v0_s32;\n }\n lhs_ptr += kr;\n lhs_packed_ptr += mr * kr;\n }\n\n // Num_blocks (rows) x Mr (cols)\n lhs_packed_scales[0] = kai_cast_f16_f32(sf);\n\n lhs_packed_scales += mr;\n }\n if (((m_idx + 1) % mr) == 0) {\n lhs_packed_start_ptr += lhs_packed_stride;\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_multiplier = sizeof(uint16_t);\nstatic const size_t kai_max_bl = KAI_SME_VEC_LENGTH_MAX_BYTES;\nstatic const size_t kai_nr_tile = 4;\nstatic const size_t kai_bl_multiple_of = 32;\n\n#if defined(_MSC_VER)\n#define KAI_ALIGNED_AS(N) __declspec(align(N))\n#elif defined(__GNUC__) || defined(__clang__)\n#define KAI_ALIGNED_AS(N) __attribute__((aligned(N)))\n#else\n#define KAI_ALIGNED_AS(N)\n#endif\n\nstatic inline void convert_chunk32_s1s0_s16s0(uint8_t* dst_lo, uint8_t* dst_hi, const uint8_t* src_ptr) {\n // Two sequential 128-bit loads followed by unzip have better throughput than a structured LD2.\n const uint8x16_t v0 = vld1q_u8(src_ptr);\n const uint8x16_t v1 = vld1q_u8(src_ptr + 16);\n\n const uint8x16_t even_bytes = vuzp1q_u8(v0, v1);\n const uint8x16_t odd_bytes = vuzp2q_u8(v0, v1);\n\n const uint8x16_t lo_pairs = vsliq_n_u8(even_bytes, odd_bytes, 4);\n const uint8x16_t hi_pairs = vsriq_n_u8(odd_bytes, even_bytes, 4);\n\n vst1q_u8(dst_lo, lo_pairs);\n vst1q_u8(dst_hi, hi_pairs);\n}\n\nstatic inline void convert_tail16_s1s0_s16s0(uint8_t* dst_lo, uint8_t* dst_hi, const uint8_t* src_ptr) {\n const uint8x16_t v0 = vld1q_u8(src_ptr);\n const uint8x16_t even_dup = vuzp1q_u8(v0, v0);\n const uint8x16_t odd_dup = vuzp2q_u8(v0, v0);\n\n const uint8x16_t lo_pairs_dup = vsliq_n_u8(even_dup, odd_dup, 4);\n const uint8x16_t hi_pairs_dup = vsriq_n_u8(odd_dup, even_dup, 4);\n const uint8x16_t packed = vcombine_u8(vget_low_u8(lo_pairs_dup), vget_low_u8(hi_pairs_dup));\n\n KAI_ALIGNED_AS(16) uint8_t tmp[16];\n vst1q_u8(tmp, packed);\n\n for (size_t i = 0; i < 8; ++i) {\n dst_lo[i] = tmp[i];\n dst_hi[i] = tmp[8 + i];\n }\n}\n\nstatic inline void convert_s1s0_s16s0_scalar(uint16_t* dst_blk, const uint8_t* src_blk, size_t bl) {\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n for (size_t bl4_idx = 0; bl4_idx < bl / 4; bl4_idx++) {\n const size_t byte_idx0 = bl4_idx * 2;\n const size_t byte_idx1 = byte_idx0 + 1;\n uint8_t packed0 = 0;\n uint8_t packed1 = 0;\n\n if (byte_idx0 < split) {\n // First half of byte0: pack low nibbles into sequential order.\n const size_t k0 = byte_idx0 * 2;\n packed0 = (src_blk[k0] & 0xF) | (src_blk[k0 + 1] << 4);\n } else {\n // Second half of byte0: pack high nibbles into sequential order.\n const size_t k0 = byte_idx0 * 2 - half;\n packed0 = (src_blk[k0] >> 4) | (src_blk[k0 + 1] & 0xF0);\n }\n // Repeated for byte1\n if (byte_idx1 < split) {\n const size_t k1 = byte_idx1 * 2;\n packed1 = (src_blk[k1] & 0xF) | (src_blk[k1 + 1] << 4);\n } else {\n const size_t k1 = byte_idx1 * 2 - half;\n packed1 = (src_blk[k1] >> 4) | (src_blk[k1 + 1] & 0xF0);\n }\n dst_blk[bl4_idx] = (uint16_t)packed0 | ((uint16_t)packed1 << 8);\n }\n}\n\nstatic inline void convert_s1s0_s16s0_neon(uint16_t* dst_blk, const uint8_t* src_blk, size_t bl) {\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n uint8_t* dst_bytes = (uint8_t*)dst_blk;\n uint8_t* dst_low = dst_bytes;\n uint8_t* dst_high = dst_bytes + split;\n\n // Special-case bl == 32 (half == 16) so that the whole block is\n // handled with a single 128-bit load and store.\n if (half == 16) {\n const uint8x16_t v0 = vld1q_u8(src_blk);\n const uint8x16_t even_dup = vuzp1q_u8(v0, v0);\n const uint8x16_t odd_dup = vuzp2q_u8(v0, v0);\n\n const uint8x16_t lo_pairs_dup = vsliq_n_u8(even_dup, odd_dup, 4);\n const uint8x16_t hi_pairs_dup = vsriq_n_u8(odd_dup, even_dup, 4);\n\n const uint8x16_t packed = vcombine_u8(vget_low_u8(lo_pairs_dup), vget_low_u8(hi_pairs_dup));\n vst1q_u8(dst_bytes, packed);\n return;\n }\n\n const uint8_t* src_ptr = src_blk;\n uint8_t* dst_low_ptr = dst_low;\n uint8_t* dst_high_ptr = dst_high;\n\n size_t remaining = half;\n\n // Process two 32-byte chunks per iteration when possible to reduce loop\n // overhead while keeping all loads and stores 128-bit wide.\n for (; remaining >= 64; remaining -= 64) {\n convert_chunk32_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n convert_chunk32_s1s0_s16s0(dst_low_ptr + 16, dst_high_ptr + 16, src_ptr + 32);\n\n src_ptr += 64;\n dst_low_ptr += 32;\n dst_high_ptr += 32;\n }\n for (; remaining >= 32; remaining -= 32) {\n convert_chunk32_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n\n src_ptr += 32;\n dst_low_ptr += 16;\n dst_high_ptr += 16;\n }\n\n // Handle the remaining 16 bytes (if any) using a single 128-bit load\n // and store to a temporary buffer, followed by scalar writes.\n if (remaining != 0) {\n convert_tail16_s1s0_s16s0(dst_low_ptr, dst_high_ptr, src_ptr);\n }\n}\n\nstatic inline void convert_s1s0_s16s0_neon_rows4(\n uint16_t* dst0, uint16_t* dst1, uint16_t* dst2, uint16_t* dst3, const uint8_t* src0, const uint8_t* src1,\n const uint8_t* src2, const uint8_t* src3, size_t bl) {\n KAI_ASSUME((bl % kai_bl_multiple_of) == 0);\n\n const size_t half = bl / 2;\n const size_t split = bl / 4;\n\n uint8_t* dst0_bytes = (uint8_t*)dst0;\n uint8_t* dst1_bytes = (uint8_t*)dst1;\n uint8_t* dst2_bytes = (uint8_t*)dst2;\n uint8_t* dst3_bytes = (uint8_t*)dst3;\n\n uint8_t* dst0_low = dst0_bytes;\n uint8_t* dst1_low = dst1_bytes;\n uint8_t* dst2_low = dst2_bytes;\n uint8_t* dst3_low = dst3_bytes;\n\n uint8_t* dst0_high = dst0_bytes + split;\n uint8_t* dst1_high = dst1_bytes + split;\n uint8_t* dst2_high = dst2_bytes + split;\n uint8_t* dst3_high = dst3_bytes + split;\n\n // bl == 32 (half == 16) is common and can be handled without a loop.\n if (half == 16) {\n const uint8x16_t r0 = vld1q_u8(src0);\n const uint8x16_t r1 = vld1q_u8(src1);\n const uint8x16_t r2 = vld1q_u8(src2);\n const uint8x16_t r3 = vld1q_u8(src3);\n\n const uint8x16_t r0_even = vuzp1q_u8(r0, r0);\n const uint8x16_t r0_odd = vuzp2q_u8(r0, r0);\n const uint8x16_t r1_even = vuzp1q_u8(r1, r1);\n const uint8x16_t r1_odd = vuzp2q_u8(r1, r1);\n const uint8x16_t r2_even = vuzp1q_u8(r2, r2);\n const uint8x16_t r2_odd = vuzp2q_u8(r2, r2);\n const uint8x16_t r3_even = vuzp1q_u8(r3, r3);\n const uint8x16_t r3_odd = vuzp2q_u8(r3, r3);\n\n const uint8x16_t r0_lo = vsliq_n_u8(r0_even, r0_odd, 4);\n const uint8x16_t r0_hi = vsriq_n_u8(r0_odd, r0_even, 4);\n const uint8x16_t r1_lo = vsliq_n_u8(r1_even, r1_odd, 4);\n const uint8x16_t r1_hi = vsriq_n_u8(r1_odd, r1_even, 4);\n const uint8x16_t r2_lo = vsliq_n_u8(r2_even, r2_odd, 4);\n const uint8x16_t r2_hi = vsriq_n_u8(r2_odd, r2_even, 4);\n const uint8x16_t r3_lo = vsliq_n_u8(r3_even, r3_odd, 4);\n const uint8x16_t r3_hi = vsriq_n_u8(r3_odd, r3_even, 4);\n\n const uint8x16_t r0_packed = vcombine_u8(vget_low_u8(r0_lo), vget_low_u8(r0_hi));\n const uint8x16_t r1_packed = vcombine_u8(vget_low_u8(r1_lo), vget_low_u8(r1_hi));\n const uint8x16_t r2_packed = vcombine_u8(vget_low_u8(r2_lo), vget_low_u8(r2_hi));\n const uint8x16_t r3_packed = vcombine_u8(vget_low_u8(r3_lo), vget_low_u8(r3_hi));\n\n vst1q_u8(dst0_bytes, r0_packed);\n vst1q_u8(dst1_bytes, r1_packed);\n vst1q_u8(dst2_bytes, r2_packed);\n vst1q_u8(dst3_bytes, r3_packed);\n return;\n }\n\n const uint8_t* src0_ptr = src0;\n const uint8_t* src1_ptr = src1;\n const uint8_t* src2_ptr = src2;\n const uint8_t* src3_ptr = src3;\n\n size_t remaining = half;\n\n for (; remaining >= 64; remaining -= 64) {\n convert_chunk32_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_chunk32_s1s0_s16s0(dst0_low + 16, dst0_high + 16, src0_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_chunk32_s1s0_s16s0(dst1_low + 16, dst1_high + 16, src1_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_chunk32_s1s0_s16s0(dst2_low + 16, dst2_high + 16, src2_ptr + 32);\n convert_chunk32_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n convert_chunk32_s1s0_s16s0(dst3_low + 16, dst3_high + 16, src3_ptr + 32);\n\n src0_ptr += 64;\n src1_ptr += 64;\n src2_ptr += 64;\n src3_ptr += 64;\n\n dst0_low += 32;\n dst1_low += 32;\n dst2_low += 32;\n dst3_low += 32;\n\n dst0_high += 32;\n dst1_high += 32;\n dst2_high += 32;\n dst3_high += 32;\n }\n for (; remaining >= 32; remaining -= 32) {\n convert_chunk32_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_chunk32_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_chunk32_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_chunk32_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n\n src0_ptr += 32;\n src1_ptr += 32;\n src2_ptr += 32;\n src3_ptr += 32;\n\n dst0_low += 16;\n dst1_low += 16;\n dst2_low += 16;\n dst3_low += 16;\n\n dst0_high += 16;\n dst1_high += 16;\n dst2_high += 16;\n dst3_high += 16;\n }\n\n if (remaining != 0) {\n convert_tail16_s1s0_s16s0(dst0_low, dst0_high, src0_ptr);\n convert_tail16_s1s0_s16s0(dst1_low, dst1_high, src1_ptr);\n convert_tail16_s1s0_s16s0(dst2_low, dst2_high, src2_ptr);\n convert_tail16_s1s0_s16s0(dst3_low, dst3_high, src3_ptr);\n }\n}\n\nstatic inline void interleave_rows4_u16(\n uint16_t* dst_row_base, size_t nr, const uint16_t* row0, const uint16_t* row1, const uint16_t* row2,\n const uint16_t* row3, size_t bl4) {\n uint16_t* dst_ptr = dst_row_base;\n\n const uint16_t* row0_ptr = row0;\n const uint16_t* row1_ptr = row1;\n const uint16_t* row2_ptr = row2;\n const uint16_t* row3_ptr = row3;\n\n size_t remaining = bl4;\n\n // Store two columns per iteration to reduce branch and address-generation\n // overhead while keeping all loads sequential.\n for (; remaining >= 2; remaining -= 2) {\n const uint64_t packed0 = (uint64_t)row0_ptr[0] | ((uint64_t)row1_ptr[0] << 16) | ((uint64_t)row2_ptr[0] << 32) |\n ((uint64_t)row3_ptr[0] << 48);\n const uint64_t packed1 = (uint64_t)row0_ptr[1] | ((uint64_t)row1_ptr[1] << 16) | ((uint64_t)row2_ptr[1] << 32) |\n ((uint64_t)row3_ptr[1] << 48);\n\n *((uint64_t*)dst_ptr) = packed0;\n *((uint64_t*)(dst_ptr + nr)) = packed1;\n\n row0_ptr += 2;\n row1_ptr += 2;\n row2_ptr += 2;\n row3_ptr += 2;\n dst_ptr += 2 * nr;\n }\n\n if (remaining != 0) {\n const uint64_t packed = (uint64_t)row0_ptr[0] | ((uint64_t)row1_ptr[0] << 16) | ((uint64_t)row2_ptr[0] << 32) |\n ((uint64_t)row3_ptr[0] << 48);\n *((uint64_t*)dst_ptr) = packed;\n }\n}\n\nstatic inline void store_row_strided_u16(\n uint16_t* dst_block_base, size_t row_idx, size_t nr, const uint16_t* src_vals, size_t bl4, size_t nr1, size_t nr2,\n size_t nr3, size_t dst_step) {\n const uint16_t* src_ptr = src_vals;\n uint16_t* dst_ptr = dst_block_base + row_idx;\n\n size_t remaining_bl4 = bl4;\n for (; remaining_bl4 >= 4; remaining_bl4 -= 4) {\n dst_ptr[0] = src_ptr[0];\n dst_ptr[nr1] = src_ptr[1];\n dst_ptr[nr2] = src_ptr[2];\n dst_ptr[nr3] = src_ptr[3];\n src_ptr += 4;\n dst_ptr += dst_step;\n }\n for (; remaining_bl4 != 0; --remaining_bl4) {\n *dst_ptr = *src_ptr;\n ++src_ptr;\n dst_ptr += nr;\n }\n}\n\ninline static size_t kai_num_blocks_per_row(size_t k, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n return kai_roundup(k, bl) / bl;\n}\n\ninline static size_t kai_num_bytes_per_block(size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n return (bl / 2) + kai_num_bytes_multiplier;\n}\n\ninline static size_t kai_rhs_stride(size_t k, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n\n return num_bytes_per_block * num_blocks_per_row;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_blocks_per_row = kai_num_blocks_per_row(k, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n\n return nr * (num_bytes_per_block * num_blocks_per_row);\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME((n_idx % nr) == 0);\n\n // The scales are stored after all the nr packed quantized values\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t bl) {\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, size_t bl, const uint8_t* rhs,\n const float* bias, void* rhs_packed, size_t extra_bytes, const struct kai_rhs_pack_qs4cxs1s0_param* params) {\n KAI_ASSUME(num_groups == 1);\n KAI_ASSUME((bl % 32) == 0);\n KAI_ASSUME(bl <= kai_max_bl);\n KAI_ASSUME((k % 2) == 0);\n KAI_ASSUME((k % kr) == 0);\n KAI_ASSUME((k % bl) == 0);\n KAI_ASSUME(bias == NULL);\n KAI_ASSUME(extra_bytes == 0);\n\n KAI_ASSUME(kr == 4);\n KAI_ASSUME(sr == 2);\n KAI_ASSUME(kr >= 1 && kr <= 16);\n KAI_ASSUME(rhs != NULL);\n KAI_ASSUME(rhs_packed != NULL);\n KAI_ASSUME(params != NULL);\n KAI_ASSUME(params->rhs_zero_point == 8);\n KAI_ASSUME(params->lhs_zero_point == 1);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t num_blocks = k / bl;\n const size_t rhs_stride = kai_rhs_stride(k, bl);\n const size_t rhs_packed_stride =\n kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(k, nr, kr, bl);\n const size_t num_bytes_per_block = kai_num_bytes_per_block(bl);\n const size_t bl4 = bl / 4;\n const size_t block_stride_u16 = bl4 * nr;\n const size_t scales_offset = rhs_packed_stride - (nr * num_blocks * kai_num_bytes_multiplier);\n\n uint8_t* rhs_packed_ptr = rhs_packed;\n\n if (kr == 4 && sr == 2 && (nr % kai_nr_tile) == 0 && (bl % kai_bl_multiple_of) == 0) {\n // Reuse scratch buffers across all rows and blocks. Four buffers allow\n // row-block interleaving with wide stores across the contiguous row\n // dimension.\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_0[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_1[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_2[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n KAI_ALIGNED_AS(16) uint16_t blk_s1s0_rows_3[KAI_SME_VEC_LENGTH_MAX_BYTES / 4] = {0};\n\n const size_t nr1 = nr;\n const size_t nr2 = nr1 + nr;\n const size_t nr3 = nr2 + nr;\n const size_t dst_step = nr3 + nr;\n\n for (size_t group_start = 0; group_start < n; group_start += nr, rhs_packed_ptr += rhs_packed_stride) {\n const size_t rows_in_group = KAI_MIN(n - group_start, nr);\n const uint8_t* rhs_group_base = rhs + group_start * rhs_stride;\n\n uint16_t* group_base_u16 = (uint16_t*)rhs_packed_ptr;\n uint16_t* rhs_packed_scales = (uint16_t*)(rhs_packed_ptr + scales_offset);\n\n const uint8_t* src_block_base = rhs_group_base;\n uint16_t* dst_block_base = group_base_u16;\n uint16_t* scales_block = rhs_packed_scales;\n\n for (size_t block_idx = 0; block_idx < num_blocks; ++block_idx) {\n size_t row_idx = 0;\n const uint8_t* src_row_block = src_block_base;\n\n for (; row_idx + kai_nr_tile <= rows_in_group;\n row_idx += kai_nr_tile, src_row_block += kai_nr_tile * rhs_stride) {\n const uint8_t* restrict src_row0 = src_row_block;\n const uint8_t* restrict src_row1 = src_row0 + rhs_stride;\n const uint8_t* restrict src_row2 = src_row1 + rhs_stride;\n const uint8_t* restrict src_row3 = src_row2 + rhs_stride;\n\n const uint16_t scale0 = *((const uint16_t*)src_row0);\n const uint16_t scale1 = *((const uint16_t*)src_row1);\n const uint16_t scale2 = *((const uint16_t*)src_row2);\n const uint16_t scale3 = *((const uint16_t*)src_row3);\n\n const uint64_t packed_scales = (uint64_t)scale0 | ((uint64_t)scale1 << 16) |\n ((uint64_t)scale2 << 32) | ((uint64_t)scale3 << 48);\n *((uint64_t*)(scales_block + row_idx)) = packed_scales;\n\n convert_s1s0_s16s0_neon_rows4(\n blk_s1s0_rows_0, blk_s1s0_rows_1, blk_s1s0_rows_2, blk_s1s0_rows_3,\n src_row0 + kai_num_bytes_multiplier, src_row1 + kai_num_bytes_multiplier,\n src_row2 + kai_num_bytes_multiplier, src_row3 + kai_num_bytes_multiplier, bl);\n\n interleave_rows4_u16(\n dst_block_base + row_idx, nr, blk_s1s0_rows_0, blk_s1s0_rows_1, blk_s1s0_rows_2,\n blk_s1s0_rows_3, bl4);\n }\n\n for (; row_idx < rows_in_group; ++row_idx, src_row_block += rhs_stride) {\n const uint16_t* blk_scale_ptr = (const uint16_t*)src_row_block;\n const uint8_t* blk_s16s0 = src_row_block + kai_num_bytes_multiplier;\n\n scales_block[row_idx] = *blk_scale_ptr;\n\n convert_s1s0_s16s0_neon(blk_s1s0_rows_0, blk_s16s0, bl);\n store_row_strided_u16(dst_block_base, row_idx, nr, blk_s1s0_rows_0, bl4, nr1, nr2, nr3, dst_step);\n }\n\n src_block_base += num_bytes_per_block;\n dst_block_base += block_stride_u16;\n scales_block += nr;\n }\n }\n return;\n }\n\n for (uint64_t n_idx = 0; n_idx < n; n_idx++) {\n uint16_t* rhs_packed_scales =\n (uint16_t*)(rhs_packed_ptr + rhs_packed_stride - (nr * num_blocks * kai_num_bytes_multiplier));\n\n for (size_t block_idx = 0; block_idx < num_blocks; block_idx++) {\n uint16_t blk_s1s0[KAI_SME_VEC_LENGTH_MAX_BYTES / 4];\n\n const uint16_t* blk_scale_ptr =\n (const uint16_t*)(rhs + (block_idx * num_bytes_per_block) + n_idx * rhs_stride);\n const uint8_t* blk_s16s0 = (const uint8_t*)blk_scale_ptr + kai_num_bytes_multiplier;\n\n convert_s1s0_s16s0_scalar(blk_s1s0, blk_s16s0, bl);\n\n for (size_t bl4_idx = 0; bl4_idx < bl / 4; bl4_idx++) {\n // Uint16 holds 4 int4 values\n ((uint16_t*)rhs_packed_ptr)[(block_idx * bl / 4 + bl4_idx) * nr + (n_idx % nr)] = blk_s1s0[bl4_idx];\n }\n\n // Num. block (rows) x Nr (cols)\n rhs_packed_scales[(n_idx % nr) + block_idx * nr] = *blk_scale_ptr;\n }\n\n if (((n_idx + 1) % nr) == 0) {\n rhs_packed_ptr += rhs_packed_stride;\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the offset in bytes for the RHS matrix (not packed), which holds\n/// the int4 values in a N x K matrix, where N is number of rows and K is the number of columns.\n///\n/// Two int4 K values are stored in one byte. These values are stored in blocks, where each block\n/// has it own scale factor. The scale factor is expected to be a f16 value and stored at the beginning of each block.\n/// The first byte in the block holds the K-index + 0 and K-index + 16 values.\n/// The K-index + 0 value is stored in the lower order part of the byte (low nibble) while\n/// the K-index + 16 value is stored in the higher order part (high nibble).\n/// For example, if the block length is 32, the values are stored in the following order:\n/// |byte(s16, s0),byte(s17, s1),byte(s18, s2),...,byte(s31, s15),float16(scale)|\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, //\n size_t rhs_stride); //\n\n/// Gets the offset in bytes for the packed RHS matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n_idx, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl); //\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a\n/// multiple of 32.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl);\n\n/// Gets the size in bytes for the quantized and packed RHS matrix.\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] bl The block length, which defines the number of K values stored in a single block. It must be a multiple\n/// of 32.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t bl); //\n\n/// Runs the RHS packing micro-kernel.\n///\n/// The int4 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Two int4 values are stored in one byte. The lower order part of the byte (low) holds\n/// the first nibble (K-index + 0). The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] bl The block length, which defines the number of\n/// K values stored in a single block. It must be a multiple of 32.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] bias The biases.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n size_t bl, //\n const uint8_t* rhs, //\n const float* bias, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_qs4cxs1s0_param* params); //\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa against gemm_qs4c32_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qsi8d32p_f32_neon.h\"\n#include \"kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr size_t BL = 32;\n// Interleave B_q4 [N, K/2] and the raw f16 B_scales [N, K/32] into the per-block [scale f16][16 data bytes]\n// layout kai_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon expects.\nvoid interleave_qs4c32(const uint8_t* b_q4, const uint16_t* b_scales, uint8_t* dst) {\n const size_t nb = K / BL, data = BL / 2;\n for (size_t n = 0; n < (size_t)N; ++n)\n for (size_t b = 0; b < nb; ++b) {\n std::memcpy(dst, &b_scales[n * nb + b], sizeof(uint16_t));\n dst += sizeof(uint16_t);\n std::memcpy(dst, b_q4 + (n * nb + b) * data, data);\n dst += data;\n }\n}\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qsi8d32p_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qsi8d32p_f32_neon((size_t)M, (size_t)K, BL, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(uint16_t)*N*(K/BL));\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon((size_t)N, (size_t)K, nr, kr, BL);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n const size_t nb = K / BL;\n uint8_t* inter = static_cast(std::malloc((size_t)N * nb * (BL / 2 + sizeof(uint16_t))));\n if (inter == nullptr) return -1;\n interleave_qs4c32(B_q4, B_scales, inter);\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qsi4c32ps1s0scalef16_qsu4c32s16s0_neon(1, (size_t)N, (size_t)K, nr, kr, sr, BL, inter, nullptr, rhs_packed, 0, ¶ms);\n std::free(inter);\n }\n\n kai_run_matmul_clamp_f32_qsi8d32p1vlx4_qsi4c32p4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, BL, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4cx_n512_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..4b1950fae9cbb021b7a15ee089be6c5e6a6743ce --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs4cx_n512_k512.json @@ -0,0 +1,67 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qs4cx_n512_k512", + "definition": "gemm_qs4cx_n512_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qs4cx_n512_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "dotprod", + "i8mm" + ], + "compile_flags": [ + "-O3", + "-march=armv8.2-a+dotprod+i8mm" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_kxn_qsi4cxp_qs4cxs1s0 OR kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0 to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix with\n/// the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of 4.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 4-bit quantized symmetric per-channel (qsu4cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of 8.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of 4.\n/// @param[in] n_idx Column index in the DST matrix. It must be a multiple of 8.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dx) and packed\n/// RHS matrix: Signed 4-bit quantized symmetric per-channel (qsu4cx) and packed.\n/// Output tile: (rows x cols) = 4 x 8\n/// Accumulation performed in a single for loop: 32\n/// Instruction used: i8mm\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS.\n/// @param[in] lhs_packed The LHS matrix packed.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS matrix packed, which is obtained by calling @ref\n/// kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0\n/// @param[out] dst Result of the vector-by-matrix\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. For now, it must be sizeof(float)\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, float* dst, size_t dst_stride_row,\n size_t dst_stride_col, float scalar_min, float scalar_max);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n// Do not flag up inline assembly blocks\n#pragma GCC diagnostic ignored \"-Woverlength-strings\"\n\n#if !defined(__ARM_FEATURE_MATMUL_INT8)\n#error \"I8mm extension required to compile this micro-kernel\"\n#else\n#include \"kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_m_step = 4;\nstatic const size_t kai_n_step = 8;\nstatic const size_t kai_mr = 4;\nstatic const size_t kai_nr = 8;\nstatic const size_t kai_kr = 16;\nstatic const size_t kai_sr = 2;\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Since we pack a float and int32 value at the end of the row,\n // we must make sure that k is a multiple of 4 for alignment\n size_t kr_sr_roundedup4 = kai_roundup(kai_kr * kai_sr, 4);\n return kai_roundup(k, kr_sr_roundedup4);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return kai_mr * (k_internal * sizeof(int8_t) + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\ninline static size_t kai_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return kai_nr * ((k_internal / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t m_idx, size_t k) {\n KAI_ASSERT((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t n_idx, size_t k) {\n KAI_ASSERT((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSERT((m_idx % kai_m_step) == 0);\n KAI_ASSERT((n_idx % kai_n_step) == 0);\n\n return (n_idx * sizeof(float)) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(size_t m, size_t n) {\n return m * n * sizeof(float);\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max) {\n KAI_ASSERT(dst_stride_col == sizeof(float));\n\n if (m == 0) {\n return;\n }\n\n const size_t k_internal = kai_k_roundedup(k);\n\n size_t num_blocks = k_internal / 32;\n\n float clamp_vals[2] = {scalar_min, scalar_max};\n\n __asm__ __volatile__(\n \"mov x28, #0x80\\n\"\n \"mov x20, #0x20\\n\"\n \"movi v12.16b, #0xf0\\n\"\n \"mov x27, %x[m]\\n\"\n \"madd x28, %x[num_blocks], x28, x20\\n\"\n \"cbz x27, 11f\\n\"\n \"1:\" // Row loop\n \"mov x26, %x[rhs_packed]\\n\"\n \"mov x25, %x[n]\\n\"\n \"add x24, %x[dst], %x[dst_stride_row], LSL #2\\n\"\n \"2:\" // Column loop\n \"mov x21, %x[lhs_packed]\\n\"\n \"movi v11.4s, #0x0\\n\"\n \"movi v10.4s, #0x0\\n\"\n \"mov x20, %x[num_blocks]\\n\"\n \"movi v9.4s, #0x0\\n\"\n \"movi v8.4s, #0x0\\n\"\n \"movi v7.4s, #0x0\\n\"\n \"movi v6.4s, #0x0\\n\"\n \"movi v5.4s, #0x0\\n\"\n \"movi v4.4s, #0x0\\n\"\n \"3:\" // Sub block loop\n \"ldr q3, [x26, #0x0]\\n\"\n \"ldr q2, [x26, #0x10]\\n\"\n \"subs x20, x20, #0x1\\n\"\n \"ldr q1, [x26, #0x20]\\n\"\n \"ldr q0, [x26, #0x30]\\n\"\n \"ldr q31, [x21, #0x0]\\n\"\n \"ldr q30, [x21, #0x10]\\n\"\n \"ldr q29, [x26, #0x40]\\n\"\n \"ldr q28, [x26, #0x50]\\n\"\n \"shl v19.16b, v3.16b, #0x4\\n\"\n \"shl v18.16b, v2.16b, #0x4\\n\"\n \"ldr q27, [x26, #0x60]\\n\"\n \"ldr q26, [x26, #0x70]\\n\"\n \"shl v17.16b, v1.16b, #0x4\\n\"\n \"shl v16.16b, v0.16b, #0x4\\n\"\n \"ldr q25, [x21, #0x20]\\n\"\n \"ldr q24, [x21, #0x30]\\n\"\n \"and v3.16b, v3.16b, v12.16b\\n\"\n \"and v2.16b, v2.16b, v12.16b\\n\"\n \"ldr q23, [x21, #0x40]\\n\"\n \"ldr q22, [x21, #0x50]\\n\"\n \".inst 0x4e93a7eb // smmla v11.4s, v31.16b, v19.16b\\n\"\n \".inst 0x4e92a7e9 // smmla v9.4s, v31.16b, v18.16b\\n\"\n \"ldr q21, [x21, #0x60]\\n\"\n \"ldr q20, [x21, #0x70]\\n\"\n \".inst 0x4e91a7ea // smmla v10.4s, v31.16b, v17.16b\\n\"\n \".inst 0x4e90a7e8 // smmla v8.4s, v31.16b, v16.16b\\n\"\n \".inst 0x4e93a7c7 // smmla v7.4s, v30.16b, v19.16b\\n\"\n \".inst 0x4e92a7c5 // smmla v5.4s, v30.16b, v18.16b\\n\"\n \"shl v19.16b, v29.16b, #0x4\\n\"\n \"add x26, x26, #0x80\\n\"\n \".inst 0x4e91a7c6 // smmla v6.4s, v30.16b, v17.16b\\n\"\n \".inst 0x4e90a7c4 // smmla v4.4s, v30.16b, v16.16b\\n\"\n \"shl v18.16b, v28.16b, #0x4\\n\"\n \"add x21, x21, #0x80\\n\"\n \"shl v17.16b, v27.16b, #0x4\\n\"\n \"shl v16.16b, v26.16b, #0x4\\n\"\n \".inst 0x4e93a72b // smmla v11.4s, v25.16b, v19.16b\\n\"\n \"and v1.16b, v1.16b, v12.16b\\n\"\n \"and v0.16b, v0.16b, v12.16b\\n\"\n \".inst 0x4e92a729 // smmla v9.4s, v25.16b, v18.16b\\n\"\n \".inst 0x4e93a707 // smmla v7.4s, v24.16b, v19.16b\\n\"\n \".inst 0x4e92a705 // smmla v5.4s, v24.16b, v18.16b\\n\"\n \"and v29.16b, v29.16b, v12.16b\\n\"\n \".inst 0x4e91a72a // smmla v10.4s, v25.16b, v17.16b\\n\"\n \".inst 0x4e90a728 // smmla v8.4s, v25.16b, v16.16b\\n\"\n \"and v28.16b, v28.16b, v12.16b\\n\"\n \".inst 0x4e91a706 // smmla v6.4s, v24.16b, v17.16b\\n\"\n \".inst 0x4e90a704 // smmla v4.4s, v24.16b, v16.16b\\n\"\n \"and v27.16b, v27.16b, v12.16b\\n\"\n \".inst 0x4e83a6eb // smmla v11.4s, v23.16b, v3.16b\\n\"\n \".inst 0x4e82a6e9 // smmla v9.4s, v23.16b, v2.16b\\n\"\n \"and v26.16b, v26.16b, v12.16b\\n\"\n \".inst 0x4e83a6c7 // smmla v7.4s, v22.16b, v3.16b\\n\"\n \".inst 0x4e82a6c5 // smmla v5.4s, v22.16b, v2.16b\\n\"\n \".inst 0x4e81a6ea // smmla v10.4s, v23.16b, v1.16b\\n\"\n \".inst 0x4e80a6e8 // smmla v8.4s, v23.16b, v0.16b\\n\"\n \".inst 0x4e81a6c6 // smmla v6.4s, v22.16b, v1.16b\\n\"\n \".inst 0x4e80a6c4 // smmla v4.4s, v22.16b, v0.16b\\n\"\n \".inst 0x4e9da6ab // smmla v11.4s, v21.16b, v29.16b\\n\"\n \".inst 0x4e9ca6a9 // smmla v9.4s, v21.16b, v28.16b\\n\"\n \".inst 0x4e9da687 // smmla v7.4s, v20.16b, v29.16b\\n\"\n \".inst 0x4e9ca685 // smmla v5.4s, v20.16b, v28.16b\\n\"\n \".inst 0x4e9ba6aa // smmla v10.4s, v21.16b, v27.16b\\n\"\n \".inst 0x4e9aa6a8 // smmla v8.4s, v21.16b, v26.16b\\n\"\n \".inst 0x4e9ba686 // smmla v6.4s, v20.16b, v27.16b\\n\"\n \".inst 0x4e9aa684 // smmla v4.4s, v20.16b, v26.16b\\n\"\n \"bgt 3b\\n\"\n \"ldr q20, [x26, #0x0]\\n\"\n \"ldr q19, [x26, #0x10]\\n\"\n \"uzp1 v0.2d, v11.2d, v9.2d\\n\"\n \"uzp2 v31.2d, v11.2d, v9.2d\\n\"\n \"ld1 { v18.4s }, [x21]\\n\"\n \"ldr q17, [x26, #0x20]\\n\"\n \"uzp1 v30.2d, v10.2d, v8.2d\\n\"\n \"uzp2 v29.2d, v10.2d, v8.2d\\n\"\n \"ldr q28, [x26, #0x30]\\n\"\n \"uzp1 v27.2d, v7.2d, v5.2d\\n\"\n \"uzp2 v26.2d, v7.2d, v5.2d\\n\"\n \"add x21, x21, #0x10\\n\"\n \"ldr q16, [x21, #0x0]\\n\"\n \"uzp1 v25.2d, v6.2d, v4.2d\\n\"\n \"uzp2 v24.2d, v6.2d, v4.2d\\n\"\n \"add x26, x26, #0x40\\n\"\n \"mla v0.4s, v20.4s, v18.s[0]\\n\"\n \"mla v30.4s, v19.4s, v18.s[0]\\n\"\n \"mla v31.4s, v20.4s, v18.s[1]\\n\"\n \"mla v29.4s, v19.4s, v18.s[1]\\n\"\n \"mla v27.4s, v20.4s, v18.s[2]\\n\"\n \"mla v25.4s, v19.4s, v18.s[2]\\n\"\n \"fmul v23.4s, v17.4s, v16.s[0]\\n\"\n \"mla v26.4s, v20.4s, v18.s[3]\\n\"\n \"mla v24.4s, v19.4s, v18.s[3]\\n\"\n \"fmul v22.4s, v28.4s, v16.s[0]\\n\"\n \"scvtf v0.4s, v0.4s\\n\"\n \"scvtf v30.4s, v30.4s\\n\"\n \"fmul v21.4s, v17.4s, v16.s[1]\\n\"\n \"scvtf v31.4s, v31.4s\\n\"\n \"fmul v20.4s, v28.4s, v16.s[1]\\n\"\n \"scvtf v29.4s, v29.4s\\n\"\n \"fmul v19.4s, v17.4s, v16.s[2]\\n\"\n \"scvtf v27.4s, v27.4s\\n\"\n \"fmul v18.4s, v28.4s, v16.s[2]\\n\"\n \"scvtf v25.4s, v25.4s\\n\"\n \"fmul v17.4s, v17.4s, v16.s[3]\\n\"\n \"scvtf v26.4s, v26.4s\\n\"\n \"fmul v16.4s, v28.4s, v16.s[3]\\n\"\n \"scvtf v24.4s, v24.4s\\n\"\n \"fmul v11.4s, v0.4s, v23.4s\\n\"\n \"fmul v10.4s, v30.4s, v22.4s\\n\"\n \"fmul v9.4s, v31.4s, v21.4s\\n\"\n \"fmul v8.4s, v29.4s, v20.4s\\n\"\n \"fmul v7.4s, v27.4s, v19.4s\\n\"\n \"fmul v6.4s, v25.4s, v18.4s\\n\"\n \"fmul v5.4s, v26.4s, v17.4s\\n\"\n \"fmul v4.4s, v24.4s, v16.4s\\n\"\n \"ldr q19, [x26, #0x0]\\n\"\n \"ldr q18, [x26, #0x10]\\n\"\n \"add x20, %x[clamp_vals], #0x4\\n\"\n \"cmp x25, #0x8\\n\"\n \"ld1r { v17.4s }, [%x[clamp_vals]]\\n\"\n \"ld1r { v16.4s }, [x20]\\n\"\n \"add x26, x26, #0x20\\n\"\n \"fadd v11.4s, v11.4s, v19.4s\\n\"\n \"fadd v10.4s, v10.4s, v18.4s\\n\"\n \"fadd v9.4s, v9.4s, v19.4s\\n\"\n \"fadd v8.4s, v8.4s, v18.4s\\n\"\n \"fadd v7.4s, v7.4s, v19.4s\\n\"\n \"fadd v6.4s, v6.4s, v18.4s\\n\"\n \"fadd v5.4s, v5.4s, v19.4s\\n\"\n \"fadd v4.4s, v4.4s, v18.4s\\n\"\n \"fmax v11.4s, v11.4s, v17.4s\\n\"\n \"fmax v10.4s, v10.4s, v17.4s\\n\"\n \"fmax v9.4s, v9.4s, v17.4s\\n\"\n \"fmax v8.4s, v8.4s, v17.4s\\n\"\n \"fmax v7.4s, v7.4s, v17.4s\\n\"\n \"fmax v6.4s, v6.4s, v17.4s\\n\"\n \"fmax v5.4s, v5.4s, v17.4s\\n\"\n \"fmax v4.4s, v4.4s, v17.4s\\n\"\n \"fmin v11.4s, v11.4s, v16.4s\\n\"\n \"fmin v10.4s, v10.4s, v16.4s\\n\"\n \"fmin v9.4s, v9.4s, v16.4s\\n\"\n \"fmin v8.4s, v8.4s, v16.4s\\n\"\n \"fmin v7.4s, v7.4s, v16.4s\\n\"\n \"fmin v6.4s, v6.4s, v16.4s\\n\"\n \"fmin v5.4s, v5.4s, v16.4s\\n\"\n \"fmin v4.4s, v4.4s, v16.4s\\n\"\n \"blt 5f\\n\"\n \"mov x20, %x[dst]\\n\"\n \"cmp x27, #0x1\\n\"\n \"str q11, [x20, #0x0]\\n\"\n \"str q10, [x20, #0x10]\\n\"\n \"add x20, x20, %x[dst_stride_row]\\n\"\n \"ble 10f\\n\"\n \"cmp x27, #0x2\\n\"\n \"str q9, [x20, #0x0]\\n\"\n \"str q8, [x20, #0x10]\\n\"\n \"add x20, x20, %x[dst_stride_row]\\n\"\n \"ble 10f\\n\"\n \"cmp x27, #0x3\\n\"\n \"str q7, [x20, #0x0]\\n\"\n \"str q6, [x20, #0x10]\\n\"\n \"add x20, x20, %x[dst_stride_row]\\n\"\n \"ble 10f\\n\"\n \"str q5, [x20, #0x0]\\n\"\n \"str q4, [x20, #0x10]\\n\"\n \"b 10f\\n\"\n \"5:\" // Partial output\n \"mov x23, %x[dst]\\n\"\n \"cmp x27, #0x1\\n\"\n \"add x22, x23, %x[dst_stride_row]\\n\"\n \"csel x22, x22, x23, GT\\n\"\n \"cmp x27, #0x2\\n\"\n \"add x21, x23, %x[dst_stride_row], LSL #1\\n\"\n \"csel x21, x21, x22, GT\\n\"\n \"cmp x27, #0x3\\n\"\n \"add x20, x21, %x[dst_stride_row]\\n\"\n \"csel x20, x20, x21, GT\\n\"\n \"tbz x25, #2, 7f\\n\"\n \"st1 { v5.4s }, [x20], #0x10\\n\"\n \"st1 { v7.4s }, [x21], #0x10\\n\"\n \"st1 { v9.4s }, [x22], #0x10\\n\"\n \"st1 { v11.4s }, [x23], #0x10\\n\"\n \"tbz x25, #1, 6f\\n\"\n \"st1 { v4.d }[0], [x20], #0x8\\n\"\n \"st1 { v6.d }[0], [x21], #0x8\\n\"\n \"st1 { v8.d }[0], [x22], #0x8\\n\"\n \"st1 { v10.d }[0], [x23], #0x8\\n\"\n \"tbz x25, #0, 9f\\n\"\n \"st1 { v4.s }[2], [x20]\\n\"\n \"st1 { v6.s }[2], [x21]\\n\"\n \"st1 { v8.s }[2], [x22]\\n\"\n \"st1 { v10.s }[2], [x23]\\n\"\n \"b 9f\\n\"\n \"6:\" // Output block 0: partial_1_4\n \"tbz x25, #0, 9f\\n\"\n \"st1 { v4.s }[0], [x20]\\n\"\n \"st1 { v6.s }[0], [x21]\\n\"\n \"st1 { v8.s }[0], [x22]\\n\"\n \"st1 { v10.s }[0], [x23]\\n\"\n \"b 9f\\n\"\n \"7:\" // Output block 0: partial_2_0\n \"tbz x25, #1, 8f\\n\"\n \"st1 { v5.d }[0], [x20], #0x8\\n\"\n \"st1 { v7.d }[0], [x21], #0x8\\n\"\n \"st1 { v9.d }[0], [x22], #0x8\\n\"\n \"st1 { v11.d }[0], [x23], #0x8\\n\"\n \"tbz x25, #0, 9f\\n\"\n \"st1 { v5.s }[2], [x20]\\n\"\n \"st1 { v7.s }[2], [x21]\\n\"\n \"st1 { v9.s }[2], [x22]\\n\"\n \"st1 { v11.s }[2], [x23]\\n\"\n \"b 9f\\n\"\n \"8:\" // Output block 0: partial_1_0\n \"st1 { v5.s }[0], [x20]\\n\"\n \"st1 { v7.s }[0], [x21]\\n\"\n \"st1 { v9.s }[0], [x22]\\n\"\n \"st1 { v11.s }[0], [x23]\\n\"\n \"9:\" // Output block 0: Done\n \"10:\" // Output stage exit\n \"subs x25, x25, #0x8\\n\"\n \"add %x[dst], %x[dst], #0x20\\n\"\n \"bgt 2b\\n\"\n \"subs x27, x27, #0x4\\n\"\n \"add %x[lhs_packed], %x[lhs_packed], x28\\n\"\n \"mov %x[dst], x24\\n\"\n \"bgt 1b\\n\"\n \"11:\" // Row loop skip\n : [dst] \"+&r\"(dst), [lhs_packed] \"+&r\"(lhs_packed)\n : [clamp_vals] \"r\"(clamp_vals), [dst_stride_row] \"r\"(dst_stride_row), [m] \"r\"(m), [n] \"r\"(n),\n [num_blocks] \"r\"(num_blocks), [rhs_packed] \"r\"(rhs_packed)\n : \"cc\", \"memory\", \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\", \"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v16\", \"v17\",\n \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\", \"v30\", \"v31\", \"x20\",\n \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\", \"x27\", \"x28\");\n}\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_kxn_qsi4cxp_qs4cxs1s0 OR kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0 to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_kxn_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_kxn_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_kxn_qsi4cxp_qs4cxs1s0 micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Signed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of 1\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Signed 4-bit quantized symmetric per-channel (qsi4cxp) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of 8.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(\n size_t n_idx, //\n size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of 1.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of 8.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed\n/// RHS matrix: Signed 4-bit quantized symmetric per-channel (qsi4cxp) and packed.\n/// Output tile: (rows x cols) = 1 x 8\n/// Accumulation performed in a single for loop: 32\n/// Extension used: dotprod\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS packed matrix, which is obtained by calling @ref\n/// kai_run_rhs_pack_kxn_qsi4cxp_qs4cxs1s0\n/// OR kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(\n size_t m, size_t n, size_t k,\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__ARM_FEATURE_DOTPROD)\n#error \"Dotprod extension required to compile this micro-kernel\"\n#else // Architectural features check.\n#include \"kai_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_m_step = 1;\nstatic const size_t kai_n_step = 8;\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_nr = 8;\nstatic const size_t kai_kr = 16;\nstatic const size_t kai_sr = 2;\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Since we pack a float and int32 value at the end of the row,\n // we must make sure that k is a multiple of 4 for alignment\n size_t kr_sr_roundedup4 = kai_roundup(kai_kr * kai_sr, 4);\n return kai_roundup(k, kr_sr_roundedup4);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return kai_mr * (k_internal * sizeof(int8_t) + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\ninline static size_t kai_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return kai_nr * ((k_internal / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(size_t m_idx, size_t k) {\n KAI_ASSERT((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(size_t n_idx, size_t k) {\n KAI_ASSERT((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSERT((m_idx % kai_m_step) == 0);\n KAI_ASSERT((n_idx % kai_n_step) == 0);\n\n return (n_idx * sizeof(float)) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(size_t m, size_t n) {\n return m * n * sizeof(float);\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max) {\n KAI_ASSERT(dst_stride_col == sizeof(float));\n\n if (m == 0) {\n return;\n }\n\n const size_t k_internal = kai_k_roundedup(k);\n\n size_t num_blocks = k_internal / 32;\n\n float clamp_vals[2] = {scalar_min, scalar_max};\n __asm__ __volatile__(\n \"mov x26, #0x20\\n\"\n \"mov x20, #0x8\\n\"\n \"movi v5.16b, #0xf0\\n\"\n \"mov x25, %x[m]\\n\"\n \"madd x26, %x[num_blocks], x26, x20\\n\"\n \"1:\" // Row loop\n \"mov x24, %x[rhs_packed]\\n\"\n \"mov x23, %x[n]\\n\"\n \"add x22, %x[dst], %x[dst_stride_row]\\n\"\n \"2:\" // Column loop\n \"mov x21, %x[lhs_packed]\\n\"\n \"movi v4.4s, #0x0\\n\"\n \"movi v3.4s, #0x0\\n\"\n \"mov x20, %x[num_blocks]\\n\"\n \"movi v2.4s, #0x0\\n\"\n \"movi v1.4s, #0x0\\n\"\n \"3:\" // Sub block loop\n \"ldr q0, [x24, #0x0]\\n\"\n \"ldr q31, [x24, #0x10]\\n\"\n \"subs x20, x20, #0x1\\n\"\n \"ldr q30, [x24, #0x20]\\n\"\n \"ldr q29, [x24, #0x30]\\n\"\n \"ld1r { v28.2d }, [x21], #0x8\\n\"\n \"ldr q27, [x24, #0x40]\\n\"\n \"ldr q26, [x24, #0x50]\\n\"\n \"ldr q25, [x24, #0x60]\\n\"\n \"shl v24.16b, v0.16b, #0x4\\n\"\n \"shl v18.16b, v31.16b, #0x4\\n\"\n \"ldr q23, [x24, #0x70]\\n\"\n \"shl v17.16b, v30.16b, #0x4\\n\"\n \"shl v16.16b, v29.16b, #0x4\\n\"\n \"add x24, x24, #0x80\\n\"\n \"ld1r { v22.2d }, [x21], #0x8\\n\"\n \"shl v21.16b, v27.16b, #0x4\\n\"\n \"and v0.16b, v0.16b, v5.16b\\n\"\n \"ld1r { v20.2d }, [x21], #0x8\\n\"\n \"ld1r { v19.2d }, [x21], #0x8\\n\"\n \".inst 0x4e9c9704 // sdot v4.4s, v24.16b, v28.16b\\n\"\n \".inst 0x4e9c9643 // sdot v3.4s, v18.16b, v28.16b\\n\"\n \"shl v18.16b, v26.16b, #0x4\\n\"\n \".inst 0x4e9c9622 // sdot v2.4s, v17.16b, v28.16b\\n\"\n \".inst 0x4e9c9601 // sdot v1.4s, v16.16b, v28.16b\\n\"\n \"shl v17.16b, v25.16b, #0x4\\n\"\n \"shl v16.16b, v23.16b, #0x4\\n\"\n \"and v31.16b, v31.16b, v5.16b\\n\"\n \"and v30.16b, v30.16b, v5.16b\\n\"\n \"and v29.16b, v29.16b, v5.16b\\n\"\n \".inst 0x4e9696a4 // sdot v4.4s, v21.16b, v22.16b\\n\"\n \".inst 0x4e969643 // sdot v3.4s, v18.16b, v22.16b\\n\"\n \"and v27.16b, v27.16b, v5.16b\\n\"\n \".inst 0x4e969622 // sdot v2.4s, v17.16b, v22.16b\\n\"\n \".inst 0x4e969601 // sdot v1.4s, v16.16b, v22.16b\\n\"\n \"and v26.16b, v26.16b, v5.16b\\n\"\n \"and v25.16b, v25.16b, v5.16b\\n\"\n \"and v23.16b, v23.16b, v5.16b\\n\"\n \".inst 0x4e949404 // sdot v4.4s, v0.16b, v20.16b\\n\"\n \".inst 0x4e9497e3 // sdot v3.4s, v31.16b, v20.16b\\n\"\n \".inst 0x4e9497c2 // sdot v2.4s, v30.16b, v20.16b\\n\"\n \".inst 0x4e9497a1 // sdot v1.4s, v29.16b, v20.16b\\n\"\n \".inst 0x4e939764 // sdot v4.4s, v27.16b, v19.16b\\n\"\n \".inst 0x4e939743 // sdot v3.4s, v26.16b, v19.16b\\n\"\n \".inst 0x4e939722 // sdot v2.4s, v25.16b, v19.16b\\n\"\n \".inst 0x4e9396e1 // sdot v1.4s, v23.16b, v19.16b\\n\"\n \"bgt 3b\\n\"\n \"ldr q25, [x24, #0x0]\\n\"\n \"ldr q24, [x24, #0x10]\\n\"\n \"addp v4.4s, v4.4s, v3.4s\\n\"\n \"addp v2.4s, v2.4s, v1.4s\\n\"\n \"ld1r { v23.4s }, [x21]\\n\"\n \"ldr q22, [x24, #0x20]\\n\"\n \"add x21, x21, #0x4\\n\"\n \"add x20, %x[clamp_vals], #0x4\\n\"\n \"ld1r { v17.4s }, [x21]\\n\"\n \"ldr q16, [x24, #0x30]\\n\"\n \"cmp x23, #0x8\\n\"\n \"ldr q21, [x24, #0x40]\\n\"\n \"ldr q20, [x24, #0x50]\\n\"\n \"add x24, x24, #0x60\\n\"\n \"ld1r { v19.4s }, [%x[clamp_vals]]\\n\"\n \"ld1r { v18.4s }, [x20]\\n\"\n \"mla v4.4s, v25.4s, v23.s[0]\\n\"\n \"mla v2.4s, v24.4s, v23.s[0]\\n\"\n \"fmul v22.4s, v22.4s, v17.4s\\n\"\n \"fmul v16.4s, v16.4s, v17.4s\\n\"\n \"scvtf v4.4s, v4.4s\\n\"\n \"scvtf v2.4s, v2.4s\\n\"\n \"fmul v17.4s, v4.4s, v22.4s\\n\"\n \"fmul v16.4s, v2.4s, v16.4s\\n\"\n \"fadd v17.4s, v17.4s, v21.4s\\n\"\n \"fadd v16.4s, v16.4s, v20.4s\\n\"\n \"fmax v17.4s, v17.4s, v19.4s\\n\"\n \"fmax v16.4s, v16.4s, v19.4s\\n\"\n \"fmin v17.4s, v17.4s, v18.4s\\n\"\n \"fmin v16.4s, v16.4s, v18.4s\\n\"\n \"blt 4f\\n\"\n \"str q17, [%x[dst], #0x0]\\n\"\n \"str q16, [%x[dst], #0x10]\\n\"\n \"b 9f\\n\"\n \"4:\" // Partial output\n \"mov x20, %x[dst]\\n\"\n \"tbz x23, #2, 6f\\n\"\n \"st1 { v17.4s }, [x20], #0x10\\n\"\n \"tbz x23, #1, 5f\\n\"\n \"st1 { v16.d }[0], [x20], #0x8\\n\"\n \"tbz x23, #0, 8f\\n\"\n \"st1 { v16.s }[2], [x20]\\n\"\n \"b 8f\\n\"\n \"5:\" // Output block 0: partial_1_4\n \"tbz x23, #0, 8f\\n\"\n \"st1 { v16.s }[0], [x20]\\n\"\n \"b 8f\\n\"\n \"6:\" // Output block 0: partial_2_0\n \"tbz x23, #1, 7f\\n\"\n \"st1 { v17.d }[0], [x20], #0x8\\n\"\n \"tbz x23, #0, 8f\\n\"\n \"st1 { v17.s }[2], [x20]\\n\"\n \"b 8f\\n\"\n \"7:\" // Output block 0: partial_1_0\n \"st1 { v17.s }[0], [x20]\\n\"\n \"8:\" // Output block 0: Done\n \"9:\" // Stores done\n \"subs x23, x23, #0x8\\n\"\n \"add %x[dst], %x[dst], #0x20\\n\"\n \"bgt 2b\\n\"\n \"subs x25, x25, #0x1\\n\"\n \"add %x[lhs_packed], %x[lhs_packed], x26\\n\"\n \"mov %x[dst], x22\\n\"\n \"bgt 1b\\n\"\n : [dst] \"+&r\"(dst), [lhs_packed] \"+&r\"(lhs_packed)\n : [clamp_vals] \"r\"(clamp_vals), [dst_stride_row] \"r\"(dst_stride_row), [m] \"r\"(m), [n] \"r\"(n),\n [num_blocks] \"r\"(num_blocks), [rhs_packed] \"r\"(rhs_packed)\n : \"cc\", \"memory\", \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\",\n \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\", \"v30\", \"v31\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#define kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0_params kai_rhs_pack_qs4cxs1s0_param\n\n/// Get the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed).\n///\n/// @note The int4 values are stored in a N x K matrix. Two int4 values are stored in one byte.\n/// The lower order part of the byte (low) holds the first nibble (K-index + 0).\n/// The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix, which contains the packed 4-bit quantized symmetric per-channel\n/// (qsu4cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int4 values are stored in a N x K matrix. Two int4 values are stored in one byte.\n/// The lower order part of the byte (low) holds the first nibble (K-index + 0).\n/// The higher order of the byte holds the second nibble (K-index + 1).\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of rows.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be an even value.\n/// @param[in] nr The number of N rows to interleave on the same output output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] rhs The RHS matrix containing the 4-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 2).\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const uint8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return nr * ((k_internal / 2) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0_params* params) {\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n KAI_ASSERT(params->lhs_zero_point == 1);\n KAI_ASSERT(params->rhs_zero_point == 0 || params->rhs_zero_point == 8);\n\n const uint8_t rhs_zero_point = params->rhs_zero_point;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(k, nr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_num_bytes_per_row = nr * (kai_k_roundedup(k) / 2);\n const size_t block_length_in_bytes = kr / sr;\n const size_t k_interleaved_v = 16U;\n const size_t rhs_stride = kai_roundup(k, 2) / 2;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n\n int32_t* sums = (int32_t*)(dst_row + nr * (k_internal / 2));\n\n // Initialize to zero the RHS reduction sums\n memset(sums, 0, nr * sizeof(int32_t));\n\n for (size_t dst_byte_idx = 0; dst_byte_idx < dst_num_bytes_per_row; ++dst_byte_idx) {\n const size_t block_idx = dst_byte_idx / block_length_in_bytes;\n const size_t block_byte_idx = dst_byte_idx % block_length_in_bytes;\n const size_t super_block_idx = block_idx / nr;\n const size_t nr_idx = block_idx % nr;\n\n const size_t k_adjustment =\n ((block_byte_idx + super_block_idx * block_length_in_bytes) / k_interleaved_v) * k_interleaved_v;\n const size_t k0_idx = block_byte_idx + super_block_idx * block_length_in_bytes + k_adjustment;\n const size_t k1_idx = k0_idx + k_interleaved_v;\n const size_t n0_idx = dst_row_idx * nr + nr_idx;\n\n // Clamp the index to avoid out-of-bound reads\n const size_t n0_valid_idx = KAI_MIN(n0_idx, n - 1);\n\n const size_t src_addr_byte0 = (k0_idx / 2) + n0_valid_idx * rhs_stride;\n const size_t src_addr_byte1 = (k1_idx / 2) + n0_valid_idx * rhs_stride;\n\n const size_t shift_right_x0 = (k0_idx % 2) * 4;\n const size_t shift_right_x1 = (k1_idx % 2) * 4;\n\n if (rhs_zero_point == 8) {\n uint8_t byte0 = rhs_zero_point | rhs_zero_point << 4;\n uint8_t byte1 = rhs_zero_point | rhs_zero_point << 4;\n\n if (k0_idx < k) {\n byte0 = rhs[src_addr_byte0];\n }\n\n if (k1_idx < k) {\n byte1 = rhs[src_addr_byte1];\n }\n\n // The following operations where we extract the values from the bytes\n // can be also written in the following and less efficient manner:\n /*\n uint8_t src_x0_lo = 0;\n uint8_t src_x0_hi = 0;\n\n if ((k0_idx % 2) == 0) {\n src_x0_lo = (byte0 & 0x0F);\n } else {\n src_x0_lo = (byte0 >> 4);\n }\n\n if ((k1_idx % 2) == 0) {\n src_x0_hi = (byte1 & 0x0F);\n } else {\n src_x0_hi = (byte1 >> 4);\n }\n */\n const uint8_t src_x0_lo = (byte0 >> shift_right_x0) & 0x0F;\n const uint8_t src_x0_hi = (byte1 >> shift_right_x1) & 0x0F;\n\n sums[nr_idx] += (int32_t)src_x0_lo + (int32_t)src_x0_hi - 2 * (int32_t)rhs_zero_point;\n\n const uint8_t dst_qs0 = src_x0_lo | (src_x0_hi << 4);\n\n *dst_row = dst_qs0 ^ 0x88;\n dst_row += sizeof(uint8_t);\n } else {\n int8_t byte0 = 0;\n int8_t byte1 = 0;\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n if (k0_idx < k) {\n byte0 = rhs[src_addr_byte0];\n }\n\n if (k1_idx < k) {\n byte1 = rhs[src_addr_byte1];\n }\n\n // The logic behind the following operations where we extract the\n // values from the bytes is same as unsigned\n\n int8_t src_x0_lo = (byte0 >> shift_right_x0) & 0x0F;\n int8_t src_x0_hi = (byte1 >> shift_right_x1) & 0x0F;\n\n const int8_t dst_qs0 = src_x0_lo | (src_x0_hi << 4);\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n\n *(int8_t*)dst_row = dst_qs0;\n dst_row += sizeof(int8_t);\n\n src_x0_lo = kai_ext_sign_i8_i4(src_x0_lo);\n src_x0_hi = kai_ext_sign_i8_i4(src_x0_hi);\n sums[nr_idx] += (int32_t)src_x0_lo + (int32_t)src_x0_hi;\n }\n }\n\n // Adjust the reduction sums\n for (size_t i = 0; i < nr; ++i) {\n sums[i] = sums[i] * 16;\n dst_row += sizeof(int32_t);\n }\n\n // Adjust the scales\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n *((float*)(dst_row)) = scale[src_row_idx] * 0.0625F;\n dst_row += sizeof(float);\n }\n\n // Set the bias\n if (bias == NULL) {\n memset(dst_row, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n ((float*)dst_row)[i] = bias[src_row_idx];\n }\n }\n }\n}\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm against gemm_qs4cx_n512_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsi4cxp_qs4cxs1s0.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n // M == 1 runs the dedicated GEMV ukernel, as a KleidiAI user would pick it. Both variants\n // share one packed-RHS layout (same nr/kr/sr), so a single cached weight pack serves both.\n const bool gemv = (M == 1);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm();\n if (kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod() != nr || kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod() != kr ||\n kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod() != sr) return -2;\n const size_t mr = gemv ? kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod() : kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = gemv ? (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr)) : (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr));\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n if (gemv) {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n } else {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q4_snap = nullptr;\n static size_t B_q4_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q4_snap, B_q4_snap_size, B_q4, (size_t)N*K/2)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi4cxp_qs4cxs1s0((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 8;\n kai_run_rhs_pack_nxk_qsi4cxp_qs4cxs1s0(1, (size_t)N, (size_t)K, nr, kr, sr, B_q4, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n if (gemv) {\n kai_run_matmul_clamp_f32_qai8dxp1x8_qsi4cxp8x8_1x8x32_neon_dotprod((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n } else {\n kai_run_matmul_clamp_f32_qai8dxp4x8_qsi4cxp8x8_4x8x32_neon_i8mm((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n }\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_n512_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..7dc224b63c9350edcba557bf7037a0618ad9a42c --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_n512_k512.json @@ -0,0 +1,71 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qs8cx_n512_k512", + "definition": "gemm_qs8cx_n512_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qs8cx_n512_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "dotprod", + "i8mm" + ], + "compile_flags": [ + "-O3", + "-march=armv8.2-a+dotprod+i8mm" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon to pack the RHS NxK matrix.\n/// -# @ref kai_rhs_pack_kxn_qsi8cxp_qsi8cx_neon to pack the RHS KxN matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be a multiple of 16\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m_idx, //\n size_t k); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of 4.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t n_idx, //\n size_t k); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be a multiple of 16.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of 4.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) and packed\n/// RHS matrix: Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) and packed.\n/// Output tile: (rows x cols) = 16 x 4\n///\n/// Features used: i8mm\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_MATMUL_INT8)) && !defined(_M_ARM64)\n#error \"I8mm extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n float* dst;\n const void* lhs_packed;\n const void* rhs_packed;\n const float* clamp_vals;\n size_t dst_stride_row;\n size_t m;\n size_t n;\n size_t num_blocks;\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(KernelArgs* args);\n\n// Compute args\nstatic const size_t kai_m_step = 16;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 4;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 8;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_zp_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_qvalue_rhs = 1;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_rsum_rhs = 4;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n size_t lhs_packed_stride = kai_mr * ((k_internal * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs);\n // Since the LHS matrix is asymmetric with per-row quantization, we must include the\n // the number of bytes to hold the zero point value\n lhs_packed_stride += kai_mr * kai_num_bytes_zp_lhs;\n\n return lhs_packed_stride;\n}\n\ninline static size_t kai_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n size_t rhs_packed_stride = kai_nr * (k_internal * kai_num_bytes_qvalue_rhs);\n rhs_packed_stride += kai_nr * kai_num_bytes_multiplier_rhs;\n // Since the LHS matrix is quantized asymmetric with per-row quantization, we also include\n // the number of bytes for the reduction sum\n rhs_packed_stride += kai_nr * kai_num_bytes_rsum_rhs;\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += kai_nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(size_t n_idx, size_t k) {\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n\n if (m == 0) {\n return;\n }\n\n const size_t k_internal = kai_k_roundedup(k);\n const size_t num_blocks = k_internal / kai_k_multiple_of;\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.clamp_vals = clamp_vals;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.num_blocks = num_blocks;\n\n kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm)\n // Save callee-saved registers x19-x28 and d8-d15\n stp x19, x20, [sp, -176]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp x25, x26, [sp, 48]\n stp x27, x28, [sp, 64]\n stp d8, d9, [sp, 80]\n stp d10, d11, [sp, 96]\n stp d12, d13, [sp, 112]\n stp d14, d15, [sp, 128]\n\n // Load arguments from struct KernelArgs (passed in x0)\n ldr x19, [x0, #0] // running_dst = dst\n ldr x15, [x0, #8] // running_lhs_packed = lhs_packed\n ldr x17, [x0, #24] // clamp_vals\n ldr x28, [x0, #32] // dst_stride_row\n ldr x13, [x0, #40] // m\n ldr x14, [x0, #56] // num_blocks\n\n mov x12, #0x80\n mov x20, #0x20\n cmp x13, #0x10\n madd x12, x14, x12, x20\n blt label_14\n\nKAI_ASM_LABEL(label_1) // Row loop\n ldr x11, [x0, #16] // Reset rhs_packed\n ldr x10, [x0, #48] // Reset n\n add x9, x19, x28, LSL #4\n\nKAI_ASM_LABEL(label_2) // Column loop\n mov x27, x15\n movi v31.4s, #0x0\n movi v30.4s, #0x0\n mov x23, x14 // num_blocks\n movi v29.4s, #0x0\n movi v28.4s, #0x0\n movi v27.4s, #0x0\n movi v26.4s, #0x0\n add x22, x27, x12\n add x21, x22, x12\n add x20, x21, x12\n movi v25.4s, #0x0\n movi v24.4s, #0x0\n movi v23.4s, #0x0\n movi v22.4s, #0x0\n movi v21.4s, #0x0\n movi v20.4s, #0x0\n movi v19.4s, #0x0\n movi v18.4s, #0x0\n movi v17.4s, #0x0\n movi v16.4s, #0x0\n\nKAI_ASM_LABEL(label_3) // Sub block loop\n ldr q2, [x11, #0x0]\n ldr q1, [x11, #0x10]\n subs x23, x23, #0x1\n ldr q5, [x27, #0x0]\n ldr q9, [x27, #0x10]\n ldr q8, [x22, #0x0]\n ldr q7, [x22, #0x10]\n ldr q4, [x21, #0x0]\n ldr q14, [x21, #0x10]\n ldr q3, [x20, #0x0]\n ldr q0, [x20, #0x10]\n KAI_ASM_INST(0x4e82a4bf) // smmla v31.4s, v5.16b, v2.16b\n KAI_ASM_INST(0x4e81a4be) // smmla v30.4s, v5.16b, v1.16b\n ldr q6, [x11, #0x20]\n ldr q5, [x11, #0x30]\n KAI_ASM_INST(0x4e82a53d) // smmla v29.4s, v9.16b, v2.16b\n KAI_ASM_INST(0x4e81a53c) // smmla v28.4s, v9.16b, v1.16b\n ldr q13, [x27, #0x20]\n ldr q12, [x27, #0x30]\n KAI_ASM_INST(0x4e82a51b) // smmla v27.4s, v8.16b, v2.16b\n KAI_ASM_INST(0x4e81a51a) // smmla v26.4s, v8.16b, v1.16b\n ldr q11, [x22, #0x20]\n ldr q10, [x22, #0x30]\n KAI_ASM_INST(0x4e82a4f9) // smmla v25.4s, v7.16b, v2.16b\n KAI_ASM_INST(0x4e81a4f8) // smmla v24.4s, v7.16b, v1.16b\n ldr q9, [x21, #0x20]\n ldr q8, [x21, #0x30]\n KAI_ASM_INST(0x4e82a497) // smmla v23.4s, v4.16b, v2.16b\n KAI_ASM_INST(0x4e81a496) // smmla v22.4s, v4.16b, v1.16b\n ldr q7, [x20, #0x20]\n ldr q4, [x20, #0x30]\n KAI_ASM_INST(0x4e82a5d5) // smmla v21.4s, v14.16b, v2.16b\n KAI_ASM_INST(0x4e81a5d4) // smmla v20.4s, v14.16b, v1.16b\n ldr q15, [x11, #0x40]\n ldr q14, [x11, #0x50]\n KAI_ASM_INST(0x4e82a473) // smmla v19.4s, v3.16b, v2.16b\n KAI_ASM_INST(0x4e81a472) // smmla v18.4s, v3.16b, v1.16b\n ldr q3, [x27, #0x40]\n KAI_ASM_INST(0x4e82a411) // smmla v17.4s, v0.16b, v2.16b\n ldr q2, [x27, #0x50]\n KAI_ASM_INST(0x4e81a410) // smmla v16.4s, v0.16b, v1.16b\n ldr q1, [x22, #0x40]\n ldr q0, [x22, #0x50]\n KAI_ASM_INST(0x4e86a5bf) // smmla v31.4s, v13.16b, v6.16b\n KAI_ASM_INST(0x4e85a5be) // smmla v30.4s, v13.16b, v5.16b\n ldr q13, [x21, #0x40]\n KAI_ASM_INST(0x4e86a59d) // smmla v29.4s, v12.16b, v6.16b\n KAI_ASM_INST(0x4e85a59c) // smmla v28.4s, v12.16b, v5.16b\n ldr q12, [x21, #0x50]\n KAI_ASM_INST(0x4e86a57b) // smmla v27.4s, v11.16b, v6.16b\n KAI_ASM_INST(0x4e85a57a) // smmla v26.4s, v11.16b, v5.16b\n ldr q11, [x20, #0x40]\n KAI_ASM_INST(0x4e86a559) // smmla v25.4s, v10.16b, v6.16b\n KAI_ASM_INST(0x4e85a558) // smmla v24.4s, v10.16b, v5.16b\n ldr q10, [x20, #0x50]\n KAI_ASM_INST(0x4e86a537) // smmla v23.4s, v9.16b, v6.16b\n KAI_ASM_INST(0x4e85a536) // smmla v22.4s, v9.16b, v5.16b\n ldr q9, [x11, #0x60]\n KAI_ASM_INST(0x4e86a515) // smmla v21.4s, v8.16b, v6.16b\n KAI_ASM_INST(0x4e85a514) // smmla v20.4s, v8.16b, v5.16b\n ldr q8, [x11, #0x70]\n add x11, x11, #0x80\n KAI_ASM_INST(0x4e86a4f3) // smmla v19.4s, v7.16b, v6.16b\n KAI_ASM_INST(0x4e85a4f2) // smmla v18.4s, v7.16b, v5.16b\n ldr q7, [x27, #0x60]\n KAI_ASM_INST(0x4e86a491) // smmla v17.4s, v4.16b, v6.16b\n ldr q6, [x27, #0x70]\n KAI_ASM_INST(0x4e85a490) // smmla v16.4s, v4.16b, v5.16b\n ldr q5, [x22, #0x60]\n ldr q4, [x22, #0x70]\n KAI_ASM_INST(0x4e8fa47f) // smmla v31.4s, v3.16b, v15.16b\n KAI_ASM_INST(0x4e8ea47e) // smmla v30.4s, v3.16b, v14.16b\n ldr q3, [x21, #0x60]\n KAI_ASM_INST(0x4e8fa45d) // smmla v29.4s, v2.16b, v15.16b\n KAI_ASM_INST(0x4e8ea45c) // smmla v28.4s, v2.16b, v14.16b\n ldr q2, [x21, #0x70]\n add x27, x27, #0x80\n KAI_ASM_INST(0x4e8fa43b) // smmla v27.4s, v1.16b, v15.16b\n KAI_ASM_INST(0x4e8ea43a) // smmla v26.4s, v1.16b, v14.16b\n ldr q1, [x20, #0x60]\n add x22, x22, #0x80\n KAI_ASM_INST(0x4e8fa419) // smmla v25.4s, v0.16b, v15.16b\n KAI_ASM_INST(0x4e8ea418) // smmla v24.4s, v0.16b, v14.16b\n ldr q0, [x20, #0x70]\n add x21, x21, #0x80\n KAI_ASM_INST(0x4e8fa5b7) // smmla v23.4s, v13.16b, v15.16b\n KAI_ASM_INST(0x4e8ea5b6) // smmla v22.4s, v13.16b, v14.16b\n add x20, x20, #0x80\n KAI_ASM_INST(0x4e8fa595) // smmla v21.4s, v12.16b, v15.16b\n KAI_ASM_INST(0x4e8ea594) // smmla v20.4s, v12.16b, v14.16b\n KAI_ASM_INST(0x4e8fa573) // smmla v19.4s, v11.16b, v15.16b\n KAI_ASM_INST(0x4e8ea572) // smmla v18.4s, v11.16b, v14.16b\n KAI_ASM_INST(0x4e8fa551) // smmla v17.4s, v10.16b, v15.16b\n KAI_ASM_INST(0x4e8ea550) // smmla v16.4s, v10.16b, v14.16b\n KAI_ASM_INST(0x4e89a4ff) // smmla v31.4s, v7.16b, v9.16b\n KAI_ASM_INST(0x4e88a4fe) // smmla v30.4s, v7.16b, v8.16b\n KAI_ASM_INST(0x4e89a4dd) // smmla v29.4s, v6.16b, v9.16b\n KAI_ASM_INST(0x4e88a4dc) // smmla v28.4s, v6.16b, v8.16b\n KAI_ASM_INST(0x4e89a4bb) // smmla v27.4s, v5.16b, v9.16b\n KAI_ASM_INST(0x4e88a4ba) // smmla v26.4s, v5.16b, v8.16b\n KAI_ASM_INST(0x4e89a499) // smmla v25.4s, v4.16b, v9.16b\n KAI_ASM_INST(0x4e88a498) // smmla v24.4s, v4.16b, v8.16b\n KAI_ASM_INST(0x4e89a477) // smmla v23.4s, v3.16b, v9.16b\n KAI_ASM_INST(0x4e88a476) // smmla v22.4s, v3.16b, v8.16b\n KAI_ASM_INST(0x4e89a455) // smmla v21.4s, v2.16b, v9.16b\n KAI_ASM_INST(0x4e88a454) // smmla v20.4s, v2.16b, v8.16b\n KAI_ASM_INST(0x4e89a433) // smmla v19.4s, v1.16b, v9.16b\n KAI_ASM_INST(0x4e88a432) // smmla v18.4s, v1.16b, v8.16b\n KAI_ASM_INST(0x4e89a411) // smmla v17.4s, v0.16b, v9.16b\n KAI_ASM_INST(0x4e88a410) // smmla v16.4s, v0.16b, v8.16b\n bgt label_3\n\n ldr q7, [x11, #0x0]\n ld1 { v4.4s }, [x27]\n uzp1 v3.2d, v31.2d, v30.2d\n uzp2 v2.2d, v31.2d, v30.2d\n ldr q6, [x11, #0x10]\n uzp1 v1.2d, v29.2d, v28.2d\n uzp2 v0.2d, v29.2d, v28.2d\n add x27, x27, #0x10\n ldr q28, [x27, #0x0]\n add x11, x11, #0x20\n mla v3.4s, v7.4s, v4.s[0]\n mla v2.4s, v7.4s, v4.s[1]\n mla v1.4s, v7.4s, v4.s[2]\n mla v0.4s, v7.4s, v4.s[3]\n fmul v31.4s, v6.4s, v28.s[0]\n fmul v30.4s, v6.4s, v28.s[1]\n fmul v29.4s, v6.4s, v28.s[2]\n fmul v28.4s, v6.4s, v28.s[3]\n scvtf v3.4s, v3.4s\n scvtf v2.4s, v2.4s\n scvtf v1.4s, v1.4s\n scvtf v0.4s, v0.4s\n fmul v31.4s, v3.4s, v31.4s\n fmul v30.4s, v2.4s, v30.4s\n fmul v29.4s, v1.4s, v29.4s\n fmul v28.4s, v0.4s, v28.4s\n ld1 { v5.4s }, [x22]\n uzp1 v4.2d, v27.2d, v26.2d\n uzp2 v3.2d, v27.2d, v26.2d\n add x22, x22, #0x10\n ldr q2, [x22, #0x0]\n uzp1 v1.2d, v25.2d, v24.2d\n uzp2 v0.2d, v25.2d, v24.2d\n mla v4.4s, v7.4s, v5.s[0]\n mla v3.4s, v7.4s, v5.s[1]\n mla v1.4s, v7.4s, v5.s[2]\n mla v0.4s, v7.4s, v5.s[3]\n fmul v27.4s, v6.4s, v2.s[0]\n fmul v26.4s, v6.4s, v2.s[1]\n fmul v25.4s, v6.4s, v2.s[2]\n scvtf v4.4s, v4.4s\n fmul v24.4s, v6.4s, v2.s[3]\n scvtf v3.4s, v3.4s\n scvtf v1.4s, v1.4s\n scvtf v0.4s, v0.4s\n fmul v27.4s, v4.4s, v27.4s\n fmul v26.4s, v3.4s, v26.4s\n fmul v25.4s, v1.4s, v25.4s\n fmul v24.4s, v0.4s, v24.4s\n ld1 { v5.4s }, [x21]\n uzp1 v4.2d, v23.2d, v22.2d\n uzp2 v3.2d, v23.2d, v22.2d\n add x21, x21, #0x10\n ldr q2, [x21, #0x0]\n uzp1 v1.2d, v21.2d, v20.2d\n uzp2 v0.2d, v21.2d, v20.2d\n mla v4.4s, v7.4s, v5.s[0]\n mla v3.4s, v7.4s, v5.s[1]\n mla v1.4s, v7.4s, v5.s[2]\n mla v0.4s, v7.4s, v5.s[3]\n fmul v23.4s, v6.4s, v2.s[0]\n fmul v22.4s, v6.4s, v2.s[1]\n fmul v21.4s, v6.4s, v2.s[2]\n scvtf v4.4s, v4.4s\n fmul v20.4s, v6.4s, v2.s[3]\n scvtf v3.4s, v3.4s\n scvtf v1.4s, v1.4s\n scvtf v0.4s, v0.4s\n fmul v23.4s, v4.4s, v23.4s\n fmul v22.4s, v3.4s, v22.4s\n fmul v21.4s, v1.4s, v21.4s\n fmul v20.4s, v0.4s, v20.4s\n ld1 { v5.4s }, [x20]\n uzp1 v4.2d, v19.2d, v18.2d\n uzp2 v3.2d, v19.2d, v18.2d\n add x20, x20, #0x10\n ldr q2, [x20, #0x0]\n uzp1 v1.2d, v17.2d, v16.2d\n uzp2 v0.2d, v17.2d, v16.2d\n mla v4.4s, v7.4s, v5.s[0]\n mla v3.4s, v7.4s, v5.s[1]\n mla v1.4s, v7.4s, v5.s[2]\n mla v0.4s, v7.4s, v5.s[3]\n fmul v19.4s, v6.4s, v2.s[0]\n fmul v18.4s, v6.4s, v2.s[1]\n fmul v17.4s, v6.4s, v2.s[2]\n scvtf v4.4s, v4.4s\n fmul v16.4s, v6.4s, v2.s[3]\n scvtf v3.4s, v3.4s\n scvtf v1.4s, v1.4s\n scvtf v0.4s, v0.4s\n fmul v19.4s, v4.4s, v19.4s\n fmul v18.4s, v3.4s, v18.4s\n fmul v17.4s, v1.4s, v17.4s\n fmul v16.4s, v0.4s, v16.4s\n ldr q2, [x11, #0x0]\n ld1r { v1.4s }, [x17]\n add x20, x17, #0x4\n cmp x10, #0x4\n ld1r { v0.4s }, [x20]\n add x11, x11, #0x10\n fadd v31.4s, v31.4s, v2.4s\n fadd v30.4s, v30.4s, v2.4s\n fadd v29.4s, v29.4s, v2.4s\n fadd v28.4s, v28.4s, v2.4s\n fadd v27.4s, v27.4s, v2.4s\n fadd v26.4s, v26.4s, v2.4s\n fadd v25.4s, v25.4s, v2.4s\n fadd v24.4s, v24.4s, v2.4s\n fadd v23.4s, v23.4s, v2.4s\n fadd v22.4s, v22.4s, v2.4s\n fadd v21.4s, v21.4s, v2.4s\n fadd v20.4s, v20.4s, v2.4s\n fadd v19.4s, v19.4s, v2.4s\n fadd v18.4s, v18.4s, v2.4s\n fadd v17.4s, v17.4s, v2.4s\n fadd v16.4s, v16.4s, v2.4s\n fmax v31.4s, v31.4s, v1.4s\n fmax v30.4s, v30.4s, v1.4s\n fmax v29.4s, v29.4s, v1.4s\n fmax v28.4s, v28.4s, v1.4s\n fmax v27.4s, v27.4s, v1.4s\n fmax v26.4s, v26.4s, v1.4s\n fmax v25.4s, v25.4s, v1.4s\n fmax v24.4s, v24.4s, v1.4s\n fmax v23.4s, v23.4s, v1.4s\n fmax v22.4s, v22.4s, v1.4s\n fmax v21.4s, v21.4s, v1.4s\n fmax v20.4s, v20.4s, v1.4s\n fmax v19.4s, v19.4s, v1.4s\n fmax v18.4s, v18.4s, v1.4s\n fmax v17.4s, v17.4s, v1.4s\n fmax v16.4s, v16.4s, v1.4s\n fmin v31.4s, v31.4s, v0.4s\n fmin v30.4s, v30.4s, v0.4s\n fmin v29.4s, v29.4s, v0.4s\n fmin v28.4s, v28.4s, v0.4s\n fmin v27.4s, v27.4s, v0.4s\n fmin v26.4s, v26.4s, v0.4s\n fmin v25.4s, v25.4s, v0.4s\n fmin v24.4s, v24.4s, v0.4s\n fmin v23.4s, v23.4s, v0.4s\n fmin v22.4s, v22.4s, v0.4s\n fmin v21.4s, v21.4s, v0.4s\n fmin v20.4s, v20.4s, v0.4s\n fmin v19.4s, v19.4s, v0.4s\n fmin v18.4s, v18.4s, v0.4s\n fmin v17.4s, v17.4s, v0.4s\n fmin v16.4s, v16.4s, v0.4s\n blt label_8\n mov x20, x19\n str q31, [x20, #0x0]\n add x20, x20, x28\n str q30, [x20, #0x0]\n add x20, x20, x28\n str q29, [x20, #0x0]\n add x20, x20, x28\n str q28, [x20, #0x0]\n add x20, x20, x28\n str q27, [x20, #0x0]\n add x20, x20, x28\n str q26, [x20, #0x0]\n add x20, x20, x28\n str q25, [x20, #0x0]\n add x20, x20, x28\n str q24, [x20, #0x0]\n add x20, x20, x28\n str q23, [x20, #0x0]\n add x20, x20, x28\n str q22, [x20, #0x0]\n add x20, x20, x28\n str q21, [x20, #0x0]\n add x20, x20, x28\n str q20, [x20, #0x0]\n add x20, x20, x28\n str q19, [x20, #0x0]\n add x20, x20, x28\n str q18, [x20, #0x0]\n add x20, x20, x28\n str q17, [x20, #0x0]\n add x20, x20, x28\n str q16, [x20, #0x0]\n b label_13\n\nKAI_ASM_LABEL(label_8) // Partial output\n mov x16, x19\n add x26, x16, x28, LSL #2\n add x25, x26, x28, LSL #1\n add x24, x26, x28\n add x23, x25, x28\n add x22, x16, x28, LSL #1\n add x21, x16, x28\n add x20, x22, x28\n add x27, x23, x28\n tbz x10, #1, label_9\n st1 { v24.d }[0], [x23], #0x8\n st1 { v25.d }[0], [x25], #0x8\n st1 { v26.d }[0], [x24], #0x8\n st1 { v27.d }[0], [x26], #0x8\n st1 { v28.d }[0], [x20], #0x8\n st1 { v29.d }[0], [x22], #0x8\n st1 { v30.d }[0], [x21], #0x8\n st1 { v31.d }[0], [x16], #0x8\n tbz x10, #0, label_10\n st1 { v24.s }[2], [x23]\n st1 { v25.s }[2], [x25]\n st1 { v26.s }[2], [x24]\n st1 { v27.s }[2], [x26]\n st1 { v28.s }[2], [x20]\n st1 { v29.s }[2], [x22]\n st1 { v30.s }[2], [x21]\n st1 { v31.s }[2], [x16]\n b label_10\n\nKAI_ASM_LABEL(label_9) // Output block 0: partial_1_0\n st1 { v24.s }[0], [x23]\n st1 { v25.s }[0], [x25]\n st1 { v26.s }[0], [x24]\n st1 { v27.s }[0], [x26]\n st1 { v28.s }[0], [x20]\n st1 { v29.s }[0], [x22]\n st1 { v30.s }[0], [x21]\n st1 { v31.s }[0], [x16]\n\nKAI_ASM_LABEL(label_10) // Output block 0: Done\n add x26, x27, x28, LSL #2\n add x25, x27, x28, LSL #1\n add x24, x26, x28, LSL #1\n add x23, x27, x28\n add x22, x25, x28\n add x21, x26, x28\n add x20, x24, x28\n tbz x10, #1, label_11\n st1 { v16.d }[0], [x20], #0x8\n st1 { v17.d }[0], [x24], #0x8\n st1 { v18.d }[0], [x21], #0x8\n st1 { v19.d }[0], [x26], #0x8\n st1 { v20.d }[0], [x22], #0x8\n st1 { v21.d }[0], [x25], #0x8\n st1 { v22.d }[0], [x23], #0x8\n st1 { v23.d }[0], [x27], #0x8\n tbz x10, #0, label_12\n st1 { v16.s }[2], [x20]\n st1 { v17.s }[2], [x24]\n st1 { v18.s }[2], [x21]\n st1 { v19.s }[2], [x26]\n st1 { v20.s }[2], [x22]\n st1 { v21.s }[2], [x25]\n st1 { v22.s }[2], [x23]\n st1 { v23.s }[2], [x27]\n b label_12\n\nKAI_ASM_LABEL(label_11) // Output block 1: partial_1_0\n st1 { v16.s }[0], [x20]\n st1 { v17.s }[0], [x24]\n st1 { v18.s }[0], [x21]\n st1 { v19.s }[0], [x26]\n st1 { v20.s }[0], [x22]\n st1 { v21.s }[0], [x25]\n st1 { v22.s }[0], [x23]\n st1 { v23.s }[0], [x27]\n\nKAI_ASM_LABEL(label_12) // Output block 1: Done\n\nKAI_ASM_LABEL(label_13) // Output stage exit\n subs x10, x10, #0x4\n add x19, x19, #0x10\n bgt label_2\n mov x20, #0x4\n sub x13, x13, #0x10\n cmp x13, #0x10\n mov x19, x9\n madd x15, x20, x12, x15\n bge label_1\n\nKAI_ASM_LABEL(label_14) // Row loop skip\n cbz x13, label_23\n\nKAI_ASM_LABEL(label_15) // Row tail: Row loop\n ldr x26, [x0, #16] // Reset rhs_packed\n ldr x25, [x0, #48] // Reset n\n add x24, x19, x28, LSL #2\n\nKAI_ASM_LABEL(label_16) // Row tail: Column loop\n mov x27, x15\n movi v31.4s, #0x0\n movi v30.4s, #0x0\n mov x20, x14 // num_blocks\n movi v29.4s, #0x0\n movi v28.4s, #0x0\n\nKAI_ASM_LABEL(label_17) // Row tail: Sub block loop\n ldr q19, [x26, #0x0]\n ldr q18, [x26, #0x10]\n subs x20, x20, #0x1\n ldr q17, [x27, #0x0]\n ldr q16, [x27, #0x10]\n ldr q27, [x26, #0x20]\n ldr q26, [x26, #0x30]\n ldr q25, [x27, #0x20]\n ldr q24, [x27, #0x30]\n ldr q23, [x26, #0x40]\n ldr q22, [x26, #0x50]\n KAI_ASM_INST(0x4e93a63f) // smmla v31.4s, v17.16b, v19.16b\n KAI_ASM_INST(0x4e92a63e) // smmla v30.4s, v17.16b, v18.16b\n ldr q21, [x27, #0x40]\n ldr q20, [x27, #0x50]\n KAI_ASM_INST(0x4e93a61d) // smmla v29.4s, v16.16b, v19.16b\n KAI_ASM_INST(0x4e92a61c) // smmla v28.4s, v16.16b, v18.16b\n ldr q19, [x26, #0x60]\n ldr q18, [x26, #0x70]\n add x26, x26, #0x80\n ldr q17, [x27, #0x60]\n ldr q16, [x27, #0x70]\n add x27, x27, #0x80\n KAI_ASM_INST(0x4e9ba73f) // smmla v31.4s, v25.16b, v27.16b\n KAI_ASM_INST(0x4e9aa73e) // smmla v30.4s, v25.16b, v26.16b\n KAI_ASM_INST(0x4e9ba71d) // smmla v29.4s, v24.16b, v27.16b\n KAI_ASM_INST(0x4e9aa71c) // smmla v28.4s, v24.16b, v26.16b\n KAI_ASM_INST(0x4e97a6bf) // smmla v31.4s, v21.16b, v23.16b\n KAI_ASM_INST(0x4e96a6be) // smmla v30.4s, v21.16b, v22.16b\n KAI_ASM_INST(0x4e97a69d) // smmla v29.4s, v20.16b, v23.16b\n KAI_ASM_INST(0x4e96a69c) // smmla v28.4s, v20.16b, v22.16b\n KAI_ASM_INST(0x4e93a63f) // smmla v31.4s, v17.16b, v19.16b\n KAI_ASM_INST(0x4e92a63e) // smmla v30.4s, v17.16b, v18.16b\n KAI_ASM_INST(0x4e93a61d) // smmla v29.4s, v16.16b, v19.16b\n KAI_ASM_INST(0x4e92a61c) // smmla v28.4s, v16.16b, v18.16b\n bgt label_17\n\n ldr q18, [x26, #0x0]\n ld1 { v17.4s }, [x27]\n uzp1 v24.2d, v31.2d, v30.2d\n uzp2 v23.2d, v31.2d, v30.2d\n ldr q22, [x26, #0x10]\n uzp1 v21.2d, v29.2d, v28.2d\n uzp2 v20.2d, v29.2d, v28.2d\n add x27, x27, #0x10\n ldr q16, [x27, #0x0]\n add x26, x26, #0x20\n mla v24.4s, v18.4s, v17.s[0]\n mla v23.4s, v18.4s, v17.s[1]\n mla v21.4s, v18.4s, v17.s[2]\n mla v20.4s, v18.4s, v17.s[3]\n fmul v19.4s, v22.4s, v16.s[0]\n fmul v18.4s, v22.4s, v16.s[1]\n fmul v17.4s, v22.4s, v16.s[2]\n fmul v16.4s, v22.4s, v16.s[3]\n scvtf v24.4s, v24.4s\n scvtf v23.4s, v23.4s\n scvtf v21.4s, v21.4s\n scvtf v20.4s, v20.4s\n fmul v31.4s, v24.4s, v19.4s\n fmul v30.4s, v23.4s, v18.4s\n fmul v29.4s, v21.4s, v17.4s\n fmul v28.4s, v20.4s, v16.4s\n ldr q18, [x26, #0x0]\n ld1r { v17.4s }, [x17]\n add x20, x17, #0x4\n cmp x25, #0x4\n ld1r { v16.4s }, [x20]\n add x26, x26, #0x10\n fadd v31.4s, v31.4s, v18.4s\n fadd v30.4s, v30.4s, v18.4s\n fadd v29.4s, v29.4s, v18.4s\n fadd v28.4s, v28.4s, v18.4s\n fmax v31.4s, v31.4s, v17.4s\n fmax v30.4s, v30.4s, v17.4s\n fmax v29.4s, v29.4s, v17.4s\n fmax v28.4s, v28.4s, v17.4s\n fmin v31.4s, v31.4s, v16.4s\n fmin v30.4s, v30.4s, v16.4s\n fmin v29.4s, v29.4s, v16.4s\n fmin v28.4s, v28.4s, v16.4s\n blt label_19\n mov x20, x19\n cmp x13, #0x1\n str q31, [x20, #0x0]\n add x20, x20, x28\n ble label_22\n cmp x13, #0x2\n str q30, [x20, #0x0]\n add x20, x20, x28\n ble label_22\n cmp x13, #0x3\n str q29, [x20, #0x0]\n add x20, x20, x28\n ble label_22\n str q28, [x20, #0x0]\n b label_22\n\nKAI_ASM_LABEL(label_19) // Row tail: Partial output\n add x16, sp, #144\n mov x23, x19\n cmp x13, #0x1\n add x22, x23, x28\n csel x22, x22, x16, GT\n cmp x13, #0x2\n add x21, x23, x28, LSL #1\n csel x21, x21, x16, GT\n cmp x13, #0x3\n add x20, x21, x28\n csel x20, x20, x16, GT\n tbz x25, #1, label_20\n st1 { v28.d }[0], [x20], #0x8\n st1 { v29.d }[0], [x21], #0x8\n st1 { v30.d }[0], [x22], #0x8\n st1 { v31.d }[0], [x23], #0x8\n tbz x25, #0, label_21\n st1 { v28.s }[2], [x20]\n st1 { v29.s }[2], [x21]\n st1 { v30.s }[2], [x22]\n st1 { v31.s }[2], [x23]\n b label_21\n\nKAI_ASM_LABEL(label_20) // Row tail: Output block 0: partial_1_0\n st1 { v28.s }[0], [x20]\n st1 { v29.s }[0], [x21]\n st1 { v30.s }[0], [x22]\n st1 { v31.s }[0], [x23]\n\nKAI_ASM_LABEL(label_21) // Row tail: Output block 0: Done\n\nKAI_ASM_LABEL(label_22) // Row tail: Output stage exit\n subs x25, x25, #0x4\n add x19, x19, #0x10\n bgt label_16\n subs x13, x13, #0x4\n add x15, x15, x12\n mov x19, x24\n bgt label_15\n\nKAI_ASM_LABEL(label_23) // Row tail: Row loop skip\n\n // Restore callee-saved registers x19-x28 and d8-d15\n ldp d14, d15, [sp, 128]\n ldp d12, d13, [sp, 112]\n ldp d10, d11, [sp, 96]\n ldp d8, d9, [sp, 80]\n ldp x27, x28, [sp, 64]\n ldp x25, x26, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp], 176\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon to pack the RHS NxK matrix.\n/// -# @ref kai_rhs_pack_kxn_qsi8cxp_qsi8cx_neon to pack the RHS KxN matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed). It must be 1.\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m_idx, //\n size_t k); //\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of 4.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t n_idx, //\n size_t k); //\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix. It must be 1.\n/// @param[in] n_idx Column index in the DST matrix. It must be multiple of 4.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the DST offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m_idx, //\n size_t n_idx, //\n size_t dst_stride); //\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n); //\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) and packed\n/// RHS matrix: Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) and packed.\n/// Output tile: (rows x cols) = 1 x 4\n///\n/// Features used: dotprod\n///\n/// @param[in] m The number of output rows written. It must be 1.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float) bytes.\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n}\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(__ARM_FEATURE_DOTPROD)\n#error \"Dotprod extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n// Compute args\nstatic const size_t kai_m_step = 1;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 8;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_zp_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_qvalue_rhs = 1;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_rsum_rhs = 4;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n size_t lhs_packed_stride = kai_mr * ((k_internal * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs);\n // Since the LHS matrix is asymmetric with per-row quantization, we must include the\n // the number of bytes to hold the zero point value\n lhs_packed_stride += kai_mr * kai_num_bytes_zp_lhs;\n\n return lhs_packed_stride;\n}\n\ninline static size_t kai_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n size_t rhs_packed_stride = kai_nr * (k_internal * kai_num_bytes_qvalue_rhs);\n rhs_packed_stride += kai_nr * kai_num_bytes_multiplier_rhs;\n // Since the LHS matrix is quantized asymmetric with per-row quantization, we also include\n // the number of bytes for the reduction sum\n rhs_packed_stride += kai_nr * kai_num_bytes_rsum_rhs;\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += kai_nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(size_t n_idx, size_t k) {\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride;\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n\n if (m == 0) {\n return;\n }\n\n const size_t k_internal = kai_k_roundedup(k);\n const size_t num_blocks = k_internal / kai_k_multiple_of;\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n __asm__ __volatile__(\n \"mov x26, #0x20\\n\"\n \"mov x20, #0x8\\n\"\n \"mov x25, %x[m]\\n\"\n \"madd x26, %x[num_blocks], x26, x20\\n\"\n \"1:\" // Row loop\n \"mov x24, %x[rhs_packed]\\n\"\n \"mov x23, %x[n]\\n\"\n \"add x22, %x[dst], %x[dst_stride_row]\\n\"\n \"2:\" // Column loop\n \"mov x21, %x[lhs_packed]\\n\"\n \"movi v27.4s, #0x0\\n\"\n \"movi v26.4s, #0x0\\n\"\n \"mov x20, %x[num_blocks]\\n\"\n \"3:\" // Sub block loop\n \"ldr q25, [x24, #0x0]\\n\"\n \"ldr q17, [x24, #0x10]\\n\"\n \"subs x20, x20, #0x1\\n\"\n \"ld1r { v16.2d }, [x21], #0x8\\n\"\n \"ldr q24, [x24, #0x20]\\n\"\n \"ldr q23, [x24, #0x30]\\n\"\n \"ldr q22, [x24, #0x40]\\n\"\n \"ld1r { v21.2d }, [x21], #0x8\\n\"\n \"ldr q20, [x24, #0x50]\\n\"\n \"ld1r { v19.2d }, [x21], #0x8\\n\"\n \"ldr q18, [x24, #0x60]\\n\"\n \".inst 0x4e90973b // sdot v27.4s, v25.16b, v16.16b\\n\"\n \".inst 0x4e90963a // sdot v26.4s, v17.16b, v16.16b\\n\"\n \"ldr q17, [x24, #0x70]\\n\"\n \"add x24, x24, #0x80\\n\"\n \"ld1r { v16.2d }, [x21], #0x8\\n\"\n \".inst 0x4e95971b // sdot v27.4s, v24.16b, v21.16b\\n\"\n \".inst 0x4e9596fa // sdot v26.4s, v23.16b, v21.16b\\n\"\n \".inst 0x4e9396db // sdot v27.4s, v22.16b, v19.16b\\n\"\n \".inst 0x4e93969a // sdot v26.4s, v20.16b, v19.16b\\n\"\n \".inst 0x4e90965b // sdot v27.4s, v18.16b, v16.16b\\n\"\n \".inst 0x4e90963a // sdot v26.4s, v17.16b, v16.16b\\n\"\n \"bgt 3b\\n\"\n \"ldr q22, [x24, #0x0]\\n\"\n \"ld1r { v21.4s }, [x21]\\n\"\n \"addp v27.4s, v27.4s, v26.4s\\n\"\n \"add x21, x21, #0x4\\n\"\n \"ld1r { v20.4s }, [x21]\\n\"\n \"ldr q16, [x24, #0x10]\\n\"\n \"add x20, %x[clamp_vals], #0x4\\n\"\n \"cmp x23, #0x4\\n\"\n \"ldr q19, [x24, #0x20]\\n\"\n \"ld1r { v18.4s }, [%x[clamp_vals]]\\n\"\n \"add x24, x24, #0x30\\n\"\n \"ld1r { v17.4s }, [x20]\\n\"\n \"mla v27.4s, v22.4s, v21.s[0]\\n\"\n \"fmul v16.4s, v16.4s, v20.4s\\n\"\n \"scvtf v27.4s, v27.4s\\n\"\n \"fmul v16.4s, v27.4s, v16.4s\\n\"\n \"fadd v16.4s, v16.4s, v19.4s\\n\"\n \"fmax v16.4s, v16.4s, v18.4s\\n\"\n \"fmin v16.4s, v16.4s, v17.4s\\n\"\n \"blt 4f\\n\"\n \"str q16, [%x[dst], #0x0]\\n\"\n \"b 7f\\n\"\n \"4:\" // Partial output\n \"mov x20, %x[dst]\\n\"\n \"tbz x23, #1, 5f\\n\"\n \"st1 { v16.d }[0], [x20], #0x8\\n\"\n \"tbz x23, #0, 6f\\n\"\n \"st1 { v16.s }[2], [x20]\\n\"\n \"b 6f\\n\"\n \"5:\" // Output block 0: partial_1_0\n \"st1 { v16.s }[0], [x20]\\n\"\n \"6:\" // Output block 0: Done\n \"7:\" // Stores done\n \"subs x23, x23, #0x4\\n\"\n \"add %x[dst], %x[dst], #0x10\\n\"\n \"bgt 2b\\n\"\n \"subs x25, x25, #0x1\\n\"\n \"add %x[lhs_packed], %x[lhs_packed], x26\\n\"\n \"mov %x[dst], x22\\n\"\n \"bgt 1b\\n\"\n : [dst] \"+&r\"(dst), [lhs_packed] \"+&r\"(lhs_packed)\n : [clamp_vals] \"r\"(clamp_vals), [dst_stride_row] \"r\"(dst_stride_row), [m] \"r\"(m), [n] \"r\"(n),\n [num_blocks] \"r\"(num_blocks), [rhs_packed] \"r\"(rhs_packed)\n : \"cc\", \"memory\", \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\", \"v24\", \"v25\", \"v26\", \"v27\", \"x20\",\n \"x21\", \"x22\", \"x23\", \"x24\", \"x25\", \"x26\");\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Get the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed).\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix, which contains the packed 8-bit quantized symmetric per-channel\n/// (qs8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of rows.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be an even value.\n/// @param[in] nr The number of N rows to interleave on the same output output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n/// @param[in] rhs The RHS matrix containing the 8-bit values.\n/// Size in bytes is expected to be equal to or greater than n * k * sizeof(uint8_t).\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_qsi8cx_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n const size_t k_internal = kai_k_roundedup(k);\n\n return nr * (k_internal + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, const struct kai_rhs_pack_qsi8cx_params* params) {\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT(sr == 1);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n\n const int32_t lhs_zero_point = params->lhs_zero_point;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_num_bytes_per_row = nr * k_internal;\n const size_t rhs_stride = k;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n\n int32_t* sums = (int32_t*)(dst_row + nr * k_internal);\n\n // Initialize to zero the RHS reduction sums\n memset(sums, 0, nr * sizeof(int32_t));\n\n for (size_t dst_offset = 0; dst_offset < dst_num_bytes_per_row; dst_offset += kr) {\n const size_t block_idx = dst_offset / kr;\n const size_t nr_idx = block_idx % nr;\n const size_t super_block_idx = block_idx / nr;\n\n const size_t k0_idx = super_block_idx * kr;\n const size_t n0_idx = dst_row_idx * nr + nr_idx;\n\n // Clamp the index to avoid out-of-bound reads\n const size_t n0_valid_idx = KAI_MIN(n0_idx, n - 1);\n\n const size_t src_offset = n0_valid_idx * rhs_stride;\n\n int32_t partial_sum = 0;\n\n // Get the partial reduction sum\n for (size_t i = 0; i < kr; i++) {\n const size_t k0_valid_idx = k0_idx + i;\n int8_t v = 0;\n if (k0_valid_idx < k) {\n v = rhs[src_offset + k0_valid_idx];\n }\n ((int8_t*)dst_row)[i] = v;\n partial_sum += v;\n }\n\n sums[nr_idx] += partial_sum * lhs_zero_point;\n\n dst_row += kr;\n }\n\n // Adjust the reduction sums\n for (size_t i = 0; i < nr; ++i) {\n dst_row += sizeof(int32_t);\n }\n\n // Adjust the scales\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n *((float*)(dst_row)) = scale[src_row_idx];\n dst_row += sizeof(float);\n }\n\n // Set the bias\n if (bias == NULL) {\n memset(dst_row, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n ((float*)dst_row)[i] = bias[src_row_idx];\n }\n }\n }\n}\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm against gemm_qs8cx_n512_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n // M == 1 runs the dedicated GEMV ukernel, as a KleidiAI user would pick it. Both variants\n // share one packed-RHS layout (same nr/kr/sr), so a single cached weight pack serves both.\n const bool gemv = (M == 1);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm();\n if (kai_get_nr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod() != nr || kai_get_kr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod() != kr ||\n kai_get_sr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod() != sr) return -2;\n const size_t mr = gemv ? kai_get_mr_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod() : kai_get_mr_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = gemv ? (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr)) : (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr));\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n if (gemv) {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n } else {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q8_snap = nullptr;\n static size_t B_q8_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q8_snap, B_q8_snap_size, B_q8, (size_t)N*K)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qsi8cx_params params;\n params.lhs_zero_point = 1;\n params.scale_multiplier = 1.0f;\n kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q8, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n if (gemv) {\n kai_run_matmul_clamp_f32_qai8dxp1x8_qsi8cxp4x8_1x4_neon_dotprod((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n } else {\n kai_run_matmul_clamp_f32_qai8dxp4x8_qsi8cxp4x8_16x4_neon_i8mm((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n }\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..54738e53c01c51ecc56718a30cd67a6ad44f0ea3 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qs8cx_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qs8cx_sme2_n256_k512", + "definition": "gemm_qs8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qs8cx_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -96]!\n stp x24, x25, [sp, 16]\n stp d8, d9, [sp, 32]\n stp d10, d11, [sp, 48]\n stp d12, d13, [sp, 64]\n stp d14, d15, [sp, 80]\n KAI_ASM_INST(0xd503477f)\t// \tsmstart\n ldr\tx19, [x0] // dst\n ldr\tx20, [x0, #0x8] // lhs_packed\n cntw\tx7\n ptrue\tp2.b\n KAI_ASM_INST(0x8556c81e) // ld1rw { z30.s }, p2/z, [x0, #0x58] // clamp_min\n KAI_ASM_INST(0x8557c81f) // ld1rw { z31.s }, p2/z, [x0, #0x5c] // clamp_max\n ldr\tx12, [x0, #0x20] // m\n KAI_ASM_INST(0x25ac17e0)\t// \twhilelt\tp0.s, xzr, x12\nKAI_ASM_LABEL(label_1) // Row Loop\n ldr\tx8, [x0, #0x10] // rhs_packed\n mov\tx9, x19\n ldr\tx13, [x0, #0x28] // n\n cmp\tx7, x12\n csel\tx16, x7, x12, lt\n lsl\tx16, x16, #2\n ldr\tx24, [x0, #0x40] // rhs_row_bytes\n add\tx24, x24, x8\n mov\tx11, x8\n KAI_ASM_INST(0x25784570)\t// \twhilelt\tpn8.h, x11, x24, vlx2\n addvl\tx11, x8, #0x2\n KAI_ASM_INST(0x25784572)\t// \twhilelt\tpn10.h, x11, x24, vlx2\nKAI_ASM_LABEL(label_2) // Column Loop\n mov\tx10, x20\n mov\tx11, x8\n mov\tx17, x9\n KAI_ASM_INST(0x25ad67f1)\t// \twhilelt\tpn9.s, xzr, x13, vlx4\n KAI_ASM_INST(0xc00800ff)\t// \tzero\t{za}\n ldr\tx24, [x0, #0x48] // m_blk\n add\tx14, x10, x24\nKAI_ASM_LABEL(label_3) // Block Loop\n ld1w\t{ z4.s }, p0/z, [x10]\n addvl\tx10, x10, #0x1\n KAI_ASM_INST(0xa0402168)\t// \tld1h\t{ z8.h, z9.h }, pn8/z, [x11]\n KAI_ASM_INST(0xa0884880)\t// \tsmopa\tza0.s, p2/m, p2/m, z4.b, z8.b\n KAI_ASM_INST(0xa0894881)\t// \tsmopa\tza1.s, p2/m, p2/m, z4.b, z9.b\n KAI_ASM_INST(0xa041296a)\t// \tld1h\t{ z10.h, z11.h }, pn10/z, [x11, #0x2, mul vl]\n KAI_ASM_INST(0xa08a4882)\t// \tsmopa\tza2.s, p2/m, p2/m, z4.b, z10.b\n KAI_ASM_INST(0xa08b4883)\t// \tsmopa\tza3.s, p2/m, p2/m, z4.b, z11.b\n addvl\tx11, x11, #0x4\n cmp\tx10, x14\n b.lt\tlabel_3\n KAI_ASM_INST(0xa040c560)\t// \tld1w\t{ z0.s - z3.s }, pn9/z, [x11]\n KAI_ASM_INST(0xa041c564)\t// \tld1w\t{ z4.s - z7.s }, pn9/z, [x11, #0x4, mul vl]\n KAI_ASM_INST(0xa042c568)\t// \tld1w\t{ z8.s - z11.s }, pn9/z, [x11, #0x8, mul vl]\n addvl\tx11, x11, #0xc\n mov\tx14, #0x0 // =0\n addvl\tx15, x10, #0x1\nKAI_ASM_LABEL(label_4)\n KAI_ASM_INST(0x8540c950) // ld1rw { z16.s }, p2/z, [x10]\n KAI_ASM_INST(0x8540c9f1) // ld1rw { z17.s }, p2/z, [x15]\n add\tx10, x10, #0x4\n add\tx15, x15, #0x4\n KAI_ASM_INST(0xc006440c)\t// \tmov\t{ z12.b - z15.b }, za0h.b[w14, 0x0:0x3]\n fmul\tz20.s, z17.s, z4.s\n fmul\tz21.s, z17.s, z5.s\n fmul\tz22.s, z17.s, z6.s\n fmul\tz23.s, z17.s, z7.s\n mla\t z12.s, p2/m, z16.s, z0.s\n mla\t z13.s, p2/m, z16.s, z1.s\n mla\t z14.s, p2/m, z16.s, z2.s\n mla\t z15.s, p2/m, z16.s, z3.s\n KAI_ASM_INST(0xc132e18c)\t// \tscvtf\t{ z12.s - z15.s }, { z12.s - z15.s }\n fmul\tz24.s, z20.s, z12.s\n fmul\tz25.s, z21.s, z13.s\n fmul\tz26.s, z22.s, z14.s\n fmul\tz27.s, z23.s, z15.s\n fadd\tz24.s, p2/m, z24.s, z8.s\n fadd\tz25.s, p2/m, z25.s, z9.s\n fadd\tz26.s, p2/m, z26.s, z10.s\n fadd\tz27.s, p2/m, z27.s, z11.s\n KAI_ASM_INST(0xc1bfcbd8) // fclamp\t{ z24.s - z27.s }, z30.s, z31.s\n KAI_ASM_INST(0xa060c638) // \tst1w\t{ z24.s - z27.s }, pn9, [x17]\n ldr\tx24, [x0, #0x18] // dst_stride_row\n add\tx17, x17, x24\n add\tx14, x14, #0x4\n cmp\tx14, x16\n b.lt label_4\n ldr\tx24, [x0, #0x38] // rhs_stride\n add\tx8, x8, x24\n addvl\tx9, x9, #0x4\n ldr\tx24, [x0, #0x40] // rhs_row_bytes\n add\tx24, x24, x8\n mov\tx11, x8\n KAI_ASM_INST(0x25784570)\t// \twhilelt\tpn8.h, x11, x24, vlx2\n addvl\tx11, x8, #0x2\n KAI_ASM_INST(0x25784572)\t// \twhilelt\tpn10.h, x11, x24, vlx2\n cntw\tx24, ALL, MUL #0x4\n sub\tx13, x13, x24\n subs xzr, xzr, x13 // cmp xzr, x13\n b.mi\tlabel_2\n ldr\tx24, [x0, #0x30]\n add\tx20, x20, x24\n ldr\tx24, [x0, #0x50]\n add\tx19, x19, x24\n cntw\tx24\n sub\tx12, x12, x24\n whilelt\tp0.s, xzr, x12\n b.mi\tlabel_1\n KAI_ASM_INST(0xd503467f)\t// \tsmstop\n ldp d14, d15, [sp, 80]\n ldp d12, d13, [sp, 64]\n ldp d10, d11, [sp, 48]\n ldp d8, d9, [sp, 32]\n ldp x24, x25, [sp, 16]\n ldp x19, x20, [sp], 96\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error \"This file must be compiled for AArch64, FEAT_SVE2\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n float* dst; // 0\n const void* lhs_packed; // 0x8\n const void* rhs_packed; // 0x10\n size_t dst_stride_row; // 0x18\n size_t m; // 0x20\n size_t n; // 0x28\n size_t lhs_stride; // 0x30\n size_t rhs_stride; // 0x38\n size_t rhs_row_bytes; // 0x40\n size_t m_blk; // 0x48\n size_t dst_inc; // 0x50\n float clamp_min; // 0x58\n float clamp_max; // 0x5c\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // multiple of vector length\nstatic const size_t kai_n_step = 4; // multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // multiple of vector length\nstatic const size_t kai_nr = 4; // multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = 1;\nstatic const size_t kai_num_bytes_multiplier_lhs = 4;\nstatic const size_t kai_num_bytes_zp_lhs = 4;\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric), and reduction sum (if LHS is\n// asymmetric))\nstatic const size_t kai_num_bytes_qvalue_rhs = 1;\nstatic const size_t kai_num_bytes_multiplier_rhs = 4;\nstatic const size_t kai_num_bytes_rsum_rhs = 4;\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = 4;\n// Extra args\nstatic const size_t kai_num_bytes_bias = 4;\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_get_lhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n size_t lhs_packed_stride = mr * ((k_internal * kai_num_bytes_qvalue_lhs) + kai_num_bytes_multiplier_lhs);\n // Since the LHS matrix is asymmetric with per-row quantization, we must include the\n // the number of bytes to hold the zero point value\n lhs_packed_stride += mr * kai_num_bytes_zp_lhs;\n\n return lhs_packed_stride;\n}\n\ninline static size_t kai_get_rhs_packed_stride(size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSERT((k_internal % kai_k_multiple_of) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n size_t rhs_packed_stride = nr * (k_internal * kai_num_bytes_qvalue_rhs);\n rhs_packed_stride += nr * kai_num_bytes_multiplier_rhs;\n // Since the LHS matrix is quantized asymmetric with per-row quantization, we also include\n // the number of bytes for the reduction sum\n rhs_packed_stride += nr * kai_num_bytes_rsum_rhs;\n // Since the bias is packed with the RHS matrix, the stride is adjusted with the number of bytes of the bias\n rhs_packed_stride += nr * kai_num_bytes_bias;\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u8() / kai_kr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSERT((m_idx % kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k) {\n KAI_ASSERT((n_idx % kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSERT((m_idx % kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n KAI_ASSERT((n_idx % kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n return ((n_idx * kai_num_bytes_dst_value) + m_idx * dst_stride);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return (m * n * kai_num_bytes_dst_value);\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* restrict lhs_packed, //\n const void* restrict rhs_packed, //\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max) {\n KAI_ASSERT(dst_stride_col == sizeof(float));\n KAI_ASSERT(n > 0);\n KAI_ASSERT(m > 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n\n KernelArgs args;\n const size_t k_internal = kai_k_roundedup(k);\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.lhs_stride = kai_get_lhs_packed_stride(k);\n args.rhs_stride = kai_get_rhs_packed_stride(k);\n args.rhs_row_bytes = nr * k_internal;\n args.m_blk = mr * k_internal;\n args.dst_inc = mr * dst_stride_row;\n args.clamp_min = scalar_min;\n args.clamp_max = scalar_max;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# @ref kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix in a single step.\n/// -# @ref kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon to pack the RHS NxK matrix.\n/// -# @ref kai_rhs_pack_kxn_qsi8cxp_qsi8cx_neon to pack the RHS KxN matrix.\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix.\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the LHS and RHS matrices\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Quantized Asymmetric Signed 8-bit with per-row quantization (qai8dx) and packed\n/// RHS matrix: Quantized Symmetric Signed 8-bit with per-channel quantization (qsi8cx) and packed.\n/// Output tile: (rows x cols) = 1vl x 4vl\n///\n/// Features used: sme2\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix.\n/// @param[in] lhs_packed The LHS packed matrix. The micro-kernel to pack the native LHS matrix is reported at the\n/// top of this file.\n/// @param[in] rhs_packed The RHS packed matrix. The micro-kernel to pack the native RHS matrix is reported at the\n/// top of this file.\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, //\n size_t n, //\n size_t k, //\n const void* lhs_packed, //\n const void* rhs_packed, //\n float* dst, //\n size_t dst_stride_row, //\n size_t dst_stride_col, //\n float scalar_min, //\n float scalar_max); //\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n const size_t k_internal = kai_k_roundedup(k);\n\n return nr * (k_internal + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, const struct kai_rhs_pack_qsi8cx_params* params) {\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT(sr == 1);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n\n const int32_t lhs_zero_point = params->lhs_zero_point;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(k, nr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const size_t dst_num_rows = kai_roundup(n, nr) / nr;\n const size_t dst_num_bytes_per_row = nr * k_internal;\n const size_t rhs_stride = k;\n\n for (size_t dst_row_idx = 0; dst_row_idx < dst_num_rows; ++dst_row_idx) {\n uint8_t* dst_row = (uint8_t*)rhs_packed + dst_row_idx * rhs_packed_stride;\n\n int32_t* sums = (int32_t*)(dst_row + nr * k_internal);\n\n // Initialize to zero the RHS reduction sums\n memset(sums, 0, nr * sizeof(int32_t));\n\n for (size_t dst_offset = 0; dst_offset < dst_num_bytes_per_row; dst_offset += kr) {\n const size_t block_idx = dst_offset / kr;\n const size_t nr_idx = block_idx % nr;\n const size_t super_block_idx = block_idx / nr;\n\n const size_t k0_idx = super_block_idx * kr;\n const size_t n0_idx = dst_row_idx * nr + nr_idx;\n\n // Clamp the index to avoid out-of-bound reads\n const size_t n0_valid_idx = KAI_MIN(n0_idx, n - 1);\n\n const size_t src_offset = n0_valid_idx * rhs_stride;\n\n int32_t partial_sum = 0;\n\n // Get the partial reduction sum\n for (size_t i = 0; i < kr; i++) {\n const size_t k0_valid_idx = k0_idx + i;\n int8_t v = 0;\n if (k0_valid_idx < k) {\n v = rhs[src_offset + k0_valid_idx];\n }\n ((int8_t*)dst_row)[i] = v;\n partial_sum += v;\n }\n\n sums[nr_idx] += partial_sum * lhs_zero_point;\n\n dst_row += kr;\n }\n\n // Adjust the reduction sums\n for (size_t i = 0; i < nr; ++i) {\n dst_row += sizeof(int32_t);\n }\n\n // Adjust the scales\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n *((float*)(dst_row)) = scale[src_row_idx];\n dst_row += sizeof(float);\n }\n\n // Set the bias\n if (bias == NULL) {\n memset(dst_row, 0, nr * kai_num_bytes_bias);\n } else {\n for (size_t i = 0; i < nr; ++i) {\n // Clamp the row index to avoid out-of-bound reads\n const size_t src_row_idx = KAI_MIN(dst_row_idx * nr + i, n - 1);\n ((float*)dst_row)[i] = bias[src_row_idx];\n }\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Get the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed).\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix, which contains the packed 8-bit quantized symmetric per-channel\n/// (qs8cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int8 values are stored in a N x K matrix.\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of rows.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be an even value.\n/// @param[in] nr The number of N rows to interleave on the same output output row.\n/// @param[in] kr The number of K values loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It must be 1.\n/// @param[in] rhs The RHS matrix containing the 8-bit values.\n/// Size in bytes is expected to be equal to or greater than n * k * sizeof(uint8_t).\n/// @param[in] bias The biases.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\nvoid kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(\n size_t num_groups, //\n size_t n, //\n size_t k, //\n size_t nr, //\n size_t kr, //\n size_t sr, //\n const int8_t* rhs, //\n const float* bias, //\n const float* scale, //\n void* rhs_packed, //\n size_t extra_bytes, //\n const struct kai_rhs_pack_qsi8cx_params* params);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa against gemm_qs8cx_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsi8cxp_qsi8cx_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q8_snap = nullptr;\n static size_t B_q8_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q8_snap, B_q8_snap_size, B_q8, (size_t)N*K)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsi8cxp_qsi8cx_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qsi8cx_params params;\n params.lhs_zero_point = 1;\n params.scale_multiplier = 1.0f;\n kai_run_rhs_pack_nxk_qsi8cxp_qsi8cx_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q8, bias, B_scales, rhs_packed, 0, ¶ms);\n }\n\n kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsi8cxp4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity());\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..8416b98d91b827fdb448dab7b8bd694604d389e9 --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_n256_k512.json @@ -0,0 +1,74 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qsu2cx_n256_k512", + "definition": "gemm_qsu2cx_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qsu2cx_n256_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "dotprod" + ], + "compile_flags": [ + "-O3", + "-march=armv8.2-a+dotprod" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix with\n/// the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 2-bit quantized symmetric per-channel (qsu2cxp) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed\n/// RHS matrix: Signed 2-bit quantized symmetric per-channel (qsu2cxp) and packed.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix. It must be a\n/// a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS packed matrix, which is obtained by calling @ref\n/// kai_run_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\n/// @param[in] lut Look up table for mapping 2-bit to 8-bit values.\nvoid kai_run_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, float* dst, size_t dst_stride_row,\n size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if !defined(__aarch64__) && !defined(__ARM_FEATURE_DOTPROD) && !defined(_M_ARM64)\n#error \"Dotprod extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 4\n\n/// Look-up table used for int2 -> int8 conversion\nstatic const int32_t lut_i8_i2[KAI_LUT_NENTRIES] = {-2, -1, 0, 1};\n\ntypedef struct {\n float* dst; // 0x00\n const void* lhs_packed; // 0x08\n const void* rhs_packed; // 0x10\n size_t m; // 0x18\n size_t n; // 0x20\n size_t k_internal; // 0x28\n size_t dst_stride_row; // 0x30\n size_t lhs_packed_stride; // 0x38\n const int8_t* lut_vals; // 0x40\n const float* clamp_vals; // 0x48\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 8;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 4;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = sizeof(int8_t);\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 4; // 4 2-bit quantized int values in a byte\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias_rhs = sizeof(float);\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = sizeof(float);\n// Extra args\nstatic const size_t kai_k_multiple_of = 32;\n\nstatic size_t kai_k_roundedup(const size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nstatic size_t kai_get_lhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n return kai_mr * (k_internal * kai_num_bytes_qvalue_lhs + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\nstatic size_t kai_get_rhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n return kai_nr *\n ((k_internal / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs +\n kai_num_bytes_bias_rhs);\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t n_idx, size_t k) {\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + (m_idx * dst_stride);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut_arg) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME(m > 0);\n KAI_ASSUME(n > 0);\n KAI_ASSUME(k > 0);\n KAI_ASSUME(k % kai_k_multiple_of == 0);\n\n const int32_t* lut = lut_arg != NULL ? lut_arg : lut_i8_i2;\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const int8_t lut_s8[16] = {lut[0], lut[1], lut[2], lut[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.m = m;\n args.n = n;\n args.k_internal = kai_k_roundedup(k);\n args.dst_stride_row = dst_stride_row;\n args.lhs_packed_stride = kai_get_lhs_packed_stride(k);\n args.lut_vals = lut_s8;\n args.clamp_vals = clamp_vals;\n\n kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod)\n stp x19, x20, [sp, -144]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp x25, x26, [sp, 48]\n stp x27, x28, [sp, 64]\n stp d8, d9, [sp, 80]\n stp d10, d11, [sp, 96]\n stp d12, d13, [sp, 112]\n stp d14, d15, [sp, 128]\n\n ldr x19, [x0, #0x08] // lhs_packed\n ldr x26, [x0, #0x00] // dst\n ldr x28, [x0, #0x38] // lhs_packed_stride\n add x27, x28, x28\n ldr x10, [x0, #0x30] // dst_stride_row\n lsl x9, x10, #3\n lsl x8, x10, #2\n ldr x20, [x0, #0x40] // lut_vals\n ldr q2, [x20]\n ldr x20, [x0, #0x48] // clamp_vals\n ld1r { v0.4s }, [x20]\n add x20, x20, #0x4\n ld1r { v1.4s }, [x20]\n ldr x25, [x0, #0x18] // m\n movi v3.16b, #0x03\n cmp x25, #0x8\n b.lt Row_Loop_Skip\n\nKAI_ASM_LABEL(Row_Loop)\n mov x11, x26\n add x12, x11, x10\n add x13, x12, x10\n add x14, x13, x10\n add x15, x14, x10\n add x16, x15, x10\n add x17, x16, x10\n add x6, x17, x10\n ldr x24, [x0, #0x10] // rhs_packed\n ldr x23, [x0, #0x20] // n\n\nKAI_ASM_LABEL(Column_Loop)\n mov x21, x19\n add x22, x19, x28\n movi v4.4s, #0\n movi v5.4s, #0\n movi v6.4s, #0\n movi v7.4s, #0\n movi v8.4s, #0\n movi v9.4s, #0\n movi v10.4s, #0\n movi v11.4s, #0\n ldr x20, [x0, #0x28] // k_internal\n\nKAI_ASM_LABEL(K_Loop)\n ldr q12, [x24], #0x10\n and v13.16b, v12.16b, v3.16b\n ushr v14.16b, v12.16b, #2\n and v14.16b, v14.16b, v3.16b\n ushr v15.16b, v12.16b, #4\n and v15.16b, v15.16b, v3.16b\n ushr v16.16b, v12.16b, #6\n tbl v13.16b, { v2.16b }, v13.16b\n tbl v14.16b, { v2.16b }, v14.16b\n tbl v15.16b, { v2.16b }, v15.16b\n tbl v16.16b, { v2.16b }, v16.16b\n ldp q12, q17, [x21], #0x20\n ldp q18, q19, [x22], #0x20\n sdot v4.4s, v13.16b, v12.4b[0]\n sdot v5.4s, v13.16b, v12.4b[1]\n sdot v6.4s, v13.16b, v12.4b[2]\n sdot v7.4s, v13.16b, v12.4b[3]\n sdot v8.4s, v13.16b, v18.4b[0]\n sdot v9.4s, v13.16b, v18.4b[1]\n sdot v10.4s, v13.16b, v18.4b[2]\n sdot v11.4s, v13.16b, v18.4b[3]\n sdot v4.4s, v14.16b, v17.4b[0]\n sdot v5.4s, v14.16b, v17.4b[1]\n sdot v6.4s, v14.16b, v17.4b[2]\n sdot v7.4s, v14.16b, v17.4b[3]\n sdot v8.4s, v14.16b, v19.4b[0]\n sdot v9.4s, v14.16b, v19.4b[1]\n sdot v10.4s, v14.16b, v19.4b[2]\n sdot v11.4s, v14.16b, v19.4b[3]\n ldp q12, q17, [x21], #0x20\n ldp q18, q19, [x22], #0x20\n sdot v4.4s, v15.16b, v12.4b[0]\n sdot v5.4s, v15.16b, v12.4b[1]\n sdot v6.4s, v15.16b, v12.4b[2]\n sdot v7.4s, v15.16b, v12.4b[3]\n sdot v8.4s, v15.16b, v18.4b[0]\n sdot v9.4s, v15.16b, v18.4b[1]\n sdot v10.4s, v15.16b, v18.4b[2]\n sdot v11.4s, v15.16b, v18.4b[3]\n sdot v4.4s, v16.16b, v17.4b[0]\n sdot v5.4s, v16.16b, v17.4b[1]\n sdot v6.4s, v16.16b, v17.4b[2]\n sdot v7.4s, v16.16b, v17.4b[3]\n sdot v8.4s, v16.16b, v19.4b[0]\n sdot v9.4s, v16.16b, v19.4b[1]\n sdot v10.4s, v16.16b, v19.4b[2]\n sdot v11.4s, v16.16b, v19.4b[3]\n subs x20, x20, #0x10\n b.ne K_Loop\n ldp q12, q14, [x21], #0x20\n ldp q13, q15, [x22], #0x20\n ldp q16, q17, [x24], #0x20\n mla v4.4s, v16.4s, v12.s[0]\n mla v5.4s, v16.4s, v12.s[1]\n mla v6.4s, v16.4s, v12.s[2]\n mla v7.4s, v16.4s, v12.s[3]\n mla v8.4s, v16.4s, v13.s[0]\n mla v9.4s, v16.4s, v13.s[1]\n mla v10.4s, v16.4s, v13.s[2]\n mla v11.4s, v16.4s, v13.s[3]\n scvtf v4.4s, v4.4s\n scvtf v5.4s, v5.4s\n scvtf v6.4s, v6.4s\n scvtf v7.4s, v7.4s\n scvtf v8.4s, v8.4s\n scvtf v9.4s, v9.4s\n scvtf v10.4s, v10.4s\n scvtf v11.4s, v11.4s\n fmul v4.4s, v4.4s, v17.4s\n fmul v5.4s, v5.4s, v17.4s\n fmul v6.4s, v6.4s, v17.4s\n fmul v7.4s, v7.4s, v17.4s\n fmul v8.4s, v8.4s, v17.4s\n fmul v9.4s, v9.4s, v17.4s\n fmul v10.4s, v10.4s, v17.4s\n fmul v11.4s, v11.4s, v17.4s\n ldr q18, [x24], #0x10\n fmul v4.4s, v4.4s, v14.s[0]\n fmul v5.4s, v5.4s, v14.s[1]\n fmul v6.4s, v6.4s, v14.s[2]\n fmul v7.4s, v7.4s, v14.s[3]\n fmul v8.4s, v8.4s, v15.s[0]\n fmul v9.4s, v9.4s, v15.s[1]\n fmul v10.4s, v10.4s, v15.s[2]\n fmul v11.4s, v11.4s, v15.s[3]\n fadd v4.4s, v4.4s, v18.4s\n fadd v5.4s, v5.4s, v18.4s\n fadd v6.4s, v6.4s, v18.4s\n fadd v7.4s, v7.4s, v18.4s\n fadd v8.4s, v8.4s, v18.4s\n fadd v9.4s, v9.4s, v18.4s\n fadd v10.4s, v10.4s, v18.4s\n fadd v11.4s, v11.4s, v18.4s\n fmax v4.4s, v4.4s, v0.4s\n fmax v5.4s, v5.4s, v0.4s\n fmax v6.4s, v6.4s, v0.4s\n fmax v7.4s, v7.4s, v0.4s\n fmax v8.4s, v8.4s, v0.4s\n fmax v9.4s, v9.4s, v0.4s\n fmax v10.4s, v10.4s, v0.4s\n fmax v11.4s, v11.4s, v0.4s\n fmin v4.4s, v4.4s, v1.4s\n fmin v5.4s, v5.4s, v1.4s\n fmin v6.4s, v6.4s, v1.4s\n fmin v7.4s, v7.4s, v1.4s\n fmin v8.4s, v8.4s, v1.4s\n fmin v9.4s, v9.4s, v1.4s\n fmin v10.4s, v10.4s, v1.4s\n fmin v11.4s, v11.4s, v1.4s\n cmp x23, #0x4\n b.lt Partial_Output\n str q4, [x11]\n str q5, [x12]\n str q6, [x13]\n str q7, [x14]\n str q8, [x15]\n str q9, [x16]\n str q10, [x17]\n str q11, [x6]\n b Output_Store_Done\n\nKAI_ASM_LABEL(Partial_Output)\n tbz x23, #1, Output_Block_0\n st1 { v4.d }[0], [x11], #0x8\n st1 { v5.d }[0], [x12], #0x8\n st1 { v6.d }[0], [x13], #0x8\n st1 { v7.d }[0], [x14], #0x8\n st1 { v8.d }[0], [x15], #0x8\n st1 { v9.d }[0], [x16], #0x8\n st1 { v10.d }[0], [x17], #0x8\n st1 { v11.d }[0], [x6], #0x8\n tbz x23, #0, Output_Store_Done\n st1 { v4.s }[2], [x11]\n st1 { v5.s }[2], [x12]\n st1 { v6.s }[2], [x13]\n st1 { v7.s }[2], [x14]\n st1 { v8.s }[2], [x15]\n st1 { v9.s }[2], [x16]\n st1 { v10.s }[2], [x17]\n st1 { v11.s }[2], [x6]\n b Output_Store_Done\n\nKAI_ASM_LABEL(Output_Block_0)\n st1 { v4.s }[0], [x11]\n st1 { v5.s }[0], [x12]\n st1 { v6.s }[0], [x13]\n st1 { v7.s }[0], [x14]\n st1 { v8.s }[0], [x15]\n st1 { v9.s }[0], [x16]\n st1 { v10.s }[0], [x17]\n st1 { v11.s }[0], [x6]\n\nKAI_ASM_LABEL(Output_Store_Done)\n add x11, x11, #0x10\n add x12, x12, #0x10\n add x13, x13, #0x10\n add x14, x14, #0x10\n add x15, x15, #0x10\n add x16, x16, #0x10\n add x17, x17, #0x10\n add x6, x6, #0x10\n subs x23, x23, #0x4\n b.hi Column_Loop\n add x19, x19, x27\n add x26, x26, x9\n sub x25, x25, #0x8\n cmp x25, #0x8\n b.hs Row_Loop\n\nKAI_ASM_LABEL(Row_Loop_Skip)\n cbz x25, Exit\n\nKAI_ASM_LABEL(Tail_Row_Loop)\n mov x27, x25\n mov x11, x26\n add x12, x11, x10\n add x13, x12, x10\n add x14, x13, x10\n ldr x24, [x0, #0x10] // rhs_packed\n ldr x23, [x0, #0x20] // n\n\nKAI_ASM_LABEL(Tail_Column_Loop)\n mov x21, x19\n movi v4.4s, #0\n movi v5.4s, #0\n movi v6.4s, #0\n movi v7.4s, #0\n ldr x20, [x0, #0x28] // k_internal\n\nKAI_ASM_LABEL(Tail_K_Loop)\n ldr q12, [x24], #0x10\n and v13.16b, v12.16b, v3.16b\n ushr v14.16b, v12.16b, #2\n and v14.16b, v14.16b, v3.16b\n ushr v15.16b, v12.16b, #4\n and v15.16b, v15.16b, v3.16b\n ushr v16.16b, v12.16b, #6\n tbl v13.16b, { v2.16b }, v13.16b\n tbl v14.16b, { v2.16b }, v14.16b\n tbl v15.16b, { v2.16b }, v15.16b\n tbl v16.16b, { v2.16b }, v16.16b\n ld1r { v17.4s }, [x21], #0x4\n ld1r { v18.4s }, [x21], #0x4\n ld1r { v19.4s }, [x21], #0x4\n ld1r { v20.4s }, [x21], #0x4\n sdot v4.4s, v13.16b, v17.16b\n sdot v5.4s, v13.16b, v18.16b\n sdot v6.4s, v13.16b, v19.16b\n sdot v7.4s, v13.16b, v20.16b\n ld1r { v17.4s }, [x21], #0x4\n ld1r { v18.4s }, [x21], #0x4\n ld1r { v19.4s }, [x21], #0x4\n ld1r { v20.4s }, [x21], #0x4\n sdot v4.4s, v14.16b, v17.16b\n sdot v5.4s, v14.16b, v18.16b\n sdot v6.4s, v14.16b, v19.16b\n sdot v7.4s, v14.16b, v20.16b\n ld1r { v17.4s }, [x21], #0x4\n ld1r { v18.4s }, [x21], #0x4\n ld1r { v19.4s }, [x21], #0x4\n ld1r { v20.4s }, [x21], #0x4\n sdot v4.4s, v15.16b, v17.16b\n sdot v5.4s, v15.16b, v18.16b\n sdot v6.4s, v15.16b, v19.16b\n sdot v7.4s, v15.16b, v20.16b\n ld1r { v17.4s }, [x21], #0x4\n ld1r { v18.4s }, [x21], #0x4\n ld1r { v19.4s }, [x21], #0x4\n ld1r { v20.4s }, [x21], #0x4\n sdot v4.4s, v16.16b, v17.16b\n sdot v5.4s, v16.16b, v18.16b\n sdot v6.4s, v16.16b, v19.16b\n sdot v7.4s, v16.16b, v20.16b\n subs x20, x20, #0x10\n b.ne Tail_K_Loop\n ldp q12, q13, [x21], #0x20\n ldp q14, q15, [x24], #0x20\n mla v4.4s, v14.4s, v12.s[0]\n mla v5.4s, v14.4s, v12.s[1]\n mla v6.4s, v14.4s, v12.s[2]\n mla v7.4s, v14.4s, v12.s[3]\n scvtf v4.4s, v4.4s\n scvtf v5.4s, v5.4s\n scvtf v6.4s, v6.4s\n scvtf v7.4s, v7.4s\n fmul v4.4s, v4.4s, v15.4s\n fmul v5.4s, v5.4s, v15.4s\n fmul v6.4s, v6.4s, v15.4s\n fmul v7.4s, v7.4s, v15.4s\n ldr q16, [x24], #0x10\n fmul v4.4s, v4.4s, v13.s[0]\n fmul v5.4s, v5.4s, v13.s[1]\n fmul v6.4s, v6.4s, v13.s[2]\n fmul v7.4s, v7.4s, v13.s[3]\n fadd v4.4s, v4.4s, v16.4s\n fadd v5.4s, v5.4s, v16.4s\n fadd v6.4s, v6.4s, v16.4s\n fadd v7.4s, v7.4s, v16.4s\n fmax v4.4s, v4.4s, v0.4s\n fmax v5.4s, v5.4s, v0.4s\n fmax v6.4s, v6.4s, v0.4s\n fmax v7.4s, v7.4s, v0.4s\n fmin v4.4s, v4.4s, v1.4s\n fmin v5.4s, v5.4s, v1.4s\n fmin v6.4s, v6.4s, v1.4s\n fmin v7.4s, v7.4s, v1.4s\n mov x22, x11\n cmp x27, #0x1\n add x21, x22, x10\n csel x21, x21, x22, gt\n cmp x27, #0x2\n add x20, x22, x10, lsl #1\n csel x20, x20, x21, gt\n cmp x27, #0x3\n add x6, x20, x10\n csel x6, x6, x20, gt\n cmp x23, #0x4\n b.lt Tail_Partial_Output\n str q7, [x6]\n str q6, [x20]\n str q5, [x21]\n str q4, [x22]\n b Tail_Output_Done\n\nKAI_ASM_LABEL(Tail_Partial_Output)\n tbz x23, #1, Tail_Output_Block_0\n st1 { v7.d }[0], [x6], #0x8\n st1 { v6.d }[0], [x20], #0x8\n st1 { v5.d }[0], [x21], #0x8\n st1 { v4.d }[0], [x22], #0x8\n tbz x23, #0, Tail_Output_Done\n st1 { v7.s }[2], [x6]\n st1 { v6.s }[2], [x20]\n st1 { v5.s }[2], [x21]\n st1 { v4.s }[2], [x22]\n b Tail_Output_Done\n\nKAI_ASM_LABEL(Tail_Output_Block_0)\n st1 { v7.s }[0], [x6]\n st1 { v6.s }[0], [x20]\n st1 { v5.s }[0], [x21]\n st1 { v4.s }[0], [x22]\n\nKAI_ASM_LABEL(Tail_Output_Done)\n add x11, x11, #0x10\n add x12, x12, #0x10\n add x13, x13, #0x10\n add x14, x14, #0x10\n subs x23, x23, #0x4\n b.hi Tail_Column_Loop\n add x19, x19, x28\n add x26, x26, x8\n subs x25, x25, #0x4\n b.hi Tail_Row_Loop\n\nKAI_ASM_LABEL(Exit)\n ldp d14, d15, [sp, 128]\n ldp d12, d13, [sp, 112]\n ldp d10, d11, [sp, 96]\n ldp d8, d9, [sp, 80]\n ldp x27, x28, [sp, 64]\n ldp x25, x26, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix with\n/// the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 2-bit quantized symmetric per-channel (qsu2cxp) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed\n/// RHS matrix: Signed 2-bit quantized symmetric per-channel (qsu2cxp) and packed.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix. It must be a\n/// a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS packed matrix, which is obtained by calling @ref\n/// kai_run_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\n/// @param[in] lut Look up table for mapping 2-bit to 8-bit values.\nvoid kai_run_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, float* dst, size_t dst_stride_row,\n size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(__ARM_FEATURE_DOTPROD) && !defined(_M_ARM64)\n#error \"Dotprod extension required to compile this micro-kernel\"\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 4\n\n/// Look-up table used for int2 -> int8 conversion\nstatic const int32_t lut_i8_i2[KAI_LUT_NENTRIES] = {-2, -1, 0, 1};\n\ntypedef struct {\n float* dst; // 0x00\n const void* lhs_packed; // 0x08\n const void* rhs_packed; // 0x10\n size_t m; // 0x18\n size_t n; // 0x20\n size_t k_internal; // 0x28\n size_t dst_stride_row; // 0x30\n size_t lhs_packed_stride; // 0x38\n const int8_t* lut_vals; // 0x40\n const float* clamp_vals; // 0x48\n} KernelArgs;\n\nvoid kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1;\nstatic const size_t kai_n_step = 4;\n// Packing args\nstatic const size_t kai_mr = 1;\nstatic const size_t kai_nr = 4;\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = sizeof(int8_t);\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 4; // 4 2-bit quantized int values in a byte\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias_rhs = sizeof(float);\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = sizeof(float);\n// Extra args\nstatic const size_t kai_k_multiple_of = 32;\n\nstatic size_t kai_k_roundedup(const size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nstatic size_t kai_get_lhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n return kai_mr * (k_internal * kai_num_bytes_qvalue_lhs + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\nstatic size_t kai_get_rhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n return kai_nr *\n ((k_internal / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs +\n kai_num_bytes_bias_rhs);\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_m_step;\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_n_step;\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_mr;\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_nr;\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_mr) == 0);\n\n return (m_idx / kai_mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t n_idx, size_t k) {\n KAI_ASSUME((n_idx % kai_nr) == 0);\n\n return (n_idx / kai_nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_m_step) == 0);\n KAI_ASSUME((n_idx % kai_n_step) == 0);\n\n return (n_idx * kai_num_bytes_dst_value) + (m_idx * dst_stride);\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut_arg) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME(m > 0);\n KAI_ASSUME(n > 0);\n KAI_ASSUME(k > 0);\n\n KAI_ASSUME(k % kai_k_multiple_of == 0);\n KAI_ASSUME(m == 1);\n\n const int32_t* lut = lut_arg != NULL ? lut_arg : lut_i8_i2;\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const int8_t lut_s8[16] = {lut[0], lut[1], lut[2], lut[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const float clamp_vals[2] = {scalar_min, scalar_max};\n\n KernelArgs args;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst = dst;\n args.dst_stride_row = dst_stride_row;\n args.lhs_packed_stride = kai_get_lhs_packed_stride(k);\n args.m = m;\n args.n = n;\n args.k_internal = kai_k_roundedup(k);\n args.lut_vals = lut_s8;\n args.clamp_vals = clamp_vals;\n\n kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod(&args);\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod)\n stp x19, x20, [sp, -96]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp x25, x26, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 80]\n\n ldr x26, [x0, #0x00] // dst\n ldr x19, [x0, #0x08] // lhs_packed\n ldr x28, [x0, #0x38] // lhs_packed_stride\n ldr x20, [x0, #0x40] // lut_vals\n ldr q2, [x20]\n ldr x20, [x0, #0x48] // clamp_vals\n ld1r { v0.4s }, [x20]\n add x20, x20, #0x4\n ld1r { v1.4s }, [x20]\n ldr x25, [x0, #0x18] // m\n movi v3.16b, #0x03\n\nKAI_ASM_LABEL(Row_Loop)\n ldr x24, [x0, #0x10] // rhs_packed\n ldr x23, [x0, #0x20] // n\n ldr x17, [x0, #0x30] // dst_stride_row\n add x22, x26, x17\n\nKAI_ASM_LABEL(Column_Loop)\n mov x21, x19\n movi v4.4s, #0\n ldr x20, [x0, #0x28] // k_internal\n\nKAI_ASM_LABEL(K_Loop)\n ldr q5, [x24], #0x10\n ldr q6, [x21], #0x10\n and v16.16b, v5.16b, v3.16b\n ushr v17.16b, v5.16b, #2\n and v17.16b, v17.16b, v3.16b\n ushr v18.16b, v5.16b, #4\n and v18.16b, v18.16b, v3.16b\n ushr v19.16b, v5.16b, #6\n tbl v16.16b, { v2.16b }, v16.16b\n tbl v17.16b, { v2.16b }, v17.16b\n tbl v18.16b, { v2.16b }, v18.16b\n tbl v19.16b, { v2.16b }, v19.16b\n sdot v4.4s, v16.16b, v6.4b[0]\n sdot v4.4s, v17.16b, v6.4b[1]\n sdot v4.4s, v18.16b, v6.4b[2]\n sdot v4.4s, v19.16b, v6.4b[3]\n subs x20, x20, #0x10\n b.ne K_Loop\n\n ld1r { v5.4s }, [x21], #0x4\n ldp q6, q7, [x24], #0x20\n mla v4.4s, v6.4s, v5.4s\n ld1r { v5.4s }, [x21]\n fmul v5.4s, v5.4s, v7.4s\n scvtf v4.4s, v4.4s\n fmul v4.4s, v4.4s, v5.4s\n ldr q6, [x24], #0x10\n fadd v4.4s, v4.4s, v6.4s\n fmax v4.4s, v4.4s, v0.4s\n fmin v4.4s, v4.4s, v1.4s\n cmp x23, #0x4\n blt Partial_Output\n str q4, [x26]\n b Output_Store_Done\n\nKAI_ASM_LABEL(Partial_Output)\n mov x20, x26\n tbz x23, #1, Output_Block_0\n st1 { v4.d }[0], [x20], #0x8\n tbz x23, #0, Output_Store_Done\n st1 { v4.s }[2], [x20]\n b Output_Store_Done\n\nKAI_ASM_LABEL(Output_Block_0)\n st1 { v4.s }[0], [x20]\n\nKAI_ASM_LABEL(Output_Store_Done)\n subs x23, x23, #0x4\n add x26, x26, #0x10\n bgt Column_Loop\n subs x25, x25, #0x1\n add x19, x19, x28\n mov x26, x22\n bgt Row_Loop\n\n ldp d8, d9, [sp, 80]\n ldr x28, [sp, 64]\n ldp x25, x26, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp], 96\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon_params\n#define kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Get the n step value.\n///\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed)\n///\n/// @note The int2 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Four int2 values are stored in one byte as s3s2s1s0. The lower order part of the byte (low) holds\n/// the first 2-bit (K-index + 0), then the higher order of the byte holds the second 2-bit (K-index + 1)\n/// and so on..\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 2-bit quantized symmetric per-channel (qsi2cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int2 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Four int2 values are stored in one byte as s3s2s1s0. The lower order part of the byte (low) holds\n/// the first 2-bit (K-index + 0), then the higher order of the byte holds the second 2-bit (K-index + 1)\n/// and so on..\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be a a multiple of 32.\n/// @param[in] nr The number of N columns to interleave on the same output output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] rhs The RHS matrix containing the 2-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 4).\n/// @param[in] bias The biases. The bias is set to 0.f if this argument is NULL.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\n/// @param[in] lut_arg Look up table for mapping 2-bit to 8-bit values.\nvoid kai_run_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon_params* params, const int32_t* lut_arg);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 4\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\n/// Look-up table used for 2-bit -> int8 conversion\nstatic const int32_t lut_i8_i2[KAI_LUT_NENTRIES] = {-2, -1, 0, 1};\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n // multiple of 4 because 4 2-bit quantized int elements in a byte\n KAI_ASSERT((k_internal % 4) == 0);\n\n return nr * ((k_internal / 4) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon_params* params, const int32_t* lut_arg) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % kr) == 0);\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n KAI_ASSERT(params->lhs_zero_point == 1);\n KAI_ASSERT(params->rhs_zero_point == 2);\n KAI_ASSUME(k % kai_k_multiple_of == 0);\n KAI_ASSUME((kr / sr) == 4);\n KAI_ASSUME(nr == 4);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t rhs_stride = kai_roundup(k, 4) / 4;\n const size_t rhs_packed_stride =\n kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(k, nr, kr, sr);\n const size_t block_length = kr / sr;\n const size_t dst_nr_block_size = nr * 4 * block_length * sizeof(uint8_t) / 4;\n const int32_t* lut = lut_arg != NULL ? lut_arg : lut_i8_i2;\n const size_t k_byte_increment = 8;\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const int8_t lut_s8[8] = {(int8_t)lut[0], (int8_t)lut[1], (int8_t)lut[2], (int8_t)lut[3], 0, 0, 0, 0};\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const int8x8_t vlut_s8 = vld1_s8(lut_s8);\n\n // Iterate over n src rows in blocks of nr rows\n for (size_t row_idx = 0; row_idx < n; row_idx += nr) {\n int8_t* dst_row = (int8_t*)rhs_packed + ((row_idx / nr) * rhs_packed_stride);\n\n int32_t* const sums = (int32_t*)(dst_row + (nr * (k_internal / 4)));\n float* const scaling_factors = (float*)((uint8_t*)sums + (nr * kai_num_bytes_sum_rhs));\n // Update destination row pointer\n float* const biases = (float*)((uint8_t*)scaling_factors + (nr * kai_num_bytes_multiplier_rhs));\n\n // initialize sums to 0\n memset(sums, 0, nr * kai_num_bytes_sum_rhs);\n\n // Copy the scaling factors and bias\n size_t rows_left = n - row_idx;\n // Saving scales.\n if (rows_left >= nr) {\n memcpy(scaling_factors, &scale[row_idx], nr * kai_num_bytes_multiplier_rhs);\n } else {\n // Fill remaining values\n memcpy(scaling_factors, &scale[row_idx], rows_left * kai_num_bytes_multiplier_rhs);\n // Set leftover to 0\n memset(&scaling_factors[rows_left], 0, (nr - rows_left) * kai_num_bytes_multiplier_rhs);\n }\n if (bias == NULL) {\n // Set bias to 0\n memset(biases, 0, nr * kai_num_bytes_bias);\n } else {\n if (rows_left >= nr) {\n memcpy(biases, &bias[row_idx], nr * kai_num_bytes_bias);\n } else {\n // Fill remaining values\n memcpy(biases, &bias[row_idx], rows_left * kai_num_bytes_bias);\n // Set leftover to 0\n memset(&biases[rows_left], 0, (nr - rows_left) * kai_num_bytes_bias);\n }\n }\n\n int32_t row_sum[4] = {0};\n const uint32_t pack_mask = 0x03030303U;\n const uint64_t pack_byte_mul = 0x01041040ULL;\n\n const uint8_t* const src_rows_0 = rhs + ((row_idx + 0) * rhs_stride);\n const uint8_t* const src_rows_1 = rhs + ((row_idx + 1) * rhs_stride);\n const uint8_t* const src_rows_2 = rhs + ((row_idx + 2) * rhs_stride);\n const uint8_t* const src_rows_3 = rhs + ((row_idx + 3) * rhs_stride);\n\n size_t nr_block_idx = 0;\n\n // Vectorized loop: Iterate over 4 rows at a time.\n for (; (nr_block_idx < nr) && (row_idx + nr < n); nr_block_idx += nr) {\n // Iterate over k src columns in blocks of kr columns and update all 4 rows.\n for (size_t k_byte_idx = 0; k_byte_idx < rhs_stride; k_byte_idx += k_byte_increment) {\n // Load the input\n const uint8x8_t vrow0_u8 = vld1_u8(src_rows_0 + k_byte_idx);\n const uint8x8_t vrow1_u8 = vld1_u8(src_rows_1 + k_byte_idx);\n const uint8x8_t vrow2_u8 = vld1_u8(src_rows_2 + k_byte_idx);\n const uint8x8_t vrow3_u8 = vld1_u8(src_rows_3 + k_byte_idx);\n\n // Extract 2-bit values\n const uint32x2_t row0_u32 = vreinterpret_u32_u8(vrow0_u8);\n const uint32x2_t row1_u32 = vreinterpret_u32_u8(vrow1_u8);\n const uint32x2_t row2_u32 = vreinterpret_u32_u8(vrow2_u8);\n const uint32x2_t row3_u32 = vreinterpret_u32_u8(vrow3_u8);\n\n const uint32_t row0_src_u32_lo = vget_lane_u32(row0_u32, 0);\n const uint32_t row0_src_u32_hi = vget_lane_u32(row0_u32, 1);\n const uint32_t row1_src_u32_lo = vget_lane_u32(row1_u32, 0);\n const uint32_t row1_src_u32_hi = vget_lane_u32(row1_u32, 1);\n const uint32_t row2_src_u32_lo = vget_lane_u32(row2_u32, 0);\n const uint32_t row2_src_u32_hi = vget_lane_u32(row2_u32, 1);\n const uint32_t row3_src_u32_lo = vget_lane_u32(row3_u32, 0);\n const uint32_t row3_src_u32_hi = vget_lane_u32(row3_u32, 1);\n\n const uint32_t row0_src_lo_s0 = row0_src_u32_lo & pack_mask;\n const uint32_t row0_src_lo_s1 = (row0_src_u32_lo >> 2) & pack_mask;\n const uint32_t row0_src_lo_s2 = (row0_src_u32_lo >> 4) & pack_mask;\n const uint32_t row0_src_lo_s3 = (row0_src_u32_lo >> 6) & pack_mask;\n const uint32_t row0_src_hi_s0 = row0_src_u32_hi & pack_mask;\n const uint32_t row0_src_hi_s1 = (row0_src_u32_hi >> 2) & pack_mask;\n const uint32_t row0_src_hi_s2 = (row0_src_u32_hi >> 4) & pack_mask;\n const uint32_t row0_src_hi_s3 = (row0_src_u32_hi >> 6) & pack_mask;\n\n const uint32_t row1_src_lo_s0 = row1_src_u32_lo & pack_mask;\n const uint32_t row1_src_lo_s1 = (row1_src_u32_lo >> 2) & pack_mask;\n const uint32_t row1_src_lo_s2 = (row1_src_u32_lo >> 4) & pack_mask;\n const uint32_t row1_src_lo_s3 = (row1_src_u32_lo >> 6) & pack_mask;\n const uint32_t row1_src_hi_s0 = row1_src_u32_hi & pack_mask;\n const uint32_t row1_src_hi_s1 = (row1_src_u32_hi >> 2) & pack_mask;\n const uint32_t row1_src_hi_s2 = (row1_src_u32_hi >> 4) & pack_mask;\n const uint32_t row1_src_hi_s3 = (row1_src_u32_hi >> 6) & pack_mask;\n\n const uint32_t row2_src_lo_s0 = row2_src_u32_lo & pack_mask;\n const uint32_t row2_src_lo_s1 = (row2_src_u32_lo >> 2) & pack_mask;\n const uint32_t row2_src_lo_s2 = (row2_src_u32_lo >> 4) & pack_mask;\n const uint32_t row2_src_lo_s3 = (row2_src_u32_lo >> 6) & pack_mask;\n const uint32_t row2_src_hi_s0 = row2_src_u32_hi & pack_mask;\n const uint32_t row2_src_hi_s1 = (row2_src_u32_hi >> 2) & pack_mask;\n const uint32_t row2_src_hi_s2 = (row2_src_u32_hi >> 4) & pack_mask;\n const uint32_t row2_src_hi_s3 = (row2_src_u32_hi >> 6) & pack_mask;\n\n const uint32_t row3_src_lo_s0 = row3_src_u32_lo & pack_mask;\n const uint32_t row3_src_lo_s1 = (row3_src_u32_lo >> 2) & pack_mask;\n const uint32_t row3_src_lo_s2 = (row3_src_u32_lo >> 4) & pack_mask;\n const uint32_t row3_src_lo_s3 = (row3_src_u32_lo >> 6) & pack_mask;\n const uint32_t row3_src_hi_s0 = row3_src_u32_hi & pack_mask;\n const uint32_t row3_src_hi_s1 = (row3_src_u32_hi >> 2) & pack_mask;\n const uint32_t row3_src_hi_s2 = (row3_src_u32_hi >> 4) & pack_mask;\n const uint32_t row3_src_hi_s3 = (row3_src_u32_hi >> 6) & pack_mask;\n\n const int8x8_t vrow0_s0 = vcreate_s8((((uint64_t)row0_src_hi_s0) << 32) | row0_src_lo_s0);\n const int8x8_t vrow0_s1 = vcreate_s8((((uint64_t)row0_src_hi_s1) << 32) | row0_src_lo_s1);\n const int8x8_t vrow0_s2 = vcreate_s8((((uint64_t)row0_src_hi_s2) << 32) | row0_src_lo_s2);\n const int8x8_t vrow0_s3 = vcreate_s8((((uint64_t)row0_src_hi_s3) << 32) | row0_src_lo_s3);\n\n const int8x8_t vrow1_s0 = vcreate_s8((((uint64_t)row1_src_hi_s0) << 32) | row1_src_lo_s0);\n const int8x8_t vrow1_s1 = vcreate_s8((((uint64_t)row1_src_hi_s1) << 32) | row1_src_lo_s1);\n const int8x8_t vrow1_s2 = vcreate_s8((((uint64_t)row1_src_hi_s2) << 32) | row1_src_lo_s2);\n const int8x8_t vrow1_s3 = vcreate_s8((((uint64_t)row1_src_hi_s3) << 32) | row1_src_lo_s3);\n\n const int8x8_t vrow2_s0 = vcreate_s8((((uint64_t)row2_src_hi_s0) << 32) | row2_src_lo_s0);\n const int8x8_t vrow2_s1 = vcreate_s8((((uint64_t)row2_src_hi_s1) << 32) | row2_src_lo_s1);\n const int8x8_t vrow2_s2 = vcreate_s8((((uint64_t)row2_src_hi_s2) << 32) | row2_src_lo_s2);\n const int8x8_t vrow2_s3 = vcreate_s8((((uint64_t)row2_src_hi_s3) << 32) | row2_src_lo_s3);\n\n const int8x8_t vrow3_s0 = vcreate_s8((((uint64_t)row3_src_hi_s0) << 32) | row3_src_lo_s0);\n const int8x8_t vrow3_s1 = vcreate_s8((((uint64_t)row3_src_hi_s1) << 32) | row3_src_lo_s1);\n const int8x8_t vrow3_s2 = vcreate_s8((((uint64_t)row3_src_hi_s2) << 32) | row3_src_lo_s2);\n const int8x8_t vrow3_s3 = vcreate_s8((((uint64_t)row3_src_hi_s3) << 32) | row3_src_lo_s3);\n\n const int8x8_t vrow0_s0_i8 = vtbl1_s8(vlut_s8, vrow0_s0);\n const int8x8_t vrow0_s1_i8 = vtbl1_s8(vlut_s8, vrow0_s1);\n const int8x8_t vrow0_s2_i8 = vtbl1_s8(vlut_s8, vrow0_s2);\n const int8x8_t vrow0_s3_i8 = vtbl1_s8(vlut_s8, vrow0_s3);\n\n const int8x8_t vrow1_s0_i8 = vtbl1_s8(vlut_s8, vrow1_s0);\n const int8x8_t vrow1_s1_i8 = vtbl1_s8(vlut_s8, vrow1_s1);\n const int8x8_t vrow1_s2_i8 = vtbl1_s8(vlut_s8, vrow1_s2);\n const int8x8_t vrow1_s3_i8 = vtbl1_s8(vlut_s8, vrow1_s3);\n\n const int8x8_t vrow2_s0_i8 = vtbl1_s8(vlut_s8, vrow2_s0);\n const int8x8_t vrow2_s1_i8 = vtbl1_s8(vlut_s8, vrow2_s1);\n const int8x8_t vrow2_s2_i8 = vtbl1_s8(vlut_s8, vrow2_s2);\n const int8x8_t vrow2_s3_i8 = vtbl1_s8(vlut_s8, vrow2_s3);\n\n const int8x8_t vrow3_s0_i8 = vtbl1_s8(vlut_s8, vrow3_s0);\n const int8x8_t vrow3_s1_i8 = vtbl1_s8(vlut_s8, vrow3_s1);\n const int8x8_t vrow3_s2_i8 = vtbl1_s8(vlut_s8, vrow3_s2);\n const int8x8_t vrow3_s3_i8 = vtbl1_s8(vlut_s8, vrow3_s3);\n\n // Calculate the row sum\n row_sum[0] +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vrow0_s0_i8, vrow0_s1_i8), vadd_s8(vrow0_s2_i8, vrow0_s3_i8)));\n row_sum[1] +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vrow1_s0_i8, vrow1_s1_i8), vadd_s8(vrow1_s2_i8, vrow1_s3_i8)));\n row_sum[2] +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vrow2_s0_i8, vrow2_s1_i8), vadd_s8(vrow2_s2_i8, vrow2_s3_i8)));\n row_sum[3] +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vrow3_s0_i8, vrow3_s1_i8), vadd_s8(vrow3_s2_i8, vrow3_s3_i8)));\n\n // Re-order and pack the 2b layout optimized for the matmul kernel.\n const uint32_t row0_dst_lo_s0 = (uint32_t)(((uint64_t)row0_src_lo_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row0_dst_lo_s1 = (uint32_t)(((uint64_t)row0_src_lo_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row0_dst_lo_s2 = (uint32_t)(((uint64_t)row0_src_lo_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row0_dst_lo_s3 = (uint32_t)(((uint64_t)row0_src_lo_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row0_packed_lo = row0_dst_lo_s0 | row0_dst_lo_s1 | row0_dst_lo_s2 | row0_dst_lo_s3;\n\n const uint32_t row0_dst_hi_s0 = (uint32_t)(((uint64_t)row0_src_hi_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row0_dst_hi_s1 = (uint32_t)(((uint64_t)row0_src_hi_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row0_dst_hi_s2 = (uint32_t)(((uint64_t)row0_src_hi_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row0_dst_hi_s3 = (uint32_t)(((uint64_t)row0_src_hi_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row0_packed_hi = row0_dst_hi_s0 | row0_dst_hi_s1 | row0_dst_hi_s2 | row0_dst_hi_s3;\n\n const uint32_t row1_dst_lo_s0 = (uint32_t)(((uint64_t)row1_src_lo_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row1_dst_lo_s1 = (uint32_t)(((uint64_t)row1_src_lo_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row1_dst_lo_s2 = (uint32_t)(((uint64_t)row1_src_lo_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row1_dst_lo_s3 = (uint32_t)(((uint64_t)row1_src_lo_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row1_packed_lo = row1_dst_lo_s0 | row1_dst_lo_s1 | row1_dst_lo_s2 | row1_dst_lo_s3;\n\n const uint32_t row1_dst_hi_s0 = (uint32_t)(((uint64_t)row1_src_hi_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row1_dst_hi_s1 = (uint32_t)(((uint64_t)row1_src_hi_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row1_dst_hi_s2 = (uint32_t)(((uint64_t)row1_src_hi_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row1_dst_hi_s3 = (uint32_t)(((uint64_t)row1_src_hi_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row1_packed_hi = row1_dst_hi_s0 | row1_dst_hi_s1 | row1_dst_hi_s2 | row1_dst_hi_s3;\n\n const uint32_t row2_dst_lo_s0 = (uint32_t)(((uint64_t)row2_src_lo_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row2_dst_lo_s1 = (uint32_t)(((uint64_t)row2_src_lo_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row2_dst_lo_s2 = (uint32_t)(((uint64_t)row2_src_lo_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row2_dst_lo_s3 = (uint32_t)(((uint64_t)row2_src_lo_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row2_packed_lo = row2_dst_lo_s0 | row2_dst_lo_s1 | row2_dst_lo_s2 | row2_dst_lo_s3;\n\n const uint32_t row2_dst_hi_s0 = (uint32_t)(((uint64_t)row2_src_hi_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row2_dst_hi_s1 = (uint32_t)(((uint64_t)row2_src_hi_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row2_dst_hi_s2 = (uint32_t)(((uint64_t)row2_src_hi_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row2_dst_hi_s3 = (uint32_t)(((uint64_t)row2_src_hi_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row2_packed_hi = row2_dst_hi_s0 | row2_dst_hi_s1 | row2_dst_hi_s2 | row2_dst_hi_s3;\n\n const uint32_t row3_dst_lo_s0 = (uint32_t)(((uint64_t)row3_src_lo_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row3_dst_lo_s1 = (uint32_t)(((uint64_t)row3_src_lo_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row3_dst_lo_s2 = (uint32_t)(((uint64_t)row3_src_lo_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row3_dst_lo_s3 = (uint32_t)(((uint64_t)row3_src_lo_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row3_packed_lo = row3_dst_lo_s0 | row3_dst_lo_s1 | row3_dst_lo_s2 | row3_dst_lo_s3;\n\n const uint32_t row3_dst_hi_s0 = (uint32_t)(((uint64_t)row3_src_hi_s0 * pack_byte_mul) >> 24) & 0xFFU;\n const uint32_t row3_dst_hi_s1 = (uint32_t)(((uint64_t)row3_src_hi_s1 * pack_byte_mul) >> 16) & 0xFF00U;\n const uint32_t row3_dst_hi_s2 = (uint32_t)(((uint64_t)row3_src_hi_s2 * pack_byte_mul) >> 8) & 0xFF0000U;\n const uint32_t row3_dst_hi_s3 = (uint32_t)(((uint64_t)row3_src_hi_s3 * pack_byte_mul)) & 0xFF000000U;\n const uint32_t row3_packed_hi = row3_dst_hi_s0 | row3_dst_hi_s1 | row3_dst_hi_s2 | row3_dst_hi_s3;\n\n const uint8x16_t out_lo = vcombine_u8(\n vcreate_u8((((uint64_t)row1_packed_lo) << 32) | row0_packed_lo),\n vcreate_u8((((uint64_t)row3_packed_lo) << 32) | row2_packed_lo));\n const uint8x16_t out_hi = vcombine_u8(\n vcreate_u8((((uint64_t)row1_packed_hi) << 32) | row0_packed_hi),\n vcreate_u8((((uint64_t)row3_packed_hi) << 32) | row2_packed_hi));\n\n // Store the packed values\n vst1q_u8((uint8_t*)dst_row, out_lo);\n vst1q_u8((uint8_t*)dst_row + dst_nr_block_size, out_hi);\n\n dst_row += 2 * dst_nr_block_size;\n }\n }\n // Tail Loop: Iterate over rows in the nr row block\n for (; nr_block_idx < nr; ++nr_block_idx) {\n const uint8_t* const src_row = rhs + ((row_idx + nr_block_idx) * rhs_stride);\n // Go to the first kr block for this row in the nr block\n uint8_t* dst_kr_block = (uint8_t*)dst_row + (nr_block_idx * 4);\n int32_t sum = 0;\n\n // Iterate over k src columns in blocks of kr columns\n for (size_t col_idx = 0; col_idx + 16 <= k_internal; col_idx += 16) {\n // We pad dst with 0s if the rounded k or n values have been exceeded\n if (row_idx + nr_block_idx >= n) {\n // Initialize with RHS ZP 2 in every 2-bit (Binary rep of this in 8-bit: 10101010)\n dst_kr_block[0] = 170;\n dst_kr_block[1] = 170;\n dst_kr_block[2] = 170;\n dst_kr_block[3] = 170;\n dst_kr_block += dst_nr_block_size;\n continue;\n }\n\n // Load the 4 2-bit values from source\n const uint8_t rhs_byte_0 = src_row[(col_idx + 0) / 4];\n const uint8_t rhs_byte_1 = src_row[(col_idx + 4) / 4];\n const uint8_t rhs_byte_2 = src_row[(col_idx + 8) / 4];\n const uint8_t rhs_byte_3 = src_row[(col_idx + 12) / 4];\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n // extract i8 values from the 4 2-bit values\n int32_t partial_sum_0 = 0;\n\n int8_t val_0[4] = {2, 2, 2, 2};\n int8_t val_1[4] = {2, 2, 2, 2};\n int8_t val_2[4] = {2, 2, 2, 2};\n int8_t val_3[4] = {2, 2, 2, 2};\n\n for (size_t i = 0; i < 4; ++i) {\n if (col_idx + i < k) {\n val_0[i] = ((int8_t)((rhs_byte_0 >> (i * 2)) & 0x03));\n val_1[i] = ((int8_t)((rhs_byte_1 >> (i * 2)) & 0x03));\n val_2[i] = ((int8_t)((rhs_byte_2 >> (i * 2)) & 0x03));\n val_3[i] = ((int8_t)((rhs_byte_3 >> (i * 2)) & 0x03));\n // Add the i2 values to the row sum\n partial_sum_0 += (lut[val_0[i]] + lut[val_1[i]] + lut[val_2[i]] + lut[val_3[i]]);\n }\n }\n\n sum += partial_sum_0;\n\n // Pack and write to dst\n dst_kr_block[0] =\n (val_0[0] & 0x3) | ((val_1[0] << 2) & 0x0C) | ((val_2[0] << 4) & 0x30) | ((val_3[0] << 6) & 0xC0);\n dst_kr_block[1] =\n (val_0[1] & 0x3) | ((val_1[1] << 2) & 0x0C) | ((val_2[1] << 4) & 0x30) | ((val_3[1] << 6) & 0xC0);\n dst_kr_block[2] =\n (val_0[2] & 0x3) | ((val_1[2] << 2) & 0x0C) | ((val_2[2] << 4) & 0x30) | ((val_3[2] << 6) & 0xC0);\n dst_kr_block[3] =\n (val_0[3] & 0x3) | ((val_1[3] << 2) & 0x0C) | ((val_2[3] << 4) & 0x30) | ((val_3[3] << 6) & 0xC0);\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n\n // Go to the next kr block for this row in the nr rows\n dst_kr_block += dst_nr_block_size;\n }\n row_sum[nr_block_idx] = sum;\n }\n // Save sum\n memcpy(sums, row_sum, nr * sizeof(int32_t));\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod against gemm_qsu2cx_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n // M == 1 runs the dedicated GEMV ukernel, as a KleidiAI user would pick it. Both variants\n // share one packed-RHS layout (same nr/kr/sr), so a single cached weight pack serves both.\n const bool gemv = (M == 1);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod();\n if (kai_get_nr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod() != nr || kai_get_kr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod() != kr ||\n kai_get_sr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod() != sr) return -2;\n const size_t mr = gemv ? kai_get_mr_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod() : kai_get_mr_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = gemv ? (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr)) : (kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr));\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n if (gemv) {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n } else {\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q2_snap = nullptr;\n static size_t B_q2_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q2_snap, B_q2_snap_size, B_q2, (size_t)N*K/4)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_qs4cxs1s0_param params;\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 2;\n kai_run_rhs_pack_nxk_qsu2cxp4x4bf32sf32_qsu2cx_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q2, bias, B_scales, rhs_packed, 0, ¶ms, nullptr);\n }\n\n if (gemv) {\n kai_run_matmul_clamp_f32_qai8dxp1x4_qsu2cxp4x4bf32sf32_1x4_neon_dotprod((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity(), nullptr);\n } else {\n kai_run_matmul_clamp_f32_qai8dxp4x4_qsu2cxp4x4bf32sf32_8x4_neon_dotprod((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity(), nullptr);\n }\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..3ca0902a542badfc8855696196a1784253dba35b --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_qsu2cx_sme2_n256_k512.json @@ -0,0 +1,68 @@ +{ + "name": "baseline-kleidiai-arm_gemm_qsu2cx_sme2_n256_k512", + "definition": "gemm_qsu2cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_qsu2cx_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa with its own LHS/RHS packers; binding.cpp bakes N/K and caches the weight pack.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_quant_pack_qai8dxp_f32 to dynamically quantize and pack the LHS matrix\n/// -# kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon to pack the RHS matrix\n\n/// --------------------------------------------------\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @return the m step value\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the n step value.\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @return the n step\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the mr value, which must be used to pack the LHS matrix with\n/// the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel\n///\n/// @return the mr value\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the nr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon micro-kernel\n///\n/// @return the nr value\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the kr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon micro-kernel\n///\n/// @return the kr value\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the sr value, which must be used to pack the RHS matrix with\n/// the @ref kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon micro-kernel\n///\n/// @return the sr value\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qai8dxp) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 2-bit quantized symmetric per-channel (qsu2cxp) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K).\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes for the DST matrix\n///\n/// @param[in] m_idx Row index in the DST matrix.\n/// @param[in] n_idx Column index in the DST matrix.\n/// @param[in] dst_stride The number of bytes in in each row of the DST matrix\n///\n/// @return the destination(DST) offset in bytes\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes for the destination (DST) matrix.\n///\n/// @param[in] m Number of rows in the destination (DST) matrix.\n/// @param[in] n Number of columns in the destination (DST) matrix.\n///\n/// @return the destination (DST) matrix size in bytes\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication (matmul) micro-kernel followed by a clamp (min-max) operation.\n///\n/// LHS matrix: Signed 8-bit quantized asymmetric per-row (qai8dxp) and packed\n/// RHS matrix: Signed 2-bit quantized symmetric per-channel (qsu2cxp) and packed.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] n The number of output columns written.\n/// @param[in] k The number of channels. The common dimension between the LHS and RHS matrix. It must be a\n/// a multiple of 32.\n/// @param[in] lhs_packed The LHS packed matrix.\n/// When the activation are dynamically quantized, you can obtain this matrix\n/// by calling the @ref kai_lhs_quant_pack_qai8dxp_f32 micro-kernel which performs\n/// both the dynamic quantization to 8-bit and activation packing in a single step.\n/// @param[in] rhs_packed The RHS packed matrix, which is obtained by calling @ref\n/// kai_run_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon\n/// @param[out] dst The DST matrix.\n/// @param[in] dst_stride_row Stride in bytes between two rows of the DST matrix.\n/// @param[in] dst_stride_col Stride in bytes between two columns of the DST matrix. It must be sizeof(float).\n/// @param[in] scalar_min Min value used to clamp the final result.\n/// @param[in] scalar_max Max value used to clamp the final result.\n/// @param[in] lut Look up table for mapping 2-bit to 8-bit values.\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* lhs_packed, const void* rhs_packed, float* dst, size_t dst_stride_row,\n size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif // __cplusplus\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 4\n\n/// Look-up table used for int2 -> int8 conversion\nstatic const int32_t lut_i8_i2[KAI_LUT_NENTRIES] = {-2, -1, 0, 1};\n\ntypedef struct {\n float* dst; // 0 (0x00)\n const void* lhs_packed; // 8 (0x08)\n const void* rhs_packed; // 16 (0x10)\n size_t dst_stride_row; // 24 (0x18)\n size_t lhs_stride; // 32 (0x20)\n size_t rhs_stride; // 40 (0x28)\n size_t m; // 48 (0x30)\n size_t n; // 56 (0x38)\n size_t k; // 64 (0x40)\n const int32_t* lut; // 72 (0x48)\n float scalar_max; // 80 (0x50)\n float scalar_min; // 84 (0x54)\n} KernelArgs;\n\nextern void kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(KernelArgs* args_ptr);\n\n// Compute args\nstatic const size_t kai_m_step = 1; // multiple of vector length\nstatic const size_t kai_n_step = 4; // multiple of vector length\n// Packing args\nstatic const size_t kai_mr = 1; // multiple of vector length\nstatic const size_t kai_nr = 4; // multiple of vector length\nstatic const size_t kai_kr = 4;\nstatic const size_t kai_sr = 1;\n// LHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_qvalue_lhs = sizeof(int8_t);\nstatic const size_t kai_num_bytes_multiplier_lhs = sizeof(float);\nstatic const size_t kai_num_bytes_offset_lhs = sizeof(int32_t);\n// RHS format args (num. bytes per value, multiplier, zero_point (if asymmetric))\nstatic const size_t kai_num_bytes_recip_qvalue_rhs = 4; // 4 2-bit quantized int values in a byte\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_bias_rhs = sizeof(float);\n// DST format args\nstatic const size_t kai_num_bytes_dst_value = sizeof(float);\n// Extra args\nstatic const size_t kai_k_multiple_of = 32;\n\nstatic size_t kai_k_roundedup(const size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nstatic size_t kai_get_lhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n return mr * (k_internal * kai_num_bytes_qvalue_lhs + kai_num_bytes_multiplier_lhs + kai_num_bytes_offset_lhs);\n}\n\nstatic size_t kai_get_rhs_packed_stride(const size_t k) {\n const size_t k_internal = kai_k_roundedup(k);\n KAI_ASSUME((k_internal % kai_k_multiple_of) == 0);\n\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n\n size_t rhs_packed_stride = nr *\n ((k_internal / kai_num_bytes_recip_qvalue_rhs) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs +\n kai_num_bytes_bias_rhs);\n\n return rhs_packed_stride;\n}\n\nsize_t kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_m_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_n_step * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_mr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_nr * kai_get_sme_vector_length_u32();\n}\n\nsize_t kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_kr;\n}\n\nsize_t kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(void) {\n return kai_sr;\n}\n\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t m_idx, size_t k) {\n KAI_ASSUME((m_idx % kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (m_idx / mr) * kai_get_lhs_packed_stride(k);\n}\n\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t n_idx, size_t k) {\n KAI_ASSUME((n_idx % kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n\n return (n_idx / nr) * kai_get_rhs_packed_stride(k);\n}\n\nsize_t kai_get_dst_offset_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m_idx, size_t n_idx, size_t dst_stride) {\n KAI_ASSUME((m_idx % kai_get_m_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n KAI_ASSUME((n_idx % kai_get_n_step_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa()) == 0);\n\n return ((n_idx * kai_num_bytes_dst_value) + (m_idx * dst_stride));\n}\n\nsize_t kai_get_dst_size_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(size_t m, size_t n) {\n return m * n * kai_num_bytes_dst_value;\n}\n\nvoid kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(\n size_t m, size_t n, size_t k, const void* restrict lhs_packed, const void* restrict rhs_packed,\n float* restrict dst, // NOLINT(readability-non-const-parameter)\n size_t dst_stride_row, size_t dst_stride_col, float scalar_min, float scalar_max, const int32_t* lut) {\n KAI_ASSUME(dst_stride_col == sizeof(float));\n KAI_ASSUME(m > 0);\n KAI_ASSUME(n > 0);\n KAI_ASSUME(k > 0);\n KAI_ASSUME(k % kai_k_multiple_of == 0);\n\n KernelArgs args;\n args.dst = dst;\n args.lhs_packed = lhs_packed;\n args.rhs_packed = rhs_packed;\n args.dst_stride_row = dst_stride_row;\n args.m = m;\n args.n = n;\n args.k = kai_k_roundedup(k);\n args.lhs_stride = kai_get_lhs_packed_stride(k);\n args.rhs_stride = kai_get_rhs_packed_stride(k);\n args.scalar_max = scalar_max;\n args.scalar_min = scalar_min;\n args.lut = lut != NULL ? lut : lut_i8_i2;\n\n kai_commit_za();\n\n kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa(&args);\n}\n\n#endif // Architectural feature check\n" + }, + { + "path": "kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n KAI_ASM_CODE(matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa)\n KAI_ASM_ALIGN\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa)\n stp x19, x20, [sp, -112]!\n stp x21, x22, [sp, 16]\n stp x23, x24, [sp, 32]\n stp d8, d9, [sp, 48]\n stp d10, d11, [sp, 64]\n stp d12, d13, [sp, 80]\n stp d14, d15, [sp, 96]\n KAI_ASM_INST(0xd503477f) // smstart\n ldr x19, [x0, #0x0] // dst\n ldr x20, [x0, #0x8] // lhs\n ldr x7, [x0, #0x48] // lut\n KAI_ASM_INST(0xe11f80e0) // ldr zt0, [x7]\n cntw x7 // mr\n ldr x5, [x0, 0x40] // k\n mul x5, x5, x7\n cntw x6, ALL, MUL #4 // nr\n ptrue p2.b\n KAI_ASM_INST(0x8555c81e) // ld1rw { z30.s }, p2/Z, [x0, 0x54] // min\n KAI_ASM_INST(0x8554c81f) // ld1rw { z31.s }, p2/Z, [x0, 0x50] // max\n ldr x23, [x0, 0x18] // dst_stride_row\n ldr x12, [x0, 0x30] // m\n KAI_ASM_INST(0x25ac17e0) // whilelt p0.s, xzr, x12\n b.eq M_Loop_End // b.none M_Loop_End\nKAI_ASM_LABEL(M_Loop_Start) // M Loop\n ldr x8, [x0, 0x10] // rhs\n mov x9, x19\n ldr x13, [x0, 0x38] // n\n cmp x7, x12\n csel x21, x7, x12, lt\n lsl x21, x21, #2\n whilelt p3.b, xzr, x13\nKAI_ASM_LABEL(N_Loop) // N Loop\n mov x10, x20\n mov x11, x8\n mov x22, x9\n KAI_ASM_INST(0x25ad67f1) // whilelt pn9.s, xzr, x13, vlx4\n KAI_ASM_INST(0xc00800ff) // zero {za}\n add x14, x10,x5\nKAI_ASM_LABEL(K_Loop) // K Loop\n KAI_ASM_INST(0xa540a144) // ld1w { z4.s }, p0/z, [x10]\n addvl x10, x10, #1\n ld1b { z0.b }, p3/z, [x11]\n addvl x11, x11, #1\n KAI_ASM_INST(0xc08c8008) // luti2 { z8.b - z11.b }, zt0, z0[0]\n KAI_ASM_INST(0xa0884880) // smopa za0.s, p2/m, p2/m, z4.b, z8.b\n KAI_ASM_INST(0xa0894881) // smopa za1.s, p2/m, p2/m, z4.b, z9.b\n KAI_ASM_INST(0xa08a4882) // smopa za2.s, p2/m, p2/m, z4.b, z10.b\n KAI_ASM_INST(0xa08b4883) // smopa za3.s, p2/m, p2/m, z4.b, z11.b\n cmp x10, x14\n b.lt K_Loop\n // Load RHS row sum, scale factors & bias\n KAI_ASM_INST(0xa040c560) // ld1w { z0.s - z3.s }, pn9/z, [x11]\n KAI_ASM_INST(0xa041c564) // ld1w { z4.s - z7.s }, pn9/z, [x11, #4, mul vl]\n KAI_ASM_INST(0xa042c568) // ld1w { z8.s - z11.s }, pn9/z, [x11, #8, mul vl]\n KAI_ASM_INST(0x042b518b) // addvl x11, x11, #12\n mov x14, #0\n addvl x15, x10, #1\nKAI_ASM_LABEL(ZA_Loop) // Store Loop\n // Load LHS zero-points & scale factors\n KAI_ASM_INST(0x8540c950) // ld1rw { z16.s }, p2/z, [x10]\n KAI_ASM_INST(0x8540c9f1) // ld1rw { z17.s }, p2/z, [x15]\n // Load inner accumulated value\n KAI_ASM_INST(0xc006440c) // mova { z12.b - z15.b }, za0h.b[w14,3]\n add x10, x10, #4\n add x15, x15, #4\n // LHS scaling factor * RHS scaling factor\n fmul z20.s, z17.s, z4.s\n fmul z21.s, z17.s, z5.s\n fmul z22.s, z17.s, z6.s\n fmul z23.s, z17.s, z7.s\n // Zero-points x Row-sum + iacc\n mla\t z12.s, p2/m, z16.s, z0.s\n mla\t z13.s, p2/m, z16.s, z1.s\n mla\t z14.s, p2/m, z16.s, z2.s\n mla\t z15.s, p2/m, z16.s, z3.s\n KAI_ASM_INST(0xc132e18c) // scvtf { z12.s - z15.s }, { z12.s - z15.s }\n // Apply combined scale factors\n fmul z24.s, z12.s, z20.s\n fmul z25.s, z13.s, z21.s\n fmul z26.s, z14.s, z22.s\n fmul z27.s, z15.s, z23.s\n // Add the bias\n fadd z24.s, p2/m, z24.s, z8.s\n fadd z25.s, p2/m, z25.s, z9.s\n fadd z26.s, p2/m, z26.s, z10.s\n fadd z27.s, p2/m, z27.s, z11.s\n // Clamp and store\n KAI_ASM_INST(0xc1bfcbd8) // fclamp { z24.s - z27.s }, z30.s, z31.s\n KAI_ASM_INST(0xa060c6d8) // st1w { z24.s - z27.s }, pn9, [x22]\n add x22, x22, x23\n add x14, x14, #4\n cmp x14, x21\n b.lt ZA_Loop\n ldr x24, [x0, 0x28] // rhs_stride\n add x8, x8,x24\n KAI_ASM_INST(0x04295089) // addvl x9, x9, #4\n sub x13, x13, x6\n whilelt p3.b, xzr, x13\n b.mi N_Loop\n ldr x24, [x0, 0x20] // lhs_stride\n add x20, x20, x24\n ldr x24, [x0, 0x18] // dst_stride_row\n mul x24, x7, x24\n add x19, x19,x24\n sub x12, x12, x7\n whilelt p0.s, xzr, x12\n b.mi M_Loop_Start\nKAI_ASM_LABEL(M_Loop_End)\n KAI_ASM_INST(0xd503467f) // smstop\n ldp d14, d15, [sp, 96]\n ldp d12, d13, [sp, 80]\n ldp d10, d11, [sp, 64]\n ldp d8, d9, [sp, 48]\n ldp x23, x24, [sp, 32]\n ldp x21, x22, [sp, 16]\n ldp x19, x20, [sp], 112\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Gets the m step value.\n/// The micro-kernel can process any M values. However, the starting M index to\n/// be processed must be a multiple of m step.\n///\n/// @param[in] mr The number of M rows to interleave on the same output row.\n///\n/// @return the m step value\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr);\n\n/// Gets the offset in bytes for the LHS matrix (not packed)\n///\n/// This function should be called before passing the pointer to the LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] lhs_stride The number of bytes in in each row of the LHS matrix (not packed)\n///\n/// @return the offset in bytes to the LHS matrix\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride);\n\n/// Gets the offset in bytes for the packed LHS matrix,\n/// which contains the packed 8-bit quantized asymmetric per-row (qa8dx) values.\n///\n/// This function should be called before passing the pointer to the packed LHS matrix to the micro-kernel.\n///\n/// @param[in] m_idx Row index in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed LHS matrix\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Gets the size in bytes for the quantized and packed LHS matrix\n///\n/// @param[in] m Total number of rows in the LHS matrix (not packed).\n/// @param[in] k Total number of columns in the LHS matrix (not packed).\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed LHS matrix size in bytes\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to quantize and pack the LHS matrix.\n///\n/// @param[in] m The number of output rows written.\n/// @param[in] k The number of channels. The common dimension of LHS & RHS. It must be multiple of 8.\n/// @param[in] mr The number of M rows to interleave on the same output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// However, kr must be multiple of sr.\n/// @param[in] m_idx_start The starting M index.\n/// @param[in] lhs LHS of the vector-by-matrix.\n/// @param[in] lhs_stride Stride in bytes between two rows of LHS.\n/// @param[out] lhs_packed The quantized and packed LHS matrix.\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* lhs, size_t lhs_stride,\n void* lhs_packed);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai_lhs_quant_pack_qai8dxp_f32.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n\n#if defined(__aarch64__)\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\nstatic const size_t kai_num_bytes_per_multiplier = sizeof(float);\nstatic const size_t kai_num_bytes_per_offset = sizeof(int32_t);\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n size_t kai_k_multiple_of = 32;\n return kai_roundup(k, kai_k_multiple_of);\n}\n\ninline static size_t kai_lhs_packed_stride(size_t k, size_t mr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % 2) == 0);\n\n return mr * (k_internal * sizeof(int8_t) + kai_num_bytes_per_multiplier + kai_num_bytes_per_offset);\n}\n\nsize_t kai_get_m_step_lhs_quant_pack_qai8dxp_f32(size_t mr) {\n return mr;\n}\n\nsize_t kai_get_lhs_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t lhs_stride) {\n return m_idx * lhs_stride;\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_quant_pack_qai8dxp_f32(size_t m_idx, size_t k, size_t mr, size_t kr, size_t sr) {\n // It always points to the beginning of the row\n return (m_idx / mr) * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32(size_t m, size_t k, size_t mr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(m, mr) / mr;\n\n return num_rows * kai_lhs_packed_stride(k, mr, kr, sr);\n}\n\nvoid kai_run_lhs_quant_pack_qai8dxp_f32(\n size_t m, size_t k, size_t mr, size_t kr, size_t sr, size_t m_idx_start, const float* restrict lhs,\n size_t lhs_stride, void* restrict lhs_packed) {\n KAI_ASSERT((kr % sr) == 0);\n\n if (m == 0) {\n return;\n }\n\n const size_t num_rows = m;\n\n const float* src_ptr = lhs;\n\n const size_t dst_stride = kai_lhs_packed_stride(k, mr, kr, sr);\n const size_t k_internal = kai_k_roundedup(k);\n const int32_t k_block_len = (int32_t)(kr / sr);\n\n const int32_t num_blocks_k = (int32_t)(k / k_block_len);\n const int32_t num_blocks_k_internal = (int32_t)(k_internal / k_block_len);\n\n for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {\n float max0 = -FLT_MAX;\n float min0 = FLT_MAX;\n\n // Find min/max for each channel\n int32_t k_idx = 0;\n\n#if defined(__aarch64__)\n float32x4_t vmax0 = vdupq_n_f32(-FLT_MAX);\n float32x4_t vmin0 = vdupq_n_f32(FLT_MAX);\n\n for (; k_idx <= ((int32_t)k - 8); k_idx += 8) {\n const float32x4_t src0_0 = vld1q_f32(src_ptr + 0 + (size_t)k_idx);\n const float32x4_t src0_1 = vld1q_f32(src_ptr + 4 + (size_t)k_idx);\n\n // Calculate the max\n vmax0 = vmaxq_f32(src0_0, vmax0);\n vmax0 = vmaxq_f32(vmax0, src0_1);\n\n // Calculate the min\n vmin0 = vminq_f32(src0_0, vmin0);\n vmin0 = vminq_f32(vmin0, src0_1);\n }\n // Get the max/min\n max0 = vmaxvq_f32(vmax0);\n min0 = vminvq_f32(vmin0);\n#endif\n for (; k_idx < (int32_t)k; ++k_idx) {\n const float src0_0 = *(src_ptr + (size_t)k_idx);\n max0 = fmaxf(src0_0, max0);\n min0 = fminf(src0_0, min0);\n }\n\n // Maximum/minimum int8 values\n const float qmin = (float)INT8_MIN;\n const float qmax = (float)INT8_MAX;\n\n const float rmin0 = fminf(0.0F, min0);\n const float rmax0 = fmaxf(0.0F, max0);\n const float scale0 = rmin0 == rmax0 ? 1.F : (qmax - qmin) / (rmax0 - rmin0);\n\n // Reciprocal to quantize\n const float recip_scale0 = scale0 ? 1.0F / scale0 : 0.0F;\n\n const float descaled_min0 = rmin0 * scale0;\n const float descaled_max0 = rmax0 * scale0;\n\n const float zero_point_from_min_error0 = qmin + descaled_min0;\n const float zero_point_from_max_error0 = qmax + descaled_max0;\n\n float zero_point0 =\n zero_point_from_min_error0 + zero_point_from_max_error0 > 0 ? qmin - descaled_min0 : qmax - descaled_max0;\n\n zero_point0 = fmaxf(zero_point0, qmin);\n zero_point0 = fminf(zero_point0, qmax);\n\n // Round to nearest integer\n const int32_t nudged_zero_point0 = (int32_t)rintf(zero_point0);\n\n const size_t dst_x = ((row_idx + m_idx_start) % mr);\n\n uint8_t* dst_ptr = (uint8_t*)lhs_packed + (dst_x * k_block_len * sizeof(int8_t));\n\n // Quantize the channels\n int32_t block_idx = 0;\n\n#if defined(__aarch64__)\n if (k_block_len == 8) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n const float32x4_t src_1 = vld1q_f32(src_ptr + k_idx_start + 4);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n float32x4_t v1_f32 = vmulq_n_f32(src_1, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int32x4_t v1_s32 = vcvtaq_s32_f32(v1_f32);\n\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n int16x4_t v1_s16 = vqmovn_s32(v1_s32);\n int16x8_t v_s16 = vcombine_s16(v0_s16, v1_s16);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x8_t vnzp_s16 = vdupq_n_s16(nzp_s16);\n v_s16 = vaddq_s16(v_s16, vnzp_s16);\n v_s16 = vmaxq_s16(v_s16, vdupq_n_s16(INT8_MIN));\n v_s16 = vminq_s16(v_s16, vdupq_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(v_s16);\n vst1_s8((int8_t*)(dst_ptr), v0_s8);\n dst_ptr += 8 * sizeof(int8_t);\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n } else if (k_block_len == 4) {\n for (; block_idx < num_blocks_k; ++block_idx) {\n // Clamp at the last valid k-index\n const int32_t k_idx_start = block_idx * k_block_len;\n\n const float32x4_t src_0 = vld1q_f32(src_ptr + k_idx_start);\n\n // Scale the values\n float32x4_t v0_f32 = vmulq_n_f32(src_0, scale0);\n int32x4_t v0_s32 = vcvtaq_s32_f32(v0_f32);\n int16x4_t v0_s16 = vqmovn_s32(v0_s32);\n\n // Add zero points\n int16_t nzp_s16 = (int16_t)nudged_zero_point0;\n int16x4_t vnzp_s16 = vdup_n_s16(nzp_s16);\n int16x4_t v_s16 = vadd_s16(v0_s16, vnzp_s16);\n v_s16 = vmax_s16(v_s16, vdup_n_s16(INT8_MIN));\n v_s16 = vmin_s16(v_s16, vdup_n_s16(INT8_MAX));\n\n int8x8_t v0_s8 = vqmovn_s16(vcombine_s16(v_s16, vdup_n_s16(0)));\n\n *((int8_t*)(dst_ptr)) = vget_lane_s8(v0_s8, 0);\n *((int8_t*)(dst_ptr + 1)) = vget_lane_s8(v0_s8, 1);\n *((int8_t*)(dst_ptr + 2)) = vget_lane_s8(v0_s8, 2);\n *((int8_t*)(dst_ptr + 3)) = vget_lane_s8(v0_s8, 3);\n\n dst_ptr += mr * k_block_len * sizeof(int8_t);\n }\n } else\n#endif\n {\n for (; block_idx < num_blocks_k; ++block_idx) {\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n const int32_t k_idx_start = (block_idx * k_block_len) + k_block_idx;\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n }\n\n for (; block_idx < num_blocks_k_internal; ++block_idx) {\n // left over k\n for (int32_t k_block_idx = 0; k_block_idx < k_block_len; ++k_block_idx) {\n // Clamp at the last valid k-index\n const size_t k_idx_start = KAI_MIN((size_t)((block_idx * k_block_len) + k_block_idx), k - 1);\n\n const float src0_0 = *(src_ptr + k_idx_start);\n\n // Scale the values\n int32_t v0_s32 = (int32_t)(roundf(src0_0 * scale0));\n\n v0_s32 = v0_s32 + nudged_zero_point0;\n v0_s32 = KAI_MAX(v0_s32, INT8_MIN);\n v0_s32 = KAI_MIN(v0_s32, INT8_MAX);\n\n *((int8_t*)(dst_ptr)) = (int8_t)v0_s32;\n dst_ptr += sizeof(int8_t);\n }\n dst_ptr += (mr - 1) * k_block_len * sizeof(int8_t);\n }\n\n dst_ptr = (uint8_t*)lhs_packed + mr * (k_internal * sizeof(int8_t));\n\n dst_ptr += dst_x * kai_num_bytes_per_offset;\n\n // LHS offset at the beginning of the row\n *((int32_t*)(dst_ptr)) = -nudged_zero_point0;\n\n // Assuming the same sizeof() for kai_num_bytes_per_offset and kai_num_bytes_per_multiplier\n KAI_ASSERT(kai_num_bytes_per_offset == kai_num_bytes_per_multiplier);\n\n dst_ptr += mr * kai_num_bytes_per_offset;\n\n // Store the scale quantization params\n *((float*)(dst_ptr)) = recip_scale0;\n\n src_ptr += (lhs_stride / sizeof(float));\n\n // Move to the next row if we have interleaved all Mr rows\n if ((((row_idx + 1) + m_idx_start) % mr) == 0) {\n lhs_packed = (void*)((uint8_t*)lhs_packed + dst_stride);\n }\n }\n}\n" + }, + { + "path": "kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if !defined(__aarch64__) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64.\n#else // Architectural features check.\n\n#include \"kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon.h\"\n\n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#define KAI_LUT_NENTRIES 4\n\nstatic const size_t kai_num_bytes_sum_rhs = sizeof(int32_t);\nstatic const size_t kai_num_bytes_multiplier_rhs = sizeof(float);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\n/// Look-up table used for int2 -> int8 conversion\nstatic const int32_t lut_i8_i2[KAI_LUT_NENTRIES] = {-2, -1, 0, 1};\nstatic const size_t kai_k_multiple_of = 32;\n\ninline static size_t kai_k_roundedup(size_t k) {\n // Round up k to be a multiple of 32.\n return kai_roundup(k, kai_k_multiple_of);\n}\n\nsize_t kai_get_n_step_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t nr) {\n return nr;\n}\n\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t n_idx, size_t rhs_stride) {\n return n_idx * rhs_stride;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_UNUSED(kr);\n KAI_UNUSED(sr);\n\n const size_t k_internal = kai_k_roundedup(k);\n\n // multiple of 4 because 4 2-bit quantized int elements in a byte\n KAI_ASSERT((k_internal % 4) == 0);\n\n return nr * ((k_internal / 4) + kai_num_bytes_multiplier_rhs + kai_num_bytes_sum_rhs + kai_num_bytes_bias);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr) {\n KAI_ASSERT((n_idx % nr) == 0);\n\n return (n_idx / nr) * kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(k, nr, kr, sr);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr) {\n const size_t num_rows = kai_roundup(n, nr) / nr;\n\n return num_rows * kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(k, nr, kr, sr);\n}\n\nvoid kai_run_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon_params* params, const int32_t* lut_arg) {\n const size_t k_internal = kai_k_roundedup(k);\n\n KAI_ASSERT((k_internal % kr) == 0);\n KAI_ASSERT(num_groups == 1);\n KAI_ASSERT(extra_bytes == 0);\n KAI_ASSERT((kr % sr) == 0);\n KAI_ASSERT(rhs != NULL);\n KAI_ASSERT(scale != NULL);\n KAI_ASSERT(rhs_packed != NULL);\n KAI_ASSERT(params != NULL);\n KAI_ASSERT(params->lhs_zero_point == 1);\n KAI_ASSERT(params->rhs_zero_point == 2);\n KAI_ASSUME(k % kai_k_multiple_of == 0);\n KAI_ASSUME((kr / sr) == 4);\n\n // Note: The input matrix (rhs) is expected with:\n // \"k\" columns and \"n\" rows (NxK)\n\n const size_t rhs_stride = kai_roundup(k, 4) / 4;\n const size_t rhs_packed_stride = kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(k, nr, kr, sr);\n const int32_t* lut = lut_arg != NULL ? lut_arg : lut_i8_i2;\n const size_t num_bytes_processed = 8;\n\n // NOLINTBEGIN(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n const int8_t lut_s8[8] = {lut[0], lut[1], lut[2], lut[3], 0, 0, 0, 0};\n // NOLINTEND(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n\n const int8x8_t vlut_s8 = vld1_s8(lut_s8);\n const uint8x8_t mask_2b = vdup_n_u8(0x03);\n // Iterate over n src rows in blocks of nr rows\n for (size_t row_idx = 0; row_idx < n; row_idx += nr) {\n int8_t* dst_row = (int8_t*)rhs_packed + ((row_idx / nr) * rhs_packed_stride);\n\n int32_t* const sums = (int32_t*)(dst_row + (nr * (k_internal / 4)));\n float* const scaling_factors = (float*)((uint8_t*)sums + (nr * kai_num_bytes_sum_rhs));\n float* const biases = (float*)((uint8_t*)scaling_factors + (nr * kai_num_bytes_multiplier_rhs));\n\n // initialize sums to 0\n memset(sums, 0, nr * kai_num_bytes_sum_rhs);\n\n // Copy the scaling factors and bias\n size_t rows_left = n - row_idx;\n // Saving scales.\n if (rows_left >= nr) {\n memcpy(scaling_factors, &scale[row_idx], nr * kai_num_bytes_multiplier_rhs);\n } else {\n // Fill remaining values\n memcpy(scaling_factors, &scale[row_idx], rows_left * kai_num_bytes_multiplier_rhs);\n // Set leftover to 0\n memset(&scaling_factors[rows_left], 0, (nr - rows_left) * kai_num_bytes_multiplier_rhs);\n }\n if (bias == NULL) {\n // Set bias to 0\n memset(biases, 0, nr * kai_num_bytes_bias);\n } else {\n if (rows_left >= nr) {\n memcpy(biases, &bias[row_idx], nr * kai_num_bytes_bias);\n } else {\n // Fill remaining values\n memcpy(biases, &bias[row_idx], rows_left * kai_num_bytes_bias);\n // Set leftover to 0\n memset(&biases[rows_left], 0, (nr - rows_left) * kai_num_bytes_bias);\n }\n }\n // Iterate over rows in the nr row block\n for (size_t k_byte_idx = 0; k_byte_idx < rhs_stride; k_byte_idx += num_bytes_processed) {\n for (size_t nr_block_idx = 0; nr_block_idx < nr; nr_block_idx += num_bytes_processed) {\n // Clamp the indices to avoid out-of-bound reads\n const size_t n0_idx = KAI_MIN(row_idx + nr_block_idx, n - 1);\n const size_t n1_idx = KAI_MIN(n0_idx + 1, n - 1);\n const size_t n2_idx = KAI_MIN(n0_idx + 2, n - 1);\n const size_t n3_idx = KAI_MIN(n0_idx + 3, n - 1);\n const size_t n4_idx = KAI_MIN(n0_idx + 4, n - 1);\n const size_t n5_idx = KAI_MIN(n0_idx + 5, n - 1);\n const size_t n6_idx = KAI_MIN(n0_idx + 6, n - 1);\n const size_t n7_idx = KAI_MIN(n0_idx + 7, n - 1);\n\n // Initialize partial sum\n int32_t partial_sum0 = 0;\n int32_t partial_sum1 = 0;\n int32_t partial_sum2 = 0;\n int32_t partial_sum3 = 0;\n int32_t partial_sum4 = 0;\n int32_t partial_sum5 = 0;\n int32_t partial_sum6 = 0;\n int32_t partial_sum7 = 0;\n\n const uint8_t* src_base = rhs + k_byte_idx;\n const uint8x8_t vsrc0_0 = vld1_u8(src_base + n0_idx * rhs_stride);\n const uint8x8_t vsrc1_0 = vld1_u8(src_base + n1_idx * rhs_stride);\n const uint8x8_t vsrc2_0 = vld1_u8(src_base + n2_idx * rhs_stride);\n const uint8x8_t vsrc3_0 = vld1_u8(src_base + n3_idx * rhs_stride);\n const uint8x8_t vsrc4_0 = vld1_u8(src_base + n4_idx * rhs_stride);\n const uint8x8_t vsrc5_0 = vld1_u8(src_base + n5_idx * rhs_stride);\n const uint8x8_t vsrc6_0 = vld1_u8(src_base + n6_idx * rhs_stride);\n const uint8x8_t vsrc7_0 = vld1_u8(src_base + n7_idx * rhs_stride);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc0_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc0_0, mask_2b));\n const int8x8_t vsrc0_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc0_0, 2), mask_2b));\n const int8x8_t vsrc0_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc0_0, 4), mask_2b));\n const int8x8_t vsrc0_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc0_0, 6), mask_2b));\n\n const int8x8_t vsrc0_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc0_0_s0);\n const int8x8_t vsrc0_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc0_0_s1);\n const int8x8_t vsrc0_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc0_0_s2);\n const int8x8_t vsrc0_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc0_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc1_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc1_0, mask_2b));\n const int8x8_t vsrc1_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc1_0, 2), mask_2b));\n const int8x8_t vsrc1_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc1_0, 4), mask_2b));\n const int8x8_t vsrc1_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc1_0, 6), mask_2b));\n\n const int8x8_t vsrc1_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc1_0_s0);\n const int8x8_t vsrc1_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc1_0_s1);\n const int8x8_t vsrc1_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc1_0_s2);\n const int8x8_t vsrc1_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc1_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc2_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc2_0, mask_2b));\n const int8x8_t vsrc2_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc2_0, 2), mask_2b));\n const int8x8_t vsrc2_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc2_0, 4), mask_2b));\n const int8x8_t vsrc2_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc2_0, 6), mask_2b));\n\n const int8x8_t vsrc2_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc2_0_s0);\n const int8x8_t vsrc2_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc2_0_s1);\n const int8x8_t vsrc2_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc2_0_s2);\n const int8x8_t vsrc2_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc2_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc3_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc3_0, mask_2b));\n const int8x8_t vsrc3_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc3_0, 2), mask_2b));\n const int8x8_t vsrc3_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc3_0, 4), mask_2b));\n const int8x8_t vsrc3_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc3_0, 6), mask_2b));\n\n const int8x8_t vsrc3_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc3_0_s0);\n const int8x8_t vsrc3_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc3_0_s1);\n const int8x8_t vsrc3_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc3_0_s2);\n const int8x8_t vsrc3_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc3_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc4_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc4_0, mask_2b));\n const int8x8_t vsrc4_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc4_0, 2), mask_2b));\n const int8x8_t vsrc4_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc4_0, 4), mask_2b));\n const int8x8_t vsrc4_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc4_0, 6), mask_2b));\n\n const int8x8_t vsrc4_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc4_0_s0);\n const int8x8_t vsrc4_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc4_0_s1);\n const int8x8_t vsrc4_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc4_0_s2);\n const int8x8_t vsrc4_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc4_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc5_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc5_0, mask_2b));\n const int8x8_t vsrc5_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc5_0, 2), mask_2b));\n const int8x8_t vsrc5_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc5_0, 4), mask_2b));\n const int8x8_t vsrc5_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc5_0, 6), mask_2b));\n\n const int8x8_t vsrc5_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc5_0_s0);\n const int8x8_t vsrc5_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc5_0_s1);\n const int8x8_t vsrc5_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc5_0_s2);\n const int8x8_t vsrc5_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc5_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc6_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc6_0, mask_2b));\n const int8x8_t vsrc6_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc6_0, 2), mask_2b));\n const int8x8_t vsrc6_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc6_0, 4), mask_2b));\n const int8x8_t vsrc6_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc6_0, 6), mask_2b));\n\n const int8x8_t vsrc6_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc6_0_s0);\n const int8x8_t vsrc6_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc6_0_s1);\n const int8x8_t vsrc6_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc6_0_s2);\n const int8x8_t vsrc6_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc6_0_s3);\n\n // Extract 2-bit values from the byte.\n const int8x8_t vsrc7_0_s0 = vreinterpret_s8_u8(vand_u8(vsrc7_0, mask_2b));\n const int8x8_t vsrc7_0_s1 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc7_0, 2), mask_2b));\n const int8x8_t vsrc7_0_s2 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc7_0, 4), mask_2b));\n const int8x8_t vsrc7_0_s3 = vreinterpret_s8_u8(vand_u8(vshr_n_u8(vsrc7_0, 6), mask_2b));\n\n const int8x8_t vsrc7_0_s0_s8 = vtbl1_s8(vlut_s8, vsrc7_0_s0);\n const int8x8_t vsrc7_0_s1_s8 = vtbl1_s8(vlut_s8, vsrc7_0_s1);\n const int8x8_t vsrc7_0_s2_s8 = vtbl1_s8(vlut_s8, vsrc7_0_s2);\n const int8x8_t vsrc7_0_s3_s8 = vtbl1_s8(vlut_s8, vsrc7_0_s3);\n\n // Calculate the partial sum\n partial_sum0 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc0_0_s0_s8, vsrc0_0_s1_s8), vadd_s8(vsrc0_0_s2_s8, vsrc0_0_s3_s8)));\n partial_sum1 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc1_0_s0_s8, vsrc1_0_s1_s8), vadd_s8(vsrc1_0_s2_s8, vsrc1_0_s3_s8)));\n partial_sum2 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc2_0_s0_s8, vsrc2_0_s1_s8), vadd_s8(vsrc2_0_s2_s8, vsrc2_0_s3_s8)));\n partial_sum3 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc3_0_s0_s8, vsrc3_0_s1_s8), vadd_s8(vsrc3_0_s2_s8, vsrc3_0_s3_s8)));\n partial_sum4 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc4_0_s0_s8, vsrc4_0_s1_s8), vadd_s8(vsrc4_0_s2_s8, vsrc4_0_s3_s8)));\n partial_sum5 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc5_0_s0_s8, vsrc5_0_s1_s8), vadd_s8(vsrc5_0_s2_s8, vsrc5_0_s3_s8)));\n partial_sum6 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc6_0_s0_s8, vsrc6_0_s1_s8), vadd_s8(vsrc6_0_s2_s8, vsrc6_0_s3_s8)));\n partial_sum7 +=\n vaddlvq_s16(vaddl_s8(vadd_s8(vsrc7_0_s0_s8, vsrc7_0_s1_s8), vadd_s8(vsrc7_0_s2_s8, vsrc7_0_s3_s8)));\n\n // Update the sum\n sums[nr_block_idx + 0] += partial_sum0;\n sums[nr_block_idx + 1] += partial_sum1;\n sums[nr_block_idx + 2] += partial_sum2;\n sums[nr_block_idx + 3] += partial_sum3;\n sums[nr_block_idx + 4] += partial_sum4;\n sums[nr_block_idx + 5] += partial_sum5;\n sums[nr_block_idx + 6] += partial_sum6;\n sums[nr_block_idx + 7] += partial_sum7;\n\n // Rearrange to get the dst blocksn\n const uint16x4_t vdst_u16_0 = vreinterpret_u16_u8(vzip1_u8(vsrc0_0, vsrc1_0)); // 00 11 22 33\n const uint16x4_t vdst_u16_1 = vreinterpret_u16_u8(vzip2_u8(vsrc0_0, vsrc1_0)); // 44 55 66 77\n const uint16x4_t vdst_u16_2 = vreinterpret_u16_u8(vzip1_u8(vsrc2_0, vsrc3_0)); // 00 11 22 33\n const uint16x4_t vdst_u16_3 = vreinterpret_u16_u8(vzip2_u8(vsrc2_0, vsrc3_0)); // 44 55 66 77\n const uint16x4_t vdst_u16_4 = vreinterpret_u16_u8(vzip1_u8(vsrc4_0, vsrc5_0)); // 00 11 22 33\n const uint16x4_t vdst_u16_5 = vreinterpret_u16_u8(vzip2_u8(vsrc4_0, vsrc5_0)); // 44 55 66 77\n const uint16x4_t vdst_u16_6 = vreinterpret_u16_u8(vzip1_u8(vsrc6_0, vsrc7_0)); // 00 11 22 33\n const uint16x4_t vdst_u16_7 = vreinterpret_u16_u8(vzip2_u8(vsrc6_0, vsrc7_0)); // 44 55 66 77\n\n const uint32x2_t vdst_u32_0 = vreinterpret_u32_u16(vzip1_u16(vdst_u16_0, vdst_u16_2)); // 0000 1111\n const uint32x2_t vdst_u32_1 = vreinterpret_u32_u16(vzip1_u16(vdst_u16_4, vdst_u16_6)); // 0000 1111\n const uint32x2_t vdst_u32_2 = vreinterpret_u32_u16(vzip2_u16(vdst_u16_0, vdst_u16_2)); // 2222 3333\n const uint32x2_t vdst_u32_3 = vreinterpret_u32_u16(vzip2_u16(vdst_u16_4, vdst_u16_6)); // 2222 3333\n const uint32x2_t vdst_u32_4 = vreinterpret_u32_u16(vzip1_u16(vdst_u16_1, vdst_u16_3)); // 4444 5555\n const uint32x2_t vdst_u32_5 = vreinterpret_u32_u16(vzip1_u16(vdst_u16_5, vdst_u16_7)); // 4444 5555\n const uint32x2_t vdst_u32_6 = vreinterpret_u32_u16(vzip2_u16(vdst_u16_1, vdst_u16_3)); // 6666 7777\n const uint32x2_t vdst_u32_7 = vreinterpret_u32_u16(vzip2_u16(vdst_u16_5, vdst_u16_7)); // 6666 7777\n\n const uint32x2_t vdst_0 = vzip1_u32(vdst_u32_0, vdst_u32_1); // 00000000\n const uint32x2_t vdst_1 = vzip2_u32(vdst_u32_0, vdst_u32_1); // 11111111\n const uint32x2_t vdst_2 = vzip1_u32(vdst_u32_2, vdst_u32_3); // 22222222\n const uint32x2_t vdst_3 = vzip2_u32(vdst_u32_2, vdst_u32_3); // 33333333\n const uint32x2_t vdst_4 = vzip1_u32(vdst_u32_4, vdst_u32_5); // 44444444\n const uint32x2_t vdst_5 = vzip2_u32(vdst_u32_4, vdst_u32_5); // 55555555\n const uint32x2_t vdst_6 = vzip1_u32(vdst_u32_6, vdst_u32_7); // 66666666\n const uint32x2_t vdst_7 = vzip2_u32(vdst_u32_6, vdst_u32_7); // 77777777\n\n // Store the packed values\n vst1_u32((uint32_t*)dst_row, vdst_0);\n vst1_u32((uint32_t*)(dst_row + nr), vdst_1);\n vst1_u32((uint32_t*)(dst_row + nr * 2), vdst_2);\n vst1_u32((uint32_t*)(dst_row + nr * 3), vdst_3);\n vst1_u32((uint32_t*)(dst_row + nr * 4), vdst_4);\n vst1_u32((uint32_t*)(dst_row + nr * 5), vdst_5);\n vst1_u32((uint32_t*)(dst_row + nr * 6), vdst_6);\n vst1_u32((uint32_t*)(dst_row + nr * 7), vdst_7);\n\n dst_row += 8 * sizeof(uint8_t);\n }\n dst_row += 7 * nr * sizeof(uint8_t);\n }\n }\n}\n#endif // Architectural features check.\n" + }, + { + "path": "kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon_params\n#define kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon_params kai_rhs_pack_qs4cxs1s0_param\n#endif\n\n/// Get the n step value.\n///\n/// The micro-kernel can process any N values. However, the starting N index to\n/// be processed must be a multiple of n step.\n///\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n///\n/// @return the n step value\nsize_t kai_get_n_step_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t nr);\n\n/// Gets the offset in bytes for the RHS matrix (not packed)\n///\n/// @note The int2 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Four int2 values are stored in one byte as s3s2s1s0. The lower order part of the byte (low) holds\n/// the first 2-bit (K-index + 0), then the higher order of the byte holds the second 2-bit (K-index + 1)\n/// and so on..\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] rhs_stride The number of bytes in in each row of the RHS matrix (not packed)\n///\n/// @return the offset in bytes to the RHS matrix (not packed)\nsize_t kai_get_rhs_offset_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t n_idx, size_t rhs_stride);\n\n/// Get the row stride in bytes to the packed RHS matrix\n///\n/// @param[in] k In the RHS matrix (not packed), K is the number of columns.\n/// @param[in] nr The number of columns written by the matmul micro-kernel.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the stride in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_stride_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Gets the offset in bytes for the packed RHS matrix,\n/// which contains the packed 2-bit quantized symmetric per-channel (qsi2cx) values.\n///\n/// @param[in] n_idx Row index in the RHS matrix (not packed). It must be a multiple of n_step.\n/// @param[in] k The common dimension between the LHS and RHS matrix (K)\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the offset in bytes to the packed RHS matrix\nsize_t kai_get_rhs_packed_offset_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t n_idx, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// @brief Gets the size in bytes for the packed RHS matrix\n///\n/// @param[in] n The number of rows in the RHS matrix (not packed)\n/// @param[in] k The number of columns in the RHS matrix (not packed).\n/// @param[in] nr The number of columns written by the matmul micro-kernel\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n///\n/// @return the packed RHS matrix size in bytes\nsize_t kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t n, size_t k, size_t nr, size_t kr, size_t sr);\n\n/// Run the micro-kernel to pack the RHS matrix.\n///\n/// @note The int2 values are stored in a N x K matrix, where N is number of rows and K is the number of columns.\n/// Four int2 values are stored in one byte as s3s2s1s0. The lower order part of the byte (low) holds\n/// the first 2-bit (K-index + 0), then the higher order of the byte holds the second 2-bit (K-index + 1)\n/// and so on..\n///\n/// @param[in] num_groups The number of groups. It must be 1.\n/// @param[in] n The number of columns of the output matrix (N).\n/// @param[in] k The common dimension between the LHS and RHS matrix (K). It must be a a multiple of 32.\n/// @param[in] nr The number of N columns to interleave on the same output output row.\n/// @param[in] kr The number of columns loaded in the single inner most loop of the matmul micro-kernel.\n/// @param[in] sr The number of kr splits. It can be 1 (no splits) up to kr.\n/// @param[in] rhs The RHS matrix containing the 2-bit values.\n/// Size in bytes is expected to be greater than or equal to n * k * (sizeof(uint8_t) / 4).\n/// @param[in] bias The biases. The bias is set to 0.f if this argument is NULL.\n/// @param[in] scale The scale for each output channel.\n/// @param[out] rhs_packed The packed RHS matrix.\n/// @param[in] extra_bytes Extra bytes to append to the end of each row of the packed RHS matrix.\n/// @param[in] params Parameters for the micro-kernel.\n/// @param[in] lut_arg Look up table for mapping 2-bit to 8-bit values.\nvoid kai_run_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(\n size_t num_groups, size_t n, size_t k, size_t nr, size_t kr, size_t sr, const uint8_t* rhs, const float* bias,\n const float* scale, void* rhs_packed, size_t extra_bytes,\n const struct kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon_params* params, const int32_t* lut_arg);\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa against gemm_qsu2cx_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n#include \n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa.h\"\n#include \"kai_lhs_quant_pack_qai8dxp_f32.h\"\n#include \"kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n// Widen n raw fp16 patterns to fp32 (exact).\nvoid widen_f16(const uint16_t* src, float* dst, size_t n) {\n size_t i = 0;\n for (; i + 4 <= n; i += 4) vst1q_f32(dst + i, vcvt_f32_f16(vreinterpret_f16_u16(vld1_u16(src + i))));\n for (; i < n; ++i) dst[i] = vgetq_lane_f32(vcvt_f32_f16(vreinterpret_f16_u16(vdup_n_u16(src[i]))), 0);\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n // The SME2 mopa kernel takes any M in a single call, so there is no GEMV dispatch here.\n const size_t mr = kai_get_mr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t nr = kai_get_nr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t kr = kai_get_kr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n const size_t sr = kai_get_sr_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa();\n (void)sr;\n\n // LHS: the activation is (re)quantized/packed on EVERY call into a grow-only scratch buffer,\n // so the baseline is timed doing the same per-input work a real inference does.\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n {\n const size_t lhs_packed_size = kai_get_lhs_packed_size_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr);\n if (lhs_packed_size > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(lhs_packed_size);\n lhs_cap = lhs_packed_size;\n if (lhs_packed == nullptr) return -1;\n }\n kai_run_lhs_quant_pack_qai8dxp_f32((size_t)M, (size_t)K, mr, kr, sr, 0, A, (size_t)K * sizeof(float), lhs_packed);\n }\n\n // RHS: weight-derived pack, cached while every weight-side input is unchanged.\n static uint8_t* B_q2_snap = nullptr;\n static size_t B_q2_snap_size = 0;\n static uint8_t* B_scales_snap = nullptr;\n static size_t B_scales_snap_size = 0;\n static uint8_t* bias_snap = nullptr;\n static size_t bias_snap_size = 0;\n static void* rhs_packed = nullptr;\n const bool stale = false\n | refresh_cache(B_q2_snap, B_q2_snap_size, B_q2, (size_t)N*K/4)\n | refresh_cache(B_scales_snap, B_scales_snap_size, B_scales, sizeof(float)*N)\n | refresh_cache(bias_snap, bias_snap_size, bias, sizeof(float)*N);\n if (stale) {\n std::free(rhs_packed);\n const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon((size_t)N, (size_t)K, nr, kr, sr);\n rhs_packed = std::malloc(rhs_packed_size);\n if (rhs_packed == nullptr) return -1;\n struct kai_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon_params params {};\n params.lhs_zero_point = 1;\n params.rhs_zero_point = 2;\n kai_run_rhs_pack_nxk_qsu2cxp4vlx4_qsu2cx_neon(1, (size_t)N, (size_t)K, nr, kr, sr, B_q2, bias, B_scales, rhs_packed, 0, ¶ms, nullptr);\n }\n\n kai_run_matmul_clamp_f32_qai8dxp1vlx4_qsu2cxp4vlx4_1vlx4vl_sme2_mopa((size_t)M, (size_t)N, (size_t)K, lhs_packed, rhs_packed, output, (size_t)N * sizeof(float), sizeof(float), -std::numeric_limits::infinity(), std::numeric_limits::infinity(), nullptr);\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_u8_f32_sme2_n256_k512.json b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_u8_f32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..18cf4b6d1d094bb458a82ba00a53c54a4ec2e62d --- /dev/null +++ b/solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_u8_f32_sme2_n256_k512.json @@ -0,0 +1,88 @@ +{ + "name": "baseline-kleidiai-arm_gemm_u8_f32_sme2_n256_k512", + "definition": "gemm_u8_f32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "baseline-kleidiai-arm", + "description": "baseline-kleidiai-arm baseline for gemm_u8_f32_sme2_n256_k512: KleidiAI kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa (new-style uker API) with its x8p4vsx4 LHS/RHS packers; global scale and per-column bias applied by the kernel.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "binding.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [ + "sme2" + ], + "compile_flags": [ + "-O2", + "-march=armv8.2-a+sve+sve2", + "-fno-tree-vectorize", + "-fno-tree-slp-vectorize" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "kai/kai_common.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#pragma once\n\n#if defined(__ARM_NEON)\n#include \n#endif // defined(__ARM_NEON)\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// NOLINTBEGIN(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n//\n// * cppcoreguidelines-avoid-do-while: do-while is necessary for macros.\n// * cppcoreguidelines-pro-type-vararg: use of variadic arguments in fprintf is expected.\n// * cert-err33-c: checking the output of fflush and fprintf is not necessary for error reporting.\n\n#ifndef KLEIDIAI_ERROR_TRAP\n#define KLEIDIAI_ERROR_TRAP 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KLEIDIAI_HAS_BUILTIN_UNREACHABLE 0\n#endif\n\n#ifndef KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KLEIDIAI_HAS_BUILTIN_ASSUME0 0\n#endif\n\n#if KLEIDIAI_ERROR_TRAP\n#define KAI_ABORT() __builtin_trap()\n#else\n#define KAI_ABORT() abort()\n#endif\n\n#if KLEIDIAI_HAS_BUILTIN_UNREACHABLE\n#define KAI_UNREACHABLE() __builtin_unreachable()\n#elif KLEIDIAI_HAS_BUILTIN_ASSUME0\n#define KAI_UNREACHABLE() __assume(0);\n#else\n#define KAI_UNREACHABLE()\n#endif\n\n#ifdef NDEBUG\n#define KAI_ERROR(msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) \\\n do { \\\n KAI_UNUSED(msg); \\\n if (!(cond)) { \\\n KAI_UNREACHABLE(); \\\n } \\\n } while (0)\n#else\n#define KAI_ERROR(msg) \\\n do { \\\n fflush(stdout); \\\n fprintf(stderr, \"%s:%d %s\", __FILE__, __LINE__, msg); \\\n KAI_ABORT(); \\\n } while (0)\n\n#define KAI_ASSERT_MSG(cond, msg) KAI_ASSERT_ALWAYS_MSG(cond, msg)\n#endif // NDEBUG\n\n#define KAI_ASSERT_ALWAYS_MSG(cond, msg) \\\n do { \\\n if (!(cond)) { \\\n KAI_ERROR(msg); \\\n } \\\n } while (0)\n\n// NOLINTEND(cppcoreguidelines-avoid-do-while,cppcoreguidelines-pro-type-vararg,cert-err33-c)\n\n/// KAI_ASSERT* is used for logic sanity checking in the program\n/// flow. Checks are optimized away in release builds same as\n/// `assert`\n#define KAI_ASSERT(cond) KAI_ASSERT_MSG(cond, #cond)\n#define KAI_ASSERT_IF_MSG(precond, cond, msg) KAI_ASSERT_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_IF(precond, cond) KAI_ASSERT_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// `KAI_ASSERT_ALWAYS*` is same as `KAI_ASSERT*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSERT_ALWAYS(cond) KAI_ASSERT_ALWAYS_MSG(cond, #cond)\n#define KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, msg) KAI_ASSERT_ALWAYS_MSG(!(precond) || (cond), msg)\n#define KAI_ASSERT_ALWAYS_IF(precond, cond) KAI_ASSERT_ALWAYS_IF_MSG(precond, cond, #precond \" |-> \" #cond)\n\n/// KAI_ASSUME* is used for function pre-condition checking, similar to `[[assume]]` in C++23.\n/// So KAI_ASSUME should be used directly on the function parameters, rather than inside\n/// function logic.\n#define KAI_ASSUME_MSG KAI_ASSERT_MSG\n#define KAI_ASSUME KAI_ASSERT\n#define KAI_ASSUME_IF_MSG KAI_ASSERT_IF_MSG\n#define KAI_ASSUME_IF KAI_ASSERT_IF\n\n/// `KAI_ASSUME_ALWAYS*` is same as `KAI_ASSUME*`, but doesn't get removed by `NDEBUG`\n#define KAI_ASSUME_ALWAYS_MSG KAI_ASSERT_ALWAYS_MSG\n#define KAI_ASSUME_ALWAYS KAI_ASSERT_ALWAYS\n#define KAI_ASSUME_ALWAYS_IF_MSG KAI_ASSERT_ALWAYS_IF_MSG\n#define KAI_ASSUME_ALWAYS_IF KAI_ASSERT_ALWAYS_IF\n\n/// Indicate that result of `x` is unused\n#define KAI_UNUSED(x) (void)(x)\n\n/// Return minimum or maximum of `a` and `b`\n#define KAI_MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define KAI_MAX(a, b) (((a) > (b)) ? (a) : (b))\n\n/// KleidiAI shared constants\nenum {\n /// Largest supported SME vector length in bytes\n KAI_SME_VEC_LENGTH_MAX_BYTES = 256,\n\n /// Size of one vscale unit, in bytes\n KAI_VSCALE_UNIT_BYTES = 16,\n\n /// Maximum possible VSCALE\n KAI_VSCALE_MAX = KAI_SME_VEC_LENGTH_MAX_BYTES / KAI_VSCALE_UNIT_BYTES,\n};\n\n/// Gets the version of the project in the Major.Minor.Patch semantic versioning format.\n///\n/// @return Project version as a string literal.\ninline const char* kai_get_version(void) {\n return \"1.31.0\";\n}\n\n/// KleidiAI data types\n/// Format: (reserved)|(num-bytes)|(type)|(variant-type)\nenum kai_datatype {\n kai_dt_unknown = 0x0000,\n kai_dt_f32 = 0x0411,\n kai_dt_f16 = 0x0212,\n kai_dt_bf16 = 0x0213,\n kai_dt_int32 = 0x0421,\n kai_dt_int16 = 0x0222,\n kai_dt_int8 = 0x0124,\n kai_dt_uint32 = 0x0431,\n kai_dt_uint16 = 0x0232,\n kai_dt_uint8 = 0x0134,\n kai_dt_bool = 0x0441\n};\n\n/// Gets number of bytes for a given data type\n/// @param[in] dt KleidiAI data type\n///\n/// @return the numbers of bytes for the data type\ninline static size_t kai_get_datatype_size_in_bytes(enum kai_datatype dt) {\n return (size_t)(dt >> 8);\n}\n\n/// Converts a scalar f16 value to f32\n/// @param[in] f16 The f16 value\n///\n/// @return the f32 value\n#if defined(__ARM_NEON)\ninline static float kai_cast_f32_f16(uint16_t f16) {\n float16_t f32 = 0;\n memcpy(&f32, &f16, sizeof(uint16_t));\n return (float)f32;\n}\n#endif\n\n/// Converts a scalar bf16 value to f32\n/// @param[in] bf16 The f16 value\n///\n/// @return the f32 value\ninline static float kai_cast_f32_bf16(uint16_t bf16) {\n const uint32_t i32 = (bf16 << 16);\n float f32 = 0;\n memcpy(&f32, &i32, sizeof(i32));\n return f32;\n}\n\n/// Converts a f32 value to bf16\n/// @param[in] f32 The f32 value\n///\n/// @return the bf16 value\ninline static uint16_t kai_cast_bf16_f32(float f32) {\n uint16_t bf16 = 0;\n#ifdef __ARM_FEATURE_BF16\n __asm__ __volatile__(\"bfcvt %h[output], %s[input]\" : [output] \"=w\"(bf16) : [input] \"w\"(f32));\n#else\n const uint32_t* i32 = (uint32_t*)(&f32);\n bf16 = (*i32 >> 16);\n#endif\n return bf16;\n}\n\n/// Converts a scalar f32 value to f16\n/// @param[in] f32 The f32 value\n///\n/// @return the f16 value\n#if defined(__ARM_NEON)\ninline static uint16_t kai_cast_f16_f32(float f32) {\n uint16_t f16 = 0;\n float16_t tmp = (float16_t)f32;\n memcpy(&f16, &tmp, sizeof(uint16_t));\n return f16;\n}\n#endif\n\n/// Divide a value, `a`, with a value `b` and round up the result\ninline static size_t kai_div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\n/// Round up a value, `a` to a multiple of `b`\ninline static size_t kai_roundup(size_t a, size_t b) {\n return kai_div_ceil(a, b) * b;\n}\n\n#if defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n/// Gets the SME vector length for 8-bit elements.\nuint64_t kai_get_sme_vector_length_u8(void);\n\n/// Gets the SME vector length for 16-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u16(void) {\n return kai_get_sme_vector_length_u8() / 2;\n}\n\n/// Gets the SME vector length for 32-bit elements.\ninline static uint64_t kai_get_sme_vector_length_u32(void) {\n return kai_get_sme_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SME\ninline static uint64_t kai_get_sme_vscale(void) {\n return kai_get_sme_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Commit ZA to lazy save buffer\nvoid kai_commit_za(void);\n#endif // defined(__ARM_FEATURE_SVE2) || defined(_M_ARM64)\n\n/// Gets the SVE vector length for 8-bit elements.\nuint64_t kai_get_sve_vector_length_u8(void);\n\n/// Gets the SVE vector length for 16-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u16(void) {\n return kai_get_sve_vector_length_u8() / 2;\n}\n\n/// Gets the SVE vector length for 32-bit elements.\ninline static uint64_t kai_get_sve_vector_length_u32(void) {\n return kai_get_sve_vector_length_u8() / 4;\n}\n\n/// Gets the vscale scale factor for SVE\ninline static uint64_t kai_get_sve_vscale(void) {\n return kai_get_sve_vector_length_u8() / KAI_VSCALE_UNIT_BYTES;\n}\n\n/// Extends the sign bit of int 4-bit value (stored in int8_t variable)\n/// @param[in] value The 4-bit int value\n///\n/// @return the int8_t value with sign extended\ninline static int8_t kai_ext_sign_i8_i4(int8_t value) {\n // Make sure value holds correct int4 value\n KAI_ASSUME(value <= 0xF);\n\n return (value ^ 0x8) - 8; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)\n}\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 8-bit with per-channel quantization)\nstruct kai_rhs_pack_qsi8cx_params {\n int32_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n float scale_multiplier; ///< Product of input (refers to lhs and rhs) and output quantization scales.\n};\n\n/// Parameter struct for RHS matrix packing (Quantized Symmetric Integer 4-bit with per-block quantizatio and s1s0\n/// nibble ordering)\nstruct kai_rhs_pack_nxk_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing (KxN variant for int4 qsi4c32p_qsu4c32s1s0)\nstruct kai_rhs_pack_kxn_qsi4c32p_qsu4c32s1s0_params {\n int8_t lhs_zero_point;\n uint8_t rhs_zero_point;\n enum kai_datatype scale_dt;\n};\n\n/// Parameter struct for RHS matrix packing\nstruct kai_rhs_pack_qs4cxs1s0_param {\n int8_t lhs_zero_point; ///< LHS Matrix quantization zero-point\n uint8_t rhs_zero_point; ///< RHS Matrix quantization zero-point\n};\n\n/// Requantization and clamp parameters for GEMM/GEMV output stage.\nstruct kai_matmul_requantize32_params {\n int32_t min_value; ///< Minimum output value.\n int32_t max_value; ///< Maximum output value.\n int32_t output_zero_point; ///< Output quantization zero point.\n};\n\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "kai/kai_common_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n #define KAI_ASM_FUNCTION_USE(name) name\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #define KAI_ASM_FUNCTION_USE(name) _##name\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #define KAI_ASM_FUNCTION_USE(name) name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kai_common)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n stp fp, lr, [sp, #-16]!\n mov fp, sp\n mrs x9, TPIDR2_EL0\n cbz x9, leave\n bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n msr TPIDR2_EL0, xzr\nleave:\n ldp fp, lr, [sp], #16\n#endif\n ret\n KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n ret\n KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n KAI_ASM_END\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// For micro-kernel naming and associated packing micro-kernel that goes with it, see:\n/// * docs/microkernel_tables.md\n/// * kai/ukernels/matmul/README.md\n/// This provides information such as the data type and packing format of the buffers.\n/// Any information that is not present in the above files is documented here.\n///\n/// Documentation conventions in this file:\n/// * Only required or conditionally required configuration parameters,\n/// operands, activation arguments, and flags are documented.\n/// * See the *_types.h file for the description of those argument types.\n/// * Accumulation data type matches the output data type by default. It is\n/// documented along with the API only when the data types differ.\n/// * Any argument not listed for a micro-kernel is unused and does not need\n/// to be populated.\n///\n\n/// Half-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst\n/// * rhs - rhs with per-n accumulator bias\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16p4vsx2_f16p4vsx2bf16_8vsx8vs_sme2_mopa(void);\n\n/// Single-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n/// * FEAT_FP16\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - f16p4vsx2 packed FP16 values.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to FP16 values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f16p4vsx2_qsi4c32p16vsx4s1s0sf16_f16p_4vsx16vs_sme2_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p1x4sf16 packed with per-block FP16 scale.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to 8-bit values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p1x4sf16_qsi4c32p16vsx4s1s0sf16_i8p_1x16vs_sme2_dot(void);\n\n/// Single-precision floating-point matrix multiplication using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst\n/// * rhs - rhs with per-n accumulator bias\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f32p4vsx1_f32p4vsx1bf32_8vsx8vs_sme2_mopa(void);\n\n/// Matrix multiplication with single-precision floating-point accumulation using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be a non-zero multiple of 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p4vsx4sf16 packed with per-block FP16 scale.\n/// * rhs - qsi4c32p16vsx4s1s0sf16 packed with per-block FP16 scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * operand.lut.ptr - 16-byte-aligned buffer of 16 32-bit entries mapping packed 4-bit RHS codes to 8-bit values.\n/// NULL\n/// selects the default QSI4 mapping.\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p4vsx4sf16_qsi4c32p16vsx4s1s0sf16_i8p_4vsx16vs_sme2_mopa(void);\n\n/// Matrix multiplication with 32-bit integer accumulation using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst, rhs\n/// * bias\n/// * acc_bias_m, acc_bias_n\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_i32_u8p4vsx4_u8p4vsx4_i32_i32_8vsx8vs_sme2_mopa(void);\n\n/// Matrix multiplication with 32-bit integer accumulation and FP32 output using SME2 MOPA instruction.\n///\n/// Required operands:\n/// * lhs, dst, rhs\n/// * bias\n/// * acc_bias_m, acc_bias_n, scale_bias_n\n/// * scale\n/// * acc_scale_global\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Accumulation: I32, then converted to F32 using global scaling and per column bias\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamping output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication using SME2 MLA instruction.\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - rhs matrix and per-n accumulator bias vector.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f32_f32p4vsx1bf32_1x32vs_sme2_mla(void);\n\n/// Half-precision floating-point matrix multiplication using SVE2.1 FDOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SVE2p1\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Accumulation: F32, then converted to F16.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16_f16p16vsx2bf16_6x16vs_sve2p1_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi8cxp8x4_1x8_sve_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi8cxp32x4_1x32_sve_dot(void);\n\n/// Dynamically quantized INT8 vector-matrix multiplication using SVE DOT instructions.\n///\n/// Required CPU features:\n/// * FEAT_SVE with a vector length of exactly 256 bits\n///\n/// Required operands:\n/// * dst\n/// * lhs - Packed QAI8DXP data with per-M zero point and scale.\n/// * rhs - Packed QSI8CXP data with per-N row sum, scale, and bias.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x8_qsi8cxp8x8_1x8_sve_dot(void);\n\n/// Half-precision floating-point vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - rhs matrix and per-n accumulator bias vector.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f16_f16_f16p4vsx2bf16_1x32vs_sme2_dot(void);\n\n/// Statically quantized INT8 matrix multiplication with INT4 RHS using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p8vsx4_qsi4cxp8vsx4sf32bi32_8vsx8vs_sme2_mopa(void);\n\n/// Statically quantized INT8 matrix multiplication using SME2 outer product (MOPA) and SME2.1 quarter tile outer\n/// product (MOP4A) instructions.\n///\n/// Required CPU features:\n/// * FEAT_SME2.1\n/// * FEAT_SME_MOP4\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p4vsx4_qsi8cxp4vsx4sf32bi32_8vsx8vs_sme2p1_mop4_mopa(void);\n\n/// Statically quantized INT8 matrix-vector multiplication with packed UINT2 RHS using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N destination-domain corrected bias and scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsu2cxp16vsx4sf32bi32_1x64vs_sme2_dot(void);\n\n/// Statically quantized INT8 matrix multiplication with packed UINT2 RHS using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N destination-domain corrected bias and scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p8vsx4_qsu2cxp16vsx4sf32bi32_8vsx16vs_sme2_mopa(void);\n\n/// Statically quantized INT8 matrix multiplication using SME2 MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8p4vsx4_qsi8cxp4vsx4bi32sf32_8vsx8vs_sme2_mopa(void);\n\n/// Statically quantized INT8 vector-matrix multiplication using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - RHS matrix with per-N bias and per-N scale.\n/// * dst_bias_global\n///\n/// Optional arguments:\n/// * clamp - INT32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsi8cxp4vsx4bi32sf32_1x32vs_sme2_dot(void);\n\n/// Statically quantized INT8 vector-matrix multiplication with packed INT4 RHS using SME2 DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Required operands:\n/// * dst\n/// * lhs\n/// * rhs - Packed RHS matrix with per-N bias and per-N scale.\n/// * bias\n/// * scale_bias_global - Output zero point as an I32 scalar.\n///\n/// Optional arguments:\n/// * clamp - I32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_qai8_qai8_qsi4cxp8vsx4sf32bi32_1x64vs_sme2_dot(void);\n\n/// Matrix multiplication with FP16 packed LHS and QAI4C32P RHS with FP32 output using SME2 MOPA.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n/// * FEAT_FP16\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be 32.\n///\n/// Required operands:\n/// * lhs - FP16 data packed in 4vsx2 panels.\n/// * rhs - qai4c32p16vsx4s1s0sf16 packed with per-block FP16 offset and scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * clamp - FP32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_f16p4vsx2_qai4c32p16vsx4s1s0sf16_4vsx16vs_sme2_mopa(void);\n\n/// Vector-matrix multiplication with dynamically quantized INT8 packed LHS and QAI4C32P RHS packed inputs with FP32\n/// output using SME2 DOT.\n///\n/// Required CPU features:\n/// * FEAT_SME2\n///\n/// Configuration parameters:\n/// * format.bl - Block length. Must be 32.\n///\n/// Required operands:\n/// * lhs - qsi8d32p1x4sf16 data packed with per-block FP16 sum and scale.\n/// * rhs - qai4c32p16vsx4s1s0sf16 packed with per-block FP16 offset and scale.\n/// * dst - FP32 output matrix.\n///\n/// Optional arguments:\n/// * clamp - FP32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qsi8d32p1x4_qai4c32p16vsx4s1s0sf16_1x16vs_sme2_dot(void);\n\n/// Single-precision floating-point matrix multiplication with statically-blockwise quantized unsigned INT4 RHS,\n/// using SME MOPA instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * dst\n/// * lhs - Dynamically quantized asymmetric per-row (qai8dxp) LHS, packed with @ref\n/// kai_lhs_quant_pack_qai8dxp_f32.\n/// * rhs - Packed RHS matrix, obtained with @ref kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme or\n/// @ref\n/// kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp4vsx4_qsi4c32p16vsx4_4vsx16vs_sme_mopa(void);\n\n/// Single-precision floating-point vector-matrix multiplication with statically-blockwise quantized unsigned INT4\n/// RHS, using SME DOT instruction.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * dst\n/// * lhs - Dynamically quantized asymmetric per-row (qai8dxp) LHS, packed with @ref\n/// kai_lhs_quant_pack_qai8dxp_f32.\n/// * rhs - Packed RHS matrix, obtained with @ref kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme or\n/// @ref\n/// kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme.\n///\n/// Optional arguments:\n/// * clamp - F32 output clamp values if KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP flag is set.\n///\n/// Supported flags:\n/// * KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP - Clamp output data.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_qai8dxp1x4_qsi4c32p16vsx4_1x16vs_sme_dot(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_format_config {\n size_t bl;\n};\n\n/// Micro-kernel configuration for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_config {\n struct kai_matmul_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// LHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lhs_args {\n const void* ptr; ///< LHS buffer.\n struct kai_matmul_uker_lhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n};\n\n/// RHS buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_rhs_args {\n const void* ptr; ///< RHS buffer.\n struct kai_matmul_uker_rhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Strides in bytes of the output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_stride_args {\n size_t m; ///< Strides in bytes in M dimension.\n};\n\n/// Output buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_dst_args {\n void* ptr; ///< Output buffer.\n struct kai_matmul_uker_dst_stride_args stride; ///< Strides in bytes.\n};\n\n//// Bias types ////\n///\n/// Bias can be applied at multiple stages:\n/// * `acc_bias` - Bias applied at the accumulation stage\n/// * `scale_bias` - Bias applied to the scaled accumulation stage\n///\n/// There are different kind of biases.\n/// * `global` - Scalar value applied to entire _stage_ for a global value shift\n/// * `m` - Scalar value applied to each row of _stage_ for a per row value shift\n/// * `n` - Scalar value applied to each column _stage_ for a per column value shift\n\n/// Accumulation stage ///\n\n/// Global accumulation bias parameters\nstruct kai_matmul_uker_acc_bias_global_args {\n const void* ptr; ///< Global accumulation bias value\n};\n\n/// Per-M accumulation bias\nstruct kai_matmul_uker_acc_bias_m_args {\n const void* ptr; ///< Per-M accumulation bias vector\n};\n\n/// Per-N accumulation bias\nstruct kai_matmul_uker_acc_bias_n_args {\n const void* ptr; ///< Per-N accumulation bias buffer.\n};\n\n/// Scaling stage ///\n\n/// Global scaled accumulation bias parameter\nstruct kai_matmul_uker_scale_bias_global_args {\n const void* ptr; ///< Scalar scaling bias parameter.\n};\n\n/// Per-M scaled accumulation bias\nstruct kai_matmul_uker_scale_bias_m_args {\n const void* ptr; ///< Per-M scaling bias buffer.\n};\n\n/// Per-N scaled accumulation bias\nstruct kai_matmul_uker_scale_bias_n_args {\n const void* ptr; ///< Per-N scaling bias buffer.\n};\n\n/// Bias parameters\nstruct kai_matmul_uker_bias_args {\n struct kai_matmul_uker_acc_bias_global_args acc_bias_global; ///< Accumulation bias, global\n struct kai_matmul_uker_acc_bias_m_args acc_bias_m; ///< Accumulation bias, per row\n struct kai_matmul_uker_acc_bias_n_args acc_bias_n; ///< Accumulation bias, per column\n struct kai_matmul_uker_scale_bias_global_args scale_bias_global; ///< Scale bias, scalar\n struct kai_matmul_uker_scale_bias_m_args scale_bias_m; ///< Scale bias, per row\n struct kai_matmul_uker_scale_bias_n_args scale_bias_n; ///< Scale bias, column\n};\n\n//// Scaling types ////\n///\n/// Scaling can be applied at multiple stages\n/// * `acc_scale` - Scaling applied to the biased accumulation stage\n///\n/// There are different kind of scaling.\n/// * `global` - Scalar value applied to entire _stage_ for a global scaling\n/// * `m` - Scalar value applied to each element in row of _stage_ for a per row scaling\n/// * `n` - Scalar value applied to each element in column of _stage_ for a per column scaling\n\n/// Global scale parameter for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_global_args {\n const void* ptr; ///< Global scale parameter.\n};\n\n/// Per-M accumulation scale buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_m_args {\n const void* ptr; ///< Per-M accumulation scale buffer.\n};\n\n/// Per-N accumulation scale buffer for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_acc_scale_n_args {\n const void* ptr; ///< Per-N accumulation scale buffer.\n};\n\n/// Scale parameters\nstruct kai_matmul_uker_scale_args {\n struct kai_matmul_uker_acc_scale_global_args acc_scale_global; ///< Accumulation scale, scalar\n struct kai_matmul_uker_acc_scale_m_args acc_scale_m; ///< Accumulation scale, per row\n struct kai_matmul_uker_acc_scale_n_args acc_scale_n; ///< Accumulation scale, per column\n};\n\n//// Activation parameter types ////\n\n/// Clamping activation arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_clamp_args {\n const void* min_ptr; ///< Pointer to the minimum value.\n const void* max_ptr; ///< Pointer to the maximum value.\n};\n\n/// Activation function arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_activation_args {\n struct kai_matmul_uker_clamp_args clamp; ///< Output clamping function.\n};\n\n//// Lookup table parameter types ////\n\n/// Lookup table arguments for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_lut_args {\n const void* ptr; ///< Lookup table buffer.\n};\n\n//// Operand and high level argument types ////\n\n/// Operands for matrix multiplication micro-kernel.\nstruct kai_matmul_uker_operand_args {\n struct kai_matmul_uker_dst_args dst; ///< Output buffer.\n struct kai_matmul_uker_lhs_args lhs; ///< LHS buffer.\n struct kai_matmul_uker_rhs_args rhs; ///< RHS buffer.\n struct kai_matmul_uker_bias_args bias; ///< Bias parameters\n struct kai_matmul_uker_scale_args scale; ///< Scale parameters\n struct kai_matmul_uker_lut_args lut; ///< Lookup table arguments.\n};\n\n/// Matrix multiplication micro-kernel run arguments.\nstruct kai_matmul_uker_args {\n uint64_t flags; ///< Control flags.\n struct kai_matmul_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_uker_operand_args operand; ///< Operands.\n struct kai_matmul_uker_activation_args activation; ///< Fused activation function.\n};\n\n/// Matrix multiplication micro-kernel run flags.\nenum kai_matmul_uker_flags_args {\n KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP = 0x10000, ///< Clamping output data.\n};\n\n/// Matrix multiplication micro-kernel API.\nstruct kai_matmul_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_uker_dim_args (*get_step)(const struct kai_matmul_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_uker_lhs_stride_args (*get_lhs_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* shape);\n\n /// Gets the offset in bytes of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* index,\n const struct kai_matmul_uker_lhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_uker_rhs_stride_args (*get_rhs_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* shape);\n\n /// Gets the offset in bytes of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* index,\n const struct kai_matmul_uker_rhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The stride in bytes.\n struct kai_matmul_uker_dst_stride_args (*get_dst_stride)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape);\n\n /// Gets the offset in bytes of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the output data.\n ///\n /// @return The offset in bytes.\n size_t (*get_dst_offset)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* index,\n const struct kai_matmul_uker_dst_stride_args* stride);\n\n /// Gets the size in bytes of the output data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the output data.\n ///\n /// @return The size in bytes.\n size_t (*get_dst_size)(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape,\n const struct kai_matmul_uker_dst_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_lhs.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Non-transposed LHS dynamic quantization and packing micro-kernel for FP32 data.\n///\n/// Required CPU features:\n/// * FEAT_AdvSIMD\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: qsi8d32p1x4sf16 data. Every 32-value block contains INT8 values followed by an FP16\n/// dequantized sum and an FP16 scale.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: FP32 data in MxK layout, where K must be a multiple of 32.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_qsi8d32p1x4sf16_f32_neon(void);\n\n/// Non-transposed LHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 8-bit data in 4vsx4 blocked format.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 8-bit data in plain format.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed LHS packing micro-kernel for 16-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 16-bit data in 4vsx2 blocked format.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 16-bit data in plain format.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x16p4vsx2_x16_sme(void);\n\n/// Non-transposed LHS packing micro-kernel for 32-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * lhs_packed - The packed LHS matrix.\n/// * LHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * lhs - The LHS matrix.\n/// * LHS matrix: 32-bit data in MxK layout.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x32p4vsx1_x32_sme(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_lhs_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_format_config {\n size_t mr;\n size_t kr;\n size_t sr;\n};\n\n/// Micro-kernel configuration for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_config {\n struct kai_matmul_pack_lhs_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_args {\n const void* ptr; ///< LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_dim_args {\n size_t m; ///< Length or coordinate in M dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_stride_args {\n size_t m; ///< Stride in bytes in M dimension.\n};\n\n/// Packed LHS buffer for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_lhs_packed_args {\n void* ptr; ///< Packed LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args stride; ///< Strides in bytes.\n};\n\n/// Operands for matrix multiplication LHS packing micro-kernel.\nstruct kai_matmul_pack_lhs_uker_operand_args {\n struct kai_matmul_pack_lhs_uker_lhs_packed_args lhs_packed; ///< Packed LHS buffer.\n struct kai_matmul_pack_lhs_uker_lhs_args lhs; ///< LHS buffer.\n};\n\n/// Matrix multiplication LHS packing micro-kernel arguments.\nstruct kai_matmul_pack_lhs_uker_args {\n uint64_t flags; ///< Control flags.\n\n struct kai_matmul_pack_lhs_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_pack_lhs_uker_operand_args operand; ///< Operands.\n};\n\n/// Matrix multiplication LHS packing micro-kernel API.\nstruct kai_matmul_pack_lhs_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_pack_lhs_uker_dim_args (*get_step)(const struct kai_matmul_pack_lhs_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_lhs_uker_lhs_stride_args (*get_lhs_stride)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_dim_args* shape);\n\n /// Gets the offset in bytes of the LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_offset)(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args (*get_lhs_packed_stride)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape);\n\n /// Gets the offset in bytes of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the packed LHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_lhs_packed_offset)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride);\n\n /// Gets the size in bytes of the packed LHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the packed LHS data.\n ///\n /// @return The size in bytes.\n size_t (*get_lhs_packed_size)(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_rhs.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n// SPDX-FileCopyrightText: Copyright 2026 Meta Platforms, Inc. and affiliates.\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs_types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SVE\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 16vsx2 blocked layout.\n/// * Per-n bias vector: 16-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 16-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_rhs_pack_kxn_x16p16vsx2bx16_x16_x16_sve(void);\n\n/// Non-transposed RHS packing micro-kernel for 32-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * Per-n bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 32-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 32-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x32p4vsx1bx32_x32_x32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 4vsx2 blocked layout.\n/// * Per-n bias vector: 16-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 16-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x16p4vsx2bx16_x16_x16_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 16-bit data with per-N 32-bit bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 8vsx2 blocked layout.\n/// * Per-N bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in KxN layout.\n/// * bias_n - The optional per-N bias vector.\n/// * Per-N bias vector: 32-bit data. A null pointer packs zero bias.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x16p8vsx2bx32_x16_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 32-bit data with per-N bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 32-bit data in 4vsx1 blocked layout.\n/// * Per-n bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 32-bit data in NxK layout.\n/// * bias_n - The per-N bias vector.\n/// * Per-N bias vector: 32-bit data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x32p4vsx1bx32_x32_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 16-bit data with per-N 32-bit bias.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 16-bit data in 8vsx2 blocked layout.\n/// * Per-N bias vector: 32-bit data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 16-bit data in NxK layout.\n/// * bias_n - The optional per-N bias vector.\n/// * Per-N bias vector: 32-bit data. A null pointer packs zero bias.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x16p8vsx2bx32_x16_x32_sme(void);\n\n/// Transposed RHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 8-bit data in 4vsx4 blocked layout.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 8-bit data in NxK layout.\n/// * bias_n - Unused by this micro-kernel.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for 8-bit data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: 8-bit data in 4vsx4 blocked layout.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: 8-bit data in KxN layout.\n/// * bias_n - Unused by this micro-kernel.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_x8p4vsx4_x8_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized INT8 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * Per-N bias vector: INT32 data.\n/// * RHS matrix: INT8 data in 4vsx4 blocked format.\n/// * Per-N scale vector: FP32 data.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: INT8 data in plain format, non-transposed.\n/// * bias_n - The per-N quantized bias vector.\n/// * Per-N bias vector: INT32 data.\n/// * k_sum_scale_global - The per-matrix row sum scale value.\n/// * Per-matrix row sum scale value: INT32 data.\n/// * scale_n - The per-N quantization scale vector.\n/// * Per-N scale vector: FP32 data.\n/// * scale_global - The per-matrix scale value.\n/// * Per-matrix scale value: FP32 data.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi8cxp4vsx4bi32sf32_qsi8_i32_f32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized signed INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, non-transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4cxp8vsx4sf32bi32_qsi4cx_f32_i32_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized unsigned INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, non-transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4cxp8vsx4sf32bi32_qsu4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized signed INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4cxp8vsx4sf32bi32_qsi4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized unsigned INT4 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, INT4 RHS in 8vsx4 blocked format, and FP32 scale.\n/// * rhs - INT4 data in plain format, transposed.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4cxp8vsx4sf32bi32_qsu4cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized int4 data with block-wise quantization and super block meta\n/// data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters: none.\n///\n/// Operands:\n/// * rhs_packed - The packed RHS matrix.\n/// * RHS matrix: qai4c32p16vsx4s1s0sf16 data with 16vsx4-ordered per-block FP16 scale and offset metadata.\n/// * rhs - The RHS matrix.\n/// * RHS matrix: qai4c32k256sf16s32s0 4-bit data in NxK layout, stored as 256-value super-blocks. K must be a\n/// multiple of 256\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qai4c32p16vsx4s1s0sf16_qai4c32k256sf16s32s0_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for static quantized UINT2 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, UINT2 RHS in 16vsx4 blocked format, and FP32 scale.\n/// * rhs - UINT2 data in plain format, non-transposed, with zero point 2.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - Negative LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsu2cxp16vsx4sf32bi32_qsu2cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for static quantized UINT2 data.\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Required operands:\n/// * rhs_packed - INT32 bias, UINT2 RHS in 16vsx4 blocked format, and FP32 scale.\n/// * rhs - UINT2 data in plain format, transposed, with zero point 2.\n/// * bias_n - Per-N INT32 bias.\n/// * k_sum_scale_global - Negative LHS zero point as an INT32 scalar.\n/// * scale_n - Per-N FP32 scale.\n/// * scale_global - FP32 scale multiplier.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsu2cxp16vsx4sf32bi32_qsu2cx_f32_i32_sme(void);\n\n/// Transposed RHS packing micro-kernel for statically-blockwise quantized unsigned INT4 data (fixed RHS zero point\n/// 8, fixed LHS zero point 1, BF16 block scales).\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * rhs_packed - Per-block INT4 RHS in s4s0 nrx4 blocked format, per-block BF16 scale, per-N FP32 row sum, and\n/// per-N FP32 bias.\n/// * rhs - INT4 data in plain format, transposed (N x K, two values packed per byte).\n/// * bias_n - Per-N FP32 bias.\n/// * scale_n - Per-block, per-N BF16 scale.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme(void);\n\n/// Non-transposed RHS packing micro-kernel for statically-blockwise quantized unsigned INT4 data (fixed RHS zero\n/// point 8, fixed LHS zero point 1, BF16 block scales).\n///\n/// Required CPU features:\n/// * FEAT_SME\n///\n/// Configuration parameters:\n/// * bl - The block length, in number of K values per block. Must be a multiple of 32.\n///\n/// Required operands:\n/// * rhs_packed - Per-block INT4 RHS in s4s0 nrx4 blocked format, per-block BF16 scale, per-N FP32 row sum, and\n/// per-N FP32 bias.\n/// * rhs - INT4 data in plain format, non-transposed (K x N, two values packed per byte).\n/// * bias_n - Per-N FP32 bias.\n/// * scale_n - Per-block, per-N BF16 scale.\n///\n/// Supported flags: none.\n///\n/// @return The micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_kxn_qsi4c32p16vsx4s4s0_qsu4c32_f32_bf16_sme(void);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai/ukernels/matmul/kai_matmul_pack_rhs_types.h", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/// Data format configuration for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_format_config {\n size_t nr;\n size_t kr;\n size_t sr;\n size_t bl;\n};\n\n/// Micro-kernel configuration for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_config {\n struct kai_matmul_pack_rhs_uker_format_config format; ///< Data format.\n};\n\n/// Problem dimensions for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Dimensions of the RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n size_t k; ///< Stride in bytes in K dimension.\n};\n\n/// RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_args {\n const void* ptr; ///< RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n};\n\n/// Packed RHS buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_rhs_packed_args {\n void* ptr; ///< Packed RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args stride; ///< Strides in bytes.\n};\n\n/// Dimensions of the per-N bias buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_bias_n_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Per-N bias buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_bias_n_args {\n const void* ptr; ///< Per-N bias buffer.\n};\n\n/// Per-matrix K sum scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_k_sum_scale_global_args {\n const void* ptr; ///< Per-matrix K sum scale buffer.\n};\n\n/// Dimensions of the per-N scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_n_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n};\n\n/// Per-N scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_n_args {\n const void* ptr; ///< Per-N scale buffer.\n};\n\n/// Dimensions of the per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_nk_dim_args {\n size_t n; ///< Length or coordinate in N dimension.\n size_t k; ///< Length or coordinate in K dimension.\n};\n\n/// Strides in bytes of the per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_nk_stride_args {\n size_t n; ///< Stride in bytes in N dimension.\n size_t k; ///< Stride in bytes in K dimension.\n};\n\n/// Per-(N, K) scale buffer for matrix multiplication RHS packing micro-kernel. Unlike `scale_n`, which holds a\n/// single value per N column, this operand holds one value per (N column, K block) pair and therefore requires\n/// explicit strides to locate an element, since the vector-buffer API used by `scale_n` cannot express a stride.\nstruct kai_matmul_pack_rhs_uker_scale_nk_args {\n const void* ptr; ///< Per-(N, K) scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_nk_stride_args stride; ///< Strides in bytes.\n};\n\n/// Per-matrix scale buffer for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_scale_global_args {\n const void* ptr; ///< Per-matrix scale buffer.\n};\n\n/// Operands for matrix multiplication RHS packing micro-kernel.\nstruct kai_matmul_pack_rhs_uker_operand_args {\n struct kai_matmul_pack_rhs_uker_rhs_args rhs; ///< RHS buffer.\n struct kai_matmul_pack_rhs_uker_rhs_packed_args rhs_packed; ///< Packed RHS buffer.\n struct kai_matmul_pack_rhs_uker_bias_n_args bias_n; ///< Per-N bias buffer.\n struct kai_matmul_pack_rhs_uker_k_sum_scale_global_args k_sum_scale_global; ///< Per-matrix K sum scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_n_args scale_n; ///< Per-N scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_global_args scale_global; ///< Per-matrix scale buffer.\n struct kai_matmul_pack_rhs_uker_scale_nk_args scale_nk; ///< Per-(N, K) scale buffer.\n};\n\n/// Matrix multiplication RHS packing micro-kernel arguments.\nstruct kai_matmul_pack_rhs_uker_args {\n uint64_t flags; ///< Control flags.\n\n struct kai_matmul_pack_rhs_uker_dim_args shape; ///< Problem shape.\n struct kai_matmul_pack_rhs_uker_operand_args operand; ///< Operands.\n};\n\n/// Matrix multiplication RHS packing micro-kernel API.\nstruct kai_matmul_pack_rhs_uker_api {\n /// Runs the micro-kernel.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] args The micro-kernel arguments.\n void (*run)(const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_args* args);\n\n /// Gets the step in each problem dimension.\n ///\n /// If this function returns a non-zero value for a given dimension, when splitting the problem,\n /// the start coordinate in that dimension must be divisible by the returned value.\n ///\n /// If this function returns zero for a given dimension, that dimension must not be split.\n ///\n /// @param[in] config The micro-kernel configuration.\n ///\n /// @return The step in each dimension.\n struct kai_matmul_pack_rhs_uker_dim_args (*get_step)(const struct kai_matmul_pack_rhs_uker_config* config);\n\n /// Gets the stride in bytes in each dimension of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_rhs_stride_args (*get_rhs_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_dim_args* shape);\n\n /// Gets the offset in bytes of the RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args* stride);\n\n /// Gets the stride in bytes in each dimension of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args (*get_rhs_packed_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape);\n\n /// Gets the offset in bytes of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the packed RHS data.\n ///\n /// @return The offset in bytes.\n size_t (*get_rhs_packed_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride);\n\n /// Gets the size in bytes of the packed RHS data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n /// @param[in] stride The stride in bytes of the packed RHS data.\n ///\n /// @return The size in bytes.\n size_t (*get_rhs_packed_size)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride);\n\n /// Gets the offset in bytes of the per-N bias data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n ///\n /// @return The offset in bytes, or zero if `bias_n` is unused.\n size_t (*get_bias_n_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_bias_n_dim_args* index);\n\n /// Gets the offset in bytes of the per-N scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n ///\n /// @return The offset in bytes.\n size_t (*get_scale_n_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_n_dim_args* index);\n\n /// Gets the stride in bytes in each dimension of the per-(N, K) scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] shape The shape.\n ///\n /// @return The strides in bytes.\n struct kai_matmul_pack_rhs_uker_scale_nk_stride_args (*get_scale_nk_stride)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_nk_dim_args* shape);\n\n /// Gets the offset in bytes of the per-(N, K) scale data.\n ///\n /// @param[in] config The micro-kernel configuration.\n /// @param[in] index The start coordinate in each dimension.\n /// @param[in] stride The stride in bytes of the per-(N, K) scale data.\n ///\n /// @return The offset in bytes.\n size_t (*get_scale_nk_offset)(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_scale_nk_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_scale_nk_stride_args* stride);\n};\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + }, + { + "path": "kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs_types.h\"\n\nenum {\n OUTPUT_ELEM_BYTES = 1,\n MR_VSCALE = 4,\n KR = 4,\n MAX_MR = MR_VSCALE * KAI_VSCALE_MAX,\n};\n\nvoid kai_matmul_pack_rows_x8p4vsx4_x8_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t get_mr(void) {\n return MR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_dim_args get_step(const struct kai_matmul_pack_lhs_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_lhs_uker_dim_args step = {\n .m = get_mr(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_lhs_stride_args get_lhs_stride(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args stride = {\n .m = shape->k * OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_offset(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_lhs_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->m * stride->m + index->k * OUTPUT_ELEM_BYTES;\n}\n\nstatic struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args get_lhs_packed_stride(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args stride = {\n .m = mr * kai_roundup(shape->k, KR) * OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_packed_offset(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* index,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n const size_t mr = get_mr();\n return index->m / mr * stride->m + index->k * mr * OUTPUT_ELEM_BYTES;\n}\n\nstatic size_t get_lhs_packed_size(\n const struct kai_matmul_pack_lhs_uker_config* config,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_dim_args* shape,\n const struct kai_matmul_pack_lhs_uker_lhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n return div_ceil(shape->m, mr) * stride->m;\n}\nstatic void run(\n const struct kai_matmul_pack_lhs_uker_config* config, const struct kai_matmul_pack_lhs_uker_args* args) {\n KAI_UNUSED(config);\n\n const size_t mr = get_mr();\n\n const size_t m = args->shape.m;\n const size_t width = args->shape.k;\n\n const uint8_t* lhs_ptr = args->operand.lhs.ptr;\n uint8_t* lhs_packed_ptr = args->operand.lhs_packed.ptr;\n\n const uint8_t* in[MAX_MR];\n kai_commit_za();\n\n for (size_t start_row = 0; start_row < m; start_row += mr) {\n const size_t height = KAI_MIN(m - start_row, mr);\n KAI_UNUSED(start_row);\n\n void* out = lhs_packed_ptr;\n lhs_packed_ptr += args->operand.lhs_packed.stride.m;\n\n for (size_t row = 0; row < height; ++row) {\n in[row] = lhs_ptr + row * args->operand.lhs.stride.m;\n }\n lhs_ptr += mr * args->operand.lhs.stride.m;\n\n // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n kai_matmul_pack_rows_x8p4vsx4_x8_sme(height, width, in, out);\n }\n}\n\nstruct kai_matmul_pack_lhs_uker_api kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme(void) {\n struct kai_matmul_pack_lhs_uker_api api = {\n .run = run,\n\n .get_step = get_step,\n\n .get_lhs_stride = get_lhs_stride,\n .get_lhs_offset = get_lhs_offset,\n\n .get_lhs_packed_stride = get_lhs_packed_stride,\n .get_lhs_packed_offset = get_lhs_packed_offset,\n .get_lhs_packed_size = get_lhs_packed_size,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs_types.h\"\n\nenum {\n OUTPUT_ELEM_BYTES = 1,\n BIAS_ELEM_BYTES = 0,\n\n NR_VSCALE = 4,\n KR = 4,\n\n MAX_NR = NR_VSCALE * KAI_VSCALE_MAX,\n};\n\nvoid kai_matmul_pack_rows_x8p4vsx4_x8_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t get_nr(void) {\n return NR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t div_ceil(size_t a, size_t b) {\n return (a + b - 1) / b;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_dim_args get_step(const struct kai_matmul_pack_rhs_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_rhs_uker_dim_args step = {\n .n = get_nr(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_rhs_stride_args get_rhs_stride(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args stride = {\n .n = shape->k * OUTPUT_ELEM_BYTES,\n .k = OUTPUT_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_rhs_offset(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_rhs_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->n * stride->n;\n}\n\nstatic struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args get_rhs_packed_stride(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args stride = {\n .n = nr * (BIAS_ELEM_BYTES + kai_roundup(shape->k, KR) * OUTPUT_ELEM_BYTES),\n };\n\n return stride;\n}\n\nstatic size_t get_rhs_packed_offset(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* index,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n const size_t nr = get_nr();\n return index->n / nr * stride->n;\n}\n\nstatic size_t get_rhs_packed_size(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_dim_args* shape,\n const struct kai_matmul_pack_rhs_uker_rhs_packed_stride_args* stride) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n return div_ceil(shape->n, nr) * stride->n;\n}\n\nstatic size_t get_bias_n_offset(\n const struct kai_matmul_pack_rhs_uker_config* config,\n const struct kai_matmul_pack_rhs_uker_bias_n_dim_args* index) {\n KAI_UNUSED(config);\n KAI_UNUSED(index);\n\n return 0;\n}\n\nstatic void run(\n const struct kai_matmul_pack_rhs_uker_config* config, const struct kai_matmul_pack_rhs_uker_args* args) {\n KAI_UNUSED(config);\n\n const size_t nr = get_nr();\n\n const size_t n = args->shape.n;\n const size_t width = args->shape.k;\n\n const uint8_t* rhs_ptr = args->operand.rhs.ptr;\n uint8_t* rhs_packed_ptr = args->operand.rhs_packed.ptr;\n\n const uint8_t* in[MAX_NR];\n kai_commit_za();\n\n for (size_t start_row = 0; start_row < n; start_row += nr) {\n const size_t height = KAI_MIN(n - start_row, nr);\n\n void* out = rhs_packed_ptr;\n rhs_packed_ptr += args->operand.rhs_packed.stride.n;\n\n for (size_t row = 0; row < height; ++row) {\n in[row] = rhs_ptr + row * args->operand.rhs.stride.n;\n }\n rhs_ptr += nr * args->operand.rhs.stride.n;\n\n KAI_UNUSED(args->operand.bias_n.ptr);\n // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n kai_matmul_pack_rows_x8p4vsx4_x8_sme(height, width, in, out);\n }\n}\n\nstruct kai_matmul_pack_rhs_uker_api kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme(void) {\n struct kai_matmul_pack_rhs_uker_api api = {\n .run = run,\n\n .get_step = get_step,\n\n .get_rhs_stride = get_rhs_stride,\n .get_rhs_offset = get_rhs_offset,\n\n .get_rhs_packed_stride = get_rhs_packed_stride,\n .get_rhs_packed_offset = get_rhs_packed_offset,\n .get_rhs_packed_size = get_rhs_packed_size,\n\n .get_bias_n_offset = get_bias_n_offset,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_matmul_pack_rows_x8p4vsx4_x8_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_pack_rows_x8p4vsx4_x8_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\nKAI_ASM_FUNCTION_LABEL(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n mov x10, #0\n cntb x21\n mov x23, x1\n incb x23\n mov x20, x1\n sub x9, x21, #0x1\n cntw x28\n sub x23, x23, #0x1\n ands x9, x20, x9\n udiv x23, x23, x21 // n_passes = ceildiv(width, VL)\n csel x9, x9, x21, NE\n lsl x22, x0, #0x1 // height * 2\n lsl x21, x28, #0x1\n sub x20, x23, #0x1\n add x9, x9, #0x3\n sub x27, x28, #0x2\n whilelt p9.b, XZR, x22\n whilelt p8.b, x21, x22\n mov x26, #0\n mov x25, x2\n lsr x20, x20, #0x1 // n_loops = (n_passes - 1) / 2\n and x24, x23, #0x1 // odd_tail = bool(n_passes & 0x1)\n lsr x9, x9, #0x2\n ldr x23, [x25, #0]\n ptrue p11.s\n zip1 p10.b, p9.b, p8.b\n ldr x22, [x25, #0x8]\n mov x21, x10\n whilelt p9.b, x26, x1\n whilelt p8.b, x26, x1\n add x25, x25, #0x10\n mov x12, #0\n cbz x27, label_2\nKAI_ASM_LABEL(label_1) // K loop: Charge: Loop\n KAI_ASM_INST(0x25246141) // psel p1.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x25646140) // psel p0.b, p8.b/Z, p10.b[w12, #4]\n KAI_ASM_INST(0xe01506e0) // ld1b { za0h.b[x12] }, p1/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe01502c4) // ld1b { za0h.b[x12, #4] }, p0/Z, [x22, x21]\n add x12, x12, #0x8\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n cmp x12, x27, LSL #2\n blt label_1\nKAI_ASM_LABEL(label_2) // K loop: Charge: End\n KAI_ASM_INST(0x25246141) // psel p1.b, p8.b/Z, p10.b[w12]\n KAI_ASM_INST(0x25646140) // psel p0.b, p8.b/Z, p10.b[w12, #4]\n mov x25, x2\n incb x26\n KAI_ASM_INST(0xe01506e0) // ld1b { za0h.b[x12] }, p1/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe01502c4) // ld1b { za0h.b[x12, #4] }, p0/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n cbz x20, label_8\n mov x20, x20\nKAI_ASM_LABEL(label_3) // K loop: Main loop\n whilelt p8.b, x26, x1\n mov x12, #0\n mov x14, #0\n cbz x27, label_5\nKAI_ASM_LABEL(label_4) // K loop: Main loop: First: Loop\n KAI_ASM_INST(0x25346143) // psel p3.b, p8.b/Z, p10.b[w12, #2]\n KAI_ASM_INST(0x25746142) // psel p2.b, p8.b/Z, p10.b[w12, #6]\n KAI_ASM_INST(0x25266d21) // psel p1.b, p11.b/Z, p9.b[w14]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n KAI_ASM_INST(0xe0150ee2) // ld1b { za0h.b[x12, #2] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe0150ac6) // ld1b { za0h.b[x12, #6] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n add x12, x12, #0x8\n KAI_ASM_INST(0xe0bfc460) // st1w { za0v.s[x14] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bcc061) // st1w { za0v.s[x14, #1] }, p0/Z, [x3, x28, LSL #2]\n add x14, x14, #0x2\n addvl x3, x3, #2\n cmp x14, x27\n blt label_4\nKAI_ASM_LABEL(label_5) // K loop: Main loop: First: Tail\n KAI_ASM_INST(0x25346143) // psel p3.b, p8.b/Z, p10.b[w12, #2]\n KAI_ASM_INST(0x25746142) // psel p2.b, p8.b/Z, p10.b[w12, #6]\n KAI_ASM_INST(0x25266d21) // psel p1.b, p11.b/Z, p9.b[w14]\n KAI_ASM_INST(0x252e6d20) // psel p0.b, p11.b/Z, p9.b[w14, #1]\n mov x25, x2\n whilelt p9.b, x26, x1\n KAI_ASM_INST(0xe0150ee2) // ld1b { za0h.b[x12, #2] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n incb x26\n mov x13, #0\n KAI_ASM_INST(0xe0150ac6) // ld1b { za0h.b[x12, #6] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n KAI_ASM_INST(0xe0bfc460) // st1w { za0v.s[x14] }, p1/Z, [x3, XZR, LSL #2]\n whilelt p8.b, x26, x1\n mov x12, #0\n KAI_ASM_INST(0xe0bcc061) // st1w { za0v.s[x14, #1] }, p0/Z, [x3, x28, LSL #2]\n addvl x3, x3, #2\n cbz x27, label_7\nKAI_ASM_LABEL(label_6) // K loop: Main loop: Second: Loop\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x25656142) // psel p2.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x25246d21) // psel p1.b, p11.b/Z, p9.b[w12]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n KAI_ASM_INST(0xe0152ee0) // ld1b { za0h.b[x13] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n KAI_ASM_INST(0xe0152ac4) // ld1b { za0h.b[x13, #4] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n add x13, x13, #0x8\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bc8069) // st1w { za2v.s[x12, #1] }, p0/Z, [x3, x28, LSL #2]\n add x12, x12, #0x2\n addvl x3, x3, #2\n cmp x12, x27\n blt label_6\nKAI_ASM_LABEL(label_7) // K loop: Main loop: Second: Tail\n KAI_ASM_INST(0x25256143) // psel p3.b, p8.b/Z, p10.b[w13]\n KAI_ASM_INST(0x25656142) // psel p2.b, p8.b/Z, p10.b[w13, #4]\n KAI_ASM_INST(0x25246d21) // psel p1.b, p11.b/Z, p9.b[w12]\n KAI_ASM_INST(0x252c6d20) // psel p0.b, p11.b/Z, p9.b[w12, #1]\n mov x25, x2\n whilelt p9.b, x26, x1\n KAI_ASM_INST(0xe0152ee0) // ld1b { za0h.b[x13] }, p3/Z, [x23, x21]\n ldr x23, [x25, #0]\n subs x20, x20, #0x1\n incb x26\n KAI_ASM_INST(0xe0152ac4) // ld1b { za0h.b[x13, #4] }, p2/Z, [x22, x21]\n ldr x22, [x25, #0x8]\n add x25, x25, #0x10\n incb x21\n KAI_ASM_INST(0xe0bf8468) // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n KAI_ASM_INST(0xe0bc8069) // st1w { za2v.s[x12, #1] }, p0/Z, [x3, x28, LSL #2]\n addvl x3, x3, #2\n bgt label_3\nKAI_ASM_LABEL(label_8) // K loop: Tails\n cbnz x24, label_11\n mov x25, x2\n whilelt p8.b, x26, x1\n mov x13, #0\n mov x12, #0\nKAI_ASM_LABEL(label_9) // K loop: Tails: Even: First\n KAI_ASM_INST(0x25306d21) // psel p1.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0x25356140) // psel p0.b, p8.b/Z, p10.b[w13, #2]\n KAI_ASM_INST(0xe0bf8460) // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n ldr x20, [x25, #0]\n cmp x12, x28\n add x25, x25, #0x8\n KAI_ASM_INST(0xe0152282) // ld1b { za0h.b[x13, #2] }, p0/Z, [x20, x21]\n add x13, x13, #0x4\n blt label_9\n whilelt p9.b, x26, x1\n whilelt p8.b, x26, x1\n mov x20, #0\n mov x12, #0\nKAI_ASM_LABEL(label_10) // K loop: Tails: Even: Second\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n add x20, x20, #0x4\n KAI_ASM_INST(0xe0bf8068) // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n cmp x12, x9\n blt label_10\n whilelt p8.b, x26, x1\n b label_13\nKAI_ASM_LABEL(label_11) // K loop: Tails: Odd\n mov x12, #0\nKAI_ASM_LABEL(label_12) // K loop: Tails: Odd: Loop\n KAI_ASM_INST(0x25306d20) // psel p0.s, p11.s/Z, p9.s[w12]\n KAI_ASM_INST(0xe0bf8060) // st1w { za0v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n add x12, x12, #0x1\n addvl x3, x3, #1\n cmp x12, x9\n blt label_12\nKAI_ASM_LABEL(label_13) // K loop: End\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_matmul_pack_rows_x8p4vsx4_x8_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_pack_cols_x8p4vsx4_x8_sme_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(matmul_pack_cols_x8p4vsx4_x8_sme)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\nKAI_ASM_FUNCTION_LABEL(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x20, [x0, #0x8]\n ptrue p1.b\n ldr x2, [x0, #0]\n ldr x3, [x0, #0x10]\n mov x4, x20\n ldr x5, [x0, #0x18]\n cmp x4, #0x10\n ldr x6, [x0, #0x20]\n ldr x7, [x0, #0x28]\n ldr x8, [x0, #0x30]\n blt label_4\nKAI_ASM_LABEL(label_1) // Main row loop: Head\n mov x17, x6\n mov x16, x7\n add x15, x17, x3\n sub x4, x4, #0x10\n add x14, x15, x3\n mov x13, x2\n add x12, x14, x3\n add x11, x12, x3\n add x10, x11, x3\n add x9, x10, x3\n add x28, x9, x3\n add x27, x28, x3\n add x26, x27, x3\n add x25, x26, x3\n add x24, x25, x3\n add x23, x24, x3\n add x22, x23, x3\n add x21, x22, x3\n add x20, x21, x3\n add x6, x20, x3\nKAI_ASM_LABEL(label_2) // Main row loop: Column loop\n whilelt p0.b, XZR, x13\n decw x13\n ld1b { z20.b }, p0/Z, [x17]\n cmp x13, #0\n incd x17, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x15]\n incd x15, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x14]\n incd x14, ALL, MUL #2\n ld1b { z16.b }, p0/Z, [x12]\n incd x12, ALL, MUL #2\n ld1b { z22.b }, p0/Z, [x11]\n incd x11, ALL, MUL #2\n ld1b { z19.b }, p0/Z, [x10]\n zip1 z21.b, z20.b, z17.b\n incd x10, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x9]\n zip1 z20.b, z18.b, z16.b\n incd x9, ALL, MUL #2\n ld1b { z16.b }, p0/Z, [x28]\n incd x28, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x27]\n incd x27, ALL, MUL #2\n ld1b { z25.b }, p0/Z, [x26]\n zip1 z24.b, z22.b, z17.b\n incd x26, ALL, MUL #2\n ld1b { z17.b }, p0/Z, [x25]\n zip1 z19.b, z19.b, z16.b\n incd x25, ALL, MUL #2\n zip1 z23.b, z21.b, z20.b\n ld1b { z16.b }, p0/Z, [x24]\n incd x24, ALL, MUL #2\n ld1b { z22.b }, p0/Z, [x23]\n incd x23, ALL, MUL #2\n ld1b { z21.b }, p0/Z, [x22]\n zip1 z20.b, z18.b, z17.b\n incd x22, ALL, MUL #2\n ld1b { z18.b }, p0/Z, [x21]\n zip1 z17.b, z25.b, z16.b\n incd x21, ALL, MUL #2\n zip1 z19.b, z24.b, z19.b\n ld1b { z16.b }, p0/Z, [x20]\n incd x20, ALL, MUL #2\n st1b { z23.b }, p1, [x16]\n zip1 z18.b, z22.b, z18.b\n zip1 z16.b, z21.b, z16.b\n zip1 z17.b, z20.b, z17.b\n st1b { z19.b }, p1, [x16, #1, MUL VL]\n zip1 z16.b, z18.b, z16.b\n st1b { z17.b }, p1, [x16, #2, MUL VL]\n st1b { z16.b }, p1, [x16, #3, MUL VL]\n add x16, x16, x5\n bgt label_2\n cmp x4, #0x10\n addvl x7, x7, #4\n bge label_1\n cbz x4, label_8\nKAI_ASM_LABEL(label_4) // Main loop skip\nKAI_ASM_LABEL(label_5) // Tail row loop: Head\n mov x17, x6\n cmp x4, #0x3\n add x15, x17, x3\n cntw x24\n add x14, x15, x3\n csel x23, x24, XZR, GT\n add x12, x14, x3\n csel x22, x24, XZR, GE\n add x6, x12, x3\n mov x16, x7\n csel x6, x6, x12, GT\n csel x12, x12, x8, GT\n csel x6, x6, x14, GE\n csel x14, x14, x8, GE\n cmp x4, #0x1\n sub x4, x4, #0x4\n csel x6, x6, x15, GT\n csel x15, x15, x8, GT\n csel x21, x24, XZR, GT\n mov x20, x2\nKAI_ASM_LABEL(label_6) // Tail row loop: Column loop\n whilelt p0.b, XZR, x20\n decw x20\n ld1b { z19.b }, p0/Z, [x17]\n cmp x20, #0\n add x17, x17, x24\n ld1b { z18.b }, p0/Z, [x15]\n add x15, x15, x21\n ld1b { z17.b }, p0/Z, [x14]\n add x14, x14, x22\n ld1b { z16.b }, p0/Z, [x12]\n add x12, x12, x23\n zip1 z17.b, z19.b, z17.b\n zip1 z16.b, z18.b, z16.b\n zip1 z16.b, z17.b, z16.b\n st1b { z16.b }, p1, [x16]\n add x16, x16, x5\n bgt label_6\n cmp x4, #0x1\n addvl x7, x7, #1\n bge label_5\nKAI_ASM_LABEL(label_8) // Done\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_matmul_pack_cols_x8p4vsx4_x8_sme)\n\n KAI_ASM_END\n" + }, + { + "path": "kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa.c", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else // Architectural features check.\n\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul.h\"\n#include \"kai/ukernels/matmul/kai_matmul_types.h\"\n\nenum {\n DST_ELEM_BYTES = 4,\n LHS_ELEM_BYTES = 1,\n RHS_ELEM_BYTES = 1,\n BIAS_ELEM_BYTES = 4,\n SCALE_ELEM_BYTES = 4,\n\n MR_VSCALE = 4,\n NR_VSCALE = 4,\n M_STEP_VSCALE = 8,\n N_STEP_VSCALE = 8,\n KR = 4,\n\n SUPPORTED_FLAGS = KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP,\n KAI_INTERNAL_FLAGS = 1 << 24,\n};\n\ntypedef struct {\n uint64_t flags;\n size_t m;\n size_t n;\n size_t k;\n const void* lhs_ptr;\n size_t lhs_stride_row;\n const void* rhs_ptr;\n size_t rhs_stride_row;\n void* dst_ptr;\n size_t dst_stride_row;\n void* acc_ptr;\n const void* acc_bias_m_ptr;\n const void* acc_bias_n_ptr;\n const void* dst_bias_n_ptr;\n const void* dst_scale_1_ptr;\n const void* min_ptr;\n const void* max_ptr;\n} kai_matmul_uker_args_internal;\n\nvoid kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa(\n const kai_matmul_uker_args_internal* args);\n\nstatic size_t get_mr(void) {\n return MR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_nr(void) {\n return NR_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_m_step(void) {\n return M_STEP_VSCALE * kai_get_sme_vscale();\n}\n\nstatic size_t get_n_step(void) {\n return N_STEP_VSCALE * kai_get_sme_vscale();\n}\n\nstatic struct kai_matmul_uker_dim_args get_step(const struct kai_matmul_uker_config* config) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_dim_args step = {\n .m = get_m_step(),\n .n = get_n_step(),\n .k = 0,\n };\n\n return step;\n}\n\nstatic struct kai_matmul_uker_lhs_stride_args get_lhs_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_lhs_stride_args stride = {\n .m = get_mr() * kai_roundup(shape->k, KR) * LHS_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_lhs_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_lhs_dim_args* index,\n const struct kai_matmul_uker_lhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->m / get_mr() * stride->m;\n}\n\nstatic struct kai_matmul_uker_rhs_stride_args get_rhs_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_rhs_stride_args stride = {\n .n = get_nr() * (kai_roundup(shape->k, KR) * RHS_ELEM_BYTES),\n };\n return stride;\n}\n\nstatic size_t get_rhs_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_rhs_dim_args* index,\n const struct kai_matmul_uker_rhs_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->n % get_nr() == 0);\n KAI_ASSUME(index->k == 0);\n\n return index->n / get_nr() * stride->n;\n}\n\nstatic struct kai_matmul_uker_dst_stride_args get_dst_stride(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape) {\n KAI_UNUSED(config);\n\n const struct kai_matmul_uker_dst_stride_args stride = {\n .m = shape->n * DST_ELEM_BYTES,\n };\n\n return stride;\n}\n\nstatic size_t get_dst_offset(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* index,\n const struct kai_matmul_uker_dst_stride_args* stride) {\n KAI_UNUSED(config);\n KAI_ASSUME(index->m % get_mr() == 0);\n KAI_ASSUME(index->n % get_nr() == 0);\n\n return index->m * stride->m + index->n * DST_ELEM_BYTES;\n}\n\nstatic size_t get_dst_size(\n const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_dst_dim_args* shape,\n const struct kai_matmul_uker_dst_stride_args* stride) {\n KAI_UNUSED(config);\n\n return shape->m * stride->m;\n}\n\nstatic void run(const struct kai_matmul_uker_config* config, const struct kai_matmul_uker_args* run_args) {\n KAI_UNUSED(config);\n KAI_ASSUME_MSG((run_args->flags & ~((size_t)SUPPORTED_FLAGS)) == 0, \"Only supported flags are accepted!\");\n\n KAI_ASSUME(run_args->operand.lhs.ptr != NULL);\n KAI_ASSUME(run_args->operand.rhs.ptr != NULL);\n KAI_ASSUME(run_args->operand.dst.ptr != NULL);\n\n kai_matmul_uker_args_internal args = {0};\n const float float_max = FLT_MAX;\n const float float_min = -FLT_MAX;\n const bool enable_clamp = (run_args->flags & KAI_MATMUL_UKER_FLAGS_ARGS_CLAMP) != 0;\n\n KAI_ASSUME(run_args->operand.scale.acc_scale_global.ptr != NULL);\n KAI_ASSUME(run_args->operand.bias.scale_bias_n.ptr != NULL);\n KAI_ASSUME(!enable_clamp || run_args->activation.clamp.min_ptr != NULL);\n KAI_ASSUME(!enable_clamp || run_args->activation.clamp.max_ptr != NULL);\n\n args.flags = KAI_INTERNAL_FLAGS;\n\n args.m = run_args->shape.m;\n args.n = run_args->shape.n;\n args.k = run_args->shape.k;\n\n args.lhs_ptr = run_args->operand.lhs.ptr;\n args.lhs_stride_row = run_args->operand.lhs.stride.m;\n\n args.rhs_ptr = run_args->operand.rhs.ptr;\n args.rhs_stride_row = run_args->operand.rhs.stride.n;\n\n args.dst_ptr = run_args->operand.dst.ptr;\n args.dst_stride_row = run_args->operand.dst.stride.m;\n\n args.acc_bias_m_ptr = run_args->operand.bias.acc_bias_m.ptr;\n args.acc_bias_n_ptr = run_args->operand.bias.acc_bias_n.ptr;\n args.dst_bias_n_ptr = run_args->operand.bias.scale_bias_n.ptr;\n args.dst_scale_1_ptr = run_args->operand.scale.acc_scale_global.ptr;\n args.min_ptr = enable_clamp ? run_args->activation.clamp.min_ptr : &float_min;\n args.max_ptr = enable_clamp ? run_args->activation.clamp.max_ptr : &float_max;\n\n kai_commit_za();\n kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa(&args);\n}\n\nstruct kai_matmul_uker_api kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa(void) {\n struct kai_matmul_uker_api api = {\n .run = run,\n .get_step = get_step,\n\n .get_lhs_stride = get_lhs_stride,\n .get_lhs_offset = get_lhs_offset,\n\n .get_rhs_stride = get_rhs_stride,\n .get_rhs_offset = get_rhs_offset,\n\n .get_dst_stride = get_dst_stride,\n .get_dst_offset = get_dst_offset,\n .get_dst_size = get_dst_size,\n };\n\n return api;\n}\n\n#endif // Architectural features check.\n" + }, + { + "path": "kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa_asm.S", + "content": "//\n// SPDX-FileCopyrightText: Copyright 2026 Arm Limited and/or its affiliates \n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER) && !defined(__clang__)\n #define KAI_ASM_GLOBAL(name) GLOBAL name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n #define KAI_ASM_FUNCTION_END(name) ENDP\n\n #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n #define KAI_ASM_ALIGN\n #define KAI_ASM_LABEL(name) name\n #define KAI_ASM_INST(hex) DCD hex\n #define KAI_ASM_END END\n#else\n #if defined(__APPLE__)\n #define KAI_ASM_GLOBAL(name) .globl _##name\n #define KAI_ASM_FUNCTION_TYPE(name)\n #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n #define KAI_ASM_FUNCTION_END(name)\n #else\n #define KAI_ASM_GLOBAL(name) .global name\n #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n #define KAI_ASM_FUNCTION_LABEL(name) name:\n #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n #endif\n\n #define KAI_ASM_CODE(name) .text\n #define KAI_ASM_ALIGN .p2align 4,,11\n #define KAI_ASM_LABEL(name) name:\n #define KAI_ASM_INST(hex) .inst hex\n #define KAI_ASM_END\n#endif\n\n KAI_ASM_CODE(kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa)\n KAI_ASM_ALIGN\n\n KAI_ASM_GLOBAL(kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa)\n stp x20, x21, [sp, -144]!\n stp x22, x23, [sp, 16]\n stp x24, x25, [sp, 32]\n stp x26, x27, [sp, 48]\n str x28, [sp, 64]\n stp d8, d9, [sp, 72]\n stp d10, d11, [sp, 88]\n stp d12, d13, [sp, 104]\n stp d14, d15, [sp, 120]\n KAI_ASM_INST(0xd503477f) // SMSTART ZA\n ldr x5, [x0, #0x18]\n ptrue p0.b\n KAI_ASM_INST(0x25207814) // ptrue pn12.b\n ldr x6, [x0, #0x0]\n cntw x7\n ldr x8, [x0, #0x8]\n add x5, x5, #0x3\n ldr x17, [x0, #0x10]\n ldr x16, [x0, #0x20]\n lsr x5, x5, #0x2\n ldr x15, [x0, #0x28]\n ldr x14, [x0, #0x38]\n ldr x13, [x0, #0x58]\n ldr x11, [x0, #0x60]\n ldr x10, [x0, #0x48]\n tbz x6, #24, label_1\n ldr x22, [x0, #0x70]\n ldr x21, [x0, #0x78]\n ldr x20, [x0, #0x80]\n ldr x9, [x0, #0x68]\n KAI_ASM_INST(0x8540c2d7) // ld1rw { z23.s }, p0/Z, [x22]\n KAI_ASM_INST(0x8540c2b0) // ld1rw { z16.s }, p0/Z, [x21]\n KAI_ASM_INST(0x8540c296) // ld1rw { z22.s }, p0/Z, [x20]\nKAI_ASM_LABEL(label_1) // load_scale: skip\n mov x28, #0x0\nKAI_ASM_LABEL(label_2) // m_loop: body\n ldr x27, [x0, #0x40]\n KAI_ASM_INST(0x25a84790) // whilelt pn8.s, x28, x8, VLx2\n mov x26, #0x0\n KAI_ASM_INST(0xa01c41b4) // ld1w { z20.s-z21.s }, p8/Z, [x13, x28, LSL #2]\n ldr x25, [x0, #0x30]\n madd x27, x28, x10, x27\nKAI_ASM_LABEL(label_3) // m_loop: n_loop: body\n KAI_ASM_INST(0xc00800ff) // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n KAI_ASM_INST(0x25b14753) // whilelt pn11.s, x26, x17, VLx2\n mov x24, x16\n add x20, x28, x7\n KAI_ASM_INST(0xc0910280) // addva za0.s, p0/M, p0/M, z20.s\n KAI_ASM_INST(0xa01a4d62) // ld1w { z2.s-z3.s }, p11/Z, [x11, x26, LSL #2]\n add x23, x24, x15\n KAI_ASM_INST(0xc0910281) // addva za1.s, p0/M, p0/M, z20.s\n cmp x20, x8\n mov x22, x25\n KAI_ASM_INST(0xc09102a2) // addva za2.s, p0/M, p0/M, z21.s\n add x20, x26, x7\n csel x23, x23, x16, LT\n KAI_ASM_INST(0xc09102a3) // addva za3.s, p0/M, p0/M, z21.s\n cmp x20, x17\n add x21, x22, x14\n mov x20, x5\n csel x21, x21, x25, LT\n KAI_ASM_INST(0xc0900040) // addha za0.s, p0/M, p0/M, z2.s\n cmp x20, #0x4\n KAI_ASM_INST(0xc0900061) // addha za1.s, p0/M, p0/M, z3.s\n KAI_ASM_INST(0xc0900042) // addha za2.s, p0/M, p0/M, z2.s\n KAI_ASM_INST(0xc0900063) // addha za3.s, p0/M, p0/M, z3.s\n blt label_6\n sub x20, x20, #0x4\n KAI_ASM_INST(0xa040930c) // ld1b { z12.b-z15.b }, pn12.b/Z, [x24]\n addvl x24, x24, #4\n cmp x20, #0x4\n KAI_ASM_INST(0xa04092e8) // ld1b { z8.b-z11.b }, pn12.b/Z, [x23]\n addvl x23, x23, #4\n KAI_ASM_INST(0xa04092dc) // ld1b { z28.b-z31.b }, pn12.b/Z, [x22]\n addvl x22, x22, #4\n KAI_ASM_INST(0xa04092b8) // ld1b { z24.b-z27.b }, pn12.b/Z, [x21]\n addvl x21, x21, #4\n blt label_5\nKAI_ASM_LABEL(label_4) // m_loop: n_loop: k_loop_x4: body\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n sub x20, x20, #0x4\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n cmp x20, #0x4\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n KAI_ASM_INST(0xa1bd01a0) // umopa za0.s, p0/M, p0/M, z13.b, z29.b\n KAI_ASM_INST(0xa1b901a1) // umopa za1.s, p0/M, p0/M, z13.b, z25.b\n KAI_ASM_INST(0xa040130c) // ld1b { z12.b-z13.b }, pn12.b/Z, [x24]\n addvl x24, x24, #2\n KAI_ASM_INST(0xa1bd0122) // umopa za2.s, p0/M, p0/M, z9.b, z29.b\n KAI_ASM_INST(0xa04012dc) // ld1b { z28.b-z29.b }, pn12.b/Z, [x22]\n addvl x22, x22, #2\n KAI_ASM_INST(0xa1b90123) // umopa za3.s, p0/M, p0/M, z9.b, z25.b\n KAI_ASM_INST(0xa04012e8) // ld1b { z8.b-z9.b }, pn12.b/Z, [x23]\n addvl x23, x23, #2\n KAI_ASM_INST(0xa1be01c0) // umopa za0.s, p0/M, p0/M, z14.b, z30.b\n KAI_ASM_INST(0xa04012b8) // ld1b { z24.b-z25.b }, pn12.b/Z, [x21]\n addvl x21, x21, #2\n KAI_ASM_INST(0xa1ba01c1) // umopa za1.s, p0/M, p0/M, z14.b, z26.b\n KAI_ASM_INST(0xa1be0142) // umopa za2.s, p0/M, p0/M, z10.b, z30.b\n KAI_ASM_INST(0xa1ba0143) // umopa za3.s, p0/M, p0/M, z10.b, z26.b\n KAI_ASM_INST(0xa1bf01e0) // umopa za0.s, p0/M, p0/M, z15.b, z31.b\n KAI_ASM_INST(0xa1bb01e1) // umopa za1.s, p0/M, p0/M, z15.b, z27.b\n KAI_ASM_INST(0xa040130e) // ld1b { z14.b-z15.b }, pn12.b/Z, [x24]\n addvl x24, x24, #2\n KAI_ASM_INST(0xa1bf0162) // umopa za2.s, p0/M, p0/M, z11.b, z31.b\n KAI_ASM_INST(0xa04012de) // ld1b { z30.b-z31.b }, pn12.b/Z, [x22]\n addvl x22, x22, #2\n KAI_ASM_INST(0xa1bb0163) // umopa za3.s, p0/M, p0/M, z11.b, z27.b\n KAI_ASM_INST(0xa04012ea) // ld1b { z10.b-z11.b }, pn12.b/Z, [x23]\n addvl x23, x23, #2\n KAI_ASM_INST(0xa04012ba) // ld1b { z26.b-z27.b }, pn12.b/Z, [x21]\n addvl x21, x21, #2\n bge label_4\nKAI_ASM_LABEL(label_5) // m_loop: n_loop: k_loop_x4: tail\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n KAI_ASM_INST(0xa1bd01a0) // umopa za0.s, p0/M, p0/M, z13.b, z29.b\n KAI_ASM_INST(0xa1b901a1) // umopa za1.s, p0/M, p0/M, z13.b, z25.b\n KAI_ASM_INST(0xa1bd0122) // umopa za2.s, p0/M, p0/M, z9.b, z29.b\n KAI_ASM_INST(0xa1b90123) // umopa za3.s, p0/M, p0/M, z9.b, z25.b\n KAI_ASM_INST(0xa1be01c0) // umopa za0.s, p0/M, p0/M, z14.b, z30.b\n KAI_ASM_INST(0xa1ba01c1) // umopa za1.s, p0/M, p0/M, z14.b, z26.b\n KAI_ASM_INST(0xa1be0142) // umopa za2.s, p0/M, p0/M, z10.b, z30.b\n KAI_ASM_INST(0xa1ba0143) // umopa za3.s, p0/M, p0/M, z10.b, z26.b\n KAI_ASM_INST(0xa1bf01e0) // umopa za0.s, p0/M, p0/M, z15.b, z31.b\n KAI_ASM_INST(0xa1bb01e1) // umopa za1.s, p0/M, p0/M, z15.b, z27.b\n KAI_ASM_INST(0xa1bf0162) // umopa za2.s, p0/M, p0/M, z11.b, z31.b\n KAI_ASM_INST(0xa1bb0163) // umopa za3.s, p0/M, p0/M, z11.b, z27.b\nKAI_ASM_LABEL(label_6) // m_loop: n_loop: k_loop_x4: done\n cbz x20, label_9\n sub x20, x20, #0x1\n ld1b { z12.b }, p0/Z, [x24]\n addvl x24, x24, #1\n ld1b { z8.b }, p0/Z, [x23]\n addvl x23, x23, #1\n ld1b { z28.b }, p0/Z, [x22]\n addvl x22, x22, #1\n ld1b { z24.b }, p0/Z, [x21]\n addvl x21, x21, #1\n cbz x20, label_8\nKAI_ASM_LABEL(label_7) // m_loop: n_loop: k_loop_x1: body\n sub x20, x20, #0x1\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n ld1b { z12.b }, p0/Z, [x24]\n addvl x24, x24, #1\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n ld1b { z28.b }, p0/Z, [x22]\n addvl x22, x22, #1\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\n ld1b { z8.b }, p0/Z, [x23]\n addvl x23, x23, #1\n ld1b { z24.b }, p0/Z, [x21]\n addvl x21, x21, #1\n cbnz x20, label_7\nKAI_ASM_LABEL(label_8) // m_loop: n_loop: k_loop_x1: tail\n KAI_ASM_INST(0xa1bc0180) // umopa za0.s, p0/M, p0/M, z12.b, z28.b\n KAI_ASM_INST(0xa1b80181) // umopa za1.s, p0/M, p0/M, z12.b, z24.b\n KAI_ASM_INST(0xa1bc0102) // umopa za2.s, p0/M, p0/M, z8.b, z28.b\n KAI_ASM_INST(0xa1b80103) // umopa za3.s, p0/M, p0/M, z8.b, z24.b\nKAI_ASM_LABEL(label_9) // m_loop: n_loop: k_loop_x1: done\n tbz x6, #24, label_11\n add x20, x28, x7\n add x21, x27, x26, LSL #2\n KAI_ASM_INST(0xa01a4d32) // ld1w { z18.s-z19.s }, p11/Z, [x9, x26, LSL #2]\n mov x12, #0x0\n whilelt p10.s, x28, x8\n whilelt p9.s, x20, x8\n madd x20, x7, x10, x21\nKAI_ASM_LABEL(label_10) // m_loop: n_loop: post_process_to_float: post_process_loop: body\n KAI_ASM_INST(0xc086040c) // mova { z12.s-z15.s }, za0h.s[x12]\n KAI_ASM_INST(0xc0860438) // mova { z24.s-z27.s }, za1h.s[x12]\n KAI_ASM_INST(0xc132e180) // scvtf { z0.s-z3.s }, { z12.s-z15.s }\n KAI_ASM_INST(0xc132e308) // scvtf { z8.s-z11.s }, { z24.s-z27.s }\n fmad z0.s, p0/M, z23.s, z18.s\n fmad z1.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0x25306d48) // psel p8.s, p11.s/Z, p10.s[w12]\n KAI_ASM_INST(0xc0860444) // mova { z4.s-z7.s }, za2h.s[x12]\n fmad z2.s, p0/M, z23.s, z18.s\n fmad z3.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0xc086047c) // mova { z28.s-z31.s }, za3h.s[x12]\n KAI_ASM_INST(0xc132e084) // scvtf { z4.s-z7.s }, { z4.s-z7.s }\n fmad z8.s, p0/M, z23.s, z19.s\n fmad z9.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc132e38c) // scvtf { z12.s-z15.s }, { z28.s-z31.s }\n fmad z10.s, p0/M, z23.s, z19.s\n fmad z11.s, p0/M, z23.s, z19.s\n fmad z4.s, p0/M, z23.s, z18.s\n fmad z5.s, p0/M, z23.s, z18.s\n KAI_ASM_INST(0xc1b6ca00) // fclamp { z0.s-z3.s }, z16.s, z22.s\n fmad z6.s, p0/M, z23.s, z18.s\n fmad z7.s, p0/M, z23.s, z18.s\n fmad z12.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc1b6ca08) // fclamp { z8.s-z11.s }, z16.s, z22.s\n fmad z13.s, p0/M, z23.s, z19.s\n fmad z14.s, p0/M, z23.s, z19.s\n fmad z15.s, p0/M, z23.s, z19.s\n KAI_ASM_INST(0xc1b6ca04) // fclamp { z4.s-z7.s }, z16.s, z22.s\n KAI_ASM_INST(0xa16042a0) // st1w { z0.s, z8.s }, p8, [x21]\n KAI_ASM_INST(0x25706d48) // psel p8.s, p11.s/Z, p10.s[w12, #1]\n add x21, x21, x10\n KAI_ASM_INST(0xc1b6ca0c) // fclamp { z12.s-z15.s }, z16.s, z22.s\n KAI_ASM_INST(0xa16042a1) // st1w { z1.s, z9.s }, p8, [x21]\n KAI_ASM_INST(0x25b06d48) // psel p8.s, p11.s/Z, p10.s[w12, #2]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a2) // st1w { z2.s, z10.s }, p8, [x21]\n KAI_ASM_INST(0x25f06d48) // psel p8.s, p11.s/Z, p10.s[w12, #3]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a3) // st1w { z3.s, z11.s }, p8, [x21]\n KAI_ASM_INST(0x25306d28) // psel p8.s, p11.s/Z, p9.s[w12]\n add x21, x21, x10\n KAI_ASM_INST(0xa1604284) // st1w { z4.s, z12.s }, p8, [x20]\n KAI_ASM_INST(0x25706d28) // psel p8.s, p11.s/Z, p9.s[w12, #1]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604285) // st1w { z5.s, z13.s }, p8, [x20]\n KAI_ASM_INST(0x25b06d28) // psel p8.s, p11.s/Z, p9.s[w12, #2]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604286) // st1w { z6.s, z14.s }, p8, [x20]\n KAI_ASM_INST(0x25f06d28) // psel p8.s, p11.s/Z, p9.s[w12, #3]\n add x12, x12, #0x4\n add x20, x20, x10\n cmp x12, x7\n KAI_ASM_INST(0xa1604287) // st1w { z7.s, z15.s }, p8, [x20]\n add x20, x20, x10\n blt label_10\n b label_13\nKAI_ASM_LABEL(label_11) // m_loop: n_loop: post_process_to_float: skip\n add x20, x28, x7\n add x21, x27, x26, LSL #2\n mov x12, #0x0\n whilelt p10.s, x28, x8\n whilelt p9.s, x20, x8\n madd x20, x7, x10, x21\nKAI_ASM_LABEL(label_12) // m_loop: n_loop: post_process_to_int: post_process_loop: body\n KAI_ASM_INST(0x25306d48) // psel p8.s, p11.s/Z, p10.s[w12]\n KAI_ASM_INST(0xc0860404) // mova { z4.s-z7.s }, za0h.s[x12]\n KAI_ASM_INST(0xc086042c) // mova { z12.s-z15.s }, za1h.s[x12]\n KAI_ASM_INST(0xc0860440) // mova { z0.s-z3.s }, za2h.s[x12]\n KAI_ASM_INST(0xc0860468) // mova { z8.s-z11.s }, za3h.s[x12]\n KAI_ASM_INST(0xa16042a4) // st1w { z4.s, z12.s }, p8, [x21]\n KAI_ASM_INST(0x25706d48) // psel p8.s, p11.s/Z, p10.s[w12, #1]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a5) // st1w { z5.s, z13.s }, p8, [x21]\n KAI_ASM_INST(0x25b06d48) // psel p8.s, p11.s/Z, p10.s[w12, #2]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a6) // st1w { z6.s, z14.s }, p8, [x21]\n KAI_ASM_INST(0x25f06d48) // psel p8.s, p11.s/Z, p10.s[w12, #3]\n add x21, x21, x10\n KAI_ASM_INST(0xa16042a7) // st1w { z7.s, z15.s }, p8, [x21]\n KAI_ASM_INST(0x25306d28) // psel p8.s, p11.s/Z, p9.s[w12]\n add x21, x21, x10\n KAI_ASM_INST(0xa1604280) // st1w { z0.s, z8.s }, p8, [x20]\n KAI_ASM_INST(0x25706d28) // psel p8.s, p11.s/Z, p9.s[w12, #1]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604281) // st1w { z1.s, z9.s }, p8, [x20]\n KAI_ASM_INST(0x25b06d28) // psel p8.s, p11.s/Z, p9.s[w12, #2]\n add x20, x20, x10\n KAI_ASM_INST(0xa1604282) // st1w { z2.s, z10.s }, p8, [x20]\n KAI_ASM_INST(0x25f06d28) // psel p8.s, p11.s/Z, p9.s[w12, #3]\n add x12, x12, #0x4\n add x20, x20, x10\n cmp x12, x7\n KAI_ASM_INST(0xa1604283) // st1w { z3.s, z11.s }, p8, [x20]\n add x20, x20, x10\n blt label_12\nKAI_ASM_LABEL(label_13) // m_loop: n_loop: post_process_done\n incw x26, ALL, MUL #2\n add x25, x25, x14, LSL #1\n cmp x26, x17\n blt label_3\n incw x28, ALL, MUL #2\n add x16, x16, x15\n cmp x28, x8\n add x16, x16, x15\n blt label_2\n KAI_ASM_INST(0xd503467f) // SMSTOP\n ldp x22, x23, [sp, 16]\n ldp x24, x25, [sp, 32]\n ldp x26, x27, [sp, 48]\n ldr x28, [sp, 64]\n ldp d8, d9, [sp, 72]\n ldp d10, d11, [sp, 88]\n ldp d12, d13, [sp, 104]\n ldp d14, d15, [sp, 120]\n ldp x20, x21, [sp], 144\n ret\n KAI_ASM_FUNCTION_END(kai_kernel_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa)\n\n KAI_ASM_END\n" + }, + { + "path": "binding.cpp", + "content": "// Binding for Arm KleidiAI kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa (new-style\n// kai_matmul_uker API) against gemm_i32_u8_sme2_n256_k512's raw ABI:\n// armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, const float* C_scale, const float* bias, int M)\n// C[m,n] = float(sum_k A[m,k] * B[n,k]) * C_scale[0] + bias[n]; scale and bias are applied inside the kernel.\n#include \n#include \n#include \n#include \n\n#include \"kai/kai_common.h\"\n#include \"kai/ukernels/matmul/kai_matmul.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_lhs.h\"\n#include \"kai/ukernels/matmul/kai_matmul_pack_rhs.h\"\n\nnamespace {\nconstexpr int N = 256;\nconstexpr int K = 512;\n\n// True if `data` differs from the cached snapshot (content-based, not pointer-based: a later\n// workload's buffer can reuse a freed buffer's address; see issue #80), updating the snapshot.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n const bool stale = snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n if (stale) {\n if (snapshot_size != size) {\n std::free(snapshot);\n snapshot = static_cast(std::malloc(size));\n snapshot_size = size;\n }\n std::memcpy(snapshot, data, size);\n }\n return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, const float* C_scale, const float* bias, int M)\n{\n const kai_matmul_uker_api mm = kai_matmul_clamp_f32_u8p4vsx4_u8p4vsx4_i32_i32_f32_f32_8vsx8vs_sme2_mopa();\n const kai_matmul_pack_lhs_uker_api pl = kai_matmul_pack_lhs_mxk_x8p4vsx4_x8_sme();\n const kai_matmul_pack_rhs_uker_api pr = kai_matmul_pack_rhs_nxk_x8p4vsx4_x8_sme();\n const kai_matmul_uker_config mm_cfg{};\n const kai_matmul_pack_lhs_uker_config pl_cfg{};\n const kai_matmul_pack_rhs_uker_config pr_cfg{};\n\n // LHS: packed on EVERY call into a grow-only scratch buffer (activation-side work).\n static void* lhs_packed = nullptr;\n static size_t lhs_cap = 0;\n const kai_matmul_pack_lhs_uker_lhs_dim_args lhs_dim{(size_t)M, (size_t)K};\n const kai_matmul_pack_lhs_uker_lhs_stride_args lhs_stride = pl.get_lhs_stride(&pl_cfg, &lhs_dim);\n const kai_matmul_pack_lhs_uker_lhs_packed_dim_args lhs_pdim{(size_t)M, (size_t)K};\n const kai_matmul_pack_lhs_uker_lhs_packed_stride_args lhs_pstride = pl.get_lhs_packed_stride(&pl_cfg, &lhs_pdim);\n {\n const size_t sz = pl.get_lhs_packed_size(&pl_cfg, &lhs_pdim, &lhs_pstride);\n if (sz > lhs_cap) {\n std::free(lhs_packed);\n lhs_packed = std::malloc(sz);\n lhs_cap = sz;\n if (lhs_packed == nullptr) return -1;\n }\n kai_matmul_pack_lhs_uker_args a{};\n a.shape = {(size_t)M, (size_t)K};\n a.operand.lhs.ptr = A;\n a.operand.lhs.stride = lhs_stride;\n a.operand.lhs_packed.ptr = lhs_packed;\n a.operand.lhs_packed.stride = lhs_pstride;\n pl.run(&pl_cfg, &a);\n }\n\n // RHS: weight pack, cached while B is unchanged.\n static uint8_t* B_snap = nullptr;\n static size_t B_snap_size = 0;\n static void* rhs_packed = nullptr;\n const kai_matmul_pack_rhs_uker_rhs_dim_args rhs_dim{(size_t)N, (size_t)K};\n const kai_matmul_pack_rhs_uker_rhs_stride_args rhs_stride = pr.get_rhs_stride(&pr_cfg, &rhs_dim);\n const kai_matmul_pack_rhs_uker_rhs_packed_dim_args rhs_pdim{(size_t)N, (size_t)K};\n const kai_matmul_pack_rhs_uker_rhs_packed_stride_args rhs_pstride = pr.get_rhs_packed_stride(&pr_cfg, &rhs_pdim);\n if (refresh_cache(B_snap, B_snap_size, B, (size_t)N * K)) {\n std::free(rhs_packed);\n const size_t sz = pr.get_rhs_packed_size(&pr_cfg, &rhs_pdim, &rhs_pstride);\n rhs_packed = std::malloc(sz);\n if (rhs_packed == nullptr) return -1;\n kai_matmul_pack_rhs_uker_args a{};\n a.shape = {(size_t)N, (size_t)K};\n a.operand.rhs.ptr = B;\n a.operand.rhs.stride = rhs_stride;\n a.operand.rhs_packed.ptr = rhs_packed;\n a.operand.rhs_packed.stride = rhs_pstride;\n pr.run(&pr_cfg, &a);\n }\n\n const kai_matmul_uker_dst_dim_args dst_dim{(size_t)M, (size_t)N};\n const kai_matmul_uker_dst_stride_args dst_stride = mm.get_dst_stride(&mm_cfg, &dst_dim);\n const kai_matmul_uker_lhs_dim_args mm_lhs_dim{(size_t)M, (size_t)K};\n const kai_matmul_uker_rhs_dim_args mm_rhs_dim{(size_t)N, (size_t)K};\n // The kernel reads the accumulation-bias pointers (per M and per N) unconditionally, so a\n // \"no bias\" call still has to pass zero-filled int32 arrays.\n static int32_t* zero_m = nullptr;\n static size_t zero_m_cap = 0;\n static int32_t* zero_n = nullptr;\n if ((size_t)M > zero_m_cap) {\n std::free(zero_m);\n zero_m = static_cast(std::calloc((size_t)M, sizeof(int32_t)));\n zero_m_cap = (size_t)M;\n if (zero_m == nullptr) return -1;\n }\n if (zero_n == nullptr) {\n zero_n = static_cast(std::calloc((size_t)N, sizeof(int32_t)));\n if (zero_n == nullptr) return -1;\n }\n kai_matmul_uker_args args{};\n args.flags = 0;\n args.operand.bias.acc_bias_m.ptr = zero_m;\n args.operand.bias.acc_bias_n.ptr = zero_n;\n args.operand.bias.scale_bias_n.ptr = bias;\n args.operand.scale.acc_scale_global.ptr = C_scale;\n args.shape = {(size_t)M, (size_t)N, (size_t)K};\n args.operand.lhs.ptr = lhs_packed;\n args.operand.lhs.stride = mm.get_lhs_stride(&mm_cfg, &mm_lhs_dim);\n args.operand.rhs.ptr = rhs_packed;\n args.operand.rhs.stride = mm.get_rhs_stride(&mm_cfg, &mm_rhs_dim);\n args.operand.dst.ptr = output;\n args.operand.dst.stride = dst_stride;\n mm.run(&mm_cfg, &args);\n\n return 0;\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json b/solutions/kleidiai/reference-scalar/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json new file mode 100644 index 0000000000000000000000000000000000000000..12494b6036ab2612da1e3fef49909836839d3530 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", + "definition": "conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer 'same' conv2d (NHWC/HWIO) for conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64. Constexpr-baked dims; armbench_entry_conv2d calls inner_conv2d. Ground-truth correctness baseline / nanobot starting point.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "conv2d.cpp::armbench_entry_conv2d", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "conv2d.h", + "content": "#pragma once\n\n// Per-definition constants for conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.\n// NHWC input / HWIO weight (channels-last) \u2014 'same' conv; N, H, W are runtime dims.\nnamespace conv2d_def {\nconstexpr int C_in = 32;\nconstexpr int C_out = 64;\nconstexpr int Kh = 3;\nconstexpr int Kw = 3;\nconstexpr int pad = 1;\n} // namespace conv2d_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// N, H, W are the var dims. input: (N, H, W, C_in); weight: (Kh, Kw, C_in, C_out); output: (N, H, W, C_out).\nvoid inner_conv2d(const float* input, float* output, const float* weight, int N, int H, int W);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "conv2d.cpp", + "content": "// Binding harness: forwards straight to inner_conv2d (no derived dims needed).\n// ABI: armbench_entry_conv2d(input*, output*, weight*, N, H, W)\n#include \"conv2d.h\"\nusing namespace conv2d_def;\n\nextern \"C\" int armbench_entry_conv2d(const float* input, float* output, const float* weight, int N, int H, int W)\n{\n inner_conv2d(input, output, weight, N, H, W);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar conv2d ('same', NHWC/HWIO).\n// LLM target: replace this file with an optimised inner_conv2d.\n// All per-definition constants live in conv2d_def:: (conv2d.h).\n#include \"conv2d.h\"\nusing namespace conv2d_def;\n\nextern \"C\" void inner_conv2d(const float* input, float* output, const float* weight, int N, int H, int W)\n{\n for (int n = 0; n < N; ++n) {\n const float* in_img = input + (long)n * H * W * C_in;\n float* out_img = output + (long)n * H * W * C_out;\n for (int oh = 0; oh < H; ++oh) {\n for (int ow = 0; ow < W; ++ow) {\n float* out_px = out_img + ((long)oh * W + ow) * C_out;\n for (int oc = 0; oc < C_out; ++oc) out_px[oc] = 0.0f;\n for (int kh = 0; kh < Kh; ++kh) {\n int ih = oh - pad + kh;\n if (ih < 0 || ih >= H) continue;\n for (int kw = 0; kw < Kw; ++kw) {\n int iw = ow - pad + kw;\n if (iw < 0 || iw >= W) continue;\n const float* in_px = in_img + ((long)ih * W + iw) * C_in;\n const float* w_row = weight + (((long)kh * Kw + kw) * C_in) * C_out;\n for (int ic = 0; ic < C_in; ++ic) {\n float a = in_px[ic];\n const float* w_ic = w_row + (long)ic * C_out;\n for (int oc = 0; oc < C_out; ++oc) {\n out_px[oc] += a * w_ic[oc];\n }\n }\n }\n }\n }\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qai4c32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..fcd641a4cef80f8d557f43c971a4eeb3e5888a56 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qai4c32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_f16_qai4c32_sme2_n256_k512", + "definition": "gemm_f16_qai4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_f16_qai4c32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_f16_qai4c32_sme2_n256_k512.\n// A f16 bit patterns, B as gemm_qai4c32_sme2, bias f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\nconstexpr int K_blocks = 16;\n} // namespace gemm_def\n\n// IEEE half -> float, bit-level so it needs no fp16 compiler support.\nstatic inline float f16_to_f32(uint16_t h) {\n const uint32_t sign = (uint32_t)(h & 0x8000u) << 16;\n uint32_t exp = (h >> 10) & 0x1Fu, man = h & 0x3FFu, bits;\n if (exp == 0) {\n if (man == 0) bits = sign;\n else { exp = 127 - 15 + 1; while (!(man & 0x400u)) { man <<= 1; --exp; } man &= 0x3FFu; bits = sign | (exp << 23) | (man << 13); }\n } else if (exp == 31) bits = sign | 0x7F800000u | (man << 13);\n else bits = sign | ((exp + 112) << 23) | (man << 13);\n union { uint32_t u; float f; } c; c.u = bits; return c.f;\n}\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, B_zeros, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_f16_qai4c32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint16_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n float sum = bias[n];\n for (int blk = 0; blk < K_blocks; ++blk) {\n const float scale = B_scales[(long)n * K_blocks + blk];\n const float zero = B_zeros[(long)n * K_blocks + blk];\n for (int j = blk * 16; j < blk * 16 + 16; ++j) {\n const uint8_t byte = b[j];\n sum += f16_to_f32(a_row[2 * j]) * (((float)(byte & 0x0F) - 8.0f) * scale + zero);\n sum += f16_to_f32(a_row[2 * j + 1]) * (((float)(byte >> 4) - 8.0f) * scale + zero);\n }\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs4cx_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs4cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..1acc25a15099ed397e28bdbfa70854cf9e1ecc43 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs4cx_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_f16_qs4cx_sme2_n256_k512", + "definition": "gemm_f16_qs4cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_f16_qs4cx_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_f16_qs4cx_sme2_n256_k512.\n// A f16 bit patterns, B_q4[N,K_half] adjacent-pair nibbles zero_point 8, B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\n} // namespace gemm_def\n\n// IEEE half -> float, bit-level so it needs no fp16 compiler support.\nstatic inline float f16_to_f32(uint16_t h) {\n const uint32_t sign = (uint32_t)(h & 0x8000u) << 16;\n uint32_t exp = (h >> 10) & 0x1Fu, man = h & 0x3FFu, bits;\n if (exp == 0) {\n if (man == 0) bits = sign;\n else { exp = 127 - 15 + 1; while (!(man & 0x400u)) { man <<= 1; --exp; } man &= 0x3FFu; bits = sign | (exp << 23) | (man << 13); }\n } else if (exp == 31) bits = sign | 0x7F800000u | (man << 13);\n else bits = sign | ((exp + 112) << 23) | (man << 13);\n union { uint32_t u; float f; } c; c.u = bits; return c.f;\n}\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_f16_qs4cx_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint16_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int j = 0; j < K_half; ++j) {\n const uint8_t byte = b[j];\n sum += f16_to_f32(a_row[2 * j]) * ((float)((int)(byte & 0x0F) - 8) * scale);\n sum += f16_to_f32(a_row[2 * j + 1]) * ((float)((int)(byte >> 4) - 8) * scale);\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs8cx_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..ea166bc6f608e5626360fa765c671724de79e64e --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_f16_qs8cx_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_f16_qs8cx_sme2_n256_k512", + "definition": "gemm_f16_qs8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_f16_qs8cx_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_f16_qs8cx_sme2_n256_k512.\n// A f16 bit patterns, B_q8[N,K] int8, B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n// IEEE half -> float, bit-level so it needs no fp16 compiler support.\nstatic inline float f16_to_f32(uint16_t h) {\n const uint32_t sign = (uint32_t)(h & 0x8000u) << 16;\n uint32_t exp = (h >> 10) & 0x1Fu, man = h & 0x3FFu, bits;\n if (exp == 0) {\n if (man == 0) bits = sign;\n else { exp = 127 - 15 + 1; while (!(man & 0x400u)) { man <<= 1; --exp; } man &= 0x3FFu; bits = sign | (exp << 23) | (man << 13); }\n } else if (exp == 31) bits = sign | 0x7F800000u | (man << 13);\n else bits = sign | ((exp + 112) << 23) | (man << 13);\n union { uint32_t u; float f; } c; c.u = bits; return c.f;\n}\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint16_t* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q8, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_f16_qs8cx_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint16_t* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint16_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const int8_t* b = B_q8 + (long)n * K;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int k = 0; k < K; ++k) sum += f16_to_f32(a_row[k]) * ((float)b[k] * scale);\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..0d530c79765ed8196f29af39faa6a6e8e45917dd --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_f16act_qs4c32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_f16act_qs4c32_sme2_n256_k512", + "definition": "gemm_f16act_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_f16act_qs4c32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_f16act_qs4c32_sme2_n256_k512.\n// A f16 bit patterns, B_q4 as gemm_qs4c32_sme2, B_scales f16 bit patterns.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\nconstexpr int K_blocks = 16;\n} // namespace gemm_def\n\n// IEEE half -> float, bit-level so it needs no fp16 compiler support.\nstatic inline float f16_to_f32(uint16_t h) {\n const uint32_t sign = (uint32_t)(h & 0x8000u) << 16;\n uint32_t exp = (h >> 10) & 0x1Fu, man = h & 0x3FFu, bits;\n if (exp == 0) {\n if (man == 0) bits = sign;\n else { exp = 127 - 15 + 1; while (!(man & 0x400u)) { man <<= 1; --exp; } man &= 0x3FFu; bits = sign | (exp << 23) | (man << 13); }\n } else if (exp == 31) bits = sign | 0x7F800000u | (man << 13);\n else bits = sign | ((exp + 112) << 23) | (man << 13);\n union { uint32_t u; float f; } c; c.u = bits; return c.f;\n}\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_f16act_qs4c32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint16_t* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint16_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n float sum = 0.0f;\n for (int blk = 0; blk < K_blocks; ++blk) {\n const float scale = f16_to_f32(B_scales[(long)n * K_blocks + blk]);\n for (int i = 0; i < 16; ++i) {\n const uint8_t byte = b[blk * 16 + i];\n sum += f16_to_f32(a_row[blk * 32 + i]) * ((float)((int)(byte & 0x0F) - 8) * scale);\n sum += f16_to_f32(a_row[blk * 32 + 16 + i]) * ((float)((int)(byte >> 4) - 8) * scale);\n }\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_f32_bf16_n512_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_f32_bf16_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..50dcd06ad654d5462faf593b94a54fe225c8f6ba --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_f32_bf16_n512_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_f32_bf16_n512_k512", + "definition": "gemm_f32_bf16_n512_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_f32_bf16_n512_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_f32_bf16_n512_k512.\n// A[M,K] f32, B[K,N] f32 (kxn), bias[N] f32; plain f32 compute (the baseline truncates to bf16 internally).\nnamespace gemm_def {\nconstexpr int N = 512;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const float* B, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n inner_gemm(A, output, B, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_f32_bf16_n512_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n const float* a_row = A + (long)m * K;\n float* out_row = output + (long)m * N;\n for (int n = 0; n < N; ++n) out_row[n] = bias[n];\n for (int k = 0; k < K; ++k) {\n const float a = a_row[k];\n const float* b_row = B + (long)k * N;\n for (int n = 0; n < N; ++n) out_row[n] += a * b_row[n];\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_i32_u8_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_i32_u8_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..6c2e364717aec23562ffd3d374cd520c21328c1f --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_i32_u8_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_i32_u8_sme2_n256_k512", + "definition": "gemm_i32_u8_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_i32_u8_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_i32_u8_sme2_n256_k512.\n// A[M,K] uint8, B[N,K] uint8; exact int32 accumulation, converted to float32 at the end.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint8_t* A, float* output, const uint8_t* B, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, int M)\n{\n inner_gemm(A, output, B, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_i32_u8_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint8_t* A, float* output, const uint8_t* B, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint8_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B + (long)n * K;\n int64_t sum = 0;\n for (int k = 0; k < K; ++k) sum += (int64_t)a_row[k] * (int64_t)b[k];\n out_row[n] = (float)(int32_t)sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..2c65a8d6e0a08ced8decf4b759d2778b5af71e29 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qai4c32_n256_k512", + "definition": "gemm_qai4c32_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qai4c32_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qai4c32_n256_k512.\n// A[M,K] f32, B_q4[N,K_half] uint8 (adjacent-pair nibbles, block length 32), B_scales/B_zeros[N,K_blocks] f32, value=(nibble-8)*scale+zero, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\nconstexpr int K_blocks = 16;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, B_zeros, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qai4c32_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n const float* a_row = A + (long)m * K;\n float* out_row = output + (long)m * N;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n float sum = bias[n];\n for (int blk = 0; blk < K_blocks; ++blk) {\n const float scale = B_scales[(long)n * K_blocks + blk];\n const float zero = B_zeros[(long)n * K_blocks + blk];\n for (int j = blk * 16; j < blk * 16 + 16; ++j) {\n const uint8_t byte = b[j];\n sum += a_row[2 * j] * (((float)(byte & 0x0F) - 8.0f) * scale + zero);\n sum += a_row[2 * j + 1] * (((float)(byte >> 4) - 8.0f) * scale + zero);\n }\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..e527a3a02d91097d6cd968884714c3ce36533b56 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qai4c32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qai4c32_sme2_n256_k512", + "definition": "gemm_qai4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qai4c32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qai4c32_sme2_n256_k512.\n// A f32, B_q4[N,K_half] uint8 adjacent-pair nibbles, B_scales/B_zeros[N,K_blocks] f32, value=(nibble-8)*scale+zero, bias f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\nconstexpr int K_blocks = 16;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, B_zeros, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qai4c32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* B_zeros, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const float* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n float sum = bias[n];\n for (int blk = 0; blk < K_blocks; ++blk) {\n const float scale = B_scales[(long)n * K_blocks + blk];\n const float zero = B_zeros[(long)n * K_blocks + blk];\n for (int j = blk * 16; j < blk * 16 + 16; ++j) {\n const uint8_t byte = b[j];\n sum += a_row[2 * j] * (((float)(byte & 0x0F) - 8.0f) * scale + zero);\n sum += a_row[2 * j + 1] * (((float)(byte >> 4) - 8.0f) * scale + zero);\n }\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..fed5197ed916e96261d16d1e5800a7efebc2ce2c --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qai8_qsi8cx_sme2_n256_k512", + "definition": "gemm_qai8_qsi8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qai8_qsi8cx_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qai8_qsi8cx_sme2_n256_k512.\n// A[M,K] int8 (scale A_scale[0], zero point 0), B_q8[N,K] int8 (per-channel B_scales), fp32 bias, output\n// scale C_scale[0] (zero point 0). int8 result is returned as float32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const int8_t* A, float* output, const float* A_scale, const int8_t* B_q8, const float* B_scales, const float* bias, const float* C_scale, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const float* A_scale, const int8_t* B_q8, const float* B_scales, const float* bias, const float* C_scale, int M)\n{\n inner_gemm(A, output, A_scale, B_q8, B_scales, bias, C_scale, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qai8_qsi8cx_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const float* A_scale, const int8_t* B_q8, const float* B_scales, const float* bias, const float* C_scale, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const int8_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const int8_t* b = B_q8 + (long)n * K;\n int32_t acc = 0;\n for (int k = 0; k < K; ++k) acc += (int32_t)a_row[k] * (int32_t)b[k];\n const float real = (float)acc * (A_scale[0] * B_scales[n]) + bias[n];\n float q = std::nearbyintf(real / C_scale[0]);\n if (q > 127.0f) q = 127.0f;\n if (q < -128.0f) q = -128.0f;\n out_row[n] = q;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..77f2c3e073f6f644c3578b3a92fd0900dd9426b1 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qai8dxp_qs4c32_sme2_n256_k512", + "definition": "gemm_qai8dxp_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qai8dxp_qs4c32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qai8dxp_qs4c32_sme2_n256_k512.\n// A[M,K] fp32, B_q4[N,K/2] adjacent-pair int4 (zero point 8), bf16 scale per 32-block, fp32 bias.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int BL = 32;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qai8dxp_qs4c32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \n#include \"gemm.h\"\nusing namespace gemm_def;\n\nstatic float bf16_to_f32(uint16_t h)\n{\n const uint32_t bits = (uint32_t)h << 16;\n float f;\n std::memcpy(&f, &bits, sizeof(f));\n return f;\n}\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const float* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b_row = B_q4 + (long)n * (K / 2);\n const uint16_t* s_row = B_scales + (long)n * (K / BL);\n float sum = bias[n];\n for (int k = 0; k < K; k += 2) {\n const uint8_t b = b_row[k / 2];\n const float scale = bf16_to_f32(s_row[k / BL]);\n sum += a_row[k] * (((float)(int)((b & 0x0F)) - 8.0f) * scale);\n sum += a_row[k + 1] * (((float)(int)((b >> 4)) - 8.0f) * scale);\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qs4c32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qs4c32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..bed6a8f38203c4ae8c2d8e575a92f70557189734 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qs4c32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qs4c32_sme2_n256_k512", + "definition": "gemm_qs4c32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qs4c32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qs4c32_sme2_n256_k512.\n// A f32, B_q4[N,K_half] (block 32: byte i low=elem i, high=elem i+16, zero_point 8), B_scales[N,K_blocks] f16 bit patterns.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\nconstexpr int K_blocks = 16;\n} // namespace gemm_def\n\n// IEEE half -> float, bit-level so it needs no fp16 compiler support.\nstatic inline float f16_to_f32(uint16_t h) {\n const uint32_t sign = (uint32_t)(h & 0x8000u) << 16;\n uint32_t exp = (h >> 10) & 0x1Fu, man = h & 0x3FFu, bits;\n if (exp == 0) {\n if (man == 0) bits = sign;\n else { exp = 127 - 15 + 1; while (!(man & 0x400u)) { man <<= 1; --exp; } man &= 0x3FFu; bits = sign | (exp << 23) | (man << 13); }\n } else if (exp == 31) bits = sign | 0x7F800000u | (man << 13);\n else bits = sign | ((exp + 112) << 23) | (man << 13);\n union { uint32_t u; float f; } c; c.u = bits; return c.f;\n}\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qs4c32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q4, const uint16_t* B_scales, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const float* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n float sum = 0.0f;\n for (int blk = 0; blk < K_blocks; ++blk) {\n const float scale = f16_to_f32(B_scales[(long)n * K_blocks + blk]);\n for (int i = 0; i < 16; ++i) {\n const uint8_t byte = b[blk * 16 + i];\n sum += a_row[blk * 32 + i] * ((float)((int)(byte & 0x0F) - 8) * scale);\n sum += a_row[blk * 32 + 16 + i] * ((float)((int)(byte >> 4) - 8) * scale);\n }\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qs4cx_n512_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qs4cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..0d4984b97748bf434db37ee660b53ef0a7a8ab6c --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qs4cx_n512_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qs4cx_n512_k512", + "definition": "gemm_qs4cx_n512_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qs4cx_n512_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qs4cx_n512_k512.\n// A[M,K] f32, B_q4[N,K_half] uint8 (adjacent-pair nibbles, zero_point=8), B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 512;\nconstexpr int K = 512;\nconstexpr int K_half = 256;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q4, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qs4cx_n512_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q4, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n const float* a_row = A + (long)m * K;\n float* out_row = output + (long)m * N;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q4 + (long)n * K_half;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int j = 0; j < K_half; ++j) {\n const uint8_t byte = b[j];\n sum += a_row[2 * j] * ((float)((int)(byte & 0x0F) - 8) * scale);\n sum += a_row[2 * j + 1] * ((float)((int)(byte >> 4) - 8) * scale);\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_n512_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_n512_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..22d891d486ab206e44fbfd780586ae31be60961d --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_n512_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qs8cx_n512_k512", + "definition": "gemm_qs8cx_n512_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qs8cx_n512_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qs8cx_n512_k512.\n// A[M,K] f32, B_q8[N,K] int8 (value = q * B_scales[n], no zero point), B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 512;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q8, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qs8cx_n512_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n const float* a_row = A + (long)m * K;\n float* out_row = output + (long)m * N;\n for (int n = 0; n < N; ++n) {\n const int8_t* b = B_q8 + (long)n * K;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int k = 0; k < K; ++k) sum += a_row[k] * ((float)b[k] * scale);\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..f2d374774fbd33e977896a569ba16e11ddb65717 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qs8cx_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qs8cx_sme2_n256_k512", + "definition": "gemm_qs8cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qs8cx_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qs8cx_sme2_n256_k512.\n// A[M,K] f32, B_q8[N,K] int8 (value = q * B_scales[n]), B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q8, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qs8cx_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const int8_t* B_q8, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const float* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const int8_t* b = B_q8 + (long)n * K;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int k = 0; k < K; ++k) sum += a_row[k] * ((float)b[k] * scale);\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..6348e33e473d02b0d1775066bf1982c266f2d230 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qsu2cx_n256_k512", + "definition": "gemm_qsu2cx_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qsu2cx_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "graviton4", + "aarch64-sve2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qsu2cx_n256_k512.\n// A[M,K] f32, B_q2[N,K_q] uint8 (four 2-bit values per byte, low bits first, zero_point=2), B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_q = 128;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q2, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qsu2cx_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n const float* a_row = A + (long)m * K;\n float* out_row = output + (long)m * N;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q2 + (long)n * K_q;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int j = 0; j < K_q; ++j) {\n const uint8_t byte = b[j];\n for (int i = 0; i < 4; ++i)\n sum += a_row[4 * j + i] * ((float)((int)((byte >> (2 * i)) & 0x03) - 2) * scale);\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..553923e3aff4c2626444c9a3b460aa38bfe05d51 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_qsu2cx_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_qsu2cx_sme2_n256_k512", + "definition": "gemm_qsu2cx_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_qsu2cx_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_qsu2cx_sme2_n256_k512.\n// A[M,K] f32, B_q2[N,K_q] uint8 (four 2-bit values per byte, low bits first, zero_point=2), B_scales[N] f32, bias[N] f32.\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\nconstexpr int K_q = 128;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n inner_gemm(A, output, B_q2, B_scales, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_qsu2cx_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const uint8_t* B_q2, const float* B_scales, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const float* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B_q2 + (long)n * K_q;\n const float scale = B_scales[n];\n float sum = bias[n];\n for (int j = 0; j < K_q; ++j) {\n const uint8_t byte = b[j];\n for (int i = 0; i < 4; ++i)\n sum += a_row[4 * j + i] * ((float)((int)((byte >> (2 * i)) & 0x03) - 2) * scale);\n }\n out_row[n] = sum;\n }\n }\n}\n" + } + ] +} diff --git a/solutions/kleidiai/reference-scalar/gemm/gemm_u8_f32_sme2_n256_k512.json b/solutions/kleidiai/reference-scalar/gemm/gemm_u8_f32_sme2_n256_k512.json new file mode 100644 index 0000000000000000000000000000000000000000..6c581369ae27bbb981ec2a087ea743357941ddf7 --- /dev/null +++ b/solutions/kleidiai/reference-scalar/gemm/gemm_u8_f32_sme2_n256_k512.json @@ -0,0 +1,36 @@ +{ + "name": "reference-scalar_gemm_u8_f32_sme2_n256_k512", + "definition": "gemm_u8_f32_sme2_n256_k512", + "dataset": "kleidiai", + "author": "reference-scalar", + "description": "Scalar raw-pointer gemm for gemm_u8_f32_sme2_n256_k512. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.", + "spec": { + "language": "cpp", + "target_hardware": [ + "apple-m4", + "aarch64-sme2" + ], + "entry_point": "gemm.cpp::armbench_entry_gemm", + "dependencies": [], + "isa_features": [], + "compile_flags": [ + "-O2", + "-std=c++14" + ], + "link_flags": [] + }, + "sources": [ + { + "path": "gemm.h", + "content": "#pragma once\n\n#include \n\n// Per-definition constants for gemm_u8_f32_sme2_n256_k512.\n// A[M,K] uint8, B[N,K] uint8; exact int32 accumulation, converted to float32, times C_scale[0] plus bias[n].\nnamespace gemm_def {\nconstexpr int N = 256;\nconstexpr int K = 512;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\nvoid inner_gemm(const uint8_t* A, float* output, const uint8_t* B, const float* C_scale, const float* bias, int M);\n#ifdef __cplusplus\n}\n#endif\n" + }, + { + "path": "gemm.cpp", + "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const uint8_t* A, float* output, const uint8_t* B, const float* C_scale, const float* bias, int M)\n{\n inner_gemm(A, output, B, C_scale, bias, M);\n return 0;\n}\n" + }, + { + "path": "kernel.cpp", + "content": "// Reference-scalar gemm for gemm_u8_f32_sme2_n256_k512.\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const uint8_t* A, float* output, const uint8_t* B, const float* C_scale, const float* bias, int M)\n{\n for (int m = 0; m < M; ++m) {\n float* out_row = output + (long)m * N;\n const uint8_t* a_row = A + (long)m * K;\n for (int n = 0; n < N; ++n) {\n const uint8_t* b = B + (long)n * K;\n int64_t sum = 0;\n for (int k = 0; k < K; ++k) sum += (int64_t)a_row[k] * (int64_t)b[k];\n out_row[n] = (float)(int32_t)sum * C_scale[0] + bias[n];\n }\n }\n}\n" + } + ] +} diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..2e957d588bfbd13b797467c753e61c96f5849bc0 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58319dd6cdbdb40e69bb2d87b2bf21921e15b83afe668d3db36ac118df4fab23 +size 524416 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..6e42ed3a41ef867da8b9aa8a207ce0787e55e800 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72419cf17f5f30223f8c45c966e075565728c78e7d2220b5468199d74f79762a +size 786560 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..ea801c88716a10cc0ed6057a62e35d379466ad32 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:650004d3dbe2668785e0e278a8b8101955ecdf6ba566348225bd66869b26afd1 +size 640 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..371a15a33d9ac67b0021751b7217d5e770c6ff86 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5ea48271ce73cfe3bc63133f507a121aeccab0e08af370eee3da076b7c325f5 +size 1048704 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f3a7f6e5fba7c03d9cdd983d4a7d54ee3fea4da8 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ee264230990a5a40a002524f5c16af80319526d4a2ed45499a5e601b1a5f9ca +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..d37c7fdec0fbe6b1268125f69360f64d14cc1462 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe66e7c2bb9b06857f218079ddb1829792450deffb848c26bef10a0f5f7b096a +size 153728 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..0e0f6eba2e6c4e7d2a751e8fc70319fccb141756 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e24de61008f31ad7124988574d37a8935bc4818479710f6c940ee67b08923f2 +size 196736 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..2e07af6d17b9cb10b5dcd202969239e17a2c092b --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:201ec941875df3cb29905de3df2fed7bbbce4d591407809bb126aa8681e7025f +size 229504 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..0db1eea13ed65281fc30210c62802ad442b8f23f --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8894aa27ce3f1cf09fc9de1624909f9122342daf5d33ebed05ba44d032df693d +size 2176 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f379aa876eacae56aef162fee9dc55f090206173 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:275d628684edc81b9e0bc40ade1c5322c8fe9b02268014e8095729601baa0efe +size 262272 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a2a21546ffe1cbdca989212316e2aeaf900b1e40 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7294b93ffcf2bbebce45c44b19ac39a6eb8c17e06379c84d1579c66098f179fa +size 327808 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..93d0ab9565ddb7a53b00f5777792d31219454f0d --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e7d60fb9cfff5fcd577a0f86b398fa21c2b55cc8c674f21c4a6c7d50614cc27 +size 397952 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f85c2e3a0c4b99da0e4cd64295e0d84a381f056e --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:017597b95193a586f16c066faa3e247cb69367bddee1c3d339e9169f5d7e4b0b +size 4224 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..3cd6f0e494a7bf37b2edad740b6ef9922b89c8b8 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db08e3b5fb04fc8fc366668a3887df1ad6c01177463c8f0936d9462b29797c00 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..519a0166ca3579c545312dd432d2caffdf64fb85 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be130acf5d488f9064e1a5c2f6bc9ea57ecdc87ccea9e03a8d4d63ca3a91be6a +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..1d8c58b181b473a0fdd73480d59713879cf2c51a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0cabfba6669ed312877e0625945d86c477d7779df193d1b1a538c8c65cffc55b +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..84c00ad15a721cea81080a941e63f0f7aa6d0e02 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dbde56a83db7a8237bdfa94774f20423714aa5ff2267c5eb00a511198de38437 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..33fd129066cf4919719f77f74ff2dab63ceffed5 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05fa78a7a8da3740a02620a76f3eb03c1b5142459acb91640f47ac782b07dd57 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a4c1fbee6a2be53fda0cfae202ff5e967cfe37df --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2416f4cc68bc4ba014d0d33a2b5bcd47d4dc4b06dbbf00534c5590a5d0d9e90f +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..039adc0ad2dfd7cef13c68996255044555d70f7b --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:118870d81be80161e40153a3d1ee993a21460b78708009d7bcc834ef223fdf1d +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..2e3307df68197196e58b9be82d27d819936ab9ae --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7ac82dd53ab8d045f8ff625f1ffd2f28f5edf4920f2023e22a57f9fac22757d +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..0fcdbf7192f3e5c7f5de4506738eab48608cb2fb --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6de509ac479ffb77619ee9d3979d72d3102ccd043be4156130606d5f7d119e28 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..b82a1e7fdc9416a58867e550052d4c1ff6f32d9a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e59880f600c43d10bbbcc66b650d6a4f7230d14ad7a6cda74a1d88f838d55883 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..28a92d7076a5fac3615eb5a0f74bbdcb55be3474 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6bbbb84cbe91c93a18233e9caf9b2996c52e2ab24706162da8da0470845645f +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..0fc9e55fbd485b9b9abb817e4b2cf1214ace88e8 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8fb719532751f9a214e0b565f378eafe00594a6eaa60943783d90b2afbd03854 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a75fb2d4d9eec000f8676b3d9cc3be697cb40a6f --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e350eae7e92d1ccc326ebb877358d4b20785b92fa51c66e3e0b2b09b1a147fcd +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..3745b363160c542d139b09fe87200de4d6a61806 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0a98b0a06bf342d3a3e730b54792bc69fe8632109856950f91fdc174dc6b488 +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..98eece42f68e72763aa46f8d23ea17a854b209ac --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c7c81e6ba8be4dd38763ccaa674fa951ee1c205f31ff5902ff759f66d1de0eb +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..46ba9484799f411bd7beef038028de02513d405f --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e070f11596a111f3dcbb188e6efc7482d8c947b46ddb74868f146d46cdca7ba +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..1c633524a2918224141fddf5b7ca8febf6b4bc05 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b6904f99742de46282d5de9531ffa0212cc8f760536aec7df67370c1a0e1b47b +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a81fae0fc023203c5869f82bcf35eb7ae47f77fe --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ae97cc6131e8e718fb386440e884d4635aeec7a3f3b4e4a1cd9c1e22fd88ad74 +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f9398e279badfc078fad30397b8d15ea05d6b3d7 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df23f95ffc37068001f060fa4e7d4f93e2324164d61a58865213495d61e7dfde +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..153365991ece26eca23e5381381fee546bf5ef35 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e51a966087624a4df99cbcc1ee74a3ed5bbc76b3cb4075512fb31da4f0bca0dc +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..d9160afe73d091b8b77286c0986314a261ba6562 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb4bce13c7ce8a531fcb8b1cf693cae7ebb23d9c7321a26402c193f48b806a6c +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..ecdc65793bb55737ef168d887c7de32e5abb0664 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3909518d0399762cb4be55d3844eefca53dea52bccf75a18bf21af7c9f2ce926 +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..3e6b410cc49916cdae5aad7d79f01c9b86b5d110 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74d80763165db6f9cf3622c3705fccd2afd104e3baf9c3720f0af5dc1e7808d8 +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..95f99b6bbe9e5473aeb81258cf87be24aa302492 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4bb2d736eb126df54e14c123d4a837fd961d9b61a3b7530b31d39c68aa47e2bd +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..40298e919b2c49b5b90f7527aa57adb2e0679b70 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b4b8e5e5452183b230460a11f91c0980b1d218e00480241fb6f8b9770225e5d +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..43606221277ad58daa6d73c6a7272049c82dcfcd --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35d1e3277b392ec69afc7dc8e3d3cff842dec5b3b2fc7bc6db7a9f14a7d9d50f +size 131200 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..e46a00c9fa35d933119d6b18f8079f96b3b65026 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4866b837f246708edef4228c89ec8a335135ee2ed2fe1b43c2241d793f5dbea +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..c2f34ae5f816896eb9ea6bf9723c06e1cb19bef1 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:23febeb259510bdcf591ad5a0c8f26128cfe314160630f4bcb1ff4b19bce8eb0 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..ca8a0ddee760ab87a798668e10bf045a83c54cb6 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:062cc7ccfcaab9b6afa43e811140769783e90685fa965c54be293c63a116a6b9 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..6a67934f5e77dde1bd3ef36a4e68b83fc37de1b7 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0c8b42f3d4f6419baee3e2d03d278de7ca5bd5100130358cd4cf3fbdbb0af50 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..cbc3c0db9f0c2325aa9988036ce32c0ec64668f4 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c3a32737f588765a68e58496fdae4c5385cb5ec8993e095d4b13fe0d8b7cee8f +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..903cf7c0ca1fd43ea93cb556db528a75219f4e72 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e14e06d921779eb6cee5648c2b883685ce40a133dba59e83ecbccec105568f11 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..3f3cabc6e0a01e5db6494d25dd93b982ef73d95e --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c6d17302caf2273b765826f736089d9af83d2239b093a7a79e6552bfd9e989a +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..1cfb173a9c03ccd58478df910efec702e1caa76e --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0650055c47c5cc91fd0aecd8f161f3bb813320ac8df7a99cc92d1bcc505dd98c +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..9db1fa92816121f5e57a647970989e015f9b5dce --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:08b5157950d8cc807e3fb2c6890a05b41142627e36bd00549845d687d6dde444 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f8161c5e9a25161e68c2cfd5d122869838b4c400 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c28cb9d08a18fe47a88993ec17370ec7e27e9ce22135c3ac463888e225e9dd4a +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..751d61187048ff0397daee24ee4cae812bd046b8 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f427a196947fb547c4debee2ba86b9e2b68cd99d2901df144a20d13eb9a8b5f3 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..9b0ced18a3e282181aaab38657e37c8857745c98 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4bb81cf3b3de1c8388140939ebb118486072b2f0f9cec691d733342adbd2267b +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..b55800f5aac7074b869ec8a9bd5c01b5a4f9ecd3 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c495098d37ec91c467bc9b3e32b26e4dbe2681ee97b64037abf4d46178ffe0ad +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..008105d38edceaabbf8709f594c81f470d660e1a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:218a5726f6dd968ed2927b8d595fa1bf3c380e80ad4d9f74204e512f804a43b0 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..941380b1e4b55ef76880259a9eff7dc9e229235f --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9331cfab66670a4dc58e6e88995c4cdd5d5c5fdf04e82aa289e7422ec2d099a3 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..aa3b8ca48e19312e5caa8648ee922d360f3de1bb --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f783a443b0728e4cfdc7023039bddca05dfd115c9d4eceaf3a42f2aac0d3f267 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..54369029f9e3fad3a0eb06cabc0ed33f6ad5db1b --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a758093a389344f75540c72c90d36b01141974bd0cb3cb011b50d3081baeac7 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..20769037e3ef2f1c91a270c50fb88b45e2a725d6 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd60517cee3128a72b830dc19b82e87dac4690a1282a41afcc3976700aa856f9 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..72b7fc83c03922529329c19f3833c13b843059d5 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9873887f4a25ce59032ce2e4d8d0a98644259eb22c85f01daa84f7a27d341399 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..c56671c601630106cf832fdccce71c325209787a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72f5fd7d0025726d5f42848e5d519622b147597e148eed5a1f974f1dce629c40 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..5c9ca8bb72d4330caef3dbddb61fa70100377809 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc5cc5775091a72119f1911af888f5d0dd7e45f8e8dd20d9eb4385e526a4c591 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..d9577cf824066a5dcaf40c12b3e4b40404cf4c2d --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8c944d06d5ffe98d05b60e6c688706fb017d3c30b0b90e7423142d31354ed8f +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..48fc86bf1559f472c65bb5edbb8eecd54b4233ff --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fdee19275477135242bf80fe2cc1fe795e87581fb8989a7a116528c51168d1bf +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..efb522db9d547cf91a17387b3d4719bcaed6f1c5 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ecbacf8eb0d1fffc02d5ccca9c26bafbc7b7f54ca615d7a225256fc5886363ca +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..160eb50ae14bc012d411ece442bf1b4ddaab6a5c --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18e9e5f14dee08ce513e5cc489f9f3d3b9c26332dbd818e5b1687faf5ac73b77 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a15a25733fd03614245ab0807ff7ffd9e56078c2 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad2200cc4f09faa88733eac37883d386834183b1613e501e38190c4dd9315593 +size 132 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1024_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1024_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..e15eece31062120cf722d1deb58535d307b9a78b --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1024_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04ad65e2a83cfa5c1d217c49991e2a250bf660566d76441af85ad6ee29f65890 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1536_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1536_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..5551c2a7c2635768dfea9c1e7329e0838f207904 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1536_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91a88279f8e77e897b6fb15059dc6957ddd3a9cbfb9938adc5af980ca3607112 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..8f83c0b8f8466e8f62ce1a78c0b547e456988bfe --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12e3f67a3c8a244930ffb8be58e288a1a186262a3d0009827672239936705e1d +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M2048_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M2048_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..70aa110d64686a36b717e7c7ee4d9904638e0a50 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M2048_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7c4393887759061af52392bb61d5b750bd5d06dbd6bcbce1b1fad921687a42d +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M256_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M256_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..e782756284d3fe5544e32f15adf06f62206d7a9d --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M256_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d8e8e61b2c36712c2a6021ceb280262c0dda011e4726987b8518be7e8afb487 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M300_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M300_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..37dbd8bb7583eb0ddcd64a4fca08e9075a749b0a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M300_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c6ce170b02d22a3013fc22705da413eb9bea36c237a71f5a7feae27d07a1ea3 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M384_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M384_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..360b71c0e377be21ee046b687870da5e67f9a61a --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M384_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a16294c2500520cab96f170280925c779118afd2da7949f2f1260334f1fdfb1 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M448_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M448_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..ef4a092dc68ec1f3368980b4304d774c17506424 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M448_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71d7d1034cecbaa571284ae37f64e35c9a8bff34654c4ae280b410f946e49afc +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M4_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M4_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..63666ee28c6ec0698486b31333a084c6db064551 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M4_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2eced6db1af1752348c9a56f0e8f7643774eefc28b79a37fc9ccd50525b33818 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M512_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M512_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..f421dd0d6bb1f2ff7bf5535bb303aebdbd23a583 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M512_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c55da825ea330ff94444c1c2adeb5956b6dc6a02821a12d89a111fbff121ae7 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M640_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M640_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..804f887263754bc7de0ce7a6df28ddc31e1f6dfb --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M640_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3d69ab34089819f0cbfc280cf353c84e33f9bd4083e6dae88e68167fd87428c +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M777_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M777_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..a5cfb14685e3becfd972b73382f083c2958dcdb0 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M777_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d630e878f238c65427491857ba527a6868a6ee3411ce525c49cb51a271ecdb00 +size 1152 diff --git a/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M8_synthetic.npy b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M8_synthetic.npy new file mode 100644 index 0000000000000000000000000000000000000000..cc8a714ed2f5945c6671bcb128a71ebec84e3f90 --- /dev/null +++ b/tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M8_synthetic.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d5f7cb285ecd2d634eeb8009adf47aefb7602203c74a1e3890f101a18460441 +size 1152 diff --git a/workloads/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.jsonl b/workloads/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..e43bffa4cc778b50570d25471475e6713b01cb32 --- /dev/null +++ b/workloads/conv2d/conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2.jsonl @@ -0,0 +1,16 @@ +{"axes": {"N": 1, "H": 1, "W": 1}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "78aecc0455555382abecfa76d38f6258"} +{"axes": {"N": 1, "H": 4, "W": 4}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "782379ac175b56b59f517fb6d07acba1"} +{"axes": {"N": 1, "H": 8, "W": 8}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "7ad9caee26f55ed78ac9526b65f1ca78"} +{"axes": {"N": 16, "H": 4, "W": 4}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "6aba9e996bb05f2bafcf0818ae83471a"} +{"axes": {"N": 8, "H": 7, "W": 7}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "301bd5b1bc1b51eeb568fc109365bb8f"} +{"axes": {"N": 4, "H": 13, "W": 9}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "00b33e33f39a505f9fe5300cad3c4c84"} +{"axes": {"N": 8, "H": 8, "W": 8}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "f4857bec17775a53820f96488de24f1a"} +{"axes": {"N": 4, "H": 16, "W": 16}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "c485bc934fa75563bbe4c3b9a2ba3334"} +{"axes": {"N": 2, "H": 24, "W": 24}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "1b5bddd880845238bd32b36a8846dea3"} +{"axes": {"N": 1, "H": 48, "W": 48}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "da7da3dce842596396154ca573333225"} +{"axes": {"N": 4, "H": 32, "W": 32}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "cf18eebc9a535e73879fbbfb8f833aad"} +{"axes": {"N": 2, "H": 64, "W": 64}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "9f2a0d7cded75eb1994c410357b5d7a0"} +{"axes": {"N": 1, "H": 96, "W": 96}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "ab64495874785379bb63862a4ecf5c3a"} +{"axes": {"N": 1, "H": 160, "W": 96}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "f0b7611a1c005fea88a2804febea8bee"} +{"axes": {"N": 1, "H": 128, "W": 128}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "aef8ccee159a5d7393963914099be65b"} +{"axes": {"N": 1, "H": 224, "W": 224}, "inputs": {"input": {"type": "random"}, "weight": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "715e303ba6d35a1d85e32acacde859cd"} diff --git a/workloads/gemm/gemm_f16_qai4c32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_f16_qai4c32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..9dd74c7d0bcf4939612284ccec3e0c9aa1b5e894 --- /dev/null +++ b/workloads/gemm/gemm_f16_qai4c32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "52.10", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9dc28e4d0f3e52f6ba66ea594b33bf71"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.84", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6a283906558a5b7ca07a3dc20c42d970"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "50.98", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "bb854c4623f6520abbf6baf55961a481"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.42", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2cc8a1cc0e2e5de5a00ba7b90b0bc29a"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.53", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "11af7489420c5c069d8a0248c665a825"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.37", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d2eaf34277bb583b890677db97d8afa2"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.23", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "4a462d0f233e582d91f20e0f3fc6020f"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.89", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "bef5228c48fd540ba2d8356ce133eaae"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.52", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "3bea20280b945a9e92e7534d6a9db3c1"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.53", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0b1ab620b46c58a8bc1ea44d0d4a284f"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.45", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "bf4edfd6a9255677a899b963400e9816"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.40", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e6798e63d9b1592eb01bcdb305e9f03a"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.29", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9ae6d5f1ad7954d1af838e74eebcc41a"} diff --git a/workloads/gemm/gemm_f16_qs4cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_f16_qs4cx_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1a27fad617523c6e7f1bba848592cecf8474e321 --- /dev/null +++ b/workloads/gemm/gemm_f16_qs4cx_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "53.60", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "90f3c3347ab95e8eb22cfd5ed46f7c0a"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.12", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "1fd1193b4493528d8ab5fbd3ab3df8f8"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.63", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f91b90068194531a84e905bc9538f353"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.06", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d8f03b6ba5e758ccb9b54a345fd5571b"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.07", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f7cd62c7e7715ab6a2161162643ac603"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.02", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "19676a1b969056708d101bb92cac431d"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.33", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "474f6fce61935cb4ab7c73d9598fa1cf"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b222bde185e352bea26220eaa72b91af"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.25", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "ed0fa51a8d1d59e694a55befd457015a"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.63", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9866221361645aedb887f111ad847c27"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.30", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "365c2bd0df0558d7a22a31dc841e1ed3"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.88", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9ae09fbc9af55daf8cc5620a8d9ece3e"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.06", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "97fa43d38ec8570c9b2f6e8d8f2e1d76"} diff --git a/workloads/gemm/gemm_f16_qs8cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_f16_qs8cx_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..4cd85b86892e3723e2ba0cc323a53b93cc38330d --- /dev/null +++ b/workloads/gemm/gemm_f16_qs8cx_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "51.79", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "1f5866d176a0563ab4b0c31230a71f2e"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "41.39", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e3bab32e705259399094f46f8850a6c4"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "51.36", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "c8193721cf6b52b291520038b1b78f75"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.90", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8ea7cc78b1515c738ea8902c728146c7"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.55", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7ba304a9a2a15f429b29d1d0024db1b6"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.22", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "1c84d4dd50565e87a704227e5722ea90"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.06", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "a79772f14f365aaeb40cdd558eabc3f1"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.45", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "c37c7097615e55d1b004b33a9811d2bc"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.09", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "df99e3998feb5ce789b6bf69f1e35518"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.95", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d0df123638de516987852eaadfc5bd00"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.15", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0add2cc8c61858baa74752dcf9f9e9dd"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.58", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "95c8420ff84c555abb3e63634a10c6e6"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.13", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8b1fe0aa1a1b568eba11614aac416cc2"} diff --git a/workloads/gemm/gemm_f16act_qs4c32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_f16act_qs4c32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..6a19acd75ff8e2d800affbcaf0fa44760f056385 --- /dev/null +++ b/workloads/gemm/gemm_f16act_qs4c32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "77.56", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "49be5531203f59ed9a9dbdb879392112"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "74.49", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "24a0efedaca9511e9d0f9bac4017116b"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "74.27", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "fbd4528054d4515d8f73efe4fda72a7d"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.00", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "810089a6f305550780c63815a284721b"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "74.88", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "df088df74b375e1188d42fdebf694f3d"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.33", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "4a4cd42f58c955fca2043a8b879d516e"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.30", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "3b0e78350bae59e28bf88b0464e5bc27"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.18", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2059cbfd7a8459a6810f8a98a3b243f2"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.26", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "cbeaa61a8f1f5f81b04b5f849dad73b0"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "74.97", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "684e10412fae5f6cb2ab7746640cc0e4"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "74.99", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "64ef9aab679c5f25b6b71ba10f4d943d"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.18", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0ea06363f60551adb0adf8bbecb504be"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "75.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "ba699689eb6653d9ae5f0d16000cca9f"} diff --git a/workloads/gemm/gemm_f32_bf16_n512_k512.jsonl b/workloads/gemm/gemm_f32_bf16_n512_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..18b3454814ecc8d683302b8cdc2a0a23c94f66d5 --- /dev/null +++ b/workloads/gemm/gemm_f32_bf16_n512_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "00bae94ba2445e0bbbbc098fb52000b1"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "73fc184c28a15c17a691667f6afe97c7"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "e50b3aef168e5675aea9fa7f5b63c53a"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "580f189223fe5a9ea57a0f0cfe2246ba"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "727bcfd9f951528eb990e9c0a86cc9c5"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "a19df25f0aaa5b15b92b427dffb9ff0c"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "4b2ecd88186a564cb714a016d26f71ed"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "2e02f858f89254379081344e3313fab4"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "3aca8e30f9be51fbb8b031d41b313a2f"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "b19e481f7cf55aaeb7425c8af8bf6343"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "4564e8c2a1ca51548b80345174316a88"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "3cf6ac50dbef505c812a4d9c2b2fbbe5"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "f5b56f9f06165a76a92e09d712dca6ce"} diff --git a/workloads/gemm/gemm_i32_u8_sme2_n256_k512.jsonl b/workloads/gemm/gemm_i32_u8_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..116d7a7d95f7601f3d85db3546b9f6513dc64464 --- /dev/null +++ b/workloads/gemm/gemm_i32_u8_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "5987875065ae5f97919f6c6b7cf816c4"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "8d4922f2d33e53b7a90914b8da41ab91"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "2c63e926637c54b69845d29f3e2bba06"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "177e1d792ffa5a5893e29a2321339f63"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "b241e0b230055065a1014198f773c167"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "5940c84a005f579ab4a764ff45a6af1c"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "710b8c3841b2520d9051fa290572e275"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "7571084154a353f1a84ec8d5fa4009b8"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "9217fe45263e54a6be8c97a388b81852"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "5459d483a4435596867f513dad2c073c"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "c3eb20a2863f5b71b70bb9f4608dfd3a"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "9faf7eec0d0a5e5187ad5704175c1987"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "17ea7c0b55d251ae95dc586c6c60c6c0"} diff --git a/workloads/gemm/gemm_qai4c32_n256_k512.jsonl b/workloads/gemm/gemm_qai4c32_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..4ecba84fb81f5bdea1dcd20e22013f00104a16bd --- /dev/null +++ b/workloads/gemm/gemm_qai4c32_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "51.55", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9d3db402cece5d04af1f56ee81040a50"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.13", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "251d997c90355d28bfa9736fc3be183a"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0a37b683b98b5885aa4be91eaee66992"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.57", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "089d01d59e51573fb1b34b5b0371dfd2"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.73", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "da9139a42fed5848a5e2c4a145b880bd"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.55", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6d5fe15b68ca5461aaf43886fec6e95b"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.59", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "07c61f6c3ec95f898bf5a255dd707540"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.36", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0bddeaa7b076525f9e685471c850370e"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.34", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "652c238443405d528333d6b255f9f6db"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.33", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8751290b50085efd990ad5479d994783"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.52", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7b1f108a47025440af86288a3e66ceba"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.60", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b7438ffcc5b1522f86389bed9fd12007"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.42", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7635524d1d0f59c6a5c09ea1e74b33d4"} diff --git a/workloads/gemm/gemm_qai4c32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qai4c32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..3882d6b0e24af7d0902876ec0457d3c2715f3bf8 --- /dev/null +++ b/workloads/gemm/gemm_qai4c32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "50.32", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d78e33b3dc5c50ff9839ecb819d8ee53"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.60", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f272fb46422958d0a23e04438918a7cc"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "49.48", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "3c3d316759d95fb98527d1eb9e4b0cf4"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.46", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f267e477496e551fbbcde5cca2002156"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.38", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "31b850e10a6a5b44ba23b2fa59c0c574"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.44", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8b80e38d8f65586b9a94f90677729e17"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.34", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2518cb9adafd5f04a44dd2bd21d216aa"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.45", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9b2c0d5891b5536aadd00c2c49a0b510"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.53", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "81a5a3ed239a5fa789734aeca2e3422e"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.39", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b003e5073ef65be6815c3995c1e4f2b4"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.46", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e2dcd709f4da5d99b3fa47afd2484246"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.45", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d3e334d5173f5bb4947d0dbca4e8d93b"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "B_zeros": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.52", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "520a8dd5301e50919b99daf44a9980bc"} diff --git a/workloads/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..cf6f45807896fb689b293a7ba66a2effa53e345d --- /dev/null +++ b/workloads/gemm/gemm_qai8_qsi8cx_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "b8758edbac745c6c99b58161ed06cad0"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M4_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "88dbe9e54cf7526eb4b0d0215adb9576"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M8_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "610c02dbf79e5fcab8bee308e944917b"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M256_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "5bfafcbbdf845450afb02f91a49fffbf"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M300_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "9e7b25bd772b535a8ab8e58a88b419b9"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M384_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "de6355168ba35610a70c645f9fe304b9"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M448_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "a853e8511635521c8967acf3afd73f78"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M512_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "ca0d43d820d153dcac2524273cef20de"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M640_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "2e94e28283505c38afe86283ca18ea8f"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M777_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "ef63885839475b89b94ba16d01516f43"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1024_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "a3ccb404a79e59e4a1217f8b65e46df6"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M1536_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "b20ed9ce14e5584a8ba437ad63d4fcbb"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "A_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/A_scale_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_q8": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_q8_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "B_scales": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/B_scales_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "bias": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/bias_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}, "C_scale": {"type": "tensor", "path": "tensors/gemm/gemm_qai8_qsi8cx_sme2_n256_k512/C_scale_M2048_synthetic.npy", "source": "gen-workload; synthetic zero-centered int8 + positive scales sized so the int8 output spans the range without mostly saturating"}}, "tags": {"from": "gen_workload", "inputs": "synthetic-calibrated"}, "uuid": "f43878da027d5b64813f30562fee57b6"} diff --git a/workloads/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..b8bcdb2da7b505534a29d77e13097095369db238 --- /dev/null +++ b/workloads/gemm/gemm_qai8dxp_qs4c32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "51.68", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "86eec0affb945291851673b487608fbf"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.93", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "4f149d47ad20595895c6a761e0e598cf"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.22", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "ab3198d9efb45f8d969005fd50b57369"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.67", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "1a4caf5e3bd5567184b6852804452c9c"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.09", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "84ee6bec83b65745bb26b7547fc8712c"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.01", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d3a904ce74c1577389ad1fe24958719b"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.24", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "68844819c9f15d51b9bfa4d14425af1d"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.23", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "5ad3da87336558bb834c274e274838c1"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.17", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7fe42c8ef1ee5ceeb379cf259754252e"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.53", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "5fde44915b2f5cd49312d47d5f46dd05"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.17", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8faa906f000c5f2882d44e71f173c4a3"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.15", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6164c3abd70b590dae064c73711e28f3"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.02", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6ee77f2c5288595b880ab96cac42af0b"} diff --git a/workloads/gemm/gemm_qs4c32_n256_k512.jsonl b/workloads/gemm/gemm_qs4c32_n256_k512.jsonl index 2c37eba8e2dcae5563c5af4d3c17085b3da19f9a..5c59fa131d27f86ca68ccaad5b8040dd1c51483a 100644 --- a/workloads/gemm/gemm_qs4c32_n256_k512.jsonl +++ b/workloads/gemm/gemm_qs4c32_n256_k512.jsonl @@ -1,13 +1,13 @@ -{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "cf934f790788599e9bef2ac18d69848b", "tags": {"from": "gen_workload"}} -{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "5c0fbdd5cd3f5a4bae3b9bdad4a969bf", "tags": {"from": "gen_workload"}} -{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "12a0520864335f429fa680e9f59e447c", "tags": {"from": "gen_workload"}} -{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "caab4f8884da5a21b91d75c9d4ebe4bf", "tags": {"from": "gen_workload"}} -{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "2b82a00a2d585d11bda9d44e8cea2b0d", "tags": {"from": "gen_workload"}} -{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "9412df9498b4550ab6d8ec4b6dd49444", "tags": {"from": "gen_workload"}} -{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "c2b2de35f9055215973650865a1da321", "tags": {"from": "gen_workload"}} -{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "49350740b6a35b0098ab8ddab1365b17", "tags": {"from": "gen_workload"}} -{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "33f41a41314b5feaaabe66c438349318", "tags": {"from": "gen_workload"}} -{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "4ad98bb20a8e5ff09794ddf4ff53ea87", "tags": {"from": "gen_workload"}} -{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "6085563d549f54b5a39002cf16aae31d", "tags": {"from": "gen_workload"}} -{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "516fb556495b527c944bf53d190764fb", "tags": {"from": "gen_workload"}} -{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "a188f6e957b05bd8b54c664835cdf4c7", "tags": {"from": "gen_workload"}} +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "cf934f790788599e9bef2ac18d69848b", "tags": {"from": "gen_workload", "baseline_sqnr_db": "49.57", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "5c0fbdd5cd3f5a4bae3b9bdad4a969bf", "tags": {"from": "gen_workload", "baseline_sqnr_db": "49.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "12a0520864335f429fa680e9f59e447c", "tags": {"from": "gen_workload", "baseline_sqnr_db": "49.43", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "caab4f8884da5a21b91d75c9d4ebe4bf", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.15", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "2b82a00a2d585d11bda9d44e8cea2b0d", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.54", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "9412df9498b4550ab6d8ec4b6dd49444", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.81", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "c2b2de35f9055215973650865a1da321", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.31", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "49350740b6a35b0098ab8ddab1365b17", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.57", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "33f41a41314b5feaaabe66c438349318", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.42", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "4ad98bb20a8e5ff09794ddf4ff53ea87", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.70", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "6085563d549f54b5a39002cf16aae31d", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.18", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "516fb556495b527c944bf53d190764fb", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.45", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "uuid": "a188f6e957b05bd8b54c664835cdf4c7", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.53", "baseline_sqnr_author": "baseline-kleidiai-arm"}} diff --git a/workloads/gemm/gemm_qs4c32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qs4c32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..fff77efb7b7c183945113e8c419139d8590fa8f2 --- /dev/null +++ b/workloads/gemm/gemm_qs4c32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.31", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "4a5ce7082591517591f384631e83ec95"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.10", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9857d1505bfb531ca47ca744ca97d612"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "49.49", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "cd69ecd122c056b1b1a2832487c44fb3"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.65", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "4eae4155509c52268530dba73e476f86"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.13", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0fc5db029a8d5ac49060699d89cbf54d"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.47", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "08275ae3b844542ba0060c64354615e9"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.63", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6687d66a6dea54579585bef8afcc480e"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.24", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d9fb6b144adc5f58ae0b3918fa467577"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.47", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "8172d5ec46bb5a2fac7104fbed2e434a"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.54", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "20ab0d0a000655a19da461037d4c2e5f"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.30", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "48bb340f47285db7ba35990aea7d1708"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.43", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "10ce1fce9ebd5bb5acc578bb69d371ae"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.46", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2b7b63fa71d3518c8c657740ccdb7602"} diff --git a/workloads/gemm/gemm_qs4cx_n512_k512.jsonl b/workloads/gemm/gemm_qs4cx_n512_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..502aef8a2ca1c161c8a0ca31a16f8dbb6748a4c9 --- /dev/null +++ b/workloads/gemm/gemm_qs4cx_n512_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.21", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "a473e997473556bcbecc7aba841798d6"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.75", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b8f1faa8b2785f1ba946f5515b06ca3f"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.65", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7fad92ebb1765bfcbc91cc2ec27a361e"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.04", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "ca3af48e6fe857b5a660a99470218258"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.40", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2c113b73551c5f81be4307dd55a989e7"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.04", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "aff8f802098956ffa41994e8a2b38e3a"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.37", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e6868b01d8ab506a8330124f234f01dc"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.88", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d572132ca3b75b058f40b229fa73f7e4"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "09e89d05522e541b851918f4ecccd505"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.01", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f94e8b16c2a659d7b320004bf4c279ea"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.08", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "82edaf2f6e3b5383bd6d47868b5b753f"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.18", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "28ec3c848cd95be2934811deec05586a"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.16", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d72ebb0f5d0f5628b7216141bb6af47b"} diff --git a/workloads/gemm/gemm_qs4cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qs4cx_sme2_n256_k512.jsonl index 74135f6a2e579772cd30bcca8a1808899f8aaf2e..43ebd8e70b11e4f1806f4647feef83a90eee6629 100644 --- a/workloads/gemm/gemm_qs4cx_sme2_n256_k512.jsonl +++ b/workloads/gemm/gemm_qs4cx_sme2_n256_k512.jsonl @@ -1,13 +1,13 @@ -{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "eea2c721bac55317ab86dc844f9209ab", "tags": {"from": "gen_workload"}} -{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "fe9152e626e05c24b1f55477240017b5", "tags": {"from": "gen_workload"}} -{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "c5cb5a5b42c451f0aee20b10571466fd", "tags": {"from": "gen_workload"}} -{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "bd9b2e7249fd5169b65919341fefa3e4", "tags": {"from": "gen_workload"}} -{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "a7de1c199e5f54018ef6bc4abb97649c", "tags": {"from": "gen_workload"}} -{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "fd4a37e9c354514eb45ed41c3d21c58f", "tags": {"from": "gen_workload"}} -{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "10e950a873135ec49fc03bf5ec34e350", "tags": {"from": "gen_workload"}} -{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "464b91d1795259cabd19a3ae505c88d4", "tags": {"from": "gen_workload"}} -{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "069d694f04ca5422ad3fd3908486ee05", "tags": {"from": "gen_workload"}} -{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "648beeae9c9f5882bf33d55a179db8da", "tags": {"from": "gen_workload"}} -{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "16bbfe8c8adf5f6e89332f9ed149098a", "tags": {"from": "gen_workload"}} -{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "f9645b07ae0a52c3b867035c674d1a13", "tags": {"from": "gen_workload"}} -{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "20c2706e5848539997ff07b7c7d34221", "tags": {"from": "gen_workload"}} +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "eea2c721bac55317ab86dc844f9209ab", "tags": {"from": "gen_workload", "baseline_sqnr_db": "44.28", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "fe9152e626e05c24b1f55477240017b5", "tags": {"from": "gen_workload", "baseline_sqnr_db": "50.12", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "c5cb5a5b42c451f0aee20b10571466fd", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.50", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "bd9b2e7249fd5169b65919341fefa3e4", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.07", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "a7de1c199e5f54018ef6bc4abb97649c", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.11", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "fd4a37e9c354514eb45ed41c3d21c58f", "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.89", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "10e950a873135ec49fc03bf5ec34e350", "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.72", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "464b91d1795259cabd19a3ae505c88d4", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.17", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "069d694f04ca5422ad3fd3908486ee05", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.40", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "648beeae9c9f5882bf33d55a179db8da", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "16bbfe8c8adf5f6e89332f9ed149098a", "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.89", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "f9645b07ae0a52c3b867035c674d1a13", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.23", "baseline_sqnr_author": "baseline-kleidiai-arm"}} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q4": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "uuid": "20c2706e5848539997ff07b7c7d34221", "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.05", "baseline_sqnr_author": "baseline-kleidiai-arm"}} diff --git a/workloads/gemm/gemm_qs8cx_n512_k512.jsonl b/workloads/gemm/gemm_qs8cx_n512_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..c1f554f21e7af09ccbed8e2d3da3bbf0663167d2 --- /dev/null +++ b/workloads/gemm/gemm_qs8cx_n512_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "55.78", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "20bf6b16a44d59cd8ff6c8023fb7ebff"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "53.50", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e87c34094ebc5092be0c33f39b3d0ce9"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "44.54", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0ecb10afc30d5f0e92f8f0e4fd0a9c6e"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.24", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "15a5cf57f98c583dbada3d560d59fe70"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.79", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "1ed69ac5fd94523db32fe69b9be479a7"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.99", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "758ee5ddf4345c5e8d19ebaa915acc51"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.00", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "9bb2bb5dce4757569298e9ae5d2ec6b6"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.49", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "83a13058a30e51fd80543c53b7a3674d"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.40", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "639d44c9375457a6bf88b1c58c0ee3ed"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.35", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2adc8f73f60d5ce087e74ee4deb154ee"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.97", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d7b21fb024df5855ac9b3fae2780cd59"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.03", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "dd520197883d5b6d99c0bd594354ebf7"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.13", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "12e2703fc2695d6897ccf016ece478bb"} diff --git a/workloads/gemm/gemm_qs8cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qs8cx_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..6ae6cfc457f1a40a0c59ab0e82acea22b58584fd --- /dev/null +++ b/workloads/gemm/gemm_qs8cx_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.61", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "0765aead0d5e5bf5bf8722d385108a23"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "44.12", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "39691452c5565dbeb34ff32a6cccd9f9"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.88", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6fea93c34dec5083a6c94995c1219345"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.86", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d54c417120005fa2befe93c0b2ce74a9"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.15", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "5043d01cf9b850538beff18445c290b5"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.02", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7907cc40c4ae509db0e8e34ae62d4c56"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.38", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "591f6a93d7da531dba4a6c76e6e3fa9e"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.90", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "77bff44e93d6513099752082c4d7be1c"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.12", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b91a7ae3f9875809aa2e8d151e1d8982"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.97", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "57cfab6399d459fd889df949f62e03fd"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.00", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "aaf8d6d815665909824e9ea9725d0312"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.86", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "ab86ad1a1c9a5ec681ea06013b0c376b"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q8": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.31", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "54eec958de7358ba89b337e2b7f6e472"} diff --git a/workloads/gemm/gemm_qsu2cx_n256_k512.jsonl b/workloads/gemm/gemm_qsu2cx_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..41bcc160ff4254b39c4d334830e3d026486f6548 --- /dev/null +++ b/workloads/gemm/gemm_qsu2cx_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "50.10", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "424accf483515b2fbf7f5d38c95f7bf1"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.33", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "10da941baab15530942e94f4188e6f8e"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "46.63", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7eb030a4aef65435941fe7903028c925"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.49", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "463e4ccf3b75537bbfef83a5b23cf67b"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.03", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e34ea5181a7d50c7b4dce64759e44bad"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.30", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "aaa41d9e34605bbeb16d5328b4c44086"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.92", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "19033868cbdb5c39bdd9c2e1ff557262"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.06", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "3f25ae92b3a7584f970a29555eb0df80"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.93", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b3e874ecc0d7516c97bd07bfcd4a60d8"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.29", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "eb06687609d453478f10c97ddf8f60b4"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.16", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b702c58089525e9f80dcd8634919d38a"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.05", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f7a801ec3a615008bf8ccf9ef9b1484f"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.17", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "5d481ae514ec5c07936a14ef2b562402"} diff --git a/workloads/gemm/gemm_qsu2cx_sme2_n256_k512.jsonl b/workloads/gemm/gemm_qsu2cx_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..0fe565ba5f30f4917a4c11dbc036e3a36ff87b78 --- /dev/null +++ b/workloads/gemm/gemm_qsu2cx_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.02", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "7c6f61905ab6585fb3dc2276ecd54980"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.86", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "2f199d0d02d25da39ef72bd24216aee3"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "47.43", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "50aa007c840257c5af212f290752fb61"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.33", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "d8a612c787b15fbca7b4b470b1a7d620"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.22", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "62923ad5a37954ebb1d1aa6d8075c9dc"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.46", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "b9d6751d7af85da5a2c07b6a7620352a"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.20", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "f526e52dcd9255f2937f8fde1cc7f4af"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.27", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6a347962fa775c3287ba3f6835449ece"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.65", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "6d5b6a89961c5d078801b13c9a52bf97"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.15", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "371bb7e3cc905614874a3ee3142c3124"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.07", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "e81499d7b15554eca439dd83392d4096"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.30", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "56a23058c9c6538da4299a8b29d88f28"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B_q2": {"type": "random"}, "B_scales": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload", "baseline_sqnr_db": "48.13", "baseline_sqnr_author": "baseline-kleidiai-arm"}, "uuid": "587a6d5eb3a65ca4b96c37d7563b3573"} diff --git a/workloads/gemm/gemm_u8_f32_sme2_n256_k512.jsonl b/workloads/gemm/gemm_u8_f32_sme2_n256_k512.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..88d704091408131399a0f3212993f02049a6920c --- /dev/null +++ b/workloads/gemm/gemm_u8_f32_sme2_n256_k512.jsonl @@ -0,0 +1,13 @@ +{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "2206c28668a153a7a58f93ea093b1d60"} +{"axes": {"M": 4}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "5a66f99bfe435be1b741332ebea6d5ff"} +{"axes": {"M": 8}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "1613cafe38f8503b881c248decbc0bb2"} +{"axes": {"M": 256}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "0c69876489f35e4b8d911d286e2e139b"} +{"axes": {"M": 300}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "b1918bdcd3d85051ba8a263d57a2b5b2"} +{"axes": {"M": 384}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "4694a41be48456aa9b3706a63e0d861c"} +{"axes": {"M": 448}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "adff07cdadb456e1914e0c5335ba3c02"} +{"axes": {"M": 512}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "9ae41ca7a16f580ab52b73dd03dfa8f4"} +{"axes": {"M": 640}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "e8dde2e477c057698c2bd967cf2cd19c"} +{"axes": {"M": 777}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "42259bc706265f268f1bb998c9285cb5"} +{"axes": {"M": 1024}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "0a6ffe5b54ce59f7b1d1153f89adfecf"} +{"axes": {"M": 1536}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "b29b4ba5a499592ab3c3df3177f73d50"} +{"axes": {"M": 2048}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "C_scale": {"type": "random"}, "bias": {"type": "random"}}, "tags": {"from": "gen_workload"}, "uuid": "bc6efc248eaf5395aaf3c6610255f58e"}