<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm</path>
<type>directory</type>
<entries>
benchmark.py
check.py
problem.yaml
PROMPT.txt
reference.py
shapes.py
sota.py

(7 entries)
</entries>

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/reference.py</path>
<type>file</type>
<content>
1: """Naive Conv3d-as-GEMM patch embedding reference (correctness only).
2: 
3: Vision-Transformer / Qwen2-VL style patch embedding: a video tensor
4: (B, C, T, H, W) is split into non-overlapping (kT, kH, kW) patches and each
5: patch projected to embed_dim. This is mathematically a 3D convolution with
6: stride == kernel and equivalently a single GEMM after a strided reshape.
7: 
8: Reference uses nn.Conv3d (cuDNN dispatch) for clarity. The agent's solution is
9: forbidden from using Conv3d / conv3d / matmul / linear / einsum, forcing them
10: to write a fused patch-gather + tensor-core GEMM kernel.
11: 
12: Output layout: (B, embed_dim, T/kT, H/kH, W/kW). No bias.
13: """
14: import torch
15: import torch.nn as nn
16: 
17: OP_TYPE = "patch_embed"
18: SUPPORTED_PRECISIONS = ["bf16"]
19: HARDWARE_REQUIRED = ["RTX_PRO_6000"]
20: 
21: 
22: class Model(nn.Module):
23:     def __init__(self, B: int, C: int, T: int, H: int, W: int,
24:                  kT: int, kH: int, kW: int, embed_dim: int):
25:         super().__init__()
26:         assert T % kT == 0 and H % kH == 0 and W % kW == 0, \
27:             f"Input dims must be divisible by patch size: T={T} kT={kT} H={H} kH={kH} W={W} kW={kW}"
28:         self.B, self.C, self.T, self.H, self.W = B, C, T, H, W
29:         self.kT, self.kH, self.kW = kT, kH, kW
30:         self.embed_dim = embed_dim
31: 
3

... (911 more chars)

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/check.py</path>
<type>file</type>
<content>
1: """Correctness runner for Conv3d-as-GEMM patch embedding.
2: 
3: Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
4: each, with per-dtype atol/rtol. Also rejects forbidden ops by grep.
5: """
6: import re
7: import sys
8: from pathlib import Path
9: 
10: import torch
11: import yaml
12: 
13: # Make the repo's src/ importable
14: REPO_ROOT = Path(__file__).resolve().parents[2]
15: sys.path.insert(0, str(REPO_ROOT))
16: 
17: from src.eval.correctness import check_correctness  # noqa: E402
18: 
19: 
20: def main():
21:     try:
22:         import reference
23:         import shapes
24:         import solution
25:     except Exception as e:
26:         print(f"FAIL: import error: {e}")
27:         sys.exit(1)
28: 
29:     problem_yaml = Path("problem.yaml")
30:     meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
31: 
32:     # --- Forbidden-op check ------------------------------------------------
33:     sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
34:     for forbidden in meta.get("forbidden", []):
35:         pat = re.escape(forbidden)
36:         if re.search(pat, sol_src):
37:             print(f"FAIL: forbidden op used: {forbidden}")
38:             sys.exit(1)
39: 
40:     device = torch.device("cuda:0")
41:     tol_override = meta.get("tolerance") o

