sync 6fdf6301e2bb

Browse files

Files changed (8) hide show

README.md +7 -5
build/webgpu/bench.json +73 -1
build/webgpu/causal-conv-with-state-tiled.wgsl.jinja +8 -7
build/webgpu/causal-conv-with-state-vec4.wgsl.jinja +13 -19
build/webgpu/causal-conv-with-state.wgsl.jinja +24 -19
build/webgpu/manifest.json +132 -217
build/webgpu/metadata.json +15 -15
build/webgpu/test.json +1515 -13

README.md CHANGED Viewed

@@ -20,17 +20,17 @@ See the [ONNX Runtime `CausalConvWithState` contrib-operator spec](https://githu
 | Name | Upstream name | Logical dtype | Rank | Shape | Description | Presence |
 | --- | --- | --- | --- | --- | --- | --- |
-| `inputT` | `input` | `T` | `3` | — | Channels-first input tensor with shape `(batch_size, channels, sequence_length)` for the supported 1-D mode. | required |
 | `weightT` | `weight` | `T` | `3` | — | Depthwise convolution kernel with shape `(channels, 1, kernel_size)` for the supported 1-D mode. | required |
 | `biasT` | `bias` | `T` | `1` | — | Optional per-channel bias with shape `(channels,)`. | optional |
-| `pastStateT` | `past_state` | `T` | derived | — | Carry state from the previous step; shape `(batch_size, channels, kernel_size - 1)`, or `(W, batch_size, channels, kernel_size - 1)` when `state_window = W > 0`, in which case only slot `W - 1` is read. If absent, the left-side padding is zero. | optional |
 ## Outputs
 | Name | Upstream name | Logical dtype | Rank | Shape | Description | Presence |
 | --- | --- | --- | --- | --- | --- | --- |
 | `outputT` | `output` | `T` | `3` | same as `inputT` | Convolution output with the same shape as `input`. | required |
-| `presentStateT` | `present_state` | `T` | derived | derived | Updated carry state; shape `(batch_size, channels, kernel_size - 1)`, or `(W, batch_size, channels, kernel_size - 1)` when `state_window = W > 0`. Slot `W - 1` holds the last `kernel_size - 1` values along the causal axis; slot `j` holds the same values for the prefix ending at position `sequence_length - W + j`. | required |
 ## Attributes
@@ -39,6 +39,8 @@ Default values (overridable per request):
 | Attribute | Default | Description |
 | --- | --- | --- |
 | `activation` | `"none"` | Activation applied after convolution and bias. Defaults to `none`; `swish` is an alias of SiLU. |
 | `ndim` | `1` | Number of spatial dimensions. This implementation supports the contrib 1D mode (`ndim = 1`). |
 | `state_window` | `0` | Contrib extension selecting the number of rollback state slots to retain, in the range 0 through 8. Defaults to 0. |
@@ -53,7 +55,7 @@ Default values (overridable per request):
 - [`metadata.json`](build/webgpu/metadata.json) — kernel metadata (id, digests, per-variant templates, provenance)
 - [`manifest.json`](build/webgpu/manifest.json) — the op contract (source of truth)
 - [`test.json`](build/webgpu/test.json) — correctness cases
-- [`bench.json`](build/webgpu/bench.json) — benchmark + tuning cases
 - [`causal-conv-with-state-tiled.wgsl.jinja`](build/webgpu/causal-conv-with-state-tiled.wgsl.jinja)
 - [`causal-conv-with-state-vec4.wgsl.jinja`](build/webgpu/causal-conv-with-state-vec4.wgsl.jinja)
 - [`causal-conv-with-state.wgsl.jinja`](build/webgpu/causal-conv-with-state.wgsl.jinja)
@@ -61,7 +63,7 @@ Default values (overridable per request):
 ## Use with `@huggingface/kernels`
 ```sh
-npm install --save-exact @huggingface/kernels@0.0.1-preview.2
 ```
 Required output shapes and logical data types are inferred from the supplied inputs and attributes; result tensors are allocated automatically.

 | Name | Upstream name | Logical dtype | Rank | Shape | Description | Presence |
 | --- | --- | --- | --- | --- | --- | --- |
+| `inputT` | `input` | `T` | `3` | — | Input with shape `(batch, channels, length)`, or `(batch, length, channels)` when `channels_last` is 1. | required |
 | `weightT` | `weight` | `T` | `3` | — | Depthwise convolution kernel with shape `(channels, 1, kernel_size)` for the supported 1-D mode. | required |
 | `biasT` | `bias` | `T` | `1` | — | Optional per-channel bias with shape `(channels,)`. | optional |
+| `pastStateT` | `past_state` | `T` | derived | — | Carry state from the previous step; shape `(batch_size, channels, (kernel_size - 1) * dilation)`, or `(W, batch_size, channels, (kernel_size - 1) * dilation)` when `state_window = W > 0`, in which case only slot `W - 1` is read. If absent, the left-side padding is zero. With `channels_last`=1, the length and channel axes are swapped. | optional |
 ## Outputs
 | Name | Upstream name | Logical dtype | Rank | Shape | Description | Presence |
 | --- | --- | --- | --- | --- | --- | --- |
 | `outputT` | `output` | `T` | `3` | same as `inputT` | Convolution output with the same shape as `input`. | required |
+| `presentStateT` | `present_state` | `T` | derived | derived | Updated carry state; shape `(batch_size, channels, (kernel_size - 1) * dilation)`, or `(W, batch_size, channels, (kernel_size - 1) * dilation)` when `state_window = W > 0`. Slot `W - 1` holds the last `(kernel_size - 1) * dilation` values along the causal axis; slot `j` holds the same values for the prefix ending at position `sequence_length - W + j`. With `channels_last`=1, the length and channel axes are swapped. | required |
 ## Attributes
 | Attribute | Default | Description |
 | --- | --- | --- |
 | `activation` | `"none"` | Activation applied after convolution and bias. Defaults to `none`; `swish` is an alias of SiLU. |
+| `channels_last` | `0` | Activation and state layout: 0 selects `(batch, channels, length)`; 1 selects `(batch, length, channels)`. |
+| `dilation` | `1` | Positive integer spacing between taps; the carry state holds (`kernel_size` - 1) * dilation raw samples. |
 | `ndim` | `1` | Number of spatial dimensions. This implementation supports the contrib 1D mode (`ndim = 1`). |
 | `state_window` | `0` | Contrib extension selecting the number of rollback state slots to retain, in the range 0 through 8. Defaults to 0. |
 - [`metadata.json`](build/webgpu/metadata.json) — kernel metadata (id, digests, per-variant templates, provenance)
 - [`manifest.json`](build/webgpu/manifest.json) — the op contract (source of truth)
 - [`test.json`](build/webgpu/test.json) — correctness cases
+- [`bench.json`](build/webgpu/bench.json) — benchmark cases
 - [`causal-conv-with-state-tiled.wgsl.jinja`](build/webgpu/causal-conv-with-state-tiled.wgsl.jinja)
 - [`causal-conv-with-state-vec4.wgsl.jinja`](build/webgpu/causal-conv-with-state-vec4.wgsl.jinja)
 - [`causal-conv-with-state.wgsl.jinja`](build/webgpu/causal-conv-with-state.wgsl.jinja)
 ## Use with `@huggingface/kernels`
 ```sh
+npm install --save-exact @huggingface/kernels@0.0.1-preview.3
 ```
 Required output shapes and logical data types are inferred from the supplied inputs and attributes; result tensors are allocated automatically.

build/webgpu/bench.json CHANGED Viewed

@@ -80,7 +80,7 @@
       "name": "causal-conv-f32-large-kernel127-prefill-b2c1024t512-alignment-pathology",
       "preset": "stress",
       "provenance": {
-        "notes": "A valid odd-width causal kernel with `K = 127` fails the tiled path's four-tap alignment requirement and selects the scalar zero-state implementation."
       },
       "vars": { "batch": 2, "channels": 1024, "length": 512, "kernel": 127 },
       "attrs": { "activation": "none" },
@@ -396,6 +396,78 @@
           }
         ]
       }
     }
   ]
 }

       "name": "causal-conv-f32-large-kernel127-prefill-b2c1024t512-alignment-pathology",
       "preset": "stress",
       "provenance": {
+        "notes": "A causal convolution with odd kernel width 127, two batches, 1,024 channels, and 512 time steps checks long zero-state windows."
       },
       "vars": { "batch": 2, "channels": 1024, "length": 512, "kernel": 127 },
       "attrs": { "activation": "none" },
           }
         ]
       }
