Dataset Viewer
Auto-converted to Parquet Duplicate
name
stringlengths
8
50
source
stringclasses
5 values
op_type
stringlengths
3
16
description
stringlengths
14
935
eval_set
bool
2 classes
eval_group
stringclasses
6 values
subset_sve
bool
2 classes
subset_sme2
bool
2 classes
num_workloads
int64
4
24
baselines
listlengths
0
3
tags
listlengths
1
6
axes
stringlengths
22
549
inputs
stringlengths
41
901
outputs
stringlengths
43
94
constraints
stringclasses
4 values
reference
stringlengths
52
2.32k
conv2d_f16_nhwc_kh3_kw3_valid_c32_c64
kleidiai
conv2d
'Valid' (no padding) 2D conv, Kh=Kw=3 stride=1, NHWC/HWIO, C_in=32/C_out=64 baked, N=1. A/weight/bias are f16 (raw uint16 bit-pattern per this repo's raw ABI convention -- bench/datasets/raw.py's _DTYPE_TO_NP_AND_PTR); output stays float32 (RawDataset always allocates a float32 output buffer). This definition exists to...
true
kleidiai-sme2
false
false
20
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"H": {"type": "var"}, "W": {"type": "var"}, "H_out": {"type": "var"}, "W_out": {"type": "var"}, "N": {"type": "const", "value": 1}, "C_in": {"type": "const", "value": 32}, "C_out": {"type": "const", "value": 64}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}}
{"input": {"shape": ["N", "H", "W", "C_in"], "dtype": "float16"}, "weight": {"shape": ["Kh", "Kw", "C_in", "C_out"], "dtype": "float16"}, "bias": {"shape": ["C_out"], "dtype": "float16"}}
{"output": {"shape": ["N", "H_out", "W_out", "C_out"], "dtype": "float32"}}
["H_out == H - Kh + 1", "W_out == W - Kw + 1"]
import numpy as np import torch import torch.nn.functional as F def run(input, weight, bias): # input: [N,H,W,C_in] f16 -> NCHW f32 for torch x = torch.from_numpy(input.astype(np.float32)).permute(0, 3, 1, 2) # weight: [Kh,Kw,C_in,C_out] -> torch [C_out,C_in,Kh,Kw] w = torch.from_numpy(weight.astype(n...
conv2d_fp32_kh1_kw1_sh1_sw1_dh1_dw1_p0
ncnn
conv2d
2D conv 1x1 stride=(1,1) dilation=(1,1) pad=(0,0). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 1}, "Kw": {"type": "const", "value": 1}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(1, 1), padding=(0, 0), dilation=(1, 1)).numpy()
conv2d_fp32_kh1_kw1_sh2_sw2_dh1_dw1_p0
ncnn
conv2d
2D conv 1x1 stride=(2,2) dilation=(1,1) pad=(0,0). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 1}, "Kw": {"type": "const", "value": 1}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(2, 2), padding=(0, 0), dilation=(1, 1)).numpy()
conv2d_fp32_kh3_kw3_sh1_sw1_dh1_dw1_p1
ncnn
conv2d
2D conv 3x3 stride=(1,1) dilation=(1,1) pad=(1,1). C_in and C_out vary per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(1, 1), padding=(1, 1), dilation=(1, 1)).numpy()
conv2d_fp32_kh3_kw3_sh2_sw2_dh1_dw1_p1
ncnn
conv2d
2D conv 3x3 stride=(2,2) dilation=(1,1) pad=(1,1). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(2, 2), padding=(1, 1), dilation=(1, 1)).numpy()
conv2d_fp32_kh7_kw7_sh2_sw2_dh1_dw1_p3
ncnn
conv2d
2D conv 7x7 stride=(2,2) dilation=(1,1) pad=(3,3). C_in and C_out vary per workload.
true
ncnn
true
true
11
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 7}, "Kw": {"type": "const", "value": 7}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(2, 2), padding=(3, 3), dilation=(1, 1)).numpy()
conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64
kleidiai
conv2d
'Same' conv2d (Kh=Kw=3, stride=1, pad=1, so H_out=H/W_out=W) in NHWC input / HWIO weight layout (channels-last) — 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...
true
kleidiai
false
false
16
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"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}}
{"input": {"shape": ["N", "H", "W", "C_in"], "dtype": "float32"}, "weight": {"shape": ["Kh", "Kw", "C_in", "C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "H", "W", "C_out"], "dtype": "float32"}}
[]
import numpy as np def run(input, weight): N, H, W, C_in = input.shape Kh, Kw, _, C_out = weight.shape pad = 1 padded = np.pad(input, ((0, 0), (pad, pad), (pad, pad), (0, 0))) out = np.zeros((N, H, W, C_out), dtype=np.float32) for n in range(N): for oh in range(H): for ow in ...
conv2d_fp32_nhwc_kh3_kw3_s1_p1_c32_c64_sme2
kleidiai
conv2d
'Same' conv2d (Kh=Kw=3, stride=1, pad=1, so H_out=H/W_out=W) in NHWC input / HWIO weight layout (channels-last) — 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...
true
kleidiai-sme2
false
false
16
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"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}}
{"input": {"shape": ["N", "H", "W", "C_in"], "dtype": "float32"}, "weight": {"shape": ["Kh", "Kw", "C_in", "C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "H", "W", "C_out"], "dtype": "float32"}}
[]
import numpy as np def run(input, weight): N, H, W, C_in = input.shape Kh, Kw, _, C_out = weight.shape pad = 1 padded = np.pad(input, ((0, 0), (pad, pad), (pad, pad), (0, 0))) out = np.zeros((N, H, W, C_out), dtype=np.float32) for n in range(N): for oh in range(H): for ow in ...
conv2d_w8a8ch_kh1_kw1_sh1_sw1_dh1_dw1_p0
ncnn
conv2d
2D conv 1x1 stride=(1,1) dilation=(1,1) pad=(0,0). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 1}, "Kw": {"type": "const", "value": 1}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C_out"], "dtype": "float32"}, "input_scale": {"shape": null, "dtype": "float32"}, "weight_scales": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scale, weight_scales): N, Cin, H, W = input.shape Cout = weight.shape[0] Kh, Kw = 1, 1 Sh, Sw = 1, 1 Dh, Dw = 1, 1 Ph, Pw = 0, 0 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 ...
conv2d_w8a8ch_kh1_kw1_sh2_sw2_dh1_dw1_p0
ncnn
conv2d
2D conv 1x1 stride=(2,2) dilation=(1,1) pad=(0,0). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 1}, "Kw": {"type": "const", "value": 1}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C_out"], "dtype": "float32"}, "input_scale": {"shape": null, "dtype": "float32"}, "weight_scales": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scale, weight_scales): N, Cin, H, W = input.shape Cout = weight.shape[0] Kh, Kw = 1, 1 Sh, Sw = 2, 2 Dh, Dw = 1, 1 Ph, Pw = 0, 0 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 ...
conv2d_w8a8ch_kh3_kw3_sh1_sw1_dh1_dw1_p1
ncnn
conv2d
2D conv 3x3 stride=(1,1) dilation=(1,1) pad=(1,1). C_in and C_out vary per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C_out"], "dtype": "float32"}, "input_scale": {"shape": null, "dtype": "float32"}, "weight_scales": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scale, weight_scales): N, Cin, H, W = input.shape Cout = weight.shape[0] Kh, Kw = 3, 3 Sh, Sw = 1, 1 Dh, Dw = 1, 1 Ph, Pw = 1, 1 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 ...
conv2d_w8a8ch_kh3_kw3_sh2_sw2_dh1_dw1_p1
ncnn
conv2d
2D conv 3x3 stride=(2,2) dilation=(1,1) pad=(1,1). C_in and C_out vary per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C_out"], "dtype": "float32"}, "input_scale": {"shape": null, "dtype": "float32"}, "weight_scales": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scale, weight_scales): N, Cin, H, W = input.shape Cout = weight.shape[0] Kh, Kw = 3, 3 Sh, Sw = 2, 2 Dh, Dw = 1, 1 Ph, Pw = 1, 1 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 ...
conv2d_w8a8ch_kh7_kw7_sh2_sw2_dh1_dw1_p3
ncnn
conv2d
2D conv 7x7 stride=(2,2) dilation=(1,1) pad=(3,3). C_in and C_out vary per workload.
true
ncnn
true
true
11
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C_in": {"type": "var"}, "C_out": {"type": "var"}, "Kh": {"type": "const", "value": 7}, "Kw": {"type": "const", "value": 7}, "Sh": {"type": "...
{"input": {"shape": ["N", "C_in", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C_out", "C_in", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C_out"], "dtype": "float32"}, "input_scale": {"shape": null, "dtype": "float32"}, "weight_scales": {"shape": ["C_out"], "dtype": "float32"}}
{"output": {"shape": ["N", "C_out", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scale, weight_scales): N, Cin, H, W = input.shape Cout = weight.shape[0] Kh, Kw = 7, 7 Sh, Sw = 2, 2 Dh, Dw = 1, 1 Ph, Pw = 3, 3 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 ...
conv2d_depthwise_f16_nhwc_kh3_kw3_s1_p1
kleidiai
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(1,1) 'same' pad=(1,1), NHWC layout, depth_multiplier=1 (C_in=C_out=C=groups), N=1, f16 throughout inputs (raw uint16 bit patterns per this repo's raw ABI convention), f32 output (RawDataset always allocates float32 output). SME2 counterpart to conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1 (f32/...
true
kleidiai-sme2
false
false
20
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"H": {"type": "var"}, "W": {"type": "var"}, "H_out": {"type": "var"}, "W_out": {"type": "var"}, "C": {"type": "var"}, "N": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "const", "value": 1}, "Sw": {"type": "const", "value": 1}, "pad_top": {"type...
{"input": {"shape": ["N", "H", "W", "C"], "dtype": "float16"}, "weight": {"shape": ["Kh", "Kw", "C"], "dtype": "float16"}, "bias": {"shape": ["C"], "dtype": "float16"}}
{"output": {"shape": ["N", "H_out", "W_out", "C"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - (Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - (Kw-1) - 1) // Sw + 1"]
import numpy as np import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input.astype(np.float32)).permute(0, 3, 1, 2) w = torch.from_numpy(weight.astype(np.float32)).permute(2, 0, 1).unsqueeze(1) b = torch.from_numpy(bias.astype(np.float32)) y = F.conv2d(x, w...
conv2d_depthwise_fp32_kh3_kw3_sh1_sw1_dh1_dw1_p1
ncnn
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(1,1) dilation=(1,1) pad=(1,1). C (=C_in=C_out=groups) varies per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=x.shape[1]).numpy()
conv2d_depthwise_fp32_kh3_kw3_sh2_sw2_dh1_dw1_p1
ncnn
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(2,2) dilation=(1,1) pad=(1,1). C (=C_in=C_out=groups) varies per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(2, 2), padding=(1, 1), dilation=(1, 1), groups=x.shape[1]).numpy()
conv2d_depthwise_fp32_kh5_kw5_sh1_sw1_dh1_dw1_p2
ncnn
conv2d_depthwise
Depthwise 2D conv 5x5 stride=(1,1) dilation=(1,1) pad=(2,2). C (=C_in=C_out=groups) varies per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 5}, "Kw": {"type": "const", "value": 5}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(1, 1), padding=(2, 2), dilation=(1, 1), groups=x.shape[1]).numpy()
conv2d_depthwise_fp32_kh5_kw5_sh2_sw2_dh1_dw1_p2
ncnn
conv2d_depthwise
Depthwise 2D conv 5x5 stride=(2,2) dilation=(1,1) pad=(2,2). C (=C_in=C_out=groups) varies per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 5}, "Kw": {"type": "const", "value": 5}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "float32"}, "bias": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): x = torch.from_numpy(input) w = torch.from_numpy(weight) b = torch.from_numpy(bias) return F.conv2d(x, w, b, stride=(2, 2), padding=(2, 2), dilation=(1, 1), groups=x.shape[1]).numpy()
conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1
kleidiai
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(1,1) 'same' pad=(1,1), NHWC layout, depth_multiplier=1 (C_in=C_out=C=groups), N=1. NHWC (not NCHW like conv2d_depthwise_fp32_kh3_kw3_sh1_sw1_dh1_dw1_p1) because this definition exists to host a KleidiAI SME2 baseline (kai_dwconv_clamp_f32_f32_f32p1vlx1b_3x3_s1_4xc_sme2_mla), which requires...
true
kleidiai-sme2
false
false
20
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"H": {"type": "var"}, "W": {"type": "var"}, "H_out": {"type": "var"}, "W_out": {"type": "var"}, "C": {"type": "var"}, "N": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh": {"type": "const", "value": 1}, "Sw": {"type": "const", "value": 1}, "pad_top": {"type...
{"input": {"shape": ["N", "H", "W", "C"], "dtype": "float32"}, "weight": {"shape": ["Kh", "Kw", "C"], "dtype": "float32"}, "bias": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "H_out", "W_out", "C"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - (Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - (Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input, weight, bias): # input: [N,H,W,C] -> NCHW for torch x = torch.from_numpy(input).permute(0, 3, 1, 2) # weight: [Kh,Kw,C] -> torch depthwise weight [C,1,Kh,Kw] w = torch.from_numpy(weight).permute(2, 0, 1).unsqueeze(1) b = torch.from_numpy(...
conv2d_depthwise_w8a8ch_kh3_kw3_sh1_sw1_dh1_dw1_p1
ncnn
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(1,1) dilation=(1,1) pad=(1,1). C (=C_in=C_out=groups) varies per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C"], "dtype": "float32"}, "input_scales": {"shape": ["C"], "dtype": "float32"}, "weight_scales": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scales, weight_scales): N, C, H, W = input.shape Kh, Kw = 3, 3 Sh, Sw = 1, 1 Dh, Dw = 1, 1 Ph, Pw = 1, 1 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 input_f = input.astype(np.fl...
conv2d_depthwise_w8a8ch_kh3_kw3_sh2_sw2_dh1_dw1_p1
ncnn
conv2d_depthwise
Depthwise 2D conv 3x3 stride=(2,2) dilation=(1,1) pad=(1,1). C (=C_in=C_out=groups) varies per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 3}, "Kw": {"type": "const", "value": 3}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C"], "dtype": "float32"}, "input_scales": {"shape": ["C"], "dtype": "float32"}, "weight_scales": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scales, weight_scales): N, C, H, W = input.shape Kh, Kw = 3, 3 Sh, Sw = 2, 2 Dh, Dw = 1, 1 Ph, Pw = 1, 1 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 input_f = input.astype(np.fl...
conv2d_depthwise_w8a8ch_kh5_kw5_sh1_sw1_dh1_dw1_p2
ncnn
conv2d_depthwise
Depthwise 2D conv 5x5 stride=(1,1) dilation=(1,1) pad=(2,2). C (=C_in=C_out=groups) varies per workload.
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 5}, "Kw": {"type": "const", "value": 5}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C"], "dtype": "float32"}, "input_scales": {"shape": ["C"], "dtype": "float32"}, "weight_scales": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scales, weight_scales): N, C, H, W = input.shape Kh, Kw = 5, 5 Sh, Sw = 1, 1 Dh, Dw = 1, 1 Ph, Pw = 2, 2 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 input_f = input.astype(np.fl...
conv2d_depthwise_w8a8ch_kh5_kw5_sh2_sw2_dh1_dw1_p2
ncnn
conv2d_depthwise
Depthwise 2D conv 5x5 stride=(2,2) dilation=(1,1) pad=(2,2). C (=C_in=C_out=groups) varies per workload.
true
ncnn
false
false
20
[ "baseline-ncnn" ]
[ "status:active", "model:mobilenetv3-large", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "C_group": {"type": "const", "value": 1}, "Kh": {"type": "const", "value": 5}, "Kw": {"type": "const", "value": 5}, "Sh...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "int8"}, "weight": {"shape": ["C", "C_group", "Kh", "Kw"], "dtype": "int8"}, "bias": {"shape": ["C"], "dtype": "float32"}, "input_scales": {"shape": ["C"], "dtype": "float32"}, "weight_scales": {"shape": ["C"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import numpy as np def run(input, weight, bias, input_scales, weight_scales): N, C, H, W = input.shape Kh, Kw = 5, 5 Sh, Sw = 2, 2 Dh, Dw = 1, 1 Ph, Pw = 2, 2 Hout = (H + 2 * Ph - Dh * (Kh - 1) - 1) // Sh + 1 Wout = (W + 2 * Pw - Dw * (Kw - 1) - 1) // Sw + 1 input_f = input.astype(np.fl...
gemm_bf16_n1024_k2048
llama.cpp
gemm
expert ffn N=1024 K=2048
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 2048}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K"], "dtype": "bfloat16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A.astype(np.float32) @ B.astype(np.float32).T
gemm_bf16_n1408_k2048
llama.cpp
gemm
expert ffn N=1408 K=2048
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1408}, "K": {"type": "const", "value": 2048}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K"], "dtype": "bfloat16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A.astype(np.float32) @ B.astype(np.float32).T
gemm_bf16_n2048_k1024
llama.cpp
gemm
expert ffn N=2048 K=1024
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1024}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K"], "dtype": "bfloat16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A.astype(np.float32) @ B.astype(np.float32).T
gemm_bf16_n2048_k1408
llama.cpp
gemm
expert ffn N=2048 K=1408
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1408}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K"], "dtype": "bfloat16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A.astype(np.float32) @ B.astype(np.float32).T
gemm_bf16_n2048_k2048
llama.cpp
gemm
attn proj N=2048 K=2048
true
llama.cpp
true
true
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 2048}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K"], "dtype": "bfloat16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A.astype(np.float32) @ B.astype(np.float32).T
gemm_bf16_n512_k512
kleidiai
gemm
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, ...
true
kleidiai-sme2
false
false
15
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B": {"shape": ["K", "N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B, bias): return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)
gemm_f16_n512_k512
kleidiai
gemm
GEMM+bias, N=512 K=512, f16 throughout inputs (A[M,K], B[K,N] -- 'kxn' layout matching kai_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme's native input layout, no transpose needed -- and bias[N], all raw uint16 bit patterns per this repo's raw ABI convention for float16-dtype tensors), f32 output (RawDataset always allocates flo...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float16"}, "B": {"shape": ["K", "N"], "dtype": "float16"}, "bias": {"shape": ["N"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B, bias): return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)
gemm_f16_qai4c32_sme2_n256_k512
kleidiai
gemm
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 doma...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, B_zeros, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 s = np.repeat(B_scales.astype(np.float32), 32, axis=1) ...
gemm_f16_qs4cx_sme2_n256_k512
kleidiai
gemm
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 nativ...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "K_half": {"type": "const", "value": 256}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 B = deq * B_scales.astype(np.float32)[:, None] return (A.astyp...
gemm_f16_qs8cx_sme2_n256_k512
kleidiai
gemm
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 wid...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float16"}, "B_q8": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q8, B_scales, bias): B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None] return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)
gemm_f16act_qs4c32_sme2_n256_k512
kleidiai
gemm
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-wei...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"A": {"shape": ["M", "K"], "dtype": "float16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_blocks"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales): n, k_half = B_q4.shape bl = 32 nb = k_half // (bl // 2) lo = (B_q4 & 0x0F).astype(np.float32) - 8.0 hi = (B_q4 >> 4).astype(np.float32) - 8.0 deq = np.concatenate([lo.reshape(n, nb, bl // 2), hi.reshape(n, nb, bl // 2)], axis=-1).reshape(n, nb * b...
gemm_f32_bf16_n512_k512
kleidiai
gemm
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. ...
false
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B": {"shape": ["K", "N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B, bias): return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)
gemm_fp32_n512_k512
kleidiai
gemm
fc N=512 K=512
true
kleidiai
true
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B": {"shape": ["N", "K"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return A @ B.T
gemm_fp32_sme2_n512_k512
kleidiai
gemm
GEMM+bias, N=512 K=512, full fp32 throughout (A[M,K], B[K,N] -- 'kxn' layout matching kai_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme's native input layout, no transpose needed -- and bias[N]), f32 output. This definition exists to host a KleidiAI SME2 baseline (kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla) -- the SME...
true
kleidiai-sme2
false
true
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B": {"shape": ["K", "N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B, bias): return (A.astype(np.float32) @ B.astype(np.float32) + bias.astype(np.float32)).astype(np.float32)
gemm_ggml_q4_K_n1024_k2560
e2e
gemm
qwen35 blk.N.attn_k.weight×8, blk.N.attn_v.weight×3: N=1024 K=2560, ggml Q4_K block rows (e2e, 0.6% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0059" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 1440}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n1024_k4096
e2e
gemm
llama blk.N.attn_k.weight×32, blk.N.attn_v.weight×16: N=1024 K=4096, ggml Q4_K block rows (e2e, 2.5% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.0246" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 2304}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n14336_k4096
e2e
gemm
llama blk.N.ffn_gate.weight×32, blk.N.ffn_up.weight×32: N=14336 K=4096, ggml Q4_K block rows (e2e, 45.8% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.4578" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 14336}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 2304}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n2560_k4096
e2e
gemm
qwen35 blk.N.attn_output.weight×8: N=2560 K=4096, ggml Q4_K block rows (e2e, 1.7% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0173" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2560}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 2304}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n2560_k9216
e2e
gemm
qwen35 blk.N.ffn_down.weight×16: N=2560 K=9216, ggml Q4_K block rows (e2e, 7.8% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0778" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2560}, "K": {"type": "const", "value": 9216}, "K_blk": {"type": "const", "value": 36}, "K_bytes": {"type": "const", "value": 5184}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n4096_k14336
e2e
gemm
llama blk.N.ffn_down.weight×16: N=4096 K=14336, ggml Q4_K block rows (e2e, 11.5% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.1145" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 4096}, "K": {"type": "const", "value": 14336}, "K_blk": {"type": "const", "value": 56}, "K_bytes": {"type": "const", "value": 8064}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n4096_k2560
e2e
gemm
qwen35 blk.N.attn_gate.weight×24: N=4096 K=2560, ggml Q4_K block rows (e2e, 5.2% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0519" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 4096}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 1440}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n4096_k4096
e2e
gemm
llama blk.N.attn_output.weight×32, blk.N.attn_q.weight×32: N=4096 K=4096, ggml Q4_K block rows (e2e, 13.1% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.1308" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 4096}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 2304}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n8192_k2560
e2e
gemm
qwen35 blk.N.attn_q.weight×8: N=8192 K=2560, ggml Q4_K block rows (e2e, 3.5% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0346" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 8192}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 1440}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q4_K_n9216_k2560
e2e
gemm
qwen35 blk.N.ffn_gate.weight×32, blk.N.ffn_up.weight×32: N=9216 K=2560, ggml Q4_K block rows (e2e, 31.1% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.3112" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 9216}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 1440}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q5_K_n2560_k4096
e2e
gemm
qwen35 blk.N.ssm_out.weight×24: N=2560 K=4096, ggml Q5_K block rows (e2e, 6.3% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0634" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2560}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 2816}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q5_K_n8192_k2560
e2e
gemm
qwen35 blk.N.attn_qkv.weight×24: N=8192 K=2560, ggml Q5_K block rows (e2e, 12.7% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.1268" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 8192}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 1760}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def unpack_scales_k4(s12): # ggml get_scale_min_k4 over the 12-byte packed field -> (sc, mn) [..., 8] s12 = s12.astype(np.uint8) sc = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) mn = np.empty(s12.shape[:-1] + (8,), dtype=np.float32) for j in range(4): sc[..., j] = ...
gemm_ggml_q6_K_n1024_k2560
e2e
gemm
qwen35 blk.N.attn_v.weight×5: N=1024 K=2560, ggml Q6_K block rows (e2e, 0.4% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.0039" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 2100}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_ggml_q6_K_n1024_k4096
e2e
gemm
llama blk.N.attn_v.weight×16: N=1024 K=4096, ggml Q6_K block rows (e2e, 1.2% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.0119" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 3360}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_ggml_q6_K_n128256_k4096
e2e
gemm
llama output.weight×1: N=128256 K=4096, ggml Q6_K block rows (e2e, 9.3% of decode bytes)
false
false
false
4
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.0933" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 128256}, "K": {"type": "const", "value": 4096}, "K_blk": {"type": "const", "value": 16}, "K_bytes": {"type": "const", "value": 3360}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_ggml_q6_K_n248320_k2560
e2e
gemm
qwen35 token_embd.weight×1: N=248320 K=2560, ggml Q6_K block rows (e2e, 19.1% of decode bytes)
false
false
false
4
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.1910" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 248320}, "K": {"type": "const", "value": 2560}, "K_blk": {"type": "const", "value": 10}, "K_bytes": {"type": "const", "value": 2100}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_ggml_q6_K_n2560_k9216
e2e
gemm
qwen35 blk.N.ffn_down.weight×16: N=2560 K=9216, ggml Q6_K block rows (e2e, 11.3% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen3.5-4b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:qwen3.5-4b", "e2e-share:0.1134" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2560}, "K": {"type": "const", "value": 9216}, "K_blk": {"type": "const", "value": 36}, "K_bytes": {"type": "const", "value": 7560}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_ggml_q6_K_n4096_k14336
e2e
gemm
llama blk.N.ffn_down.weight×16: N=4096 K=14336, ggml Q6_K block rows (e2e, 16.7% of decode bytes)
false
false
false
6
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "baseline-solution:llama.cpp", "correctness:sqnr", "e2e:llama-3.1-8b", "e2e-share:0.1669" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 4096}, "K": {"type": "const", "value": 14336}, "K_blk": {"type": "const", "value": 56}, "K_bytes": {"type": "const", "value": 11760}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B": {"shape": ["N", "K_bytes"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def f16(b): # little-endian fp16 bytes [..., 2] -> float32 [...] return np.ascontiguousarray(b).view("<f2")[..., 0].astype(np.float32) def dequant_ggml_q6_K(B): # B: uint8 [N, K/256 * 210] rows of ggml block_q6_K # {uint8 ql[128]; uint8 qh[64]; int8 scales[16]; fp16 d} n_rows,...
gemm_i32_u8_sme2_n256_k512
kleidiai
gemm
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 bas...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "uint8"}, "B": {"shape": ["N", "K"], "dtype": "uint8"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B): return (A.astype(np.int64) @ B.astype(np.int64).T).astype(np.int32).astype(np.float32)
gemm_q4_k_m_n1024_k2048
llama.cpp
gemm
expert ffn N=1024 K=2048
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 2048}, "K_half": {"type": "const", "value": 1024}, "K_sub": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_sub"], "dtype": "float16"}, "B_mins": {"shape": ["N", "K_sub"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
gemm_q4_k_m_n1408_k2048
llama.cpp
gemm
expert ffn N=1408 K=2048
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1408}, "K": {"type": "const", "value": 2048}, "K_half": {"type": "const", "value": 1024}, "K_sub": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_sub"], "dtype": "float16"}, "B_mins": {"shape": ["N", "K_sub"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
gemm_q4_k_m_n2048_k1024
llama.cpp
gemm
expert ffn N=2048 K=1024
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1024}, "K_half": {"type": "const", "value": 512}, "K_sub": {"type": "const", "value": 32}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_sub"], "dtype": "float16"}, "B_mins": {"shape": ["N", "K_sub"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
gemm_q4_k_m_n2048_k1536
llama.cpp
gemm
expert ffn N=2048 K=1536 (K rounded up from 1408 to 1536, the next multiple of 256, since Q4_K requires the reduction dim divisible by 256; real GGML would fall back to Q5_0 for the unrounded 1408 shape)
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1536}, "K_half": {"type": "const", "value": 768}, "K_sub": {"type": "const", "value": 48}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_sub"], "dtype": "float16"}, "B_mins": {"shape": ["N", "K_sub"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
gemm_q4_k_m_n2048_k2048
llama.cpp
gemm
expert ffn N=2048 K=2048
true
llama.cpp
true
true
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 2048}, "K_half": {"type": "const", "value": 1024}, "K_sub": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "bfloat16"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_sub"], "dtype": "float16"}, "B_mins": {"shape": ["N", "K_sub"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
gemm_q8_0_n1024_k2048
llama.cpp
gemm
expert ffn N=1024 K=2048
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1024}, "K": {"type": "const", "value": 2048}, "K_blk": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "int8"}, "A_scales": {"shape": ["M", "K_blk"], "dtype": "float16"}, "B": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N", "K_blk"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scales, B, B_scales): M = A.shape[0]; blk = 32 A_f = (A.reshape(M, -1, blk).astype(np.float32) * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048) B_f = (B.reshape(1024, -1, blk).astype(np.float32) * B_scales.astype(np.float32)[:, :, np.new...
gemm_q8_0_n1408_k2048
llama.cpp
gemm
expert ffn N=1408 K=2048
true
llama.cpp
true
true
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 1408}, "K": {"type": "const", "value": 2048}, "K_blk": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "int8"}, "A_scales": {"shape": ["M", "K_blk"], "dtype": "float16"}, "B": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N", "K_blk"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scales, B, B_scales): M = A.shape[0]; blk = 32 A_f = (A.reshape(M, -1, blk).astype(np.float32) * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048) B_f = (B.reshape(1408, -1, blk).astype(np.float32) * B_scales.astype(np.float32)[:, :, np.new...
gemm_q8_0_n2048_k1024
llama.cpp
gemm
expert ffn N=2048 K=1024
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1024}, "K_blk": {"type": "const", "value": 32}}
{"A": {"shape": ["M", "K"], "dtype": "int8"}, "A_scales": {"shape": ["M", "K_blk"], "dtype": "float16"}, "B": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N", "K_blk"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scales, B, B_scales): M = A.shape[0]; blk = 32 A_f = (A.reshape(M, -1, blk).astype(np.float32) * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 1024) B_f = (B.reshape(2048, -1, blk).astype(np.float32) * B_scales.astype(np.float32)[:, :, np.new...
gemm_q8_0_n2048_k1408
llama.cpp
gemm
expert ffn N=2048 K=1408
true
llama.cpp
false
false
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 1408}, "K_blk": {"type": "const", "value": 44}}
{"A": {"shape": ["M", "K"], "dtype": "int8"}, "A_scales": {"shape": ["M", "K_blk"], "dtype": "float16"}, "B": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N", "K_blk"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scales, B, B_scales): M = A.shape[0]; blk = 32 A_f = (A.reshape(M, -1, blk).astype(np.float32) * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 1408) B_f = (B.reshape(2048, -1, blk).astype(np.float32) * B_scales.astype(np.float32)[:, :, np.new...
gemm_q8_0_n2048_k2048
llama.cpp
gemm
attn proj N=2048 K=2048
true
llama.cpp
true
true
24
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 2048}, "K": {"type": "const", "value": 2048}, "K_blk": {"type": "const", "value": 64}}
{"A": {"shape": ["M", "K"], "dtype": "int8"}, "A_scales": {"shape": ["M", "K_blk"], "dtype": "float16"}, "B": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N", "K_blk"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scales, B, B_scales): M = A.shape[0]; blk = 32 A_f = (A.reshape(M, -1, blk).astype(np.float32) * A_scales.astype(np.float32)[:, :, np.newaxis]).reshape(M, 2048) B_f = (B.reshape(2048, -1, blk).astype(np.float32) * B_scales.astype(np.float32)[:, :, np.new...
gemm_qai4c32_n256_k512
kleidiai
gemm
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] al...
false
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, B_zeros, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 s = np.repeat(B_scales.astype(np.float32), 32, axis=1) ...
gemm_qai4c32_sme2_n256_k512
kleidiai
gemm
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...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, B_zeros, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 s = np.repeat(B_scales.astype(np.float32), 32, axis=1) ...
gemm_qai8_qsi8cx_sme2_n256_k512
kleidiai
gemm
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...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "S": {"type": "const", "value": 1}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, A_scale, B_q8, B_scales, bias, C_scale): acc = A.astype(np.int32) @ B_q8.astype(np.int32).T real = acc.astype(np.float32) * (A_scale[0] * B_scales.astype(np.float32))[None, :] + bias.astype(np.float32) q = np.rint(real / C_scale[0]) return np.clip(q, -128, 127).astype(np....
gemm_qai8dxp_qs4c32_n256_k512
kleidiai
gemm
GEMM+bias, N=256 K=512, weight-only-quantized block-wise int4 with dynamically int8-quantized activations (SVE): 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 s...
true
kleidiai
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 s = np.repeat(B_scales.astype(np.float32), 32, axis=1) B = deq...
gemm_qai8dxp_qs4c32_sme2_n256_k512
kleidiai
gemm
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 ...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 s = np.repeat(B_scales.astype(np.float32), 32, axis=1) B = deq...
gemm_qs4c32_n256_k512
kleidiai
gemm
fc N=256 K=512, weight-only-quantized: A is fp32, B ships pre-quantized as qs4c32 (int4 nibble-packed, block length 32, zero_point=8, per-block f16 scale) exactly like KleidiAI's own qsi4c32 RHS format — this is the wire format, there is no fp32 B anywhere upstream, matching the gemm_q4_k_m_*/moe_q8_0_* convention (qua...
true
kleidiai
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_blocks"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dequant_qs4c32(B_q4, B_scales, bl=32): n, k_half = B_q4.shape num_blocks = k_half // (bl // 2) lo = (B_q4 & 0x0F).astype(np.float32) - 8.0 hi = (B_q4 >> 4).astype(np.float32) - 8.0 lo = lo.reshape(n, num_blocks, bl // 2) hi = hi.reshape(n, num_blocks, bl // 2) deq = ...
gemm_qs4c32_sme2_n256_k512
kleidiai
gemm
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=(ni...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"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}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B_q4": {"shape": ["N", "K_half"], "dtype": "uint8"}, "B_scales": {"shape": ["N", "K_blocks"], "dtype": "float16"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales): n, k_half = B_q4.shape bl = 32 nb = k_half // (bl // 2) lo = (B_q4 & 0x0F).astype(np.float32) - 8.0 hi = (B_q4 >> 4).astype(np.float32) - 8.0 deq = np.concatenate([lo.reshape(n, nb, bl // 2), hi.reshape(n, nb, bl // 2)], axis=-1).reshape(n, nb * b...
gemm_qs4cx_n512_k512
kleidiai
gemm
GEMM+bias, N=512 K=512, weight-only-quantized per-channel int4: 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 wo...
true
kleidiai
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}, "K_half": {"type": "const", "value": 256}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q4, B_scales, bias): n, k_half = B_q4.shape deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = (B_q4 & 0x0F).astype(np.float32) - 8.0 deq[:, 1::2] = (B_q4 >> 4).astype(np.float32) - 8.0 B = deq * B_scales.astype(np.float32)[:, None] return (A.astyp...
gemm_qs4cx_sme2_n256_k512
kleidiai
gemm
GEMM+bias, N=256 K=512, weight-only-quantized with PER-CHANNEL (not per-block, unlike gemm_qs4c32_*) int4 granularity: A and bias are fp32, B ships pre-quantized as qs4cx -- one scale per output channel (row), covering the full K dimension, no block subdivision. Nibble packing is simple adjacent-pair (byte j holds k=2j...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "K_half": {"type": "const", "value": 256}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def dequant_qs4cx(B_q4, B_scales): n, k_half = B_q4.shape lo = (B_q4 & 0x0F).astype(np.float32) - 8.0 hi = (B_q4 >> 4).astype(np.float32) - 8.0 deq = np.empty((n, k_half * 2), dtype=np.float32) deq[:, 0::2] = lo deq[:, 1::2] = hi return deq * B_scales.astype(np.float32)[...
gemm_qs8cx_n512_k512
kleidiai
gemm
GEMM+bias, N=512 K=512, weight-only-quantized per-channel int8: 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, asym...
true
kleidiai
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 512}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B_q8": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q8, B_scales, bias): B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None] return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)
gemm_qs8cx_sme2_n256_k512
kleidiai
gemm
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 (qai8dx...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}}
{"A": {"shape": ["M", "K"], "dtype": "float32"}, "B_q8": {"shape": ["N", "K"], "dtype": "int8"}, "B_scales": {"shape": ["N"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q8, B_scales, bias): B = B_q8.astype(np.float32) * B_scales.astype(np.float32)[:, None] return (A.astype(np.float32) @ B.T + bias.astype(np.float32)).astype(np.float32)
gemm_qsu2cx_n256_k512
kleidiai
gemm
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; ...
false
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "K_q": {"type": "const", "value": 128}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q2, B_scales, bias): n, k_q = B_q2.shape deq = np.empty((n, k_q * 4), dtype=np.float32) for j in range(4): deq[:, j::4] = ((B_q2 >> (2 * j)) & 0x03).astype(np.float32) - 2.0 B = deq * B_scales.astype(np.float32)[:, None] return (A.astype(np.float32) @ B.T + ...
gemm_qsu2cx_sme2_n256_k512
kleidiai
gemm
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 ...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai", "correctness:sqnr" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "K_q": {"type": "const", "value": 128}}
{"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"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B_q2, B_scales, bias): n, k_q = B_q2.shape deq = np.empty((n, k_q * 4), dtype=np.float32) for j in range(4): deq[:, j::4] = ((B_q2 >> (2 * j)) & 0x03).astype(np.float32) - 2.0 B = deq * B_scales.astype(np.float32)[:, None] return (A.astype(np.float32) @ B.T + ...
gemm_u8_f32_sme2_n256_k512
kleidiai
gemm
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...
true
kleidiai-sme2
false
false
13
[ "baseline-kleidiai" ]
[ "status:active", "baseline-solution:kleidiai" ]
{"M": {"type": "var"}, "N": {"type": "const", "value": 256}, "K": {"type": "const", "value": 512}, "S": {"type": "const", "value": 1}}
{"A": {"shape": ["M", "K"], "dtype": "uint8"}, "B": {"shape": ["N", "K"], "dtype": "uint8"}, "C_scale": {"shape": ["S"], "dtype": "float32"}, "bias": {"shape": ["N"], "dtype": "float32"}}
{"C": {"shape": ["M", "N"], "dtype": "float32"}}
[]
import numpy as np def run(A, B, C_scale, bias): acc = (A.astype(np.int64) @ B.astype(np.int64).T).astype(np.int32).astype(np.float32) return (acc * C_scale.astype(np.float32)[0] + bias.astype(np.float32)).astype(np.float32)
gqa_bf16_h32_d128_kvh8
llama.cpp
gqa
Causal GQA h=32 d=128 kv=8 (n_gqa=4)
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:llama-3.1-8b", "model:mistral-7b-v0.1", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "S": {"type": "var"}, "n_heads": {"type": "const", "value": 32}, "head_dim": {"type": "const", "value": 128}, "kv_heads": {"type": "const", "value": 8}}
{"Q": {"shape": ["M", "n_heads", "head_dim"], "dtype": "bfloat16"}, "K": {"shape": ["S", "kv_heads", "head_dim"], "dtype": "bfloat16"}, "V": {"shape": ["S", "kv_heads", "head_dim"], "dtype": "bfloat16"}}
{"output": {"shape": ["M", "n_heads", "head_dim"], "dtype": "float32"}}
[]
import numpy as np def run(Q, K, V): Q = Q.astype(np.float32) K = K.astype(np.float32) V = V.astype(np.float32) M, n_heads, head_dim = Q.shape S, kv_heads, _ = K.shape gqa_ratio = n_heads // kv_heads K_e = np.repeat(K, gqa_ratio, axis=1) V_e = np.repeat(V, gqa_ratio, axis=1) scal...
mha_bf16_h16_d128_kvh16
llama.cpp
mha
MHA h=16 d=128 kv=16
true
llama.cpp
true
true
20
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "S": {"type": "var"}, "n_heads": {"type": "const", "value": 16}, "head_dim": {"type": "const", "value": 128}, "kv_heads": {"type": "const", "value": 16}}
{"Q": {"shape": ["M", "n_heads", "head_dim"], "dtype": "bfloat16"}, "K": {"shape": ["S", "kv_heads", "head_dim"], "dtype": "bfloat16"}, "V": {"shape": ["S", "kv_heads", "head_dim"], "dtype": "bfloat16"}}
{"output": {"shape": ["M", "n_heads", "head_dim"], "dtype": "float32"}}
[]
import numpy as np def run(Q, K, V): Q = Q.astype(np.float32) K = K.astype(np.float32) V = V.astype(np.float32) M = Q.shape[0]; S = K.shape[0] K_e = K V_e = V Qt = Q.transpose(1, 0, 2) Kt = K_e.transpose(1, 0, 2) Vt = V_e.transpose(1, 0, 2) scores = np.matmul(Qt, Kt.transpose(0, ...
mla_decode_bf16_h16_lora512_rope64_v128
llama.cpp
mla_decode
Causal MLA decode (weight-absorbed/compressed form) h=16 kv_lora_rank=512 qk_rope=64 v_head_dim=128 (c_q=576, MQA-style shared K/V latent, decompressed via v_mla)
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:deepseek-v3", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "S": {"type": "var"}, "n_heads": {"type": "const", "value": 16}, "kv_lora_rank": {"type": "const", "value": 512}, "qk_rope_head_dim": {"type": "const", "value": 64}, "qk_nope_head_dim": {"type": "const", "value": 128}, "v_head_dim": {"type": "const", "value": 128}, "c_q": {"type": "const", "value...
{"Q": {"shape": ["M", "n_heads", "c_q"], "dtype": "bfloat16"}, "K": {"shape": ["S", "c_q"], "dtype": "bfloat16"}, "V": {"shape": ["S", "kv_lora_rank"], "dtype": "bfloat16"}, "v_mla": {"shape": ["n_heads", "v_head_dim", "kv_lora_rank"], "dtype": "bfloat16"}}
{"output": {"shape": ["M", "n_heads", "v_head_dim"], "dtype": "float32"}}
[]
import numpy as np def run(Q, K, V, v_mla): Q = Q.astype(np.float32) K = K.astype(np.float32) V = V.astype(np.float32) v_mla = v_mla.astype(np.float32) M = Q.shape[0] S = K.shape[0] # softmax scale uses the true un-absorbed head dim (qk_nope+qk_rope=192), # not the absorbed compute di...
mla_prefill_bf16_h16_qk192_vo128
llama.cpp
mla_prefill
Causal MLA prefill (decompressed/naive form) h=16 qk_dim=192 (qk_nope=128+qk_rope=64) vo_dim=128, num_kv_heads==num_qo_heads
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:deepseek-v3", "baseline-solution:llama.cpp" ]
{"M": {"type": "var"}, "S": {"type": "var"}, "n_heads": {"type": "const", "value": 16}, "qk_dim": {"type": "const", "value": 192}, "vo_dim": {"type": "const", "value": 128}}
{"Q": {"shape": ["M", "n_heads", "qk_dim"], "dtype": "bfloat16"}, "K": {"shape": ["S", "n_heads", "qk_dim"], "dtype": "bfloat16"}, "V": {"shape": ["S", "n_heads", "vo_dim"], "dtype": "bfloat16"}}
{"output": {"shape": ["M", "n_heads", "vo_dim"], "dtype": "float32"}}
[]
import numpy as np def run(Q, K, V): Q = Q.astype(np.float32) K = K.astype(np.float32) V = V.astype(np.float32) M = Q.shape[0] S = K.shape[0] scale = 0.07216878364870323 logits = np.einsum('mhd,shd->hms', Q, K) * scale delta = S - M q_pos = np.arange(M) kv_pos = np.arange(S) ...
moe_bf16_e60_k4_d2048_ff1408
llama.cpp
moe
MoE e=60 k=4 d=2048 ff=1408
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1408}, "n_expert": {"type": "const", "value": 60}, "n_expert_used": {"type": "const", "value": 4}}
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "bfloat16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "bfloat16"}, "gate_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "bfloat16"}, "up_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "bfloat16"}, "down_proj": {"shape"...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def run(hidden_states, router_weight, gate_proj, up_proj, down_proj): hidden_states = hidden_states.astype(np.float32) router_weight = router_weight.astype(np.float32) gate_proj = gate_proj.astype(np.float32) up_proj = up_proj.astype(np.float32) down_proj = down_proj.astype(np.flo...
moe_bf16_e64_k8_d2048_ff1024
llama.cpp
moe
MoE e=64 k=8 d=2048 ff=1024
true
llama.cpp
true
true
20
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1024}, "n_expert": {"type": "const", "value": 64}, "n_expert_used": {"type": "const", "value": 8}}
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "bfloat16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "bfloat16"}, "gate_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "bfloat16"}, "up_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "bfloat16"}, "down_proj": {"shape"...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def run(hidden_states, router_weight, gate_proj, up_proj, down_proj): hidden_states = hidden_states.astype(np.float32) router_weight = router_weight.astype(np.float32) gate_proj = gate_proj.astype(np.float32) up_proj = up_proj.astype(np.float32) down_proj = down_proj.astype(np.flo...
moe_q4_k_m_e60_k4_d2048_ff1536
llama.cpp
moe
MoE q4_k_m e=60 k=4 d=2048 ff=1536 (ff rounded up from 1408 to 1536, the next multiple of 256, since Q4_K requires the reduction dim divisible by 256; real GGML would fall back to Q5_0 for the unrounded 1408 shape on down_proj)
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1536}, "n_expert": {"type": "const", "value": 60}, "n_expert_used": {"type": "const", "value": 4}, "n_embd_half": {"type": "const", "value": 1024}, "n_embd_sub": {"type": "const", "value": 64}, "n_ff_half": {"ty...
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "bfloat16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "float32"}, "gate_proj_q4": {"shape": ["n_expert", "n_ff", "n_embd_half"], "dtype": "uint8"}, "gate_proj_scales": {"shape": ["n_expert", "n_ff", "n_embd_sub"], "dtype": "float16"}, "gate...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
moe_q4_k_m_e64_k8_d2048_ff1024
llama.cpp
moe
MoE q4_k_m e=64 k=8 d=2048 ff=1024
true
llama.cpp
true
true
20
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1024}, "n_expert": {"type": "const", "value": 64}, "n_expert_used": {"type": "const", "value": 8}, "n_embd_half": {"type": "const", "value": 1024}, "n_embd_sub": {"type": "const", "value": 64}, "n_ff_half": {"ty...
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "bfloat16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "float32"}, "gate_proj_q4": {"shape": ["n_expert", "n_ff", "n_embd_half"], "dtype": "uint8"}, "gate_proj_scales": {"shape": ["n_expert", "n_ff", "n_embd_sub"], "dtype": "float16"}, "gate...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def dq4k(q4, scales, mins): K = q4.shape[-1] * 2 lo = (q4 & 0x0F).astype(np.float32) hi = (q4 >> 4).astype(np.float32) nib = np.empty(q4.shape[:-1] + (K,), dtype=np.float32) nib[..., 0::2] = lo nib[..., 1::2] = hi s = np.repeat(scales.astype(np.float32), 32, axis=-1) ...
moe_q8_0_e60_k4_d2048_ff1408
llama.cpp
moe
MoE q8_0 e=60 k=4 d=2048 ff=1408
true
llama.cpp
false
false
20
[ "baseline-llamacpp" ]
[ "status:active", "model:qwen1.5-moe-a2.7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1408}, "n_expert": {"type": "const", "value": 60}, "n_expert_used": {"type": "const", "value": 4}, "n_embd_blk": {"type": "const", "value": 64}, "n_ff_blk": {"type": "const", "value": 44}}
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "int8"}, "hs_scales": {"shape": ["n_tokens", "n_embd_blk"], "dtype": "float16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "float32"}, "gate_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "int8"}, "gate_scales": {"shape": ["n_expe...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def run(hidden_states, hs_scales, router_weight, gate_proj, gate_scales, up_proj, up_scales, down_proj, down_scales): T = hidden_states.shape[0]; blk = 32 def dq(x, s): r, K = x.shape return (x.reshape(r, -1, blk).astype(np.float32) * s.astype(n...
moe_q8_0_e64_k8_d2048_ff1024
llama.cpp
moe
MoE q8_0 e=64 k=8 d=2048 ff=1024
true
llama.cpp
true
true
20
[ "baseline-llamacpp" ]
[ "status:active", "model:olmoe-1b-7b", "baseline-solution:llama.cpp", "correctness:sqnr" ]
{"n_tokens": {"type": "var"}, "n_embd": {"type": "const", "value": 2048}, "n_ff": {"type": "const", "value": 1024}, "n_expert": {"type": "const", "value": 64}, "n_expert_used": {"type": "const", "value": 8}, "n_embd_blk": {"type": "const", "value": 64}, "n_ff_blk": {"type": "const", "value": 32}}
{"hidden_states": {"shape": ["n_tokens", "n_embd"], "dtype": "int8"}, "hs_scales": {"shape": ["n_tokens", "n_embd_blk"], "dtype": "float16"}, "router_weight": {"shape": ["n_expert", "n_embd"], "dtype": "float32"}, "gate_proj": {"shape": ["n_expert", "n_ff", "n_embd"], "dtype": "int8"}, "gate_scales": {"shape": ["n_expe...
{"output": {"shape": ["n_tokens", "n_embd"], "dtype": "float32"}}
[]
import numpy as np def run(hidden_states, hs_scales, router_weight, gate_proj, gate_scales, up_proj, up_scales, down_proj, down_scales): T = hidden_states.shape[0]; blk = 32 def dq(x, s): r, K = x.shape return (x.reshape(r, -1, blk).astype(np.float32) * s.astype(n...
pooling_fp32_global_avg
ncnn
pooling
global average pooling
true
ncnn
true
true
20
[ "baseline-ncnn" ]
[ "status:active", "model:resnet50", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "C": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}}
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}}
{"output": {"shape": ["N", "C"], "dtype": "float32"}}
[]
import numpy as np def run(input): return input.mean(axis=(-2, -1))
pooling_fp32_max_kh2_kw2_sh2_sw2_p0
ncnn
pooling
2D max pool 2x2 stride=(2,2) dilation=(1,1) pad=(0,0). C varies per workload.
true
ncnn
false
false
6
[ "baseline-ncnn" ]
[ "status:active", "model:vgg16", "baseline-solution:ncnn" ]
{"N": {"type": "var"}, "H": {"type": "var", "parent": "N"}, "W": {"type": "var", "parent": "N"}, "H_out": {"type": "var", "parent": "N"}, "W_out": {"type": "var", "parent": "N"}, "C": {"type": "var"}, "Kh": {"type": "const", "value": 2}, "Kw": {"type": "const", "value": 2}, "Sh": {"type": "const", "value": 2}, "Sw": {"...
{"input": {"shape": ["N", "C", "H", "W"], "dtype": "float32"}}
{"output": {"shape": ["N", "C", "H_out", "W_out"], "dtype": "float32"}}
["H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1", "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"]
import torch import torch.nn.functional as F def run(input): x = torch.from_numpy(input) return F.max_pool2d(x, kernel_size=(2, 2), stride=(2, 2), padding=(0, 0), dilation=(1, 1)).numpy()
End of preview. Expand in Data Studio

KernelShift

Benchmark data for KernelShift: kernel optimization tasks for Arm (AArch64) CPUs across four generations of vector and matrix extensions: Neon, SVE (AWS Graviton3, 256-bit), SVE2 (AWS Graviton4, 128-bit) and SME2 (Apple M4). Each kernel definition comes with workloads, a scalar reference that serves as the correctness check and the agent's starting point, and an expert baseline: a candidate kernel is checked against the reference and timed against the baseline.

Code, the agent environments and the evaluation scripts: https://github.com/cmu-l3/kernel-shift. Project website: https://cmu-l3.github.io/kernel-shift/.

Contents

144 kernel definitions from four open-source projects, plus the matrix multiplications of two LLMs; 99 of them form the evaluation set.

Source Definitions Evaluation set Op types Expert baseline
ncnn 23 23 conv2d, conv2d_depthwise, pooling baseline-ncnn
llama.cpp 26 26 gemm, moe, mha, gqa, mla_decode, mla_prefill, rms_norm baseline-llamacpp
SIMD Loops 47 24 one loop per definition baseline-simd-loop-{sve,sve2,sme2}
KleidiAI 30 6 SVE + 20 SME2 gemm, conv2d, conv2d_depthwise, softmax baseline-kleidiai
e2e 18 – gemm on q4_K / q5_K / q6_K weights of Qwen3.5-4B and Llama-3.1-8B baseline-llamacpp
Total 144 99
  • expected_sets.json lists the evaluation set: 79 kernels evaluated on Graviton3 (ncnn, llama.cpp, simd-loop, and kleidiai for the six KleidiAI kernels with an SVE expert) and, under kleidiai-sme2, the 20 KleidiAI kernels with an SME2 expert, evaluated on Apple M4. The other 23 SIMD Loops definitions are not in it (see TASKS.md); for example, loop_120 and loop_124 sort their input in place, so their timings are not valid.
  • subset_sve.json and subset_sme2.json: a 32-kernel subset for the SVE and SME2 tiers; they differ only in the KleidiAI GEMM.
  • The 18 e2e definitions are the quantized matrix multiplications of Qwen3.5-4B (11) and Llama-3.1-8B-Instruct (7) in llama.cpp, for the end-to-end inference experiments. They carry an e2e:<model> tag.
  • TASKS.md lists every definition with its expert baseline on each tier: whether it runs there and whether it is specialized for that tier.

Layout

definitions/<op_type>/<name>.json   kernel spec: axes, inputs/outputs, PyTorch reference
workloads/<op_type>/<name>.jsonl    one workload per line: axis values and how to build each input
solutions/<source>/<author>/...     kernels, with their sources inlined in the JSON
tensors/gemm/<name>/*.npy           recorded activations used by the e2e workloads
results/e2e-qwen3.5-4b.json         end-to-end results for Qwen3.5-4B
viewer/tasks.parquet                one row per definition, for the dataset viewer
viewer/solutions.parquet            one row per solution, for the dataset viewer

The two viewer/ tables are generated from the files above so the Hugging Face dataset viewer can show them; the benchmark code reads the original files. tasks has each definition's source, op type, evaluation-set and subset membership, workload count, baselines and PyTorch reference (shapes as JSON strings). solutions has each solution's author, description and main source file (kernel.cpp, or binding.cpp for KleidiAI).

Solution authors:

  • reference-scalar: scalar code, the correctness reference and the starting point.
  • baseline-<source>: the expert baselines. SIMD Loops has a separate one per tier, baseline-simd-loop-<isa>.
  • autovec (SIMD Loops): the loop compiled with the compiler's auto-vectorizer.
  • claude-code-claude-fable-5-1 (llama.cpp): the agent-written kernels for the 18 e2e definitions (next section); they are not baselines.

Definitions tagged correctness:sqnr (quantized and BF16 kernels) are checked by signal-to-quantization-noise ratio instead of element-wise tolerances.

End-to-end results

For the end-to-end inference experiments, Claude Code with Claude Fable 5.1 wrote a kernel for each of the 18 e2e definitions (11 for Qwen3.5-4B, 7 for Llama-3.1-8B-Instruct), in solutions/llama.cpp/claude-code-claude-fable-5-1/. The kernels are substituted into llama.cpp and compared with stock llama.cpp, which uses its repacked i8mm kernels, on AWS Graviton4.

results/e2e-qwen3.5-4b.json holds the Qwen3.5-4B results reported in the paper: prefill and decode speedups at 1, 4 and 16 threads, the prompt-length and micro-batch sweeps, perplexity on wikitext-2, and the speedup of the kernels alone over the repacked kernels.

Usage

git clone https://github.com/cmu-l3/kernel-shift
cd kernel-shift
pip install -r requirements.txt
hf download l3lab/KernelShift --repo-type dataset --local-dir bench-trace

python -m bench.cli bench --dataset simd-loop --isa sve \
    --definition loop_001 --solution reference-scalar_loop_001

Authors

Shuaiwei Huang*, Weihua Du*, Allen Wu* (Carnegie Mellon University), Ivan Fox, Manupa Karunaratne (Arm Ltd.), Yiming Yang, Sean Welleck (Carnegie Mellon University).

* Equal contribution.

License

Released under the Apache-2.0 license. The baselines derive from or wrap ncnn (BSD-3-Clause), llama.cpp / ggml (MIT), KleidiAI (Apache-2.0) and SIMD Loops (BSD-3-Clause); see each project for its license terms.

Downloads last month
-