Replace pre-PR#15 conv2d-only trace with current simd-loop set (definitions + workloads + reference/autovec solutions)

definitions/conv/conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256",
-  "op_type": "conv2d",
-  "description": "2D conv 1x1 stride=(1,1) dilation=(1,1) pad=(0,0) C_out=256. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 256
-    },
-    "Kh": {
-      "type": "const",
-      "value": 1
-    },
-    "Kw": {
-      "type": "const",
-      "value": 1
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 0
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 0
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(1, 1), padding=(0, 0), dilation=(1, 1)).numpy()\n"
-}

definitions/conv/conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128",
-  "op_type": "conv2d",
-  "description": "2D conv 3x3 stride=(1,1) dilation=(1,1) pad=(1,1) C_out=128. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 128
-    },
-    "Kh": {
-      "type": "const",
-      "value": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(1, 1), padding=(1, 1), dilation=(1, 1)).numpy()\n"
-}

definitions/conv/conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256",
-  "op_type": "conv2d",
-  "description": "2D conv 3x3 stride=(1,1) dilation=(2,2) pad=(2,2) C_out=256. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 256
-    },
-    "Kh": {
-      "type": "const",
-      "value": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 2
-    },
-    "Dw": {
-      "type": "const",
-      "value": 2
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 2
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 2
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(1, 1), padding=(2, 2), dilation=(2, 2)).numpy()\n"
-}

definitions/conv/conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128",
-  "op_type": "conv2d",
-  "description": "2D conv 3x3 stride=(2,2) dilation=(1,1) pad=(1,1) C_out=128. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 128
-    },
-    "Kh": {
-      "type": "const",
-      "value": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 2
-    },
-    "Sw": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(2, 2), padding=(1, 1), dilation=(1, 1)).numpy()\n"
-}

definitions/conv/conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64",
-  "op_type": "conv2d",
-  "description": "2D conv 5x5 stride=(1,1) dilation=(1,1) pad=(2,2) C_out=64. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 64
-    },
-    "Kh": {
-      "type": "const",
-      "value": 5
-    },
-    "Kw": {
-      "type": "const",
-      "value": 5
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 2
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 2
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(1, 1), padding=(2, 2), dilation=(1, 1)).numpy()\n"
-}

definitions/conv/conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64.json

@@ -1,112 +0,0 @@
-{
-  "name": "conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64",
-  "op_type": "conv2d",
-  "description": "2D conv 7x7 stride=(2,2) dilation=(1,1) pad=(3,3) C_out=64. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 64
-    },
-    "Kh": {
-      "type": "const",
-      "value": 7
-    },
-    "Kw": {
-      "type": "const",
-      "value": 7
-    },
-    "Sh": {
-      "type": "const",
-      "value": 2
-    },
-    "Sw": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad_top": {
-      "type": "const",
-      "value": 3
-    },
-    "pad_left": {
-      "type": "const",
-      "value": 3
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C_in",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "activation_type": {
-      "shape": null,
-      "dtype": "int32"
-    },
-    "with_bias": {
-      "shape": null,
-      "dtype": "int32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad_top - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad_left - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, activation_type, with_bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight)\n    return F.conv2d(x, w, None, stride=(2, 2), padding=(3, 3), dilation=(1, 1)).numpy()\n"
-}

definitions/conv1d/conv1d_kw1_sw1_dw1_cout512_p0.json

@@ -1,75 +0,0 @@
-{
-  "name": "conv1d_kw1_sw1_dw1_cout512_p0",
-  "op_type": "conv1d",
-  "description": "1D conv kw=1 stride=1 dilation=1 pad=0 C_out=512. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "W": {
-      "type": "var"
-    },
-    "W_out": {
-      "type": "var"
-    },
-    "C_in": {
-      "type": "var"
-    },
-    "C_out": {
-      "type": "const",
-      "value": 512
-    },
-    "Kw": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad": {
-      "type": "const",
-      "value": 0
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "C_in",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "C_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "W_out == (W + 2*pad - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input).unsqueeze(0)\n    w = torch.from_numpy(weight)\n    b = torch.from_numpy(bias)\n    return F.conv1d(x, w, b, stride=1, padding=0, dilation=1).squeeze(0).numpy()\n"
-}

definitions/conv1d/conv1d_kw3_sw1_dw1_cout512_p1.json

@@ -1,75 +0,0 @@
-{
-  "name": "conv1d_kw3_sw1_dw1_cout512_p1",
-  "op_type": "conv1d",
-  "description": "1D conv kw=3 stride=1 dilation=1 pad=1 C_out=512. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "W": {
-      "type": "var"
-    },
-    "W_out": {
-      "type": "var"
-    },
-    "C_in": {
-      "type": "var"
-    },
-    "C_out": {
-      "type": "const",
-      "value": 512
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "C_in",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C_out",
-        "C_in",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "C_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "W_out == (W + 2*pad - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input).unsqueeze(0)\n    w = torch.from_numpy(weight)\n    b = torch.from_numpy(bias)\n    return F.conv1d(x, w, b, stride=1, padding=1, dilation=1).squeeze(0).numpy()\n"
-}

definitions/conv2d_depthwise/conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1.json

@@ -1,101 +0,0 @@
-{
-  "name": "conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1",
-  "op_type": "conv2d_depthwise",
-  "description": "Depthwise 2D conv 3x3 stride=(1,1) dilation=(1,1) pad=1. C varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    c = input.shape[1]\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).unsqueeze(1)\n    b = torch.from_numpy(bias)\n    return F.conv2d(x, w, b, stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=c).numpy()\n"
-}

definitions/conv2d_depthwise/conv2d_depthwise_kh3_kw3_sh2_sw2_dh1_dw1_p1.json

@@ -1,101 +0,0 @@
-{
-  "name": "conv2d_depthwise_kh3_kw3_sh2_sw2_dh1_dw1_p1",
-  "op_type": "conv2d_depthwise",
-  "description": "Depthwise 2D conv 3x3 stride=(2,2) dilation=(1,1) pad=1. C varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 2
-    },
-    "Sw": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    c = input.shape[1]\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).unsqueeze(1)\n    b = torch.from_numpy(bias)\n    return F.conv2d(x, w, b, stride=(2, 2), padding=(1, 1), dilation=(1, 1), groups=c).numpy()\n"
-}