+    },
+    {
+      "name": "causal-conv-f32-b2c32t256k4-layout1-dilation1",
+      "preset": "smoke",
+      "vars": { "batch": 2, "channels": 32, "length": 256, "kernel": 4 },
+      "attrs": { "activation": "none", "channels_last": 1, "dilation": 1 },
+      "inputs": {
+        "inputT": { "shape": [2, 256, 32], "dtype": "float32", "dist": "normal", "seed": 205, "scale": 0.2 },
+        "weightT": { "shape": [32, 1, 4], "dtype": "float32", "dist": "normal", "seed": 206, "scale": 0.1 }
+      },
+      "outputs": {
+        "outputT": { "shape": [2, 256, 32], "dtype": "float32" },
+        "presentStateT": { "shape": [2, 3, 32], "dtype": "float32" }
+      },
+      "bench": {
+        "primary": true,
+        "metrics": [
+          { "type": "gflops", "value": "2 * numel(shapes.outputT) * dim(shapes.weightT, 1)" },
+          {
+            "type": "bandwidth",
+            "value": "(numel(shapes.inputT) + numel(shapes.weightT) + numel(shapes.outputT) + numel(shapes.presentStateT)) * 4"
+          }
+        ]
+      }
+    },
+    {
+      "name": "causal-conv-f32-b2c32t256k4-layout0-dilation2",
+      "preset": "smoke",
+      "vars": { "batch": 2, "channels": 32, "length": 256, "kernel": 4 },
+      "attrs": { "activation": "none", "channels_last": 0, "dilation": 2 },
+      "inputs": {
+        "inputT": { "shape": [2, 32, 256], "dtype": "float32", "dist": "normal", "seed": 205, "scale": 0.2 },
+        "weightT": { "shape": [32, 1, 4], "dtype": "float32", "dist": "normal", "seed": 206, "scale": 0.1 }
+      },
+      "outputs": {
+        "outputT": { "shape": [2, 32, 256], "dtype": "float32" },
+        "presentStateT": { "shape": [2, 32, 6], "dtype": "float32" }
+      },
+      "bench": {
+        "primary": true,
+        "metrics": [
+          { "type": "gflops", "value": "2 * numel(shapes.outputT) * dim(shapes.weightT, 1)" },
+          {
+            "type": "bandwidth",
+            "value": "(numel(shapes.inputT) + numel(shapes.weightT) + numel(shapes.outputT) + numel(shapes.presentStateT)) * 4"
+          }
+        ]
+      }
+    },
+    {
+      "name": "causal-conv-f32-b2c32t256k4-layout1-dilation2",
+      "preset": "smoke",
+      "vars": { "batch": 2, "channels": 32, "length": 256, "kernel": 4 },
+      "attrs": { "activation": "none", "channels_last": 1, "dilation": 2 },
+      "inputs": {
+        "inputT": { "shape": [2, 256, 32], "dtype": "float32", "dist": "normal", "seed": 205, "scale": 0.2 },
+        "weightT": { "shape": [32, 1, 4], "dtype": "float32", "dist": "normal", "seed": 206, "scale": 0.1 }
+      },
+      "outputs": {
+        "outputT": { "shape": [2, 256, 32], "dtype": "float32" },
+        "presentStateT": { "shape": [2, 6, 32], "dtype": "float32" }
+      },
+      "bench": {
+        "primary": true,
+        "metrics": [
+          { "type": "gflops", "value": "2 * numel(shapes.outputT) * dim(shapes.weightT, 1)" },
+          {
+            "type": "bandwidth",
+            "value": "(numel(shapes.inputT) + numel(shapes.weightT) + numel(shapes.outputT) + numel(shapes.presentStateT)) * 4"
+          }
+        ]
+      }
     }
   ]
 }

build/webgpu/causal-conv-with-state-tiled.wgsl.jinja CHANGED Viewed

@@ -1,7 +1,4 @@
 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
-{% if usesF16 %}
-enable f16;
-{% endif -%}
 {{ env.wgsl.resourceDeclarations }}
 const WG: u32 = {{ workgroupSize }}u;
@@ -13,8 +10,8 @@ const KERNEL_SIZE: u32 = {{ kernelSize }}u;
 // use it: the phantom taps contribute nothing. The input tile grows to match,
 // because the last lane reads TILE + KERNEL_PADDED - 2.
 const KERNEL_PADDED: u32 = {{ kernelSizePadded }}u;
-const STATE_LENGTH: u32 = KERNEL_SIZE - 1u;
-const INPUT_TILE_SIZE: u32 = TILE + KERNEL_PADDED - 1u;
 var<workgroup> input_tile: array<f32, {{ inputTileSize }}>;
 var<workgroup> weight_tile: array<f32, {{ kernelSizePadded }}>;
@@ -93,7 +90,11 @@ fn main(@builtin(local_invocation_id) lid3: vec3<u32>,
         weight_tile[k + 2u],
         weight_tile[k + 3u]
       );
-      let base0 = lane * OUTPUTS_PER_THREAD + k;
       let base1 = base0 + 4u;
       let x00 = vec4<f32>(input_tile[base0], input_tile[base0 + 1u], input_tile[base0 + 2u], input_tile[base0 + 3u]);
       let x01 = vec4<f32>(input_tile[base0 + 1u], input_tile[base0 + 2u], input_tile[base0 + 3u], input_tile[base0 + 4u]);
@@ -103,7 +104,7 @@ fn main(@builtin(local_invocation_id) lid3: vec3<u32>,
       let x11 = vec4<f32>(input_tile[base1 + 1u], input_tile[base1 + 2u], input_tile[base1 + 3u], input_tile[base1 + 4u]);
       let x12 = vec4<f32>(input_tile[base1 + 2u], input_tile[base1 + 3u], input_tile[base1 + 4u], input_tile[base1 + 5u]);
       let x13 = vec4<f32>(input_tile[base1 + 3u], input_tile[base1 + 4u], input_tile[base1 + 5u], input_tile[base1 + 6u]);
-      acc0 = fma(x00, vec4<f32>(w.x), acc0);
       acc0 = fma(x01, vec4<f32>(w.y), acc0);
       acc0 = fma(x02, vec4<f32>(w.z), acc0);
       acc0 = fma(x03, vec4<f32>(w.w), acc0);

 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
 {{ env.wgsl.resourceDeclarations }}
 const WG: u32 = {{ workgroupSize }}u;
 // use it: the phantom taps contribute nothing. The input tile grows to match,
 // because the last lane reads TILE + KERNEL_PADDED - 2.
 const KERNEL_PADDED: u32 = {{ kernelSizePadded }}u;
+const STATE_LENGTH: u32 = {% if causalDilation is defined and causalDilation != 1 %}(KERNEL_SIZE - 1u) * {{ causalDilation }}u{% else %}KERNEL_SIZE - 1u{% endif %};
+const INPUT_TILE_SIZE: u32 = {% if causalDilation is defined and causalDilation != 1 %}TILE + (KERNEL_PADDED - 1u) * {{ causalDilation }}u{% else %}TILE + KERNEL_PADDED - 1u{% endif %};
 var<workgroup> input_tile: array<f32, {{ inputTileSize }}>;
 var<workgroup> weight_tile: array<f32, {{ kernelSizePadded }}>;
         weight_tile[k + 2u],
         weight_tile[k + 3u]
       );
+{% if causalDilation is defined and causalDilation != 1 %}
+      let base0 = lane * OUTPUTS_PER_THREAD + k * {{ causalDilation }}u;
+      let base1 = base0 + 4u;
+{% for block in range(2) %}{% for tap in range(4) %}      let x{{ block }}{{ tap }} = vec4<f32>({% for o in range(4) %}{{ ", " if not loop.first else "" }}input_tile[base{{ block }} + {{ tap * causalDilation + o }}u]{% endfor %});
+{% endfor %}{% endfor %}{% else %}      let base0 = lane * OUTPUTS_PER_THREAD + k;
       let base1 = base0 + 4u;
       let x00 = vec4<f32>(input_tile[base0], input_tile[base0 + 1u], input_tile[base0 + 2u], input_tile[base0 + 3u]);
       let x01 = vec4<f32>(input_tile[base0 + 1u], input_tile[base0 + 2u], input_tile[base0 + 3u], input_tile[base0 + 4u]);
       let x11 = vec4<f32>(input_tile[base1 + 1u], input_tile[base1 + 2u], input_tile[base1 + 3u], input_tile[base1 + 4u]);
       let x12 = vec4<f32>(input_tile[base1 + 2u], input_tile[base1 + 3u], input_tile[base1 + 4u], input_tile[base1 + 5u]);
       let x13 = vec4<f32>(input_tile[base1 + 3u], input_tile[base1 + 4u], input_tile[base1 + 5u], input_tile[base1 + 6u]);
+{% endif %}      acc0 = fma(x00, vec4<f32>(w.x), acc0);
       acc0 = fma(x01, vec4<f32>(w.y), acc0);
       acc0 = fma(x02, vec4<f32>(w.z), acc0);
       acc0 = fma(x03, vec4<f32>(w.w), acc0);

build/webgpu/causal-conv-with-state-vec4.wgsl.jinja CHANGED Viewed

@@ -1,7 +1,12 @@
 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
-{% if usesF16 %}
-enable f16;
-{% endif -%}
 {{ env.wgsl.resourceDeclarations }}
 // Four outputs per invocation for a kernel narrow enough that every tap of a
