Cross-Dialect MLIR Benchmarks - NeurIPS 2026 (E&D)
Collection
NL→MLIR benchmarks (465 instances; arith/func/memref, linalg, StableHLO). Code: github.com/plawanrath/slm-to-mlir-constrained-emitter • 6 items • Updated
id stringlengths 6 23 | nl stringlengths 52 83 | mlir stringlengths 131 482 | op stringlengths 3 20 | dialect stringclasses 1
value | source stringclasses 1
value |
|---|---|---|---|---|---|
01_reduce_sum_1d | Sum a 1-D f32 tensor of 16 elements using stablehlo.reduce with an add body. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<f32> {
%init = stablehlo.constant dense<0.0> : tensor<f32>
%0 = stablehlo.reduce(%a init: %init) across dimensions = [0] : (tensor<16xf32>, tensor<f32>) -> tensor<f32>
reducer(%arg0: tensor<f32>, %arg1: tensor<f32>) {
%sum = stablehlo.add %arg0... | reduce | stablehlo+func | outofgrammar_phase_f |
02_conv_2d | Apply a 2-D convolution of an input tensor 1x4x4x3 (NHWC) with a filter 3x3x3x8. | module {
func.func @f(%a: tensor<1x4x4x3xf32>, %w: tensor<3x3x3x8xf32>) -> tensor<1x2x2x8xf32> {
%0 = stablehlo.convolution(%a, %w)
dim_numbers = [b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f],
window = {stride = [1, 1], pad = [[0, 0], [0, 0]]}
{batch_group_count = 1 : i64, feature_group_count = 1 : i6... | convolution | stablehlo+func | outofgrammar_phase_f |
03_pad_2d | Pad a 4x4 f32 tensor with 1-pixel borders of zero on each side, producing 6x6. | module {
func.func @f(%a: tensor<4x4xf32>) -> tensor<6x6xf32> {
%pad = stablehlo.constant dense<0.0> : tensor<f32>
%0 = stablehlo.pad %a, %pad, low = [1, 1], high = [1, 1], interior = [0, 0]
: (tensor<4x4xf32>, tensor<f32>) -> tensor<6x6xf32>
return %0 : tensor<6x6xf32>
}
} | pad | stablehlo+func | outofgrammar_phase_f |
04_dynamic_slice_1d | Slice 8 elements from a 1-D f32 tensor of 32 starting at dynamic index. | module {
func.func @f(%a: tensor<32xf32>, %i: tensor<i32>) -> tensor<8xf32> {
%0 = stablehlo.dynamic_slice %a, %i, sizes = [8] : (tensor<32xf32>, tensor<i32>) -> tensor<8xf32>
return %0 : tensor<8xf32>
}
} | dynamic_slice | stablehlo+func | outofgrammar_phase_f |
05_iota_1d | Produce a 1-D i32 iota tensor of 16 elements (values 0..15). | module {
func.func @f() -> tensor<16xi32> {
%0 = stablehlo.iota dim = 0 : tensor<16xi32>
return %0 : tensor<16xi32>
}
} | iota | stablehlo+func | outofgrammar_phase_f |
06_clamp_f32 | Clamp a 1-D f32 tensor of 16 elements to the [0, 1] range. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%lo = stablehlo.constant dense<0.0> : tensor<16xf32>
%hi = stablehlo.constant dense<1.0> : tensor<16xf32>
%0 = stablehlo.clamp %lo, %a, %hi : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | clamp | stablehlo+func | outofgrammar_phase_f |
07_select_f32 | Elementwise select between two f32 tensors of shape 16 based on a bool mask. | module {
func.func @f(%p: tensor<16xi1>, %x: tensor<16xf32>, %y: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.select %p, %x, %y : (tensor<16xi1>, tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
return %0 : tensor<16xf32>
}
} | select | stablehlo+func | outofgrammar_phase_f |
08_compare_lt | Elementwise less-than comparison of two f32 tensors of shape 16. | module {
func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xi1> {
%0 = stablehlo.compare LT, %a, %b, FLOAT : (tensor<16xf32>, tensor<16xf32>) -> tensor<16xi1>
return %0 : tensor<16xi1>
}
} | compare | stablehlo+func | outofgrammar_phase_f |
09_concatenate | Concatenate two 4x4 f32 tensors along axis 0 to produce an 8x4 tensor. | module {
func.func @f(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<8x4xf32> {
%0 = stablehlo.concatenate %a, %b, dim = 0 : (tensor<4x4xf32>, tensor<4x4xf32>) -> tensor<8x4xf32>
return %0 : tensor<8x4xf32>
}
} | concatenate | stablehlo+func | outofgrammar_phase_f |
10_reduce_max_2d | Reduce max across rows of a 4x8 f32 tensor, producing a 4-element vector. | module {
func.func @f(%a: tensor<4x8xf32>) -> tensor<4xf32> {
%init = stablehlo.constant dense<0xFF800000> : tensor<f32>
%0 = stablehlo.reduce(%a init: %init) across dimensions = [1] : (tensor<4x8xf32>, tensor<f32>) -> tensor<4xf32>
reducer(%arg0: tensor<f32>, %arg1: tensor<f32>) {
%m = stablehl... | reduce | stablehlo+func | outofgrammar_phase_f |
11_conv_1d | Apply a 1-D convolution to an input tensor of shape 1x16x4 (NWC) with filter 3x4x8. | module {
func.func @f(%a: tensor<1x16x4xf32>, %w: tensor<3x4x8xf32>) -> tensor<1x14x8xf32> {
%0 = stablehlo.convolution(%a, %w)
dim_numbers = [b, 0, f]x[0, i, o]->[b, 0, f],
window = {stride = [1], pad = [[0, 0]]}
{batch_group_count = 1 : i64, feature_group_count = 1 : i64}
: (tensor<1x16x... | convolution | stablehlo+func | outofgrammar_phase_f |
12_gather_simple | Gather 4 rows from an 8x16 f32 tensor using a 4-element i32 index vector. | module {
func.func @f(%a: tensor<8x16xf32>, %idx: tensor<4x1xi32>) -> tensor<4x16xf32> {
%0 = "stablehlo.gather"(%a, %idx) {
dimension_numbers = #stablehlo.gather<
offset_dims = [1],
collapsed_slice_dims = [0],
start_index_map = [0],
index_vector_dim = 1
>,
slice_... | gather | stablehlo+func | outofgrammar_phase_f |
13_slice_static | Take the first 4x4 block of an 8x8 f32 tensor using stablehlo.slice. | module {
func.func @f(%a: tensor<8x8xf32>) -> tensor<4x4xf32> {
%0 = stablehlo.slice %a [0:4, 0:4] : (tensor<8x8xf32>) -> tensor<4x4xf32>
return %0 : tensor<4x4xf32>
}
} | slice | stablehlo+func | outofgrammar_phase_f |
14_rsqrt | Compute elementwise reciprocal square root of a 16-element f32 tensor. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.rsqrt %a : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | rsqrt | stablehlo+func | outofgrammar_phase_f |
15_sign | Compute elementwise sign of a 16-element f32 tensor. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.sign %a : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | sign | stablehlo+func | outofgrammar_phase_f |
16_tanh | Compute elementwise hyperbolic tangent of a 16-element f32 tensor. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.tanh %a : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | tanh | stablehlo+func | outofgrammar_phase_f |
17_sort_1d | Sort a 1-D f32 tensor of 16 elements in ascending order using stablehlo.sort. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = "stablehlo.sort"(%a) ({
^bb0(%x: tensor<f32>, %y: tensor<f32>):
%cmp = stablehlo.compare LT, %x, %y, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
stablehlo.return %cmp : tensor<i1>
}) {dimension = 0 : i64, is_stable =... | sort | stablehlo+func | outofgrammar_phase_f |
18_power | Compute elementwise power a^b of two 16-element f32 tensors. | module {
func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.power %a, %b : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | power | stablehlo+func | outofgrammar_phase_f |
19_dynamic_update_slice | Update a 4-element slice of a 32-element f32 tensor at a dynamic index. | module {
func.func @f(%a: tensor<32xf32>, %u: tensor<4xf32>, %i: tensor<i32>) -> tensor<32xf32> {
%0 = stablehlo.dynamic_update_slice %a, %u, %i : (tensor<32xf32>, tensor<4xf32>, tensor<i32>) -> tensor<32xf32>
return %0 : tensor<32xf32>
}
} | dynamic_update_slice | stablehlo+func | outofgrammar_phase_f |
20_reverse | Reverse the order of elements in a 1-D f32 tensor of 16 elements. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.reverse %a, dims = [0] : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | reverse | stablehlo+func | outofgrammar_phase_f |
21_round | Round elementwise to nearest even integer on a 16-element f32 tensor. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xf32> {
%0 = stablehlo.round_nearest_even %a : tensor<16xf32>
return %0 : tensor<16xf32>
}
} | round | stablehlo+func | outofgrammar_phase_f |
22_is_finite | Elementwise is_finite on a 16-element f32 tensor, returning a bool tensor. | module {
func.func @f(%a: tensor<16xf32>) -> tensor<16xi1> {
%0 = stablehlo.is_finite %a : (tensor<16xf32>) -> tensor<16xi1>
return %0 : tensor<16xi1>
}
} | is_finite | stablehlo+func | outofgrammar_phase_f |
23_shift_left | Elementwise left-shift of two 16-element i32 tensors. | module {
func.func @f(%a: tensor<16xi32>, %b: tensor<16xi32>) -> tensor<16xi32> {
%0 = stablehlo.shift_left %a, %b : tensor<16xi32>
return %0 : tensor<16xi32>
}
} | shift_left | stablehlo+func | outofgrammar_phase_f |
24_xor | Elementwise bitwise xor of two 16-element i32 tensors. | module {
func.func @f(%a: tensor<16xi32>, %b: tensor<16xi32>) -> tensor<16xi32> {
%0 = stablehlo.xor %a, %b : tensor<16xi32>
return %0 : tensor<16xi32>
}
} | xor | stablehlo+func | outofgrammar_phase_f |
25_popcnt | Elementwise population-count of a 16-element i32 tensor. | module {
func.func @f(%a: tensor<16xi32>) -> tensor<16xi32> {
%0 = stablehlo.popcnt %a : tensor<16xi32>
return %0 : tensor<16xi32>
}
} | popcnt | stablehlo+func | outofgrammar_phase_f |
StableHLO-OutOfGrammar-25
Accepted to NeurIPS 2026 (Evaluations & Datasets Track)
Paper (arXiv) · Code (GitHub) · All six datasets (collection)
Hand-authored NL→StableHLO pairs using ops outside our 10-op grammar scope (n=25, stress set).
This dataset is part of the suite released with the NeurIPS 2026 Evaluations & Datasets Track paper Cross-Dialect Generalization Without Retraining: Benchmarks and Evaluation of Schema-Derived Constrained Decoding for MLIR (arXiv:2607.18254): four NL→MLIR benchmarks (MLIR-Spec-150, Linalg-Spec-30, StableHLO-Spec-30, StableHLO-Held-Out-200) and the StableHLO-OutOfGrammar-25 stress set, 435 benchmark instances across three MLIR dialects, plus MLIR-Functional-Reference-30, which attaches hand-authored inputs and expected outputs to 30 existing Spec prompts (no new prompts).
Composition
- Instances: 25
- Format: one JSON record per line in
data/test.jsonl - Schema: fields =
dialect,id,mlir,nl,op,source - Verifier:
stablehlo-opt v1.4.0(upstream truth) andiree-compile --compile-to=input(substitute, 50/50 concordant on a stratified n=50 sample) - License: Apache-2.0 (SPDX: Apache-2.0). No third-party IP restrictions.
Loading
from datasets import load_dataset
ds = load_dataset("plawanrath/StableHLO-OutOfGrammar-25", split="test")
print(ds[0])
Each record is a self-contained natural-language→MLIR pair; verify-valid pass-rate under the dialect's verifier is the primary evaluation metric.
Source format
The JSONL file at data/test.jsonl is the canonical HuggingFace interface. It is exported 1-to-1 from the source records (examples/*.json) in eval/benchmarks/stablehlo_outofgrammar_25/ of the code repository.
Datasheet
Key points (full Gebru-style datasheet: docs/datasheets/datasheet.md):
- All reference MLIR programs are verifier-clean at the time of release.
- Hand-authored (no crowdsourcing, no LLM-authored references).
- Test-only — fine-tuning on these benchmarks contaminates future evaluation and is explicitly out of scope.
Croissant metadata
croissant.json in this repository is the dataset's MLCommons Croissant 1.1 metadata, including the Responsible AI (rai:) and provenance (prov:) fields required by the NeurIPS 2026 Evaluations & Datasets Track. (Hugging Face's auto-generated Croissant endpoint covers the core fields only.)
Code
Generation, verification and evaluation code: github.com/plawanrath/slm-to-mlir-constrained-emitter.
Citation
@inproceedings{rath2026crossdialect,
title = {Cross-Dialect Generalization Without Retraining: Benchmarks and Evaluation of Schema-Derived Constrained Decoding for {MLIR}},
author = {Rath, Plawan Kumar},
booktitle = {Advances in Neural Information Processing Systems (NeurIPS), Evaluations and Datasets Track},
year = {2026},
eprint = {2607.18254},
archivePrefix = {arXiv}
}
License
Apache-2.0 (see LICENSE). Copyright 2026 Plawan Kumar Rath.
Disclaimer
Plawan Kumar Rath (@plawanrath). This work was conducted in the author's personal capacity. The views expressed here are those of the author and do not necessarily reflect the views of Meta.
- Downloads last month
- 83