definitions/conv2d_depthwise/conv2d_depthwise_kh5_kw5_sh1_sw1_dh1_dw1_p2.json

@@ -1,101 +0,0 @@
-{
-  "name": "conv2d_depthwise_kh5_kw5_sh1_sw1_dh1_dw1_p2",
-  "op_type": "conv2d_depthwise",
-  "description": "Depthwise 2D conv 5x5 stride=(1,1) dilation=(1,1) pad=2. C varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": 5
-    },
-    "Kw": {
-      "type": "const",
-      "value": 5
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    },
-    "pad": {
-      "type": "const",
-      "value": 2
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H + 2*pad - Dh*(Kh-1) - 1) // Sh + 1",
-    "W_out == (W + 2*pad - Dw*(Kw-1) - 1) // Sw + 1"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    c = input.shape[1]\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).unsqueeze(1)\n    b = torch.from_numpy(bias)\n    return F.conv2d(x, w, b, stride=(1, 1), padding=(2, 2), dilation=(1, 1), groups=c).numpy()\n"
-}

definitions/deconv2d/deconv2d_kh3_kw3_sh1_sw1_cout256.json

@@ -1,102 +0,0 @@
-{
-  "name": "deconv2d_kh3_kw3_sh1_sw1_cout256",
-  "op_type": "deconv2d",
-  "description": "Transposed 2D conv 3x3 stride=(1,1) dilation=(1,1) pad=0 C_out=256. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 256
-    },
-    "Kh": {
-      "type": "const",
-      "value": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "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"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).permute(1, 0, 2, 3)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(1, 1), padding=(0, 0), dilation=(1, 1)).numpy()\n"
-}

definitions/deconv2d/deconv2d_kh3_kw3_sh2_sw2_cout256.json

@@ -1,102 +0,0 @@
-{
-  "name": "deconv2d_kh3_kw3_sh2_sw2_cout256",
-  "op_type": "deconv2d",
-  "description": "Transposed 2D conv 3x3 stride=(2,2) dilation=(1,1) pad=0 C_out=256. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 256
-    },
-    "Kh": {
-      "type": "const",
-      "value": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 2
-    },
-    "Sw": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "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"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).permute(1, 0, 2, 3)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(2, 2), padding=(0, 0), dilation=(1, 1)).numpy()\n"
-}

definitions/deconv2d/deconv2d_kh4_kw4_sh1_sw1_cout128.json

@@ -1,102 +0,0 @@
-{
-  "name": "deconv2d_kh4_kw4_sh1_sw1_cout128",
-  "op_type": "deconv2d",
-  "description": "Transposed 2D conv 4x4 stride=(1,1) dilation=(1,1) pad=0 C_out=128. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 128
-    },
-    "Kh": {
-      "type": "const",
-      "value": 4
-    },
-    "Kw": {
-      "type": "const",
-      "value": 4
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "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"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).permute(1, 0, 2, 3)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(1, 1), padding=(0, 0), dilation=(1, 1)).numpy()\n"
-}

definitions/deconv2d/deconv2d_kh4_kw4_sh2_sw2_cout128.json

@@ -1,102 +0,0 @@
-{
-  "name": "deconv2d_kh4_kw4_sh2_sw2_cout128",
-  "op_type": "deconv2d",
-  "description": "Transposed 2D conv 4x4 stride=(2,2) dilation=(1,1) pad=0 C_out=128. C_in varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": "const",
-      "value": 128
-    },
-    "Kh": {
-      "type": "const",
-      "value": 4
-    },
-    "Kw": {
-      "type": "const",
-      "value": 4
-    },
-    "Sh": {
-      "type": "const",
-      "value": 2
-    },
-    "Sw": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "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"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C_out",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).permute(1, 0, 2, 3)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(2, 2), padding=(0, 0), dilation=(1, 1)).numpy()\n"
-}

definitions/deconv2d_depthwise/deconv2d_depthwise_kh2_kw2_sh2_sw2.json

@@ -1,97 +0,0 @@
-{
-  "name": "deconv2d_depthwise_kh2_kw2_sh2_sw2",
-  "op_type": "deconv2d_depthwise",
-  "description": "Depthwise transposed 2D conv 2x2 stride=(2,2) dilation=(1,1) pad=0. C varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": {
-      "type": "const",
-      "value": 2
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    c = input.shape[1]\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).unsqueeze(1)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(2, 2), padding=(0, 0), dilation=(1, 1), groups=c).numpy()\n"
-}

definitions/deconv2d_depthwise/deconv2d_depthwise_kh3_kw3_sh1_sw1.json

