메뉴
Write numerical equivalence tests for a Spyre-aware kernel (spyre.py) vs the original, including distribution invariance across core counts. Produces tests/triton/test_<name>_spyre.py. Use when asked to test a Spyre kernel. For plain _td kernels, use td-test.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
Convert a raw-pointer or block_ptr Triton kernel to the tl.make_tensor_descriptor API, producing a tensor_descriptor.py. Backend-agnostic — no Spyre invariants. Use when asked to port a kernel to tensor descriptors or modernize block_ptr/raw-pointer loads.
Review a tensor-descriptor Triton kernel (tensor_descriptor.py) for correct tl.make_tensor_descriptor usage — deprecated APIs removed, valid shape/strides/block_shape, no redundant masking, 16-byte rule, correctness vs original. Backend-agnostic; does not check Spyre invariants. Use spyre-review for the full Spyre compliance review.
Convert a GPU-shaped Triton kernel into a full Spyre-aware kernel (spyre.py) — tensor descriptors plus the authoring invariants (see _shared/invariants/), scratchpad batching, and Spyre-compiler gap handling. Use when asked to make a kernel Spyre-aware or port to Spyre. For a plain raw->descriptor port with no invariants, use td-convert.
Review a Spyre-aware kernel (spyre.py) for compliance with the authoring invariants (see _shared/invariants/), scratchpad utilization, Spyre-compiler descriptor patterns, and correctness vs original. Use when asked to review/verify a Spyre kernel. For a plain descriptor-API review (no invariants), use td-review.
Write numerical equivalence tests for a tensor-descriptor kernel (tensor_descriptor.py), comparing it against the original kernel. Produces tests/triton/test_<name>_td.py. Use when asked to test a _td kernel.
| name | spyre-test |
| description | Write numerical equivalence tests for a Spyre-aware kernel (spyre.py) vs the original, including distribution invariance across core counts. Produces tests/triton/test_<name>_spyre.py. Use when asked to test a Spyre kernel. For plain _td kernels, use td-test. |
Write numerical-equivalence tests for a Spyre-aware kernel against the original,
including distribution invariance (same result for any core count). Output:
tests/triton/test_<name>_spyre.py. For a _td kernel (no distribution loop),
use td-test.
Use when asked to write/add tests for a spyre.py kernel.
../_shared/preflight.md
(precision notes for Spyre DL16 can shift tolerances).kernels/<name>/spyre.py (signature), kernels/<name>/wrapper.py
(launch), and tests/triton/test_<name>.py if present (style).The right Spyre verification path is not "GPU triton":
dump_round_trip.py does this end-to-end).test_ktir_examples.py flow).The fixture framework in
https://github.com/torch-spyre/triton/tree/main/third_party/spyre/test is the
canonical reference, and includes IR-level assertion helpers (assert_present,
assert_result_type, …) usable from the review side.
Interim: until that path is wired into this repo's test harness, tests run the kernel on GPU/CUDA (the
@pytest.fixture device+torch.cudapattern below) and compare against the original kernel. Write tests against the original-kernel reference so they port cleanly to the ktir-cpu path later.
wrapper.pyLaunch both kernels through the existing kernels/<name>/wrapper.py (which
dispatches to the Spyre kernel, typically via a kernel_fn= argument) — do not
copy its launch logic into the test. A forked launch path drifts from
production and must be updated twice when the signature changes.
Distribution-invariance tests need to vary num_cores, and the wrapper should
accept num_cores as a parameter so the test drives it through the same
launch path the production code uses. If the wrapper does not yet expose
num_cores (or another parameter a test needs), extend wrapper.py rather
than building a parallel launch helper in the test.
Parametrize over representative shapes (include non-divisible), seed with
torch.manual_seed(42), random inputs, torch.testing.assert_close.
Tolerances — size to the output dtype's ULP, via a per-dtype TOL dict
(same rationale as td-test):
TOL = {
torch.float32: dict(atol=1e-5, rtol=1e-5),
torch.float16: dict(atol=1e-3, rtol=1e-3),
torch.bfloat16: dict(atol=8e-3, rtol=8e-3),
}
Loosen up only with a stated reason. Important — matmul / tl.dot
reductions: tl.dot and a NumPy @ reference accumulate the K dimension in
different orders, so a 1e-5 rtol is unrealistic — the project's
matmul/default fixture uses rtol≈1e-2. Align matmul-style tolerances with
that fixture, not the ULP table. Single-tile cases (size <= BLOCK_SIZE)
have no reduction-order divergence — assert atol=0, rtol=0.
Run the Spyre kernel with num_cores in [1, 4, 16, 32]; compare each against
the original. Also test: more cores than work items (idle cores) and
single core (sequential). This verifies the distribution loop for any
partitioning.
Non-divisible shapes; minimum size (< one tile); asymmetric shapes; zero input (eps); large values; kernel-specific edges (topk=1, single batch, vocab < BLOCK_SIZE).
(num_cores,), not derived from problem size.num_requests, num_elements) that replace
grid-size-equals-problem-size patterns.tests/triton/test_<name>_spyre.pywrapper.py with configurable num_cores
(extend the wrapper if it doesn't expose it — no forked launch path)[1,4,16,32]torch.testing.assert_close against the original onlyTOL; matmul-style tl.dot uses fixture rtol (~1e-2), not 1e-5atol=0, rtol=0torch.manual_seed(42) everywhere; random inputs