@@ -24,11 +29,7 @@ fn activate4(value: vec4<f32>) -> vec4<f32> {
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let row_vecs = params.length / 4u;
   let work_size = params.batchSize * params.channels * row_vecs;
-  // Recover the logical 1D index after an oversized dispatch is folded into y.
-  let index = gid.x + gid.y * {{ DISPATCH_FOLD_WIDTH }}u * WG;
-  if (index >= work_size) {
-    return;
-  }
   let pos4 = index % row_vecs;
   let bc = index / row_vecs;
@@ -55,20 +56,13 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let w{{ k }} = f32(weight[channel * {{ kernelSize }}u + {{ k }}u]);
 {% endfor %}
 {% endif %}
 {% for k in range(kernelSize) %}
 {% set wk = ("w." ~ ["x", "y", "z", "w"][k]) if kernelSize == 4 else ("w" ~ k) %}
-{% if loop.first and hasBias %}
-  var value = vec4<f32>(f32(bias[channel])) + {{ wk }} * vec4<f32>(
-{%- for j in range(4) %}{{ ("current." ~ ["x", "y", "z", "w"][j - S + k]) if j - S + k >= 0 else ("previous." ~ ["x", "y", "z", "w"][4 + j - S + k]) }}{{ ", " if not loop.last else "" }}{% endfor -%}
-);
-{% elif loop.first %}
-  var value = {{ wk }} * vec4<f32>(
-{%- for j in range(4) %}{{ ("current." ~ ["x", "y", "z", "w"][j - S + k]) if j - S + k >= 0 else ("previous." ~ ["x", "y", "z", "w"][4 + j - S + k]) }}{{ ", " if not loop.last else "" }}{% endfor -%}
-);
 {% else %}
-  value = value + {{ wk }} * vec4<f32>(
-{%- for j in range(4) %}{{ ("current." ~ ["x", "y", "z", "w"][j - S + k]) if j - S + k >= 0 else ("previous." ~ ["x", "y", "z", "w"][4 + j - S + k]) }}{{ ", " if not loop.last else "" }}{% endfor -%}
-);
 {% endif %}
 {% endfor %}
   output[index] = {{ outputVec4 }}(activate4(value));

 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
+{% macro flat_index_2d(workgroupSize, name="i", bound="params.count", guardInline=false) %}
+{% set wgTerm = workgroupSize ~ "u" if workgroupSize is number else workgroupSize %}
+  // 2D-folded flat index: gid.y carries the high bits past the dispatch's
+  // per-axis workgroup fold width.
+  let {{ name }} = gid.x + gid.y * {{ DISPATCH_FOLD_WIDTH }}u * {{ wgTerm }};
+  if ({{ name }} >= {{ bound }}) {
+    return;
+  }{% endmacro %}
 {{ env.wgsl.resourceDeclarations }}
 // Four outputs per invocation for a kernel narrow enough that every tap of a
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let row_vecs = params.length / 4u;
   let work_size = params.batchSize * params.channels * row_vecs;
+{{ flat_index_2d("WG", "index", "work_size") }}
   let pos4 = index % row_vecs;
   let bc = index / row_vecs;
   let w{{ k }} = f32(weight[channel * {{ kernelSize }}u + {{ k }}u]);
 {% endfor %}
 {% endif %}
+{% macro taps(k) %}{% for j in range(4) %}{{ ("current." ~ ["x", "y", "z", "w"][j - S + k]) if j - S + k >= 0 else ("previous." ~ ["x", "y", "z", "w"][4 + j - S + k]) }}{{ ", " if not loop.last else "" }}{% endfor %}{% endmacro %}
 {% for k in range(kernelSize) %}
 {% set wk = ("w." ~ ["x", "y", "z", "w"][k]) if kernelSize == 4 else ("w" ~ k) %}
+{% if loop.first %}
+  var value = {{ "vec4<f32>(f32(bias[channel])) + " if hasBias else "" }}{{ wk }} * vec4<f32>({{ taps(k) }});
 {% else %}
+  value = value + {{ wk }} * vec4<f32>({{ taps(k) }});
 {% endif %}
 {% endfor %}
   output[index] = {{ outputVec4 }}(activate4(value));

build/webgpu/causal-conv-with-state.wgsl.jinja CHANGED Viewed

@@ -1,7 +1,12 @@
 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
-{% if usesF16 %}
-enable f16;
-{% endif -%}
 {{ env.wgsl.resourceDeclarations }}
 const WG: u32 = {{ workgroupSize }}u;
@@ -20,17 +25,17 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   // one state-writing thread per (batch, channel) even when there is no output.
   let len_nz = max(1u, params.length);
   let work_size = params.batchSize * params.channels * len_nz;
-  // gid.y carries the high bits past the per-dimension dispatch limit.
-  let index = gid.x + gid.y * {{ DISPATCH_FOLD_WIDTH }}u * WG;
-  if (index >= work_size) {
-    return;
-  }
-  let pos = index % len_nz;
   let bc = index / len_nz;
   let batch = bc / params.channels;
   let channel = bc % params.channels;
-  let state_length = params.kernelSize - 1u;
   // Output exists only for real positions. At length zero this thread performs
   // only the present_state carryover below.
@@ -42,14 +47,14 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 {% endif %}
     for (var k: u32 = 0u; k < params.kernelSize; k = k + 1u) {
       var value = 0.0;
-      let virtual_pos = pos + k;
       if (virtual_pos >= state_length) {
         let input_pos = virtual_pos - state_length;
-        let input_index = (batch * params.channels + channel) * params.length + input_pos;
         value = f32(input[input_index]);
       } else {
 {% if hasState %}
-        let state_index = {{ pastSlot }}(batch * params.channels + channel) * state_length + virtual_pos;
         value = f32(past_state[state_index]);
 {% endif %}
       }
@@ -71,16 +76,16 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
           let virtual_pos = params.length + slot + 1u - params.stateWindow + s;
           if (virtual_pos >= state_length) {
             let input_pos = virtual_pos - state_length;
-            let input_index = (batch * params.channels + channel) * params.length + input_pos;
             state_value = f32(input[input_index]);
           } else {
 {% if hasState %}
-            let state_index = {{ pastSlot }}(batch * params.channels + channel) * state_length + virtual_pos;
             state_value = f32(past_state[state_index]);
 {% endif %}
           }
         }
-        present_state[slot * params.stateSlotStride + (batch * params.channels + channel) * state_length + s] = {{ outputScalar }}(state_value);
       }
     }
 {% else %}
@@ -89,15 +94,15 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
       let virtual_pos = params.length + s;
       if (virtual_pos >= state_length) {
         let input_pos = virtual_pos - state_length;
-        let input_index = (batch * params.channels + channel) * params.length + input_pos;
         state_value = f32(input[input_index]);
       } else {
 {% if hasState %}
-        let state_index = (batch * params.channels + channel) * state_length + virtual_pos;
         state_value = f32(past_state[state_index]);
 {% endif %}
       }
-      present_state[(batch * params.channels + channel) * state_length + s] = {{ outputScalar }}(state_value);
     }
 {% endif %}
   }

 {% set pastSlot = "(params.stateWindow - 1u) * params.stateSlotStride + " if hasStateWindow else "" %}
+{% macro flat_index_2d(workgroupSize, name="i", bound="params.count", guardInline=false) %}
+{% set wgTerm = workgroupSize ~ "u" if workgroupSize is number else workgroupSize %}
+  // 2D-folded flat index: gid.y carries the high bits past the dispatch's
+  // per-axis workgroup fold width.
+  let {{ name }} = gid.x + gid.y * {{ DISPATCH_FOLD_WIDTH }}u * {{ wgTerm }};
+  if ({{ name }} >= {{ bound }}) {
+    return;
+  }{% endmacro %}
 {{ env.wgsl.resourceDeclarations }}
 const WG: u32 = {{ workgroupSize }}u;
   // one state-writing thread per (batch, channel) even when there is no output.
   let len_nz = max(1u, params.length);
   let work_size = params.batchSize * params.channels * len_nz;
+{{ flat_index_2d("WG", "index", "work_size") }}
+{% if channelsLast is defined and channelsLast %}
+  let channel = index % params.channels;
+  let pos = (index / params.channels) % len_nz;
+  let batch = index / (params.channels * len_nz);
+{% else %}  let pos = index % len_nz;
   let bc = index / len_nz;
   let batch = bc / params.channels;
   let channel = bc % params.channels;
+{% endif %}  let state_length = {% if causalDilation is defined and causalDilation != 1 %}(params.kernelSize - 1u) * {{ causalDilation }}u{% else %}params.kernelSize - 1u{% endif %};
   // Output exists only for real positions. At length zero this thread performs
   // only the present_state carryover below.
 {% endif %}
     for (var k: u32 = 0u; k < params.kernelSize; k = k + 1u) {
       var value = 0.0;
+      let virtual_pos = pos + k{% if causalDilation is defined and causalDilation != 1 %} * {{ causalDilation }}u{% endif %};
       if (virtual_pos >= state_length) {
         let input_pos = virtual_pos - state_length;
+        let input_index = {% if channelsLast is defined and channelsLast %}batch * params.channels * params.length + input_pos * params.channels + channel{% else %}(batch * params.channels + channel) * params.length + input_pos{% endif %};
         value = f32(input[input_index]);
       } else {
 {% if hasState %}
+        let state_index = {{ pastSlot }}{% if channelsLast is defined and channelsLast %}batch * params.channels * state_length + virtual_pos * params.channels + channel{% else %}(batch * params.channels + channel) * state_length + virtual_pos{% endif %};
         value = f32(past_state[state_index]);
 {% endif %}
       }
           let virtual_pos = params.length + slot + 1u - params.stateWindow + s;
           if (virtual_pos >= state_length) {
             let input_pos = virtual_pos - state_length;
+            let input_index = {% if channelsLast is defined and channelsLast %}batch * params.channels * params.length + input_pos * params.channels + channel{% else %}(batch * params.channels + channel) * params.length + input_pos{% endif %};
             state_value = f32(input[input_index]);
           } else {
 {% if hasState %}
+            let state_index = {{ pastSlot }}{% if channelsLast is defined and channelsLast %}batch * params.channels * state_length + virtual_pos * params.channels + channel{% else %}(batch * params.channels + channel) * state_length + virtual_pos{% endif %};
             state_value = f32(past_state[state_index]);
 {% endif %}
           }
         }
+        present_state[slot * params.stateSlotStride + {% if channelsLast is defined and channelsLast %}batch * params.channels * state_length + s * params.channels + channel{% else %}(batch * params.channels + channel) * state_length + s{% endif %}] = {{ outputScalar }}(state_value);
       }
     }
 {% else %}
       let virtual_pos = params.length + s;
       if (virtual_pos >= state_length) {
         let input_pos = virtual_pos - state_length;
+        let input_index = {% if channelsLast is defined and channelsLast %}batch * params.channels * params.length + input_pos * params.channels + channel{% else %}(batch * params.channels + channel) * params.length + input_pos{% endif %};
         state_value = f32(input[input_index]);
       } else {
 {% if hasState %}
+        let state_index = {% if channelsLast is defined and channelsLast %}batch * params.channels * state_length + virtual_pos * params.channels + channel{% else %}(batch * params.channels + channel) * state_length + virtual_pos{% endif %};
         state_value = f32(past_state[state_index]);
 {% endif %}
       }