@@ -1,97 +0,0 @@
-{
-  "name": "deconv2d_depthwise_kh3_kw3_sh1_sw1",
-  "op_type": "deconv2d_depthwise",
-  "description": "Depthwise transposed 2D conv 3x3 stride=(1,1) dilation=(1,1) pad=0. C varies per workload.",
-  "tags": [
-    "status:active"
-  ],
-  "axes": {
-    "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": 3
-    },
-    "Kw": {
-      "type": "const",
-      "value": 3
-    },
-    "Sh": {
-      "type": "const",
-      "value": 1
-    },
-    "Sw": {
-      "type": "const",
-      "value": 1
-    },
-    "Dh": {
-      "type": "const",
-      "value": 1
-    },
-    "Dw": {
-      "type": "const",
-      "value": 1
-    }
-  },
-  "inputs": {
-    "input": {
-      "shape": [
-        "N",
-        "C",
-        "H",
-        "W"
-      ],
-      "dtype": "float32"
-    },
-    "weight": {
-      "shape": [
-        "C",
-        "Kh",
-        "Kw"
-      ],
-      "dtype": "float32"
-    },
-    "bias": {
-      "shape": [
-        "C"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "output": {
-      "shape": [
-        "N",
-        "C",
-        "H_out",
-        "W_out"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [
-    "H_out == (H - 1) * Sh + Kh",
-    "W_out == (W - 1) * Sw + Kw"
-  ],
-  "reference": "import torch\nimport torch.nn.functional as F\n\ndef run(input, weight, bias):\n    c = input.shape[1]\n    x = torch.from_numpy(input)\n    w = torch.from_numpy(weight).unsqueeze(1)\n    b = torch.from_numpy(bias)\n    return F.conv_transpose2d(x, w, b, stride=(1, 1), padding=(0, 0), dilation=(1, 1), groups=c).numpy()\n"
-}

definitions/simd-loop/loop_005.json

@@ -0,0 +1,36 @@
+{
+  "name": "loop_005",
+  "op_type": "loop_005",
+  "description": "Compute the length of many short null-terminated strings",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "N": {
+      "type": "var",
+      "description": "Buffer length (bytes)"
+    }
+  },
+  "inputs": {
+    "p": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "checksum": {
+      "shape": null,
+      "dtype": "uint32",
+      "description": "Scalar checksum"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(p):\n    b = p; n = len(b); i = 0; res = 0\n    while i < n:\n        j = i\n        while j < n and int(b[j]) != 0: j += 1\n        length = j - i; i = j + 1\n        res = (res + 1) & 0xffffffff\n        res ^= ((length % 0xffff) << 16) & 0xffffffff\n        res &= 0xffffffff\n    return np.uint32(res)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": []
+  }
+}

definitions/simd-loop/loop_006.json

@@ -0,0 +1,36 @@
+{
+  "name": "loop_006",
+  "op_type": "loop_006",
+  "description": "Compute the length of many long null-terminated strings",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "N": {
+      "type": "var",
+      "description": "Buffer length (bytes)"
+    }
+  },
+  "inputs": {
+    "p": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "checksum": {
+      "shape": null,
+      "dtype": "uint32",
+      "description": "Scalar checksum"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(p):\n    b = p; n = len(b); i = 0; res = 0\n    while i < n:\n        j = i\n        while j < n and int(b[j]) != 0: j += 1\n        length = j - i; i = j + 1\n        res = (res + 1) & 0xffffffff\n        res ^= ((length % 0xffff) << 16) & 0xffffffff\n        res &= 0xffffffff\n    return np.uint32(res)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": []
+  }
+}

definitions/simd-loop/loop_034.json

@@ -0,0 +1,42 @@
+{
+  "name": "loop_034",
+  "op_type": "loop_034",
+  "description": "Compare many short null-terminated strings for equality",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "N": {
+      "type": "var",
+      "description": "Buffer length (bytes)"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "uint8"
+    },
+    "b": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "checksum": {
+      "shape": null,
+      "dtype": "uint32",
+      "description": "Scalar checksum"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    n = len(a); res = 0; cnt = 0; length = 13; off = 0\n    while off < n:\n        k = off\n        while k < n and a[k] == b[k] and int(a[k]) != 0: k += 1\n        av = int(a[k]) if k < n else 0\n        bv = int(b[k]) if k < n else 0\n        r = av - bv\n        cmp = 2 if r > 0 else (3 if r < 0 else 1)\n        res = (res + cnt * cmp) & 0xffffffff\n        off += length; cnt += 1; length = 3 + (length + 11) % 43\n    return np.uint32(res)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": []
+  }
+}

definitions/simd-loop/loop_037.json

@@ -0,0 +1,54 @@
+{
+  "name": "loop_037",
+  "op_type": "loop_037",
+  "description": "Element-wise complex multiplication of two FP32 complex-number arrays (interleaved re/im)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "size": {
+      "type": "var",
+      "description": "axis size"
+    },
+    "cdim": {
+      "type": "const",
+      "value": 2,
+      "description": "const cdim"
+    }
+  },
+  "inputs": {
+    "a0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "float32"
+    },
+    "b0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "outputs": {
+    "c0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "float32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a0, b0):\n    ar, ai = a0[:, 0], a0[:, 1]\n    br, bi = b0[:, 0], b0[:, 1]\n    cr = ar * br - ai * bi\n    ci = ar * bi + ai * br\n    return np.stack([cr, ci], axis=1).astype(np.float32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "size"
+    ]
+  }
+}

definitions/simd-loop/loop_038.json

@@ -0,0 +1,49 @@
+{
+  "name": "loop_038",
+  "op_type": "loop_038",
+  "description": "1D convolution of an FP16 signal with an FP16 filter kernel",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "dim": {
+      "type": "var",
+      "description": "axis dim"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "dim",
+        "dim"
+      ],
+      "dtype": "float16"
+    },
+    "b": {
+      "shape": [
+        "dim",
+        "dim"
+      ],
+      "dtype": "float16"
+    }
+  },
+  "outputs": {
+    "c": {
+      "shape": [
+        "dim",
+        "dim"
+      ],
+      "dtype": "float16",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    dim = a.shape[0]\n    c = np.zeros((dim, dim), dtype=np.float16)\n    if dim >= 2:\n        k = np.float16(0.25)\n        s0 = a[:-1, :-1]; s1 = a[:-1, 1:]; s2 = a[1:, :-1]; s3 = a[1:, 1:]\n        r = (b[:-1, :-1] + s0 * k).astype(np.float16)\n        r = (r + s1 * k).astype(np.float16)\n        r = (r + s2 * k).astype(np.float16)\n        r = (r + s3 * k).astype(np.float16)\n        c[:-1, :-1] = r\n    return c\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "dim"
+    ]
+  }
+}

definitions/simd-loop/loop_101.json