... (3130 more chars)

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/benchmark.py</path>
<type>file</type>
<content>
1: """Roofline benchmark for Conv3d-as-GEMM patch embedding.
2: 
3: For each shape: times eager reference, compiled reference, SOTA (if available),
4: and the agent's solution. Reports achieved TFLOPS, GB/s, and peak_fraction.
5: 
6: Output lines the harness picks up:
7:   shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
8:   peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
9: """
10: import sys
11: from math import exp, log
12: from pathlib import Path
13: 
14: import torch
15: import yaml
16: 
17: REPO_ROOT = Path(__file__).resolve().parents[2]
18: sys.path.insert(0, str(REPO_ROOT))
19: 
20: from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
21: from src.eval.timing import time_fn  # noqa: E402
22: from src.hardware import get as get_hw  # noqa: E402
23: 
24: 
25: def _eval_formula(expr: str, vars: dict) -> float:
26:     # Very small eval: only names from `vars` are valid.
27:     return float(eval(expr, {"__builtins__": {}}, vars))
28: 
29: 
30: def main():
31:     import reference
32:     import shapes
33:     import solution
34: 
35:     meta = yaml.safe_load(Path("problem.yaml").read_text())
36:     hw = get_hw(meta["hardware"][0])
37:     peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
38:     peak_gbps = hw.peak_bandwidth_gb_s
39:     regime = meta.get("regim

... (3879 more chars)

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/shapes.py</path>
<type>file</type>
<content>
1: """Canonical shape sweep for Conv3d-as-GEMM patch embedding.
2: 
3: Sized for Qwen2-VL / ViT-style patch embedding. embed_dim=1280 matches Qwen2-VL
4: ViT; embed_dim=768 is a ViT-B/16 reference. Patch sizes are the canonical
5: 14x14 spatial / 2-frame temporal used in modern VL encoders.
6: """
7: 
8: SHAPES = [
9:     # Qwen2-VL ViT base: 224x224x2-frame video, 14x14x2 patches, embed_dim=1280
10:     {"B": 1, "C": 3, "T": 2,  "H": 224, "W": 224, "kT": 2, "kH": 14, "kW": 14, "embed_dim": 1280},
11: 
12:     # Same patch config, batch 2, 4-frame video
13:     {"B": 2, "C": 3, "T": 4,  "H": 224, "W": 224, "kT": 2, "kH": 14, "kW": 14, "embed_dim": 1280},
14: 
15:     # Larger spatial (336x336), 8-frame — exercises larger num_patches
16:     {"B": 1, "C": 3, "T": 8,  "H": 336, "W": 336, "kT": 2, "kH": 14, "kW": 14, "embed_dim": 1280},
17: 
18:     # ViT-B/16 (image-mode): kT=1, kH=kW=16, embed_dim=768
19:     {"B": 4, "C": 3, "T": 1,  "H": 224, "W": 224, "kT": 1, "kH": 16, "kW": 16, "embed_dim": 768},
20: ]

(End of file - total 20 lines)
</content>

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/problem.yaml</path>
<type>file</type>
<content>
1: name: 10_patch_embed_conv3d_gemm
2: display_name: "Conv3d-as-GEMM Patch Embedding"
3: precision: bf16
4: regime: compute  # GEMM-equivalent, embed_dim=1280 is well above the bf16 ridge
5: 
6: # Dense FLOPs: 2 * (num_patches) * (C * kT * kH * kW) * embed_dim.
7: # With stride==kernel and divisible inputs, num_patches * (kT*kH*kW) = T*H*W,
8: # so this collapses to: 2 * B * embed_dim * C * T * H * W.
9: flops_formula: "2 * B * embed_dim * C * T * H * W"
10: 
11: # Bytes moved (lower bound):
12: #   read input x:    B * C * T * H * W * 2
13: #   read weights:    embed_dim * C * kT * kH * kW * 2
14: #   write output:    B * embed_dim * (T // kT) * (H // kH) * (W // kW) * 2
15: bytes_formula: "B*C*T*H*W*2 + embed_dim*C*kT*kH*kW*2 + B*embed_dim*(T//kT)*(H//kH)*(W//kW)*2"
16: 
17: hardware: [RTX_PRO_6000]
18: peak_tflops_key: bf16
19: peak_bandwidth_key: dram
20: 
21: tolerance:
22:   bfloat16: 0.02
23: 
24: # Forbidden ops -- agent must implement the fused patch-gather + GEMM
25: # themselves. Banning Conv3d/conv3d (the cuDNN dispatch) and matmul/bmm/linear/
26: # einsum (the lazy reshape-then-cuBLAS shortcut). Unfold is also banned for
27: # completeness even though it's nominally 2D.
28: forbidden:
29:   - "torch.nn.Conv3d"
30:   - "torch.nn.functional.conv3d"
31:   - "F.conv3d"
32:   - "torch.conv3d"
33:   - "torch.matmul"
34:   - "torch.bmm"
35:   -

... (386 more chars)

<path>/home/infatoshi/cuda/KernelBench-Hard/problems/10_patch_embed_conv3d_gemm/sota.py</path>
<type>file</type>
<content>
1: """SOTA reference for Conv3d-as-GEMM patch embedding.
2: 
3: Dispatches torch.nn.functional.conv3d (cuDNN). The agent's solution is
4: forbidden from calling conv3d directly; this file is only for the benchmark's
5: reference baseline.
6: """
7: from __future__ import annotations
8: 
9: import torch
10: import torch.nn.functional as F
11: 
12: 
13: def sota_forward(x: torch.Tensor, weight: torch.Tensor,
14:                  stride: tuple[int, int, int]) -> torch.Tensor:
15:     return F.conv3d(x, weight, bias=None, stride=stride)
16: 
17: 
18: def is_available() -> bool:
19:     return True

(End of file - total 19 lines)
</content>

<path>/home/infatoshi/cuda/KernelBench-Hard/src</path>
<type>directory</type>
<entries>
__init__.py
__pycache__/
eval/
hardware/
harness/
sandbox/
viewer/

(7 entries)
</entries>

NVIDIA RTX PRO 6000 Blackwell Workstation Edition, 97887 MiB, 12.0, 595.58.03

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2026 NVIDIA Corporation
Built on Mon_Mar_02_09:52:23_PM_PST_2026
Cuda compilation tools, release 13.2, V13.2.51
Build cuda_13.2.r13.2/compiler.37434383_0

<path>/home/infatoshi/cuda/KernelBench-Hard/src/hardware</path>
<type>directory</type>
<entries>
__init__.py
__pycache__/
m4_max.py
rtx_pro_6000.py

(4 entries)
</entries>

No files found

<path>/home/infatoshi/cuda/KernelBench-Hard/src/hardware/rtx_pro_6000.py</path>
<type>file</type>
<content>
1: """RTX PRO 6000 Blackwell Workstation — SM120, consumer-lineage Blackwell.
2: 
3: Peak tensor-core throughputs are dense-matrix advertised peaks. Actual kernels
4: will see 60-85% of peak on well-tuned code.
5: """
6: from dataclasses import dataclass
7: 
8: 
9: @dataclass(frozen=True)
10: class HardwareTarget:
11:     name: str
12:     sm: str
13:     vram_gb: int
14:     peak_bandwidth_gb_s: float  # DRAM
15:     peak_tflops_dense: dict[str, float]  # dtype -> TFLOPS
16: 
17: 
18: RTX_PRO_6000 = HardwareTarget(
19:     name="RTX PRO 6000 Blackwell Workstation",
20:     sm="sm_120a",
21:     vram_gb=96,
22:     peak_bandwidth_gb_s=1800.0,
23:     peak_tflops_dense={
24:         "fp4": 800.0,
25:         "nvfp4": 800.0,
26:         "mxfp4": 800.0,
27:         "fp6": 800.0,
28:         "fp8": 400.0,
29:         "bf16": 200.0,
30:         "fp16": 200.0,
31:         "tf32": 100.0,
32:         "fp32": 12.0,  # non-tensor-core SIMT fp32
33:         "int8": 400.0,
34:         "int4": 800.0,
35:     },
36: )

(End of file - total 36 lines)
</content>

<path>/home/infatoshi/cuda/KernelBench-Hard/src/eval/correctness.py</path>
<type>file</type>
<content>
1: """Per-dtype correctness tolerance.
2: 
3: Stanford's KernelBench uses 1e-4 atol/rtol for fp32 and 1e-2 for fp16/bf16.
4: We extend to fp8 (0.1, permissive) and int (exact).
5: """
6: from __future__ import annotations
7: 
8: import torch
9: 
10: DEFAULT_TOLERANCE = {
11:     torch.float32: {"atol": 1e-4, "rtol": 1e-4},
12:     torch.float16: {"atol": 1e-2, "rtol": 1e-2},
13:     torch.bfloat16: {"atol": 1e-2, "rtol": 1e-2},
14:     torch.float8_e4m3fn: {"atol": 1e-1, "rtol": 1e-1},
15:     torch.float8_e5m2: {"atol": 1e-1, "rtol": 1e-1},
16:     torch.int8: {"atol": 0, "rtol": 0},
17:     torch.int32: {"atol": 0, "rtol": 0},
18:     torch.int64: {"atol": 0, "rtol": 0},
19: }
20: 
21: 
22: def _coerce_float(x):
23:     """Accept int/float/str scientific-notation as float; pass through dicts."""
24:     if isinstance(x, (int, float)):
25:         return float(x)
26:     if isinstance(x, str):
27:         try:
28:             return float(x)
29:         except ValueError:
30:             return x
31:     return x
32: 
33: 
34: def tolerance_for_dtype(dtype: torch.dtype, override: dict | None = None) -> dict:
35:     """Lookup atol/rtol for a given dtype, with optional per-problem override.
36: 
37:     The override dict is keyed by str(dtype). Values may be:
38:       - a single number (or a string parseable as float, e.g. "5e-2") -> used
39:         as both atol and rtol
4

... (2580 more chars)

<path>/home/infatoshi/cuda/KernelBench-Hard/src/eval/roofline.py</path>
<type>file</type>
<content>
1: """Roofline math: achieved TFLOPS / GB/s, peak fraction.
2: 
3: FLOPS and bytes formulas come from the problem's `problem.yaml`. They are the
4: dense-equivalent algorithmic work; kernels that skip work (sparsity, early
5: exit) are still measured against the dense cost.
6: """
7: from __future__ import annotations
8: 
9: 
10: def compute_tflops(flops: float, time_ms: float) -> float:
11:     """flops per invocation and wall time in ms -> TFLOPS."""
12:     if time_ms <= 0:
13:         return 0.0
14:     return flops / (time_ms * 1e-3) / 1e12
15: 
16: 
17: def compute_gbps(bytes_moved: float, time_ms: float) -> float:
18:     """bytes per invocation and wall time in ms -> GB/s."""
19:     if time_ms <= 0:
20:         return 0.0
21:     return bytes_moved / (time_ms * 1e-3) / 1e9
22: 
23: 
24: def peak_fraction(
25:     achieved: float,
26:     peak: float,
27: ) -> float:
28:     """Return achieved / peak, clamped to [0, infinity)."""
29:     if peak <= 0:
30:         return 0.0
31:     return max(0.0, achieved / peak)

(End of file - total 31 lines)
</content>

content: 'Check environment: Triton version, GPU availability, sm120 support'
status: 'in_progress'
priority: 'high'
content: 'Implement initial Triton fused patch-gather + GEMM kernel'
status: 'pending'
priority: 'high'
content: 'Run check.py for correctness on all shapes'
status: 'pending'
priority: 'high'
content: 'Run benchmark.py to measure performance'
status: 'pending'
priority: 'high'
content: 'Profile with torch.profiler or ncu if needed'
status: 'pending'
priority: 'medium'
content: 'Iterate: optimize kernel (tile sizes, pipelining, shared memory)'
status: 'pending'
priority: 'high'
content: 'Final correctness + benchmark pass'
status: 'pending'
priority: 'high'

3.6.0
13.0

tensor(2.2031, device='cuda:0', dtype=torch.bfloat16)

Traceback (most recent call last):
  File "/home/infatoshi/cuda/KernelBench-Hard/.venv/lib/python3.11/site-packages/triton/runtime/jit.py", line 461, in __init__
    self.raw_src, self.starting_line_number = inspect.getsourcelines(fn)
                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/infatoshi/.local/share/uv/python/cpython-3.11.15-linux-x86_64-gnu/lib/python3.11/inspect.py", line 1240, in getsourcelines
    lines, lnum = findsource(object)
                  ^^^^^^^^^^^^^^^^^^
  File "/home/infatoshi/.local/share/uv/python/cpython-3.11.15-linux-x86_64-gnu/lib/python3.11/inspect.py", line 1077, in findsource
    raise OSError('could not get source code')
OSError: could not get source code

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<string>", line 6, in <module>
  File "/home/infatoshi/cuda/KernelBench-Hard/.venv/lib/python3.11/site-packages/triton/runtime/jit.py", line 935, in jit
    return decorator(fn)
           ^^^^^^^^^^^^^
  File "/home/infatoshi/cuda/KernelBench-Hard/.venv/lib/python3.11/site-packages/triton/runtime/jit.py", line 923, in decorator
    return JITFunction(
           ^^^^^^^^^^^^
  File "/home/infatoshi/cuda/KernelBench-Hard/.venv/lib/python3.11/site-packages/triton/runtime/jit.py", line 756, in __init__
    super().__init__(fn)
  File "/home/infatoshi/cuda/KernelBench-Hard/.venv/lib/python3.11/site-packages/triton/runtime/jit.py", line 463, in __i

... (149 more chars)

tensor([1., 1., 1., 1.], device='cuda:0', dtype=torch.bfloat16)

Result match: True
Max diff: tensor(0., device='cuda:0')

content: 'Check environment: Triton version, GPU availability, sm120 support'
status: 'completed'
priority: 'high'
content: 'Implement initial Triton fused patch-gather + GEMM kernel'
status: 'in_progress'
priority: 'high'
content: 'Run check.py for correctness on all shapes'
status: 'pending'
priority: 'high'
content: 'Run benchmark.py to measure performance'
status: 'pending'
priority: 'high'
content: 'Profile with torch.profiler or ncu if needed'
status: 'pending'
priority: 'medium'
content: 'Iterate: optimize kernel (tile sizes, pipelining, shared memory)'
status: 'pending'
priority: 'high'
content: 'Final correctness + benchmark pass'
status: 'pending'
priority: 'high'