+      present_state[{% if channelsLast is defined and channelsLast %}batch * params.channels * state_length + s * params.channels + channel{% else %}(batch * params.channels + channel) * state_length + s{% endif %}] = {{ outputScalar }}(state_value);
     }
 {% endif %}
   }

build/webgpu/manifest.json CHANGED Viewed

@@ -19,58 +19,77 @@
       "onnx": "present_state",
       "dtype": "T",
       "rank": "3 if attrs.state_window == 0 else 4",
-      "shape": "[dim(shapes.inputT, 0), dim(shapes.inputT, 1), dim(shapes.weightT, 2) - 1] if attrs.state_window == 0 else [attrs.state_window, dim(shapes.inputT, 0), dim(shapes.inputT, 1), dim(shapes.weightT, 2) - 1]"
     }
   },
-  "attributes": { "activation": { "default": "none" }, "ndim": { "default": 1 }, "state_window": { "default": 0 } },
-  "attributeConstraints": { "activation": { "values": ["none", "silu", "swish"] }, "ndim": { "values": [1] } },
   "typeConstraints": { "T": ["float32", "float16"] },
   "tunables": { "workgroupSize": { "default": 256 }, "tiledWorkgroupSize": { "default": 128 } },
   "derive": {
     "stateWindow": "attrs.state_window",
     "windowed": "stateWindow > 0",
     "stateWindowOk": "stateWindow >= 0 and stateWindow <= 8",
     "kernelSize": "dim(shapes.weightT, ranks.weightT - 1)",
     "kernelSizePadded": "ceilDiv(kernelSize, 4) * 4",
     "weightRankOk": "ranks.weightT == 3 and dim(shapes.weightT, 1) == 1",
-    "stateLength": "kernelSize - 1",
-    "stateSlotStride": "dim(shapes.inputT, 0) * dim(shapes.inputT, 1) * stateLength",
-    "windowedLengthOk": "not windowed or dim(shapes.inputT, 2) > 0",
-    "presentStateOk": "(ranks.presentStateT == 3 and dim(shapes.presentStateT, 0) == dim(shapes.inputT, 0) and dim(shapes.presentStateT, 1) == dim(shapes.inputT, 1) and dim(shapes.presentStateT, 2) == stateLength) if not windowed else (ranks.presentStateT == 4 and dim(shapes.presentStateT, 0) == stateWindow and dim(shapes.presentStateT, 1) == dim(shapes.inputT, 0) and dim(shapes.presentStateT, 2) == dim(shapes.inputT, 1) and dim(shapes.presentStateT, 3) == stateLength)",
-    "pastStateShapeOk": "present.pastStateT and ((ranks.pastStateT == 3 and dim(shapes.pastStateT, 0) == dim(shapes.inputT, 0) and dim(shapes.pastStateT, 1) == dim(shapes.inputT, 1) and dim(shapes.pastStateT, 2) == stateLength) if not windowed else (ranks.pastStateT == 4 and dim(shapes.pastStateT, 0) == stateWindow and dim(shapes.pastStateT, 1) == dim(shapes.inputT, 0) and dim(shapes.pastStateT, 2) == dim(shapes.inputT, 1) and dim(shapes.pastStateT, 3) == stateLength))",
-    "commonContract": "ranks.inputT == 3 and weightRankOk and ranks.outputT == 3 and (tensorDtypes.inputT == \"float32\" or tensorDtypes.inputT == \"float16\") and tensorDtypes.weightT == tensorDtypes.inputT and tensorDtypes.outputT == tensorDtypes.inputT and tensorDtypes.presentStateT == tensorDtypes.inputT and f16Ok(dtypes.T) and dim(shapes.inputT, 1) == dim(shapes.weightT, 0) and dim(shapes.outputT, 0) == dim(shapes.inputT, 0) and dim(shapes.outputT, 1) == dim(shapes.inputT, 1) and dim(shapes.outputT, 2) == dim(shapes.inputT, 2) and stateWindowOk and windowedLengthOk and presentStateOk",
     "zeroStateContract": "commonContract and not present.pastStateT and not present.biasT",
-    "biasNoStateContract": "commonContract and not present.pastStateT and present.biasT and ranks.biasT == 1 and tensorDtypes.biasT == tensorDtypes.inputT and dim(shapes.biasT, 0) == dim(shapes.inputT, 1)",
     "stateNoBiasContract": "commonContract and present.pastStateT and not present.biasT and tensorDtypes.pastStateT == tensorDtypes.inputT and pastStateShapeOk",
-    "stateBiasContract": "commonContract and present.pastStateT and present.biasT and ranks.biasT == 1 and tensorDtypes.pastStateT == tensorDtypes.inputT and tensorDtypes.biasT == tensorDtypes.inputT and pastStateShapeOk and dim(shapes.biasT, 0) == dim(shapes.inputT, 1)"
   },
   "bindings": {
-    "input": { "arg": "inputT", "buffer": "read-only-storage", "elementType": "$inputVec4" },
-    "weight": { "arg": "weightT", "buffer": "read-only-storage", "elementType": "$weightElem" },
-    "output": { "arg": "outputT", "buffer": "storage", "elementType": "$outputVec4" },
-    "present_state": { "arg": "presentStateT", "buffer": "storage", "elementType": "$outputScalar" },
     "params": {
-      "buffer": "uniform",
       "struct": [
         { "name": "batchSize", "type": "u32", "value": "dim(shapes.inputT, 0)" },
-        { "name": "channels", "type": "u32", "value": "dim(shapes.inputT, 1)" },
-        { "name": "length", "type": "u32", "value": "dim(shapes.inputT, 2)" },
         { "name": "stateWindow", "type": "u32", "value": "stateWindow" },
         { "name": "stateSlotStride", "type": "u32", "value": "stateSlotStride" }
       ]
     },
-    "bias": { "arg": "biasT", "buffer": "read-only-storage", "elementType": "$inputScalar" },
-    "past_state": { "arg": "pastStateT", "buffer": "read-only-storage", "elementType": "$inputScalar" },
-    "input_2": { "arg": "inputT", "name": "input", "buffer": "read-only-storage", "elementType": "$inputScalar" },
-    "weight_2": { "arg": "weightT", "name": "weight", "buffer": "read-only-storage", "elementType": "$inputScalar" },
-    "output_2": { "arg": "outputT", "name": "output", "buffer": "storage", "elementType": "$outputScalar" },
-    "params_2": {
       "name": "params",
-      "buffer": "uniform",
       "struct": [
         { "name": "batchSize", "type": "u32", "value": "dim(shapes.inputT, 0)" },
-        { "name": "channels", "type": "u32", "value": "dim(shapes.inputT, 1)" },
-        { "name": "length", "type": "u32", "value": "dim(shapes.inputT, 2)" },
         { "name": "kernelSize", "type": "u32", "value": "kernelSize" },
         { "name": "stateWindow", "type": "u32", "value": "stateWindow" },
         { "name": "stateSlotStride", "type": "u32", "value": "stateSlotStride" }
@@ -81,18 +100,11 @@
     {
       "id": "zero_state_vec4",
       "priority": 20,
-      "when": ["zeroStateContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0"],
       "derive": {
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
         "workgroupSize": 256,
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
         "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "hasBias": false,
-        "hasState": false,
         "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
@@ -100,7 +112,6 @@
           "id": "main",
           "name": "CausalConvWithState.Vec4",
           "shader": "causal-conv-with-state-vec4.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
           "bindings": ["input", "weight", "output", "present_state", "params"],
           "dispatch": {
             "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
@@ -111,84 +122,55 @@
       ]
     },
     {
-      "id": "state_bias_vec4",
-      "priority": 20,
-      "when": ["stateBiasContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0"],
       "derive": {
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "workgroupSize": 256,
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "hasBias": true,
-        "hasState": true,
-        "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState.Vec4",
-          "shader": "causal-conv-with-state-vec4.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input", "weight", "bias", "past_state", "output", "present_state", "params"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "bias_no_state_vec4",
-      "priority": 20,
-      "when": ["biasNoStateContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0"],
-      "derive": {
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "workgroupSize": 256,
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "hasBias": true,
-        "hasState": false,
-        "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
-      },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState.Vec4",
-          "shader": "causal-conv-with-state-vec4.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input", "weight", "bias", "output", "present_state", "params"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "state_no_bias_vec4",
       "priority": 20,
-      "when": ["stateNoBiasContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0"],
       "derive": {
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
         "workgroupSize": 256,
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
         "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
-        "hasBias": false,
-        "hasState": true,
         "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
@@ -196,8 +178,7 @@
           "id": "main",
           "name": "CausalConvWithState.Vec4",
           "shader": "causal-conv-with-state-vec4.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input", "weight", "past_state", "output", "present_state", "params"],
           "dispatch": {
             "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
@@ -207,28 +188,20 @@
       ]
     },
     {
-      "id": "zero_state_tiled_large_kernel",
       "priority": 10,
-      "when": ["zeroStateContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + 2 * kernelSizePadded - 1) * 4 <= device.limits.maxComputeWorkgroupStorageSize"],
       "derive": {
-        "hasBias": false,
-        "hasState": false,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
         "workgroupSize": "tunables.tiledWorkgroupSize",
         "tileSize": "tunables.tiledWorkgroupSize * 8",
-        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + kernelSizePadded - 1",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
       },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState.TiledLargeKernel",
           "shader": "causal-conv-with-state-tiled.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "output_2", "present_state", "params"],
           "dispatch": {
             "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
@@ -238,90 +211,63 @@
       ]
     },
     {
-      "id": "state_bias_tiled_large_kernel",
-      "priority": 10,
-      "when": ["stateBiasContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + 2 * kernelSizePadded - 1) * 4 <= device.limits.maxComputeWorkgroupStorageSize"],
-      "derive": {
-        "hasBias": true,
-        "hasState": true,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.tiledWorkgroupSize",
-        "tileSize": "tunables.tiledWorkgroupSize * 8",
-        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + kernelSizePadded - 1",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
-      },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState.TiledLargeKernel",
-          "shader": "causal-conv-with-state-tiled.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "bias", "past_state", "output_2", "present_state", "params"],
           "dispatch": {
-            "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
-            "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "bias_no_state_tiled_large_kernel",
-      "priority": 10,
-      "when": ["biasNoStateContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + 2 * kernelSizePadded - 1) * 4 <= device.limits.maxComputeWorkgroupStorageSize"],
       "derive": {
-        "hasBias": true,
-        "hasState": false,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.tiledWorkgroupSize",
-        "tileSize": "tunables.tiledWorkgroupSize * 8",
-        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + kernelSizePadded - 1",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
       },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState.TiledLargeKernel",
-          "shader": "causal-conv-with-state-tiled.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "bias", "output_2", "present_state", "params"],
           "dispatch": {
-            "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
-            "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "state_no_bias_tiled_large_kernel",
       "priority": 10,
-      "when": ["stateNoBiasContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + 2 * kernelSizePadded - 1) * 4 <= device.limits.maxComputeWorkgroupStorageSize"],
       "derive": {
-        "hasBias": false,
-        "hasState": true,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
         "workgroupSize": "tunables.tiledWorkgroupSize",
         "tileSize": "tunables.tiledWorkgroupSize * 8",
-        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + kernelSizePadded - 1",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
       },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState.TiledLargeKernel",
           "shader": "causal-conv-with-state-tiled.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "past_state", "output_2", "present_state", "params"],
           "dispatch": {
             "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
@@ -331,87 +277,66 @@
       ]
     },
     {
-      "id": "zero_state",
       "priority": 0,
-      "when": ["zeroStateContract"],
-      "derive": {
-        "hasBias": false,
-        "hasState": false,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.workgroupSize",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
-      },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState",
           "shader": "causal-conv-with-state.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "output_2", "present_state", "params_2"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "state_bias",
-      "priority": 0,
-      "when": ["stateBiasContract"],
       "derive": {
-        "hasBias": true,
-        "hasState": true,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.workgroupSize",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
       },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState",
-          "shader": "causal-conv-with-state.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "bias", "past_state", "output_2", "present_state", "params_2"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
-      "id": "bias_no_state",
-      "priority": 0,
-      "when": ["biasNoStateContract"],
       "derive": {
-        "hasBias": true,
-        "hasState": false,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.workgroupSize",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
       },
       "passes": [
         {
           "id": "main",
-          "name": "CausalConvWithState",
-          "shader": "causal-conv-with-state.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "bias", "output_2", "present_state", "params_2"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
             "z": 1
           }
         }
@@ -421,26 +346,16 @@
       "id": "state_no_bias",
       "priority": 0,
       "when": ["stateNoBiasContract"],
-      "derive": {
-        "hasBias": false,
-        "hasState": true,
-        "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
-        "inputScalar": "dtypes.T",
-        "outputScalar": "dtypes.T",
-        "workgroupSize": "tunables.workgroupSize",
-        "hasStateWindow": "windowed",
-        "usesF16": "tensorDtypes.inputT == \"float16\""
-      },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState",
           "shader": "causal-conv-with-state.wgsl.jinja",
-          "derive": { "materializeConvBeforeActivation": false },
-          "bindings": ["input_2", "weight_2", "past_state", "output_2", "present_state", "params_2"],
           "dispatch": {
-            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
-            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * max(1, dim(shapes.outputT, 2))), (workgroupSize)), 65535)",
             "z": 1
           }
         }

       "onnx": "present_state",
       "dtype": "T",
       "rank": "3 if attrs.state_window == 0 else 4",
+      "shape": "([stateWindow] + stateShape) if windowed else stateShape"
     }
   },
+  "attributes": {
+    "activation": { "default": "none" },
+    "channels_last": { "default": 0 },
+    "dilation": { "default": 1 },
+    "ndim": { "default": 1 },
+    "state_window": { "default": 0 }
+  },
+  "attributeConstraints": {
+    "activation": { "values": ["none", "silu", "swish"] },
+    "channels_last": { "values": [0, 1] },
+    "ndim": { "values": [1] }
+  },
   "typeConstraints": { "T": ["float32", "float16"] },
   "tunables": { "workgroupSize": { "default": 256 }, "tiledWorkgroupSize": { "default": 128 } },
   "derive": {
+    "channels": "dim(shapes.inputT, 2 if attrs.channels_last == 1 else 1)",
+    "inputLength": "dim(shapes.inputT, 1 if attrs.channels_last == 1 else 2)",
+    "causalDilation": "attrs.dilation",
+    "channelsLast": "attrs.channels_last == 1",
     "stateWindow": "attrs.state_window",
     "windowed": "stateWindow > 0",
     "stateWindowOk": "stateWindow >= 0 and stateWindow <= 8",
     "kernelSize": "dim(shapes.weightT, ranks.weightT - 1)",
     "kernelSizePadded": "ceilDiv(kernelSize, 4) * 4",
     "weightRankOk": "ranks.weightT == 3 and dim(shapes.weightT, 1) == 1",
+    "stateLength": "(kernelSize - 1) * causalDilation",
+    "stateSlotStride": "dim(shapes.inputT, 0) * channels * stateLength",
+    "windowedLengthOk": "not windowed or inputLength > 0",
+    "stateShape": "[dim(shapes.inputT, 0), stateLength, channels] if channelsLast else [dim(shapes.inputT, 0), channels, stateLength]",
+    "presentStateOk": "sameShape(shapes.presentStateT, ([stateWindow] + stateShape) if windowed else stateShape)",
+    "pastStateShapeOk": "present.pastStateT and sameShape(shapes.pastStateT, ([stateWindow] + stateShape) if windowed else stateShape)",
+    "commonContract": "ranks.inputT == 3 and weightRankOk and ranks.outputT == 3 and (tensorDtypes.inputT == \"float32\" or tensorDtypes.inputT == \"float16\") and tensorDtypes.weightT == tensorDtypes.inputT and tensorDtypes.outputT == tensorDtypes.inputT and tensorDtypes.presentStateT == tensorDtypes.inputT and f16Ok(dtypes.T) and channels == dim(shapes.weightT, 0) and sameShape(shapes.outputT, shapes.inputT) and stateWindowOk and windowedLengthOk and presentStateOk and kernelSize >= 1 and causalDilation >= 1 and floor(causalDilation) == causalDilation",
     "zeroStateContract": "commonContract and not present.pastStateT and not present.biasT",
+    "biasNoStateContract": "commonContract and not present.pastStateT and present.biasT and ranks.biasT == 1 and tensorDtypes.biasT == tensorDtypes.inputT and dim(shapes.biasT, 0) == channels",
     "stateNoBiasContract": "commonContract and present.pastStateT and not present.biasT and tensorDtypes.pastStateT == tensorDtypes.inputT and pastStateShapeOk",
+    "stateBiasContract": "commonContract and present.pastStateT and present.biasT and ranks.biasT == 1 and tensorDtypes.pastStateT == tensorDtypes.inputT and tensorDtypes.biasT == tensorDtypes.inputT and pastStateShapeOk and dim(shapes.biasT, 0) == channels",
+    "useSilu": "attrs.activation == \"silu\" or attrs.activation == \"swish\"",
+    "inputScalar": "dtypes.T",
+    "outputScalar": "dtypes.T",
+    "hasStateWindow": "windowed",
+    "hasBias": "present.biasT",
+    "hasState": "present.pastStateT"
   },
   "bindings": {
+    "input": { "arg": "inputT", "elementType": "$inputVec4" },
+    "weight": { "arg": "weightT", "elementType": "$weightElem" },
+    "output": { "arg": "outputT", "elementType": "$outputVec4" },
+    "present_state": { "arg": "presentStateT", "elementType": "$outputScalar" },
     "params": {
       "struct": [
         { "name": "batchSize", "type": "u32", "value": "dim(shapes.inputT, 0)" },
+        { "name": "channels", "type": "u32", "value": "channels" },
+        { "name": "length", "type": "u32", "value": "inputLength" },
         { "name": "stateWindow", "type": "u32", "value": "stateWindow" },
         { "name": "stateSlotStride", "type": "u32", "value": "stateSlotStride" }
       ]
     },
+    "bias": { "arg": "biasT", "elementType": "$inputScalar" },
+    "past_state": { "arg": "pastStateT", "elementType": "$inputScalar" },
+    "input_main": { "arg": "inputT", "name": "input", "elementType": "$inputScalar" },
+    "weight_main": { "arg": "weightT", "name": "weight", "elementType": "$inputScalar" },
+    "output_main": { "arg": "outputT", "name": "output", "elementType": "$outputScalar" },
+    "params_main": {
       "name": "params",
       "struct": [
         { "name": "batchSize", "type": "u32", "value": "dim(shapes.inputT, 0)" },
+        { "name": "channels", "type": "u32", "value": "channels" },
+        { "name": "length", "type": "u32", "value": "inputLength" },
         { "name": "kernelSize", "type": "u32", "value": "kernelSize" },
         { "name": "stateWindow", "type": "u32", "value": "stateWindow" },
         { "name": "stateSlotStride", "type": "u32", "value": "stateSlotStride" }
     {
       "id": "zero_state_vec4",
       "priority": 20,
+      "when": ["zeroStateContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0", "not channelsLast", "causalDilation == 1"],
       "derive": {
         "workgroupSize": 256,
         "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
           "id": "main",
           "name": "CausalConvWithState.Vec4",
           "shader": "causal-conv-with-state-vec4.wgsl.jinja",
           "bindings": ["input", "weight", "output", "present_state", "params"],
           "dispatch": {
             "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
       ]
     },
     {
+      "id": "zero_state_tiled_large_kernel",
+      "priority": 10,
+      "when": ["zeroStateContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + kernelSizePadded + (kernelSizePadded - 1) * causalDilation) * 4 <= device.limits.maxComputeWorkgroupStorageSize", "not channelsLast"],
       "derive": {
+        "workgroupSize": "tunables.tiledWorkgroupSize",
+        "tileSize": "tunables.tiledWorkgroupSize * 8",
+        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + (kernelSizePadded - 1) * causalDilation"
       },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState.TiledLargeKernel",
+          "shader": "causal-conv-with-state-tiled.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "output_main", "present_state", "params"],
           "dispatch": {
+            "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
+            "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "zero_state",
+      "priority": 0,
+      "when": ["zeroStateContract"],
+      "derive": { "workgroupSize": "tunables.workgroupSize" },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState",
+          "shader": "causal-conv-with-state.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "output_main", "present_state", "params_main"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "state_bias_vec4",
       "priority": 20,
+      "when": ["stateBiasContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0", "not channelsLast", "causalDilation == 1"],
       "derive": {
         "workgroupSize": 256,
         "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
         "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
           "id": "main",
           "name": "CausalConvWithState.Vec4",
           "shader": "causal-conv-with-state-vec4.wgsl.jinja",
+          "bindings": ["input", "weight", "bias", "past_state", "output", "present_state", "params"],
           "dispatch": {
             "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
       ]
     },
     {
+      "id": "state_bias_tiled_large_kernel",
       "priority": 10,
+      "when": ["stateBiasContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + kernelSizePadded + (kernelSizePadded - 1) * causalDilation) * 4 <= device.limits.maxComputeWorkgroupStorageSize", "not channelsLast"],
       "derive": {
         "workgroupSize": "tunables.tiledWorkgroupSize",
         "tileSize": "tunables.tiledWorkgroupSize * 8",
+        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + (kernelSizePadded - 1) * causalDilation"
       },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState.TiledLargeKernel",
           "shader": "causal-conv-with-state-tiled.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "bias", "past_state", "output_main", "present_state", "params"],
           "dispatch": {
             "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
       ]
     },
     {
+      "id": "state_bias",
+      "priority": 0,
+      "when": ["stateBiasContract"],
+      "derive": { "workgroupSize": "tunables.workgroupSize" },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState",
+          "shader": "causal-conv-with-state.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "bias", "past_state", "output_main", "present_state", "params_main"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "bias_no_state_vec4",
+      "priority": 20,
+      "when": ["biasNoStateContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0", "not channelsLast", "causalDilation == 1"],
       "derive": {
+        "workgroupSize": 256,
+        "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
+        "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
+        "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState.Vec4",
+          "shader": "causal-conv-with-state-vec4.wgsl.jinja",
+          "bindings": ["input", "weight", "bias", "output", "present_state", "params"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "bias_no_state_tiled_large_kernel",
       "priority": 10,
+      "when": ["biasNoStateContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + kernelSizePadded + (kernelSizePadded - 1) * causalDilation) * 4 <= device.limits.maxComputeWorkgroupStorageSize", "not channelsLast"],
       "derive": {
         "workgroupSize": "tunables.tiledWorkgroupSize",
         "tileSize": "tunables.tiledWorkgroupSize * 8",
+        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + (kernelSizePadded - 1) * causalDilation"
       },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState.TiledLargeKernel",
           "shader": "causal-conv-with-state-tiled.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "bias", "output_main", "present_state", "params"],
           "dispatch": {
             "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
       ]
     },
     {
+      "id": "bias_no_state",
       "priority": 0,
+      "when": ["biasNoStateContract"],
+      "derive": { "workgroupSize": "tunables.workgroupSize" },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState",
           "shader": "causal-conv-with-state.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "bias", "output_main", "present_state", "params_main"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "state_no_bias_vec4",
+      "priority": 20,
+      "when": ["stateNoBiasContract", "kernelSize >= 2", "kernelSize <= 4", "dim(shapes.inputT, 2) >= 4", "dim(shapes.inputT, 2) % 4 == 0", "not channelsLast", "causalDilation == 1"],
       "derive": {
+        "workgroupSize": 256,
+        "inputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
+        "outputVec4": "\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\"",
+        "weightElem": "(\"vec4<f16>\" if tensorDtypes.inputT == \"float16\" else \"vec4<f32>\") if kernelSize == 4 else dtypes.T"
       },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState.Vec4",
+          "shader": "causal-conv-with-state-vec4.wgsl.jinja",
+          "bindings": ["input", "weight", "past_state", "output", "present_state", "params"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * (dim(shapes.outputT, 2) / 4)), (workgroupSize)), 65535)",
             "z": 1
           }
         }
       ]
     },
     {
+      "id": "state_no_bias_tiled_large_kernel",
+      "priority": 10,
+      "when": ["stateNoBiasContract", "kernelSize >= 32", "dim(shapes.inputT, 2) >= 256", "dim(shapes.inputT, 2) % 8 == 0", "tunables.tiledWorkgroupSize >= 1", "floor(tunables.tiledWorkgroupSize) == tunables.tiledWorkgroupSize", "tunables.tiledWorkgroupSize <= device.limits.maxComputeInvocationsPerWorkgroup", "tunables.tiledWorkgroupSize <= device.limits.maxComputeWorkgroupSizeX", "(tunables.tiledWorkgroupSize * 8 + kernelSizePadded + (kernelSizePadded - 1) * causalDilation) * 4 <= device.limits.maxComputeWorkgroupStorageSize", "not channelsLast"],
       "derive": {
+        "workgroupSize": "tunables.tiledWorkgroupSize",
+        "tileSize": "tunables.tiledWorkgroupSize * 8",
+        "inputTileSize": "tunables.tiledWorkgroupSize * 8 + (kernelSizePadded - 1) * causalDilation"
       },
       "passes": [
         {
           "id": "main",
+          "name": "CausalConvWithState.TiledLargeKernel",
+          "shader": "causal-conv-with-state-tiled.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "past_state", "output_main", "present_state", "params"],
           "dispatch": {
+            "x": "min(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
+            "y": "ceilDiv(dim(shapes.outputT, 0) * dim(shapes.outputT, 1) * ceilDiv(dim(shapes.outputT, 2), tileSize), 65535)",
             "z": 1
           }
         }
       "id": "state_no_bias",
       "priority": 0,
       "when": ["stateNoBiasContract"],
+      "derive": { "workgroupSize": "tunables.workgroupSize" },
       "passes": [
         {
           "id": "main",
           "name": "CausalConvWithState",
           "shader": "causal-conv-with-state.wgsl.jinja",
+          "bindings": ["input_main", "weight_main", "past_state", "output_main", "present_state", "params_main"],
           "dispatch": {
+            "x": "min(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
+            "y": "ceilDiv(ceilDiv((dim(shapes.inputT, 0) * channels * max(1, inputLength)), (workgroupSize)), 65535)",
             "z": 1
           }
         }

build/webgpu/metadata.json CHANGED Viewed

@@ -1,35 +1,35 @@
 {
   "name": "com.microsoft.CausalConvWithState",
-  "id": "_com_microsoft_causalconvwithstate_webgpu_2f94cdc",
   "version": 1,
   "license": "Apache-2.0",
   "backend": { "type": "webgpu" },
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "bench.json": "xexf85uhEj1seBHH80A/gzgwsempJwEy1IPsqs2Q81w=",
-      "causal-conv-with-state-tiled.wgsl.jinja": "VcSN9BQ2I4NO+PfsdA4qMne9kISCvAZeturYtZLWpmI=",
-      "causal-conv-with-state-vec4.wgsl.jinja": "rxqAeKAR/c0Qpy1FL2kyiNO1Ki+dusqnxkQcYtnhV4E=",
-      "causal-conv-with-state.wgsl.jinja": "QrQcWLijzv+pENPVNjTA/UNNzCCNXrjiEySPL/rOuMQ=",
-      "manifest.json": "nUvFIfdnmA2uQhwLhzjd141hkTwVnTFEppipUB6Fk+E=",
-      "test.json": "ITwDaH/kaBYxzYqj2uGRdZXBX7uN8/++FZ/mKSQvnho="
     }
   },
-  "provenance": { "kernel": { "sha": "91d990483a174128daf7673f3f37a7c890493ae1", "dirty": false } },
   "webgpu": {
-    "manifestSpec": "2.0",
     "variants": {
       "zero_state_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
-      "state_bias_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
-      "bias_no_state_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
-      "state_no_bias_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
       "zero_state_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
-      "state_bias_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
-      "bias_no_state_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
-      "state_no_bias_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
       "zero_state": ["causal-conv-with-state.wgsl.jinja"],
       "state_bias": ["causal-conv-with-state.wgsl.jinja"],
       "bias_no_state": ["causal-conv-with-state.wgsl.jinja"],
       "state_no_bias": ["causal-conv-with-state.wgsl.jinja"]
     }
   }

 {
   "name": "com.microsoft.CausalConvWithState",
+  "id": "_com_microsoft_causalconvwithstate_webgpu_497b636",
   "version": 1,
   "license": "Apache-2.0",
   "backend": { "type": "webgpu" },
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "bench.json": "VZ4iX04MaTq+cGsDaUFxIgUMPbEm9X5xXeAp+B/c+gw=",
+      "causal-conv-with-state-tiled.wgsl.jinja": "Q5bbjBXpHMRSmHovwIXIQnDaeHJniM+tS48x3lTDPAw=",
+      "causal-conv-with-state-vec4.wgsl.jinja": "vM/mv4hndKQ05w6NVLjq1rBHA2qPEXMdI3/nwwagvYk=",
+      "causal-conv-with-state.wgsl.jinja": "Pr6GwBHPU2HnWONPjCbz46QB24JK+34Qj3gu8P6GJBY=",
+      "manifest.json": "/R4bylER5z0eL1IPPdzJTMTvdcec+NNC/xh4gBR3cIc=",
+      "test.json": "rEWMf93peBX7/6HRgGQLjEPNevPSqCOmaATkY22GaEI="
     }
   },
+  "provenance": { "kernel": { "sha": "6fdf6301e2bbcc2f03bf1eaf493b7ad55ef33afc", "dirty": false } },
   "webgpu": {
+    "manifestSpec": "2.1",
     "variants": {
       "zero_state_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
       "zero_state_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
       "zero_state": ["causal-conv-with-state.wgsl.jinja"],
+      "state_bias_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
+      "state_bias_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
       "state_bias": ["causal-conv-with-state.wgsl.jinja"],
+      "bias_no_state_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
+      "bias_no_state_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
       "bias_no_state": ["causal-conv-with-state.wgsl.jinja"],
+      "state_no_bias_vec4": ["causal-conv-with-state-vec4.wgsl.jinja"],
+      "state_no_bias_tiled_large_kernel": ["causal-conv-with-state-tiled.wgsl.jinja"],
       "state_no_bias": ["causal-conv-with-state.wgsl.jinja"]
     }
   }

build/webgpu/test.json CHANGED Viewed

@@ -421,7 +421,7 @@
         "presentStateT": { "dtype": "float32", "shape": [1, 3, 2], "tolerance": 0.000001 }
       },
       "provenance": {
-        "notes": "Odd sequence length keeps the bias/no-state scalar fallback covered when the vec4 route is ineligible."
       }
     },
     {
@@ -624,7 +624,7 @@
     {
       "name": "vec4_zero_state_silu_compact",
       "provenance": {
-        "notes": "Compact correctness lock for the aligned K=4 vec4 prefill path, including causal zero padding, SiLU, multi-batch rows, and present-state tails."
       },
       "attrs": { "activation": "silu" },
       "inputs": {
@@ -646,9 +646,7 @@
     },
     {
       "name": "large_kernel_tiled_zero_state_compact",
-      "provenance": {
-        "notes": "Compact correctness lock for the workgroup-tiled large-kernel prefill path and its cooperative present-state update."
-      },
       "attrs": { "activation": "none" },
       "inputs": {
         "inputT": {
@@ -669,9 +667,7 @@
     },
     {
       "name": "large_kernel_tiled_bias_no_state_compact",
-      "provenance": {
-        "notes": "Compact correctness lock for the bias-only specialization of the workgroup-tiled large-kernel prefill path."
-      },
       "attrs": { "activation": "silu" },
       "inputs": {
         "inputT": {
@@ -694,7 +690,7 @@
     {
       "name": "large_kernel_tiled_state_no_bias_compact",
       "provenance": {
-        "notes": "Compact correctness lock for the carry-state specialization of the workgroup-tiled large-kernel prefill path."
       },
       "attrs": { "activation": "none" },
       "inputs": {
@@ -722,7 +718,7 @@
     {
       "name": "large_kernel_tiled_state_bias_silu_compact",
       "provenance": {
-        "notes": "Compact correctness lock for the carry-state, bias, and SiLU specialization used by the production-shape fixture."
       },
       "attrs": { "activation": "silu" },
       "inputs": {
@@ -751,7 +747,7 @@
     {
       "name": "large_kernel_tiled_state_bias_k128_wg64_multitile",
       "provenance": {
-        "notes": "Smallest swept workgroup at the production kernel size; length 520 forces a partial second output tile."
       },
       "attrs": { "activation": "silu" },
       "tunables": { "tiledWorkgroupSize": 64 },
@@ -780,7 +776,9 @@
     },
     {
       "name": "large_kernel_tiled_state_bias_k128_wg256",
-      "provenance": { "notes": "Largest swept workgroup at the production kernel and sequence sizes." },
       "attrs": { "activation": "silu" },
       "tunables": { "tiledWorkgroupSize": 256 },
       "inputs": {
@@ -1253,7 +1251,7 @@
     {
       "name": "large_kernel_tiled_unaligned_k37_state_weight_tile_pad",
       "provenance": {
-        "notes": "Kernel length 1 mod 4 carrying past state, so the padded weight tile is covered on the stateful arm where STATE_LENGTH stays the true kernel-1."
       },
       "attrs": { "activation": "none" },
       "inputs": {
@@ -1338,6 +1336,1510 @@
         "outputT": { "dtype": "float32", "shape": [1, 2, 8], "tolerance": 0.00002 },
         "presentStateT": { "dtype": "float32", "shape": [3, 1, 2, 3], "tolerance": 0.000001 }
       }
     }
   ]
 }

         "presentStateT": { "dtype": "float32", "shape": [1, 3, 2], "tolerance": 0.000001 }
       },
       "provenance": {
+        "notes": "A depthwise causal convolution with kernel length 3, a bias and no incoming state processes a 5-element (odd-length) sequence per channel, producing a 2-element carried state."
       }
     },
     {
     {
       "name": "vec4_zero_state_silu_compact",
       "provenance": {
+        "notes": "A four-tap causal convolution checks zero padding, SiLU, multiple batches and present-state tails."
       },
       "attrs": { "activation": "silu" },
       "inputs": {
     },
     {
       "name": "large_kernel_tiled_zero_state_compact",
+      "provenance": { "notes": "A large causal kernel checks prefill output and present-state updates." },
       "attrs": { "activation": "none" },
       "inputs": {
         "inputT": {
     },
     {
       "name": "large_kernel_tiled_bias_no_state_compact",
+      "provenance": { "notes": "A large causal kernel with bias checks prefill output and present-state updates." },
       "attrs": { "activation": "silu" },
       "inputs": {
         "inputT": {
     {
       "name": "large_kernel_tiled_state_no_bias_compact",
       "provenance": {
+        "notes": "A large causal kernel with carry state checks prefill output and present-state updates."
       },
       "attrs": { "activation": "none" },
       "inputs": {
     {
       "name": "large_kernel_tiled_state_bias_silu_compact",
       "provenance": {
+        "notes": "A large causal kernel with carry state, bias and SiLU checks prefill output and present-state updates."
       },
       "attrs": { "activation": "silu" },
       "inputs": {
     {
       "name": "large_kernel_tiled_state_bias_k128_wg64_multitile",
       "provenance": {
+        "notes": "A causal convolution with a 128-element kernel, incoming 127-element state and Silu activation processes a 520-element sequence, 8 past a multiple of the 128-element kernel length."
       },
       "attrs": { "activation": "silu" },
       "tunables": { "tiledWorkgroupSize": 64 },
     },
     {
       "name": "large_kernel_tiled_state_bias_k128_wg256",
+      "provenance": {
+        "notes": "A causal convolution with a 128-element kernel, incoming 127-element state and Silu activation processes a 512-element sequence, an exact multiple of the kernel length."
+      },
       "attrs": { "activation": "silu" },
       "tunables": { "tiledWorkgroupSize": 256 },
       "inputs": {
     {
       "name": "large_kernel_tiled_unaligned_k37_state_weight_tile_pad",
       "provenance": {
+        "notes": "A depthwise causal convolution with a 37-element kernel (one more than a multiple of four) carries a 36-element incoming state across a 256-element, 2-channel sequence."
       },
       "attrs": { "activation": "none" },
       "inputs": {
         "outputT": { "dtype": "float32", "shape": [1, 2, 8], "tolerance": 0.00002 },
         "presentStateT": { "dtype": "float32", "shape": [3, 1, 2, 3], "tolerance": 0.000001 }
       }
+    },
+    {
+      "name": "ort_state_window3_batched_prefill_b2_c8_l6_k4",
+      "attrs": { "activation": "silu", "state_window": 3 },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 8, 6],
+          "data": { "kind": "fillFloat32", "sinStep": 0.37, "cosStep": 0.19, "scale": 0.5 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [8, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21, "cosStep": 0.11, "scale": 0.25 }
+        },
+        "biasT": { "dtype": "float32", "shape": [8], "data": { "kind": "linspace", "start": 0.0, "end": 0.07 } },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [3, 2, 8, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.3, "cosStep": 0.13, "scale": 0.5 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 8, 6], "tolerance": 0.000001, "relTolerance": 0.000001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 8, 3], "tolerance": 0.000001, "relTolerance": 0.000001 }
+      }
+    },
+    {
+      "name": "ort_state_window3_decode_generic_k7_b2_c8",
+      "attrs": { "activation": "silu", "state_window": 3 },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 8, 1],
+          "data": { "kind": "fillFloat32", "sinStep": 0.37, "cosStep": 0.19, "scale": 0.5 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [8, 1, 7],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21, "cosStep": 0.11, "scale": 0.25 }
+        },
+        "biasT": { "dtype": "float32", "shape": [8], "data": { "kind": "linspace", "start": 0.0, "end": 0.07 } }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 8, 1], "tolerance": 0.000001, "relTolerance": 0.000001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 8, 6], "tolerance": 0.000001, "relTolerance": 0.000001 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state0_bias0_float32",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state0_bias0_float16",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state0_bias1_float32",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state0_bias1_float16",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state1_bias0_float32",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 3, 6],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state1_bias0_float16",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 3, 6],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state1_bias1_float32",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 3, 6],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation2_state1_bias1_float16",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 3, 6],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 6], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state0_bias0_float32",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state0_bias0_float16",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state0_bias1_float32",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state0_bias1_float16",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state1_bias0_float32",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 3, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [3, 2, 3, 9],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state1_bias0_float16",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 3, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [3, 2, 3, 9],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [3, 2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state1_bias1_float32",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 3, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [3, 2, 3, 9],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 5], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout0_dilation3_state1_bias1_float16",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 3, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 3, 5],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [3, 2, 3, 9],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 3, 5], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [3, 2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state0_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state0_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state0_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state0_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state1_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 3, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state1_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 3, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state1_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 3, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation1_state1_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 3, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 3, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state0_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state0_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state0_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state0_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state1_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 6, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state1_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 6, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state1_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 6, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation2_state1_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [2, 6, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 6, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state0_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state0_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state0_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state0_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state1_bias0_float32",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 3, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [3, 2, 9, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state1_bias0_float16",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 3, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [3, 2, 9, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [3, 2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state1_bias1_float32",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 3, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [3, 2, 9, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [3, 2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "layout1_dilation3_state1_bias1_float16",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 3, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [2, 5, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [3, 2, 9, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [2, 5, 3], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [3, 2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation2_state0_bias0",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [1, 2, 64], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation2_state0_bias1",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [2],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [1, 2, 64], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation2_state1_bias0",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 2, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 1, 2, 64],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 1, 2, 64], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation2_state1_bias1",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 2, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 1, 2, 64],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [2],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 1, 2, 64], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation3_state0_bias0",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [1, 2, 96], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation3_state0_bias1",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [2],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [1, 2, 96], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation3_state1_bias0",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 2, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 1, 2, 96],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 1, 2, 96], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation3_state1_bias1",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 2, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 33],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 1, 2, 96],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float32",
+          "shape": [2],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 2, 256], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 1, 2, 96], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "tiled_dilation2_f16",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float16",
+          "shape": [1, 2, 256],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float16",
+          "shape": [2, 1, 32],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float16",
+          "shape": [1, 2, 62],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        },
+        "biasT": {
+          "dtype": "float16",
+          "shape": [2],
+          "data": { "kind": "fillFloat32", "sinStep": 0.284, "cosStep": 0.185, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float16", "shape": [1, 2, 256], "tolerance": 0.002, "relTolerance": 0.002 },
+        "presentStateT": { "dtype": "float16", "shape": [1, 2, 62], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "dilated_empty_carry_layout0",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 0],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 3, 9],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 0], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 9], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "dilated_kernel1_layout0",
+      "attrs": { "channels_last": 0, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 3, 1],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 1],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 3, 1], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 3, 0], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "dilated_empty_carry_layout1",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 0, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 4],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 9, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.21299999999999997, "cosStep": 0.148, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 0, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 9, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "dilated_kernel1_layout1",
+      "attrs": { "channels_last": 1, "dilation": 3, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 1, 3],
+          "data": { "kind": "fillFloat32", "sinStep": 0.071, "cosStep": 0.074, "scale": 0.2 }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 1],
+          "data": { "kind": "fillFloat32", "sinStep": 0.142, "cosStep": 0.11099999999999999, "scale": 0.2 }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 1, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 0, 3], "tolerance": 0 }
+      }
+    },
+    {
+      "name": "ort_dilated_no_state",
+      "attrs": { "channels_last": 0, "dilation": 2, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 6],
+          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5] }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [2, 1, 3],
+          "data": { "kind": "values", "values": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6] }
+        }
+      },
+      "outputs": {
+        "outputT": {
+          "dtype": "float32",
+          "shape": [1, 2, 6],
+          "tolerance": 0.00001,
+          "relTolerance": 0.00001,
+          "data": { "kind": "values", "values": [0.3, 0.6, 1.1, 1.6, 2.2, 2.8, 0.3, 0.9, 1.75, 2.85, 4.15, 5.65] }
+        },
+        "presentStateT": { "dtype": "float32", "shape": [1, 2, 4], "tolerance": 0 }
+      },
+      "provenance": {
+        "source": "onnxruntime/test/contrib_ops/causal_conv_with_state_op_test.cc",
+        "test": "DilatedNoState"
+      }
+    },
+    {
+      "name": "ort_ChannelsLastNoState",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "none" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 4, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.0, 0.49794042226882, 0.09029813394711646, 0.180807715982481, 0.48063760148764995, -0.09364733177145158, 0.3371439558140725, 0.3982827361180434, -0.2649180704542467, 0.4478493428400238, 0.26202217084363805, -0.40033339108790883, -0.4815654652866582, -0.17762677999402132, 0.44935404790581346, -0.49761991288458135, 0.003407320037385088, 0.49823780737030027, -0.4463238397141173, 0.18398025528619233, 0.4796874169464321, -0.334619928638131, 0.3396523260724074, 0.3962135849542642]
+          }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.25, 0.24450772868103707, 0.22827223507807706, 0.20200687707803797, 0.16686570646032703, 0.12439276197293174, 0.07645422709457234, 0.025156433346732933, -0.02724668805996778]
+          }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 4, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 2, 3], "tolerance": 0 }
+      },
+      "provenance": {
+        "source": "onnxruntime/test/contrib_ops/causal_conv_with_state_op_test.cc",
+        "test": "ChannelsLastNoState"
+      }
+    },
+    {
+      "name": "ort_ChannelsLastWithStateAndBias",
+      "attrs": { "channels_last": 1, "dilation": 1, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [2, 5, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.0, 0.49635649551879424, 0.11962466460699121, 0.14297611255241777, 0.49285958941777674, -0.024194221684207075, 0.2740119683959368, 0.44820287057578, -0.16599259411036685, 0.3821644685127525, 0.3661157220151257, -0.2939285516892412, 0.4584015543858834, 0.2534534261240267, -0.3973178748786984, -0.46752628877922453, -0.23230108970687868, 0.4115404395057525, -0.49869053084904663, -0.09599295836497751, 0.4755556962035543, -0.48820800514532486, 0.04833176081570862, 0.499856227198713, -0.4369541309645112, 0.1886201859537722, 0.48241264049654564, -0.3492092346081068, 0.3131565151608276, 0.42468168925273364]
+          }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.25, 0.24450772868103707, 0.22827223507807706, 0.20200687707803797, 0.16686570646032703, 0.12439276197293174, 0.07645422709457234, 0.025156433346732933, -0.02724668805996778]
+          }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [2, 2, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.1, 0.08253356149096784, 0.036235775447667366, 0.09553364891256061, 0.06216099682706645, 0.007073720166770291, -0.02272020946930869, -0.07373937155412455, -0.09899924966004454, -0.05048461045998576, -0.09040721420170611, -0.0987479769908865]
+          }
+        },
+        "biasT": { "dtype": "float32", "shape": [3], "data": { "kind": "values", "values": [-0.02, -0.01, 0.0] } }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [2, 5, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [2, 2, 3], "tolerance": 0 }
+      },
+      "provenance": {
+        "source": "onnxruntime/test/contrib_ops/causal_conv_with_state_op_test.cc",
+        "test": "ChannelsLastWithStateAndBias"
+      }
+    },
+    {
+      "name": "ort_ChannelsLastDilated",
+      "attrs": { "channels_last": 1, "dilation": 2, "state_window": 0, "activation": "silu" },
+      "inputs": {
+        "inputT": {
+          "dtype": "float32",
+          "shape": [1, 6, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.0, 0.03260086070410765, -0.06498480608606168, 0.195270898753163, -0.16616904270849853, 0.13596155292740508, 0.3408432087797452, -0.3226470994332962, 0.30230420322282175, 0.3996671781085904, -0.3970079251679853, 0.39170711307448003, 0.3567714603813519, -0.370325872931093, 0.38141625986022976, 0.2230734869565668, -0.24939181811147415, 0.27405077876512024]
+          }
+        },
+        "weightT": {
+          "dtype": "float32",
+          "shape": [3, 1, 3],
+          "data": {
+            "kind": "values",
+            "values": [0.3, 0.29567543007286823, 0.28282639965850387, 0.2618233522937254, 0.23327181562527838, 0.19799494376549462, 0.15700978537549484, 0.11149796167815983, 0.06277159976742577]
+          }
+        },
+        "pastStateT": {
+          "dtype": "float32",
+          "shape": [1, 4, 3],
+          "data": {
+            "kind": "values",
+            "values": [-0.2, 0.08000000000000002, 0.36000000000000004, -0.13, 0.15000000000000002, 0.4300000000000001, -0.06, 0.22000000000000003, 0.5, 0.010000000000000009, 0.29000000000000004, 0.5700000000000001]
+          }
+        }
+      },
+      "outputs": {
+        "outputT": { "dtype": "float32", "shape": [1, 6, 3], "tolerance": 0.00001, "relTolerance": 0.00001 },
+        "presentStateT": { "dtype": "float32", "shape": [1, 4, 3], "tolerance": 0 }
+      },
+      "provenance": {
+        "source": "onnxruntime/test/contrib_ops/causal_conv_with_state_op_test.cc",
+        "test": "ChannelsLastDilated"
+      }
     }
   ]
 }