@@ -0,0 +1,44 @@
+{
+  "name": "loop_101",
+  "op_type": "loop_101",
+  "description": "Upscale a pixel buffer by splitting each element into its high and low halves",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    },
+    "out_len": {
+      "type": "var",
+      "description": "axis out_len"
+    }
+  },
+  "inputs": {
+    "b": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "a": {
+      "shape": [
+        "out_len"
+      ],
+      "dtype": "uint8",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(b):\n    n = b.shape[0]\n    a = np.zeros(2 * (n - 1), dtype=np.uint8)\n    if n >= 2:\n        s1 = b[:-1].astype(np.uint16)\n        s2 = b[1:].astype(np.uint16)\n        a[0::2] = ((3 * s1 + s2 + 2) >> 2).astype(np.uint8)\n        a[1::2] = ((3 * s2 + s1 + 2) >> 2).astype(np.uint8)\n    return a\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_102.json

@@ -0,0 +1,46 @@
+{
+  "name": "loop_102",
+  "op_type": "loop_102",
+  "description": "Count the frequency of each byte value in a large buffer (histogram)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "num_records": {
+      "type": "var",
+      "description": "axis num_records"
+    },
+    "histogram_size": {
+      "type": "const",
+      "value": 128,
+      "description": "const histogram_size"
+    }
+  },
+  "inputs": {
+    "records": {
+      "shape": [
+        "num_records"
+      ],
+      "dtype": "uint32"
+    }
+  },
+  "outputs": {
+    "histogram": {
+      "shape": [
+        "histogram_size"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(records):\n    return np.bincount(records.astype(np.int64), minlength=128)[:128].astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "histogram_size",
+      "num_records"
+    ]
+  }
+}

definitions/simd-loop/loop_103.json

@@ -0,0 +1,36 @@
+{
+  "name": "loop_103",
+  "op_type": "loop_103",
+  "description": "Find all whitespace character positions in a byte string",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "N": {
+      "type": "var",
+      "description": "Buffer length (bytes)"
+    }
+  },
+  "inputs": {
+    "p": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "checksum": {
+      "shape": null,
+      "dtype": "int32",
+      "description": "Scalar checksum"
+    }
+  },
+  "reference": "import numpy as np\n\n_WS = {32, 10, 13, 9}\n\ndef run(p):\n    b = p; n = len(b); i = 0\n    while i < n and int(b[i]) in _WS: i += 1\n    count = 0\n    while i < n:\n        count += 1\n        while i < n and int(b[i]) not in _WS: i += 1\n        while i < n and int(b[i]) in _WS: i += 1\n    return np.int32(count)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": []
+  }
+}

definitions/simd-loop/loop_104.json

@@ -0,0 +1,46 @@
+{
+  "name": "loop_104",
+  "op_type": "loop_104",
+  "description": "Compute byte-value frequency histogram using segmented counting",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    },
+    "histogram_size": {
+      "type": "const",
+      "value": 256,
+      "description": "const histogram_size"
+    }
+  },
+  "inputs": {
+    "data": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "histogram": {
+      "shape": [
+        "histogram_size"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(data):\n    return np.bincount(data.astype(np.int64), minlength=256)[:256].astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "histogram_size",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_105.json

@@ -0,0 +1,41 @@
+{
+  "name": "loop_105",
+  "op_type": "loop_105",
+  "description": "Sum adjacent FP value pairs in a cascading pairwise reduction",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "N": {
+      "type": "var",
+      "description": "Array length"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "float32"
+    },
+    "b": {
+      "shape": [
+        "N"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "outputs": {
+    "res": {
+      "shape": null,
+      "dtype": "float32",
+      "description": "Scalar result"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    return np.float32(np.sum(a.astype(np.float64)))\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": []
+  }
+}

definitions/simd-loop/loop_106.json

@@ -0,0 +1,40 @@
+{
+  "name": "loop_106",
+  "op_type": "loop_106",
+  "description": "Partition a vector by bit flag, concentrating set-bit elements to one side",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint32"
+    }
+  },
+  "outputs": {
+    "b": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\n_M = 0xFFFFFFFF\n\ndef _popcount(x):\n    return bin(x & _M).count('1')\n\ndef _compress(x, m):\n    x &= m\n    mk = (~m << 1) & _M\n    for i in range(5):\n        mp = (mk ^ (mk << 1)) & _M\n        mp = (mp ^ (mp << 2)) & _M\n        mp = (mp ^ (mp << 4)) & _M\n        mp = (mp ^ (mp << 8)) & _M\n        mp = (mp ^ (mp << 16)) & _M\n        mv = mp & m\n        m = (m ^ mv) | (mv >> (1 << i))\n        t = x & mv\n        x = (x ^ t) | (t >> (1 << i))\n        mk &= (~mp) & _M\n    return x & _M\n\ndef _sag(x, m):\n    return (((_compress(x, m) << _popcount(m)) & _M) | _compress(x, (~m) & _M)) & _M\n\n_PC = [0xaaaaaaaa, 0xcccccccc, 0x0f0f0f0f, 0x0ff00ff0, 0x0ffff000]\n_P = [_PC[0], _sag(_PC[1], _PC[0]), _sag(_PC[2], _PC[0]),\n      _sag(_PC[3], _PC[0]), _sag(_PC[4], _PC[0])]\n\ndef _permute(x):\n    for pi in _P:\n        x = _sag(x, pi)\n    return x\n\ndef run(a):\n    return np.array([_permute(int(v)) for v in a], dtype=np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_109.json

@@ -0,0 +1,54 @@
+{
+  "name": "loop_109",
+  "op_type": "loop_109",
+  "description": "Element-wise addition of complex numbers stored as interleaved uint32 (re, im) pairs",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "size": {
+      "type": "var",
+      "description": "axis size"
+    },
+    "cdim": {
+      "type": "const",
+      "value": 2,
+      "description": "const cdim"
+    }
+  },
+  "inputs": {
+    "a0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32"
+    },
+    "b0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32"
+    }
+  },
+  "outputs": {
+    "c0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\n_M = np.uint64(0xffffffff)\n\ndef run(a0, b0):\n    cr = (a0[:, 0].astype(np.uint64) - b0[:, 1].astype(np.uint64)) & _M\n    ci = (a0[:, 1].astype(np.uint64) + b0[:, 0].astype(np.uint64)) & _M\n    return np.stack([cr, ci], axis=1).astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "size"
+    ]
+  }
+}

definitions/simd-loop/loop_110.json

@@ -0,0 +1,58 @@
+{
+  "name": "loop_110",
+  "op_type": "loop_110",
+  "description": "Compute complex dot product of two arrays of uint32 complex numbers",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "size": {
+      "type": "var",
+      "description": "axis size"
+    },
+    "size2": {
+      "type": "var",
+      "description": "axis size2"
+    },
+    "cdim": {
+      "type": "const",
+      "value": 2,
+      "description": "const cdim"
+    }
+  },
+  "inputs": {
+    "a0": {
+      "shape": [
+        "size2",
+        "cdim"
+      ],
+      "dtype": "int8"
+    },
+    "b0": {
+      "shape": [
+        "size2",
+        "cdim"
+      ],
+      "dtype": "int8"
+    }
+  },
+  "outputs": {
+    "c0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "int32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a0, b0):\n    a = a0.astype(np.int64); b = b0.astype(np.int64)\n    ae, ao = a[0::2], a[1::2]; be, bo = b[0::2], b[1::2]\n    cr = (ae[:, 0]*be[:, 0] - ae[:, 1]*be[:, 1]) + (ao[:, 0]*bo[:, 0] - ao[:, 1]*bo[:, 1])\n    ci = (ae[:, 1]*be[:, 0] + ae[:, 0]*be[:, 1]) + (ao[:, 1]*bo[:, 0] + ao[:, 0]*bo[:, 1])\n    return np.stack([cr, ci], axis=1).astype(np.int32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "size"
+    ]
+  }
+}

definitions/simd-loop/loop_112.json

@@ -0,0 +1,54 @@
+{
+  "name": "loop_112",
+  "op_type": "loop_112",
+  "description": "Complex multiply-accumulate over arrays of uint32 complex numbers",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "size": {
+      "type": "var",
+      "description": "axis size"
+    },
+    "cdim": {
+      "type": "const",
+      "value": 2,
+      "description": "const cdim"
+    }
+  },
+  "inputs": {
+    "a0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32"
+    },
+    "b0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32"
+    }
+  },
+  "outputs": {
+    "c0": {
+      "shape": [
+        "size",
+        "cdim"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\n_M = np.uint64(0xffffffff)\n\ndef run(a0, b0):\n    ar = a0[:, 0].astype(np.uint64); ai = a0[:, 1].astype(np.uint64)\n    br = b0[:, 0].astype(np.uint64); bi = b0[:, 1].astype(np.uint64)\n    cr = (ar * br - ai * bi) & _M\n    ci = (ar * bi + ai * br) & _M\n    return np.stack([cr, ci], axis=1).astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "size"
+    ]
+  }
+}

definitions/simd-loop/loop_114.json

@@ -0,0 +1,51 @@
+{
+  "name": "loop_114",
+  "op_type": "loop_114",
+  "description": "Compute auto-correlation of an integer array with widening accumulation",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    },
+    "lags": {
+      "type": "var",
+      "description": "axis lags"
+    },
+    "scale": {
+      "type": "const",
+      "value": 4,
+      "description": "const scale"
+    }
+  },
+  "inputs": {
+    "data": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "int16"
+    }
+  },
+  "outputs": {
+    "res": {
+      "shape": [
+        "lags"
+      ],
+      "dtype": "int16",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(data):\n    n = int(data.shape[0])\n    scale = 4\n    d = data.astype(np.int64)\n    res = np.zeros(n, dtype=np.int16)\n    for lag in range(n):\n        acc = int(((d[:n - lag] * d[lag:]) >> scale).sum())\n        res[lag] = np.int16(acc >> 16)\n    return res\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "n",
+      "lags",
+      "scale"
+    ]
+  }
+}

definitions/simd-loop/loop_130.json

@@ -0,0 +1,59 @@
+{
+  "name": "loop_130",
+  "op_type": "loop_130",
+  "description": "Multiply two FP32 matrices using tiled register accumulation",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    },
+    "k": {
+      "type": "var",
+      "description": "axis k"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "k"
+      ],
+      "dtype": "float32"
+    },
+    "b": {
+      "shape": [
+        "k",
+        "n"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "outputs": {
+    "c": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "float32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    return (a.astype(np.float64) @ b.astype(np.float64)).astype(np.float32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n",
+      "k"
+    ]
+  }
+}

definitions/simd-loop/loop_135.json

@@ -0,0 +1,59 @@
+{
+  "name": "loop_135",
+  "op_type": "loop_135",
+  "description": "Multiply INT8 matrices accumulating into INT32 using tiled 4-element dot products",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    },
+    "k": {
+      "type": "var",
+      "description": "axis k"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "k"
+      ],
+      "dtype": "int8"
+    },
+    "b": {
+      "shape": [
+        "k",
+        "n"
+      ],
+      "dtype": "int8"
+    }
+  },
+  "outputs": {
+    "c": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "int32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    return (a.astype(np.int64) @ b.astype(np.int64)).astype(np.int32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n",
+      "k"
+    ]
+  }
+}

definitions/simd-loop/loop_216.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_216",
+  "op_type": "loop_216",
+  "description": "Multiply an FP32 matrix by an FP32 vector (column-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "n",
+        "m"
+      ],
+      "dtype": "float32"
+    },
+    "x": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "outputs": {
+    "b": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "float32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, x):\n    return (a.astype(np.float64).T @ x.astype(np.float64)).astype(np.float32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_217.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_217",
+  "op_type": "loop_217",
+  "description": "Multiply an INT8 matrix by an INT8 vector accumulating into INT32 (row-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "uint8"
+    },
+    "b": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "c": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    return (a.astype(np.uint64) @ b.astype(np.uint64)).astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_218.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_218",
+  "op_type": "loop_218",
+  "description": "Multiply an FP64 matrix by an FP64 vector (column-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "n",
+        "m"
+      ],
+      "dtype": "float64"
+    },
+    "x": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "float64"
+    }
+  },
+  "outputs": {
+    "b": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "float64",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, x):\n    return a.astype(np.float64).T @ x.astype(np.float64)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_219.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_219",
+  "op_type": "loop_219",
+  "description": "Multiply an INT8 matrix by an INT8 vector accumulating into INT32 (column-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "n",
+        "m"
+      ],
+      "dtype": "uint8"
+    },
+    "b": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "uint8"
+    }
+  },
+  "outputs": {
+    "c": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, b):\n    return (a.astype(np.uint64).T @ b.astype(np.uint64)).astype(np.uint32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_220.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_220",
+  "op_type": "loop_220",
+  "description": "Multiply an FP32 matrix by an FP32 vector (row-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "float32"
+    },
+    "x": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "float32"
+    }
+  },
+  "outputs": {
+    "b": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "float32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, x):\n    return (a.astype(np.float64) @ x.astype(np.float64)).astype(np.float32)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_221.json

@@ -0,0 +1,52 @@
+{
+  "name": "loop_221",
+  "op_type": "loop_221",
+  "description": "Multiply an FP64 matrix by an FP64 vector (row-major GEMV)",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "float64"
+    },
+    "x": {
+      "shape": [
+        "n"
+      ],
+      "dtype": "float64"
+    }
+  },
+  "outputs": {
+    "b": {
+      "shape": [
+        "m"
+      ],
+      "dtype": "float64",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a, x):\n    return a.astype(np.float64) @ x.astype(np.float64)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

definitions/simd-loop/loop_223.json

@@ -0,0 +1,47 @@
+{
+  "name": "loop_223",
+  "op_type": "loop_223",
+  "description": "Transpose a matrix in-place using interleaved load and store",
+  "tags": [
+    "simd-loop"
+  ],
+  "axes": {
+    "m": {
+      "type": "var",
+      "description": "axis m"
+    },
+    "n": {
+      "type": "var",
+      "description": "axis n"
+    }
+  },
+  "inputs": {
+    "a": {
+      "shape": [
+        "m",
+        "n"
+      ],
+      "dtype": "uint32"
+    }
+  },
+  "outputs": {
+    "at": {
+      "shape": [
+        "n",
+        "m"
+      ],
+      "dtype": "uint32",
+      "description": "Output array"
+    }
+  },
+  "reference": "import numpy as np\n\ndef run(a):\n    return np.ascontiguousarray(a.T)\n",
+  "simd_loop_meta": {
+    "output_inplace": false,
+    "array_pad": 0,
+    "scratch": [],
+    "axes_order": [
+      "m",
+      "n"
+    ]
+  }
+}

solutions/ncnn/baseline-ncnn-arm/conv1d/conv1d_kw1_sw1_dw1_cout512_p0.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv1d_kw1_sw1_dw1_cout512_p0",
-  "definition": "conv1d_kw1_sw1_dw1_cout512_p0",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv1d_kw1_sw1_dw1_cout512_p0. binding.cpp bakes constexpr params and implements armbench_entry_conv1d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv1d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv1d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv1d baseline.\n// Called by armbench_entry_conv1d (binding.cpp); implemented by kernel.cpp.\n// Input/output are 2D ncnn::Mats (w=seq_len, h=channels).\n// num_output is encoded in top_blob.h (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution1d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_w, int stride_w, int dilation_w,\n    int activation_type, const Mat& activation_params,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv1d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int out_c           = 512;\nconstexpr int kernel_w        = 1;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_left        = 0;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv1d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    // bottom is 2D ncnn::Mat (w=seq_len, h=C_in) \u2014 created by NcnnDataset.\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& act    = *reinterpret_cast<const ncnn::Mat*>(act_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Pad the sequence (w) dimension symmetrically.\n    ncnn::Mat bordered;\n    ncnn::copy_make_border(bottom, bordered, 0, 0, pad_left, pad_left,\n                           ncnn::BORDER_CONSTANT, 0.f, opt);\n\n    // Compute output sequence length.\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int out_w  = (bordered.w - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top as 2D (w=out_w, h=out_c) so kernel reads out_c from top.h.\n    top.create(out_w, out_c, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution1d_kernel(\n        bordered, top, weight, bias,\n        kernel_w, stride_w, dilation_w,\n        activation_type, act, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv1d.h\"\n#include \"convolution1d_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution1d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_w, int stride_w, int dilation_w,\n    int activation_type, const Mat& activation_params,\n    const Option& opt)\n{\n    // top_blob is pre-allocated 2D (w=out_w, h=out_c); read out_c from top_blob.h.\n    const int num_output = top_blob.h;\n\n    // Use heap allocation: stack-allocated ncnn ARM layers fail to populate\n    // weight_data_tm in create_pipeline on AArch64 with -O3.\n    Convolution1D_arm* conv = new Convolution1D_arm();\n    conv->num_output       = num_output;\n    conv->kernel_w         = kernel_w;\n    conv->stride_w         = stride_w;\n    conv->dilation_w       = dilation_w;\n    conv->pad_left         = 0;\n    conv->pad_right        = 0;\n    conv->pad_value        = 0.f;\n    conv->bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv->weight_data_size = static_cast<int>(weight_data.total());\n    conv->activation_type  = activation_type;\n    conv->activation_params = activation_params;\n    conv->dynamic_weight   = 0;\n    conv->weight_data      = const_cast<Mat&>(weight_data);\n    if (conv->bias_term) conv->bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv->create_pipeline(opt) != 0) { delete conv; return -1; }\n\n    Mat local_top;\n    int ret = conv->forward(bottom_blob, local_top, opt);\n    delete conv;\n    if (ret != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob (both 2D, same shape).\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy(top_blob.row(c), local_top.row(c), top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv1d/conv1d_kw3_sw1_dw1_cout512_p1.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv1d_kw3_sw1_dw1_cout512_p1",
-  "definition": "conv1d_kw3_sw1_dw1_cout512_p1",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv1d_kw3_sw1_dw1_cout512_p1. binding.cpp bakes constexpr params and implements armbench_entry_conv1d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv1d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv1d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv1d baseline.\n// Called by armbench_entry_conv1d (binding.cpp); implemented by kernel.cpp.\n// Input/output are 2D ncnn::Mats (w=seq_len, h=channels).\n// num_output is encoded in top_blob.h (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution1d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_w, int stride_w, int dilation_w,\n    int activation_type, const Mat& activation_params,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv1d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int out_c           = 512;\nconstexpr int kernel_w        = 3;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_left        = 1;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv1d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    // bottom is 2D ncnn::Mat (w=seq_len, h=C_in) \u2014 created by NcnnDataset.\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& act    = *reinterpret_cast<const ncnn::Mat*>(act_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Pad the sequence (w) dimension symmetrically.\n    ncnn::Mat bordered;\n    ncnn::copy_make_border(bottom, bordered, 0, 0, pad_left, pad_left,\n                           ncnn::BORDER_CONSTANT, 0.f, opt);\n\n    // Compute output sequence length.\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int out_w  = (bordered.w - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top as 2D (w=out_w, h=out_c) so kernel reads out_c from top.h.\n    top.create(out_w, out_c, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution1d_kernel(\n        bordered, top, weight, bias,\n        kernel_w, stride_w, dilation_w,\n        activation_type, act, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv1d.h\"\n#include \"convolution1d_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution1d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_w, int stride_w, int dilation_w,\n    int activation_type, const Mat& activation_params,\n    const Option& opt)\n{\n    // top_blob is pre-allocated 2D (w=out_w, h=out_c); read out_c from top_blob.h.\n    const int num_output = top_blob.h;\n\n    // Use heap allocation: stack-allocated ncnn ARM layers fail to populate\n    // weight_data_tm in create_pipeline on AArch64 with -O3.\n    Convolution1D_arm* conv = new Convolution1D_arm();\n    conv->num_output       = num_output;\n    conv->kernel_w         = kernel_w;\n    conv->stride_w         = stride_w;\n    conv->dilation_w       = dilation_w;\n    conv->pad_left         = 0;\n    conv->pad_right        = 0;\n    conv->pad_value        = 0.f;\n    conv->bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv->weight_data_size = static_cast<int>(weight_data.total());\n    conv->activation_type  = activation_type;\n    conv->activation_params = activation_params;\n    conv->dynamic_weight   = 0;\n    conv->weight_data      = const_cast<Mat&>(weight_data);\n    if (conv->bias_term) conv->bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv->create_pipeline(opt) != 0) { delete conv; return -1; }\n\n    Mat local_top;\n    int ret = conv->forward(bottom_blob, local_top, opt);\n    delete conv;\n    if (ret != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob (both 2D, same shape).\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy(top_blob.row(c), local_top.row(c), top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256",
-  "definition": "conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh1_kw1_sh1_sw1_dh1_dw1_cout256. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 256;\nconstexpr int kernel_h        = 1;\nconstexpr int kernel_w        = 1;\nconstexpr int stride_h        = 1;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_h      = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_top         = 0;\nconstexpr int pad_left        = 0;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128",
-  "definition": "conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh3_kw3_sh1_sw1_dh1_dw1_cout128. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 128;\nconstexpr int kernel_h        = 3;\nconstexpr int kernel_w        = 3;\nconstexpr int stride_h        = 1;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_h      = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_top         = 1;\nconstexpr int pad_left        = 1;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256",
-  "definition": "conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh3_kw3_sh1_sw1_dh2_dw2_cout256. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 256;\nconstexpr int kernel_h        = 3;\nconstexpr int kernel_w        = 3;\nconstexpr int stride_h        = 1;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_h      = 2;\nconstexpr int dilation_w      = 2;\nconstexpr int pad_top         = 2;\nconstexpr int pad_left        = 2;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128",
-  "definition": "conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh3_kw3_sh2_sw2_dh1_dw1_cout128. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 128;\nconstexpr int kernel_h        = 3;\nconstexpr int kernel_w        = 3;\nconstexpr int stride_h        = 2;\nconstexpr int stride_w        = 2;\nconstexpr int dilation_h      = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_top         = 1;\nconstexpr int pad_left        = 1;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64",
-  "definition": "conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh5_kw5_sh1_sw1_dh1_dw1_cout64. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 64;\nconstexpr int kernel_h        = 5;\nconstexpr int kernel_w        = 5;\nconstexpr int stride_h        = 1;\nconstexpr int stride_w        = 1;\nconstexpr int dilation_h      = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_top         = 2;\nconstexpr int pad_left        = 2;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d/conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64",
-  "definition": "conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_kh7_kw7_sh2_sw2_dh1_dw1_cout64. binding.cpp bakes constexpr params and implements armbench_entry_conv2d with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d baseline.\n// Called by armbench_entry_conv2d (binding.cpp); implemented by kernel.cpp.\n// num_output is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int num_output      = 64;\nconstexpr int kernel_h        = 7;\nconstexpr int kernel_w        = 7;\nconstexpr int stride_h        = 2;\nconstexpr int stride_w        = 2;\nconstexpr int dilation_h      = 1;\nconstexpr int dilation_w      = 1;\nconstexpr int pad_top         = 3;\nconstexpr int pad_left        = 3;\nconstexpr int activation_type = 0;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Compute output spatial dims.\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad_top  - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad_left - ext_kw) / stride_w + 1;\n\n    // Pre-allocate top so kernel reads num_output from top.c.\n    top.create(W_out, H_out, num_output, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::convolution2d_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad_top, pad_left,\n        activation_type, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d.h\"\n#include \"convolution_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::convolution2d_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad_top, int pad_left,\n    int activation_type,\n    const Option& opt)\n{\n    const int num_output = top_blob.c;  // pre-set by binding.cpp\n\n    Convolution_arm conv;\n    conv.num_output       = num_output;\n    conv.kernel_h         = kernel_h;    conv.kernel_w   = kernel_w;\n    conv.stride_h         = stride_h;   conv.stride_w   = stride_w;\n    conv.dilation_h       = dilation_h; conv.dilation_w = dilation_w;\n    conv.pad_top          = pad_top;    conv.pad_bottom = pad_top;\n    conv.pad_left         = pad_left;   conv.pad_right  = pad_left;\n    conv.pad_value        = 0.f;\n    conv.bias_term        = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size = static_cast<int>(weight_data.total());\n    conv.int8_scale_term  = 0;\n    conv.activation_type  = activation_type;\n    conv.activation_params = Mat();\n    conv.dynamic_weight   = 0;\n    conv.weight_data      = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    // Copy from local_top to pre-allocated top_blob, channel by channel.\n    for (int c = 0; c < num_output; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/conv2d_depthwise/conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1",
-  "definition": "conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "ncnn::*_arm baseline for conv2d_depthwise_kh3_kw3_sh1_sw1_dh1_dw1_p1. binding.cpp bakes constexpr params and implements armbench_entry_conv2d_depthwise with void* ncnn::Mat ABI; kernel.cpp delegates to libncnn.a. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_conv2d_depthwise",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "conv2d_depthwise.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for conv2d_depthwise baseline.\n// Called by armbench_entry_conv2d_depthwise (binding.cpp); implemented by kernel.cpp.\n// num_output (== C, group == C) is encoded in top_blob.c (pre-allocated by binding.cpp).\nnamespace ncnn {\nint conv2d_depthwise_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"conv2d_depthwise.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int kernel_h   = 3;\nconstexpr int kernel_w   = 3;\nconstexpr int stride_h   = 1;\nconstexpr int stride_w   = 1;\nconstexpr int dilation_h = 1;\nconstexpr int dilation_w = 1;\nconstexpr int pad        = 1;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_conv2d_depthwise(\n    void* bottom_v, void* top_v,\n    void* weight_v, void* bias_v,\n    void* act_v,   void* opt_v)\n{\n    const auto& bottom = *reinterpret_cast<const ncnn::Mat*>(bottom_v);\n    auto&       top    = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& weight = *reinterpret_cast<const ncnn::Mat*>(weight_v);\n    const auto& bias   = *reinterpret_cast<const ncnn::Mat*>(bias_v);\n    const auto& opt    = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // Depthwise: num_output == input channels.\n    const int C      = bottom.c;\n    const int ext_kh = dilation_h * (kernel_h - 1) + 1;\n    const int ext_kw = dilation_w * (kernel_w - 1) + 1;\n    const int H_out  = (bottom.h + 2 * pad - ext_kh) / stride_h + 1;\n    const int W_out  = (bottom.w + 2 * pad - ext_kw) / stride_w + 1;\n\n    top.create(W_out, H_out, C, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::conv2d_depthwise_kernel(\n        bottom, top, weight, bias,\n        kernel_h, kernel_w,\n        stride_h, stride_w,\n        dilation_h, dilation_w,\n        pad, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"conv2d_depthwise.h\"\n#include \"convolutiondepthwise_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nint ncnn::conv2d_depthwise_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data, const Mat& bias_data,\n    int kernel_h, int kernel_w,\n    int stride_h, int stride_w,\n    int dilation_h, int dilation_w,\n    int pad,\n    const Option& opt)\n{\n    const int C = top_blob.c;  // pre-set by binding.cpp (== input channels)\n\n    // ncnn's pack1 convdw3x3s1_neon reads 12 floats per iteration (for 8 outputs),\n    // potentially overreading past the last channel's allocation when the bordered blob\n    // lands near a page boundary.  Use pack4 (4-channel interleaved) when possible to\n    // take the safe convdw3x3s1_pack4_neon path instead.\n    if (C % 4 == 0) {\n        Option opt4 = opt;\n        opt4.use_packing_layout = true;\n\n        Mat bottom_pack4;\n        convert_packing(bottom_blob, bottom_pack4, 4, opt4);\n\n        ConvolutionDepthWise_arm conv;\n        conv.num_output        = C;\n        conv.kernel_h          = kernel_h;   conv.kernel_w    = kernel_w;\n        conv.stride_h          = stride_h;   conv.stride_w    = stride_w;\n        conv.dilation_h        = dilation_h; conv.dilation_w  = dilation_w;\n        conv.pad_top           = pad;        conv.pad_bottom  = pad;\n        conv.pad_left          = pad;        conv.pad_right   = pad;\n        conv.pad_value         = 0.f;\n        conv.bias_term         = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n        conv.weight_data_size  = static_cast<int>(weight_data.total());\n        conv.group             = C;\n        conv.int8_scale_term   = 0;\n        conv.activation_type   = 0;\n        conv.activation_params = Mat();\n        conv.dynamic_weight    = 0;\n        conv.weight_data       = const_cast<Mat&>(weight_data);\n        if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n        if (conv.create_pipeline(opt4) != 0) return -1;\n        Mat top_pack4;\n        if (conv.forward(bottom_pack4, top_pack4, opt4) != 0) return -1;\n\n        Mat local_top;\n        convert_packing(top_pack4, local_top, 1, opt);\n\n        for (int c = 0; c < C; ++c)\n            std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                        top_blob.h * top_blob.w * sizeof(float));\n        return 0;\n    }\n\n    // Fallback pack1 path for C not divisible by 4.\n    ConvolutionDepthWise_arm conv;\n    conv.num_output        = C;\n    conv.kernel_h          = kernel_h;   conv.kernel_w    = kernel_w;\n    conv.stride_h          = stride_h;   conv.stride_w    = stride_w;\n    conv.dilation_h        = dilation_h; conv.dilation_w  = dilation_w;\n    conv.pad_top           = pad;        conv.pad_bottom  = pad;\n    conv.pad_left          = pad;        conv.pad_right   = pad;\n    conv.pad_value         = 0.f;\n    conv.bias_term         = (!bias_data.empty() && bias_data.total() > 0) ? 1 : 0;\n    conv.weight_data_size  = static_cast<int>(weight_data.total());\n    conv.group             = C;\n    conv.int8_scale_term   = 0;\n    conv.activation_type   = 0;\n    conv.activation_params = Mat();\n    conv.dynamic_weight    = 0;\n    conv.weight_data       = const_cast<Mat&>(weight_data);\n    if (conv.bias_term) conv.bias_data = const_cast<Mat&>(bias_data);\n\n    if (conv.create_pipeline(opt) != 0) return -1;\n    Mat local_top;\n    if (conv.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    for (int c = 0; c < C; ++c)\n        std::memcpy((float*)top_blob.channel(c), (const float*)local_top.channel(c),\n                    top_blob.h * top_blob.w * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}