Benchmark · pre-generated, always available← back to leaderboard

Migration Readiness Report

openai/triton

79/ 100 ready

Manual blockers present

Advisory Summary — openai/triton → ROCm Migration

With a readiness score of 78/100, Triton is substantially port-ready: roughly 2,556 of 2,604 findings fall into buckets A or B, meaning the majority of the codebase either works as-is or requires only mechanical translation (e.g., CUDA API swaps, header renames, built-in substitutions). The 48 bucket-C manual blockers are the critical path — these likely involve backend-specific JIT/MLIR-bridge logic, PTX→GCN codegen paths, or CUDA runtime assumptions that require architectural decisions rather than find-and-replace. Recommended first step: triage the 48 manual blockers by dependency depth, prioritizing any that sit in the code-generation or kernel-launch critical path, since those will gate all downstream mechanical fixes from being validated end-to-end. Until those blockers are resolved, the 1,026 mechanical changes can be queued but not confidently verified.

1530Works as-is

1026Mechanical change

48Manual blocker

Findings

2604

Python files

375

Files scanned

1686

Custom CUDA kernels

detected

Detected but out of scope (not analyzed): C, C++, C/C++ header

Findings by file

2604 findings · 305 files

python/build_helpers.py· 9

Inline PTX assembly

src_func=lambda system, arch, version: f"cuda_nvcc-{system}-{arch}-{version}-archive/bin/ptxas{exe_extension}",

Fireworks AI:491

The lambda constructs a path to ptxas, the NVIDIA PTX assembler, which has no direct ROCm equivalent. On AMD Instinct GPUs, kernel compilation uses clang/lld targeting amdgcn rather than a separate PTX assembler stage, so this path lookup must be removed or replaced with the appropriate ROCm toolchain path (e.g., clang). Any code relying on ptxas for intermediate assembly will need to be reworked to use clang-based compilation.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -488,7 +488,7 @@
-    src_func=lambda system, arch, version: f"cuda_nvcc-{system}-{arch}-{version}-archive/bin/ptxas{exe_extension}",
+    # Advisory: ptxas has no ROCm equivalent; AMD uses clang/lld for amdgcn compilation.
+    # src_func=lambda system, arch, version: f"cuda_nvcc-{system}-{arch}-{version}-archive/bin/ptxas{exe_extension}",

Inline PTX assembly

dst_path="bin/ptxas",

Fireworks AI:492

The ptxas binary is NVIDIA's PTX assembler and is not available in the ROCm toolchain. Any build logic that copies, installs, or invokes ptxas will fail on AMD Instinct systems and should be removed or guarded behind a CUDA-only condition. ROCm uses clang/lld with the AMDGPU backend instead of a separate PTX assembler.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -492,1 +492,1 @@
-    dst_path="bin/ptxas",
+    dst_path="bin/ptxas",  # ADVISORY: ptxas is CUDA-only; remove or guard for ROCm builds

Inline PTX assembly

version=nvidia_toolchain_version["ptxas"],

Fireworks AI:494

This line references the NVIDIA-specific ptxas assembler version, which has no ROCm equivalent since AMD Instinct GPUs do not use PTX. Any build logic that invokes ptxas or compiles inline PTX assembly must be removed, disabled, or replaced with a HIP/GCN code path for ROCm targets.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -491,7 +491,11 @@
 # Advisory: ptxas is NVIDIA-only; guard or skip on ROCm builds.
-            version=nvidia_toolchain_version["ptxas"],
+            version=(
+                nvidia_toolchain_version["ptxas"]
+                if not use_rocm
+                else None
+            ),

Inline PTX assembly

# We download a separate ptxas for blackwell, since there are some bugs when using it for hopper

Fireworks AI:500

This comment references ptxas, the NVIDIA PTX assembler, which has no equivalent in the ROCm toolchain. On AMD Instinct GPUs, kernel compilation uses hipcc/clang and does not require downloading or pinning a separate PTX assembler, so this logic and any associated ptxas download/fallback code should be removed or guarded behind a CUDA-only build path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

diff --git a/python/build_helpers.py b/python/build_helpers.py
@@ -498,7 +498,9 @@
 # We download a separate ptxas for blackwell, since there are some bugs when using it for hopper
+# NOTE: ptxas is NVIDIA-only; this path is irrelevant for ROCm/AMD Instinct builds.
+# Consider guarding the following ptxas download logic with `if is_cuda_build:` so it
+# is skipped entirely when targeting ROCm.

Inline PTX assembly

src_func=lambda system, arch, version: f"cuda_nvcc-{system}-{arch}-{version}-archive/bin/ptxas{exe_extension}",

Fireworks AI:503

The lambda resolves a path to NVIDIA's ptxas PTX assembler, a CUDA-specific tool with no direct ROCm equivalent. On ROCm, PTX assembly and intermediate compilation are handled by clang/lld targeting AMDGPU, so any build logic or downstream usage relying on ptxas must be redirected to ROCm compiler tooling. This is build-infrastructure path resolution rather than inline PTX in kernel code, but it will break if left unchanged.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -503,1 +503,1 @@
-src_func=lambda system, arch, version: f"cuda_nvcc-{system}-{arch}-{version}-archive/bin/ptxas{exe_extension}",
+# Advisory: ptxas has no ROCm equivalent; redirect to clang/lld under ROCm toolchain or remove this entry if unused on AMD targets.
+src_func=lambda system, arch, version: f"rocm-{system}-{arch}-{version}/llvm/bin/clang{exe_extension}",

Inline PTX assembly

dst_path="bin/ptxas-blackwell",

Fireworks AI:504

The path references NVIDIA's ptxas assembler binary, which is part of the CUDA toolchain and has no ROCm equivalent. ROCm uses hipcc/clang for compilation and does not require a separate PTX assembler step, so any build logic that copies or validates this binary should be removed or replaced with ROCm-aware toolchain checks.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -504,1 +504,1 @@
-    dst_path="bin/ptxas-blackwell",
+    # Advisory: ptxas is NVIDIA-only; remove or gate behind CUDA-only build path for ROCm
+    # dst_path="bin/ptxas-blackwell",

Inline PTX assembly

version=nvidia_toolchain_version["ptxas-blackwell"],

Fireworks AI:506

PTX and ptxas are NVIDIA-specific; ROCm has no equivalent and uses LLVM/clang targeting the amdgcn ISA (e.g., gfx942 for MI300). This build-helper branch selecting a 'ptxas-blackwell' toolchain version will not function on AMD Instinct and must be replaced or guarded behind a CUDA-only path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -503,7 +403,11 @@
-    version=nvidia_toolchain_version["ptxas-blackwell"],
+    # Advisory: PTX/ptxas is NVIDIA-only. On ROCm, use the LLVM/clang
+    # toolchain targeting amdgcn (e.g. gfx942 for MI300). Guard this
+    # selection so it only applies under CUDA builds.
+    version=(nvidia_toolchain_version["ptxas-blackwell"]
+             if is_cuda_build else rocm_toolchain_version["amdgcn-mi300"]),

Inline PTX assembly

parser.add_argument("--triton-ptxas-path", default="", help="Path override for TRITON_PTXAS_PATH")

Fireworks AI:592

The --triton-ptxas-path argument references NVIDIA's PTX assembler (ptxas), which does not exist on ROCm. On AMD Instinct GPUs, Triton uses LLVM-based code generation and does not invoke ptxas, so this argument and any downstream logic that consumes TRITONPTXASPATH should be guarded or skipped on ROCm builds to avoid misleading configuration or runtime failures.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/build_helpers.py
+++ b/python/build_helpers.py
@@ -589,7 +589,11 @@
     # ... existing argument parsers ...
-    parser.add_argument("--triton-ptxas-path", default="", help="Path override for TRITON_PTXAS_PATH")
+    # ptxas is NVIDIA-only; Triton on ROCm uses LLVM and does not require ptxas.
+    # Advisory: guard this argument so it is only exposed/used on CUDA builds.
+    if not os.environ.get("ROCM_PATH") and not os.environ.get("HIP_PLATFORM"):
+        parser.add_argument("--triton-ptxas-path", default="", help="Path override for TRITON_PTXAS_PATH")

Inline PTX assembly

"--triton-ptxas-blackwell-path",

Fireworks AI:594

The flag --triton-ptxas-blackwell-path references NVIDIA's ptxas assembler and Blackwell architecture, neither of which exists on ROCm. On AMD Instinct, Triton targets AMDGPU via its LLVM backend and does not invoke ptxas, so this flag must be removed or guarded behind a CUDA-only condition to avoid build failures.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- python/build_helpers.py
+++ python/build_helpers.py
@@ -591,7 +591,9 @@
     # ... existing context ...
-        "--triton-ptxas-blackwell-path",
+        # Advisory: ptxas is NVIDIA-only; guard or remove for ROCm builds.
+        # On ROCm, Triton uses the AMDGPU LLVM backend and has no ptxas equivalent.
+        *("--triton-ptxas-blackwell-path",) if not is_rocm else (),

python/examples/gluon/01-attention-forward.py· 17

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import fence_async_shared

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell.float2 import Float2Tensor

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

# that processes one element of qk at a time. This improves ptxas's resulting SASS.

Fireworks AI:589

This is a comment referencing PTX and ptxas, NVIDIA-specific toolchain concepts. On ROCm, the equivalent intermediate representation is GCN ISA (amdgcn) and the assembler/toolchain is llvm-mc / roc-objdump, so the comment should be updated to reflect AMD terminology for accuracy.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/examples/gluon/01-attention-forward.py
+++ b/python/examples/gluon/01-attention-forward.py
@@ -586,7 +586,7 @@
 # that processes one element of qk at a time. This improves ptxas's resulting SASS.
+# that processes one element of qk at a time. This improves the AMD GPU compiler's resulting GCN ISA.

Inline PTX assembly

# FIXME: When using FADD2 reductions, ptxas misbehaves and spills far

Fireworks AI:660

Inline PTX assembly is NVIDIA-specific and has no direct equivalent on ROCm; any FADD2-based reduction logic must be reimplemented using HIP/ROCm intrinsics or portable device code. The ptxas reference is irrelevant on AMD toolchains (rocclr/llvm-amdgpu), so this code path will fail to compile or run on Instinct GPUs.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:947

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 10

template:951

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0:2] == (10, 3)

template:955

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

NUM_SMS = max(1, torch.cuda.get_device_properties("cuda").multi_processor_count * p.OCCUPANCY // num_ctas)

template:1126

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = max(1, torch.cuda.get_device_properties("cuda").multi_processor_count * p.OCCUPANCY // num_ctas)

template:1126

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:1171

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:1251

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.profiler # noqa: F401

template:1271

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_core.py· 39

Triton dependency

import triton

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import (

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.errors import InterpreterError

template:48

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if device not in ['cuda']:

template:117

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if device in ['cuda']:

template:125

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:126

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

def _test_unary(dtype_x, expr, numpy_expr=None, device='cuda', num_ctas=1):

template:162

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

def _test_binary(dtype_x, dtype_y, expr, numpy_expr=None, mode_x='real', mode_y='real', device='cuda', num_ctas=1,

template:221

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:1108

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

fence_sem = "acq_rel" if torch.cuda.get_device_capability()[0] < 9 else "acquire"

template:1406

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

fence_sem = "acq_rel" if torch.cuda.get_device_capability()[0] < 9 else "acquire"

template:1443

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if dst_type == 'bfloat16' and torch.cuda.get_device_capability()[0] < 9:

template:1561

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9,

template:1848

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9,

template:1866

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9,

template:1918

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if dtype_z.startswith('float8') and device not in ['cuda']:

template:2120

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if is_cuda() and 'V100' in torch.cuda.get_device_name(0):

template:2735

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:3251

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if dtype_str == "float8e4b15" and (is_hip() or (is_cuda() and torch.cuda.get_device_capability() >= (9, 0))):

template:3340

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capability = torch.cuda.get_device_capability()

template:3641

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:3922

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capability = torch.cuda.get_device_capability()

template:4329

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

@pytest.mark.parametrize("device", ['cuda', 'cpu', 'cpu_pinned'])

template:4990

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.language.core import constexpr_type

template:5949

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

# maybe delete it later after ptxas has been fixed

Fireworks AI:6098

The comment references ptxas, NVIDIA's PTX assembler, which does not exist in the ROCm toolchain. Any nearby inline PTX assembly must be replaced with AMDGPU/GCN inline assembly or an equivalent HIP/ROCm intrinsic, and ptxas-specific workarounds should be removed as they are irrelevant on AMD Instinct GPUs.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:6202

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if device in ['cuda']:

template:6507

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

capability = torch.cuda.get_device_capability()

template:6508

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if device != "cuda":

template:6749

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

X = torch.randint(0, 10, [BLOCK], device="cuda", dtype=torch.int32)

template:6760

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

Z = torch.zeros((), device="cuda", dtype=torch.int32)

template:6763

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if device != "cuda":

template:6770

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

X = torch.randint(0, 10, [BLOCK_0, BLOCK_1], device="cuda", dtype=torch.int32)

template:6785

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

Z = torch.zeros([NON_REDUCE_DIM], device="cuda", dtype=torch.int32)

template:6786

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if device != "cuda":

template:6807

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

X = torch.randint(0, 10, [BLOCK], device="cuda", dtype=torch.int32)

template:6818

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

with torch.cuda.device(x.device.index):

template:6975

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_line_info.py· 6

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hopper_or_newer, is_interpreter

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._filecheck import run_filecheck

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if backend == "cuda":

template:85

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Inline PTX assembly

# Recent ptxas versions can coalesce this minimal load-store

Fireworks AI:279

Inline PTX assembly is NVIDIA-specific and will not compile on ROCm targets, so any test relying on it for line-info verification must be backend-gated or given a GCN-equivalent path. Since this is a low-priority (bucket C) test-file finding, the advisory action is to skip or conditionally branch the PTX-dependent logic when running on AMD Instinct GPUs rather than attempting a direct ISA translation.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/language/test_line_info.py
+++ b/python/test/unit/language/test_line_info.py
@@ -276,6 +276,10 @@
 # Recent ptxas versions can coalesce this minimal load-store
+# NOTE: inline PTX below is NVIDIA-only; skip or branch for ROCm backends.
+if pytest.current_backend() == "cuda":
+    # PTX-dependent line-info checks
+    ...
+else:
+    pytest.skip("Inline PTX assembly not supported on ROCm", allow_module_level=True)

python/test/unit/plugins/test_dialect_plugin.py· 2

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna2

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

ptx_files = list(tmp_path.rglob("*.ptx"))

Fireworks AI:36

This test globs for .ptx files, which are NVIDIA-specific intermediate artifacts; ROCm compilation pipelines produce GCN ISA or HSACO/code objects instead. If the dialect plugin is migrated to emit ROCm artifacts, this test assertion must be updated to match the new file extension or the test will fail.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- python/test/unit/plugins/test_dialect_plugin.py
+++ python/test/unit/plugins/test_dialect_plugin.py
@@ -36,1 +36,1 @@
-ptx_files = list(tmp_path.rglob("*.ptx"))
+code_object_files = list(tmp_path.rglob("*.hsaco"))  # Advisory: use the ROCm code-object extension your migrated plugin emits

python/test/unit/runtime/test_autotuner.py· 10

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip_cdna2

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if use_cuda_graph and not torch.cuda.is_available():

template:20

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9,

template:311

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9,

template:360

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] != 9,

template:410

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Inline PTX assembly

temp_file = pathlib.Path(f"/tmp/test_override_{str(uuid.uuid4())}.ptx")

Fireworks AI:488

PTX is NVIDIA-specific intermediate assembly and cannot be consumed by the ROCm/HIP toolchain on AMD Instinct GPUs. The test that writes a .ptx temp file and feeds it to the autotuner will fail or be meaningless on ROCm unless the PTX is replaced with AMD ISA (GCN/CDNA) or the test is guarded/skipped for non-CUDA backends.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/runtime/test_autotuner.py
+++ b/python/test/unit/runtime/test_autotuner.py
@@ -485,6 +485,12 @@
 
 @pytest.mark.parametrize("backend", ["cuda", "hip"])
 def test_override_kernel(backend):
+    # Advisory: PTX is NVIDIA-only. On ROCm/HIP this test must emit
+    # AMD ISA (GCN/CDNA) instead, or be skipped when backend != "cuda".
+    if backend == "hip":
+        pytest.skip("PTX override not supported on ROCm; requires AMD ISA")
     temp_file = pathlib.Path(f"/tmp/test_override_{str(uuid.uuid4())}.ptx")

torch.cuda API usage

if not torch.cuda.is_available() or not torch.cuda.get_device_capability()[0] == 10:

template:509

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if not torch.cuda.is_available():

template:548

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/test_knobs.py· 16

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.cache import FileCacheManager

template:149

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.cache import FileCacheManager

template:202

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

default_ptxas = triton_root / "backends/nvidia/bin/ptxas"

Fireworks AI:243

This line hardcodes a path to NVIDIA's ptxas assembler, which does not exist in the ROCm/HIP toolchain. On AMD Instinct GPUs, there is no direct equivalent to ptxas; Triton's ROCm backend uses different compilation steps, so this test path must be guarded or replaced with a backend-aware lookup.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/test_knobs.py
+++ b/python/test/unit/test_knobs.py
@@ -240,7 +240,11 @@
-    default_ptxas = triton_root / "backends/nvidia/bin/ptxas"
+    # Advisory: ptxas is NVIDIA-only; on ROCm there is no equivalent binary.
+    # Guard this path so the test does not fail on AMD Instinct systems.
+    if (triton_root / "backends/nvidia").exists():
+        default_ptxas = triton_root / "backends/nvidia/bin/ptxas"
+    else:
+        default_ptxas = None

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()

Fireworks AI:245

This test asserts the resolved path of NVIDIA's ptxas assembler, a CUDA-specific tool with no ROCm equivalent. On AMD Instinct, the compilation path uses clang/lld targeting amdgcn, so this assertion will fail or be meaningless. The test should be guarded by a platform/backend check or replaced with an ROCm-aware equivalent knob.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/test_knobs.py
+++ b/python/test/unit/test_knobs.py
@@ -243,7 +243,11 @@
     ...
 
-    assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()
+    if torch.version.hip is None:
+        assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()
+    else:
+        # ROCm has no ptxas; skip or test the equivalent clang/amdgcn path knob.
+        pytest.skip("ptxas is NVIDIA-only; no ROCm equivalent knob under test")

Inline PTX assembly

tmp_ptxas = tmp_path / "ptxas-special"

Fireworks AI:248

The string references 'ptxas', the NVIDIA PTX assembler, which has no ROCm equivalent; ROCm uses its own compiler stack (amdclang/comgr) and does not consume PTX. Any test logic that shells out to or locates ptxas will fail on AMD Instinct and should be guarded or replaced with a ROCm-aware path. This is advisory only — no automatic fix is applied.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/test_knobs.py
+++ b/python/test/unit/test_knobs.py
@@ -245,7 +245,11 @@
-    tmp_ptxas = tmp_path / "ptxas-special"
+    # Advisory: ptxas is NVIDIA-only and absent on ROCm.
+    # Consider guarding this test behind a CUDA-only condition or
+    # substituting a ROCm compiler path (e.g., amdclang) when porting.
+    tmp_ptxas = tmp_path / "ptxas-special"  # TODO: ROCm migration — no ptxas on AMD

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == tmp_ptxas.resolve()

Fireworks AI:252

This test references the NVIDIA-specific ptxas assembler path knob, which has no direct ROCm equivalent (ROCm uses clang/LLVM for shader/assembly compilation). On ROCm builds, this assertion will fail because the nvidia.ptxas knob will not exist or will not resolve to a valid path, so the test should be skipped or adapted to the ROCm assembler toolchain.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/test_knobs.py
+++ b/python/test/unit/test_knobs.py
@@ -249,6 +249,9 @@
 
 def test_ptxas_knob_resolves(fresh_knobs, tmp_ptxas):
+    # Advisory: ptxas is NVIDIA-only; skip on ROCm builds
+    if not hasattr(fresh_knobs, "nvidia") or not hasattr(fresh_knobs.nvidia, "ptxas"):
+        pytest.skip("ptxas knob is NVIDIA-only; not available on ROCm")
     assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == tmp_ptxas.resolve()

Inline PTX assembly

fresh_knobs.nvidia.ptxas = str(default_ptxas)

Fireworks AI:257

This test references the NVIDIA-specific ptxas assembler path via a configuration knob. On ROCm there is no PTX assembler; the equivalent compilation path uses the AMD GCN/CDNA ISA compiler (e.g., clang/lld via hipcc), so this knob and its associated test logic need to be remapped to a ROCm compiler path or removed if no longer applicable.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Suggested change · advisory

--- a/python/test/unit/test_knobs.py
+++ b/python/test/unit/test_knobs.py
@@ -254,7 +254,8 @@
-    fresh_knobs.nvidia.ptxas = str(default_ptxas)
+    # Advisory: ptxas is NVIDIA-only; map to ROCm compiler path if an equivalent knob exists
+    # fresh_knobs.amd.compiler = str(default_amd_compiler)

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()

template:260

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

del fresh_knobs.nvidia.ptxas

template:263

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == tmp_ptxas.resolve()

template:265

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

fresh_knobs.nvidia.ptxas = str(default_ptxas)

template:270

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()

template:272

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == tmp_ptxas.resolve()

template:275

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

assert Path(fresh_knobs.nvidia.ptxas.path).resolve() == default_ptxas.resolve()

template:280

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

python/triton/_internal_testing.py· 17

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import TensorWrapper, reinterpret, type_canonicalisation_dict

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return False if target is None else target.backend == "cuda"

template:43

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 8

template:47

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] in [10, 11]

template:51

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0:2] == (10, 3)

template:55

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:59

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 9

template:63

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 12

template:67

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Inline PTX assembly

cuda_version = knobs.nvidia.ptxas.version

template:207

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

torch.cuda API usage

return torch.cuda.get_device_capability()[0] >= 9 and cuda_version_tuple >= min_cuda_version

template:211

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return torch.cuda.get_device_capability()[0] >= 9

template:219

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:233

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:261

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton import knobs

template:294

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/compiler/compiler.py· 1

Inline PTX assembly

# TODO: n_regs, n_spills should be metadata generated when calling `ptxas`

template:476

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

python/triton/knobs.py· 4

Triton dependency

from triton._C.libtriton import getenv, getenv_bool # type: ignore

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

# Convert ptxas-blackwell to PTXAS_BLACKWELL, not PTXAS-BLACKWELL

template:200

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

ptxas: env_nvidia_tool = env_nvidia_tool("ptxas")

template:503

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

ptxas_blackwell: env_nvidia_tool = env_nvidia_tool("ptxas-blackwell")

template:504

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

python/tutorials/gluon/08-warp-specialization.py· 28

Triton dependency

import triton

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:29

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:31

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier, fence_async_shared

template:32

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:33

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if torch.cuda.is_available():

template:41

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import nvidia

template:42

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

cublas_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:43

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:56

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:56

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:61

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:61

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

a = torch.randn(xnumel, ynumel, device="cuda")

template:317

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn(xnumel, ynumel, device="cuda")

template:318

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty_like(a, device="cuda")

template:319

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(xnumel, ynumel, device="cuda")

template:328

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(xnumel, ynumel, device="cuda")

template:329

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty_like(A, device="cuda")

template:330

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Inline PTX assembly

# Arrive after the first SMEM store and rely on ptxas to interleave.

template:531

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:584

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:584

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:601

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:602

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:603

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:622

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:626

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:627

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/nvidia/backend/compiler.py· 22

Triton dependency

from triton.backends.compiler import BaseBackend, GPUTarget, Language

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir, passes, llvm, nvidia

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.errors import PTXASError

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

return knobs.nvidia.ptxas_blackwell if arch >= 100 else knobs.nvidia.ptxas

template:39

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

return mock_ver # This is not really a version of ptxas, but it is good enough for testing

template:46

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Device string "cuda"

backend_name: str = 'cuda'

template:132

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return target.backend == 'cuda'

template:169

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.language.extra.cuda as cuda

template:226

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra.cuda import libdevice

template:236

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

# Work around ptxas rejecting PTX generated by the LLVM SLP vectorizer on sm_80.

template:449

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

# Remove the debug flag that prevents ptxas from optimizing the code

template:486

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

ptxas = get_ptxas(self.target.arch).path

template:496

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.ptx') as fsrc, \

template:497

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

# Disable ptxas optimizations if requested

template:517

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

# Accept more ptxas options if provided

template:520

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

# accesses; -O1 keeps compile time reasonable without that ptxas bug.

template:524

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

# Add --regAllocOptLevel=2 to work around ptxas 13.x bug

template:529

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

ptxas, *debug_info, *fmad, '-v', *disable_opt, *reg_alloc, *ptx_extra_options, f'--gpu-name={arch}',

template:533

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

error = '`ptxas` raised SIGSEGV'

template:555

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

error = f'`ptxas` failed with error code {e.returncode}'

template:557

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

Inline PTX assembly

f"`ptxas` stderr:\n{log}\n"

template:560

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

third_party/proton/test/test_override.py· 2

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna2

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Inline PTX assembly

ptx_files = list(tmp_path.rglob("*.ptx"))

template:35

Inline PTX is NVIDIA ISA and cannot run on AMD. The block must be hand-rewritten in HIP/GCN or replaced with a portable path.

RecommendRewrite the PTX block in HIP or a portable high-level equivalent.

docs/conf.py· 3

Triton dependency

import triton

template:302

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:317

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:327

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

pyproject.toml· 4

Triton dependency

"python/triton/knobs.py",

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

"python/triton/runtime/build.py",

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

"python/triton/runtime/driver.py",

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

"python/triton/_utils.py",

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/examples/gluon/02-conv-common.py· 6

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import mbarrier

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:14

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 10

template:18

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/examples/gluon/02-conv-dgrad.py· 17

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor, TensorDescriptorIm2Col

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.get_device_capability(device),

template:703

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:978

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(device).multi_processor_count

template:1070

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(device).multi_processor_count

template:1140

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

grad_out_nchw = torch.randn((N, Co, out_h, out_w), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1180

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1183

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE),

template:1190

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_nchw = torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1246

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

grad_out_nchw = torch.randn((N, Co, out_h, out_w), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1247

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1249

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/examples/gluon/02-conv-fprop.py· 13

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor, TensorDescriptorIm2Col

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(input_tensor.device).multi_processor_count

template:593

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(input_tensor.device).multi_processor_count

template:664

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x_nchw = torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:712

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:714

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_nchw = torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:752

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:754

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/examples/gluon/02-conv-wgrad.py· 17

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor, TensorDescriptorIm2Col

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.get_device_capability(device),

template:607

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:733

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(input_nhwc.device).multi_processor_count

template:906

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_sms = torch.cuda.get_device_properties(input_nhwc.device).multi_processor_count

template:973

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x_nchw = torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1010

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

grad_out_nchw = torch.randn((N, Co, out_h, out_w), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1016

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1019

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_nchw = torch.randn((N, Ci, H, W), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1061

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

grad_out_nchw = torch.randn((N, Co, out_h, out_w), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1063

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_nchw = torch.randn((Co, Ci, R, S), device="cuda", dtype=TORCH_GEMM_DTYPE)

template:1116

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/examples/gluon/03-matmul-multicta.py· 18

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import mbarrier, tma

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not torch.cuda.is_available():

template:23

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:26

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:26

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

a = torch.rand((M, K), device=torch.device("cuda"), dtype=torch.float16)

template:703

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.rand((K, N), device=torch.device("cuda"), dtype=torch.float16)

template:704

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.profiler.viewer as proton_viewer

template:732

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

props = torch.cuda.get_device_properties(0)

template:743

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:750

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:751

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c_triton = torch.empty((M, N), device="cuda", dtype=torch.float16)

template:752

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c_torch = torch.empty((M, N), device="cuda", dtype=torch.float16)

template:753

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.profiler as proton

template:802

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/examples/gluon/04-2cta-block-scale-matmul.py· 16

Triton dependency

import triton

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon as gluon

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.blackwell import TensorDescriptor

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not torch.cuda.is_available():

template:77

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:80

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:80

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

base = MXFP4Tensor(size=(MN, K), device="cuda").random()

template:99

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scale = MXScaleTensor(size=(MN, K // VEC_SIZE), device="cuda").random(low=1 / 128, high=2.0)

template:100

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=out_dtype)

template:774

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

sm_count = torch.cuda.get_device_properties(device).multi_processor_count

template:793

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

cublas_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:921

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((M, N), dtype=torch.float16, device="cuda")

template:932

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/examples/gluon/05-moe-bmm1-fused-gather.py· 16

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon as gluon

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language.nvidia.blackwell as blackwell

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language.nvidia.blackwell.tma as tma

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import float2

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language.nvidia.hopper.mbarrier as mbarrier

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language.extra.libdevice as libdevice

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.testing import do_bench_cudagraph

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:844

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

sms = torch.cuda.get_device_properties(bias.device).multi_processor_count

template:1166

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return (triton.runtime.driver.active.get_current_target().backend == "cuda"

template:1518

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

and torch.cuda.get_device_capability()[0] == 10)

template:1519

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

prepared = prepare_case(c, batch_size, device=f"cuda:{torch.cuda.current_device()}")

template:1526

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device=f"cuda:{torch.cuda.current_device()}",

template:1579

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = f"cuda:{torch.cuda.current_device()}"

template:1641

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/backend/test_device_backend.py· 6

Triton dependency

import triton

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.common.backend import (BaseBackend, compute_core_version_key, register_backend)

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.make_launcher import make_so_cache_key

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.cache import get_cache_manager

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.driver import DriverBase

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/backend/test_mir_stage.py· 5

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.randn(size, device='cuda')

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randn(size, device='cuda')

template:73

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(size, device='cuda')

template:127

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/conftest.py· 7

Device string "cuda"

parser.addoption("--device", action="store", default="cuda")

template:12

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton import knobs

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:36

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:50

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:60

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime._allocation import NullAllocator

template:61

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import default_alloc_fn

template:62

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/gluon/test_consan.py· 72

Triton dependency

from triton import knobs

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import blackwell

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import hopper

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import ampere

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import allocate_tensor_memory, clc, mbarrier, tma

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, run_in_process

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:124

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:136

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:148

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:159

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:190

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:237

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:278

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell")

template:328

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell")

template:370

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell")

template:411

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell")

template:443

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:480

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:524

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:569

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:608

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:678

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:730

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:773

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:831

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:891

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires ampere or newer")

template:952

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires ampere or newer")

template:996

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1039

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1141

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] != 9, reason="Requires hopper")

template:1198

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] != 9, reason="Requires hopper")

template:1245

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1294

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1363

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1487

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1565

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:1639

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] != 9, reason="Requires hopper")

template:1692

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:1778

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:1832

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:1893

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:1947

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2011

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2072

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2162

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2228

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2322

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:2395

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:2462

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] != 9, reason="Requires hopper")

template:2518

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2583

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2615

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2649

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2704

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2761

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2785

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2819

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2852

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:2895

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:2928

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:2957

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper or newer")

template:2984

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:3011

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:3075

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:3130

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires hopper")

template:3192

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:3291

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn((BLOCK_M, BLOCK_K), device="cuda", dtype=torch.float16)

template:3306

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 10, reason="Requires blackwell or newer")

template:3348

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn((BLOCK_M, K), device="cuda", dtype=torch.float16)

template:3364

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gluon/test_core.py· 143

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import (

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import max_shared_mem

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.ampere import async_copy, mma_v2

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier, fence_async_shared

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import hopper

template:29

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import tma as blackwell_tma

template:30

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.cdna4 import async_copy as cdna4_async_copy

template:31

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.extra import libdevice

template:32

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:33

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:45

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import make_cga_layout

template:46

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

inp = torch.randn(XBLOCK * 4 - 7, device="cuda")

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.randn(XBLOCK * 4 - 7, device="cuda")

template:85

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(block_m * block_n, device="cuda", dtype=torch.float32).reshape(block_m, block_n)

template:136

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((block_n, block_m), device="cuda", dtype=torch.float32)

template:137

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((block, ), device="cuda", dtype=torch.int32)

template:185

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

torch.testing.assert_close(out, torch.arange(block, device="cuda", dtype=torch.int32))

template:190

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((block, ), device="cuda", dtype=torch.float16)

template:196

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

torch.testing.assert_close(out, torch.arange(block, device="cuda", dtype=torch.float16))

template:201

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.ones((16, 16), dtype=torch.float16, device="cuda")

template:216

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(pixels_per_column * channels_per_pixel, device="cuda", dtype=torch.float32)

template:252

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(pixels_per_column, channels_per_pixel, device="cuda", dtype=torch.float32)

template:254

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.randn((16, 16), device="cuda", dtype=torch.float32)

template:309

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.randn((BLOCK_M, BLOCK_N), dtype=torch.float16, device="cuda")

template:356

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(BLOCK_M * BLOCK_N, dtype=torch.float16, device="cuda").reshape(BLOCK_M, BLOCK_N)

template:419

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

gather_idx = torch.arange(BLOCK_M - 1, -1, -1, dtype=torch.int32, device="cuda")

template:420

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scatter_idx = (torch.arange(0, BLOCK_M, dtype=torch.int32, device="cuda") + 1) % BLOCK_M

template:421

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((BLOCK_M, BLOCK_K), dtype=torch.float16, device="cuda")

template:554

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((BLOCK_K, BLOCK_N), dtype=torch.float16, device="cuda")

template:555

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((BLOCK_M, BLOCK_N), dtype=torch.float32, device="cuda")

template:556

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.empty((block_m, block_k), dtype=torch.float16, device="cuda")

template:603

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.empty((block_k, block_n), dtype=torch.float16, device="cuda")

template:604

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randint(20, 40, (BLOCK_M, NUM_K_TILES * BLOCK_K), device="cuda",

template:692

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randint(20, 40, (NUM_K_TILES * BLOCK_K, BLOCK_N), device="cuda",

template:694

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((BLOCK_M, BLOCK_N), device="cuda", dtype=torch.float32)

template:696

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

tensor_opts = dict(dtype=torch.float, device="cuda")

template:731

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.zeros((XBLOCK, XBLOCK), device="cuda", dtype=torch.float16)

template:768

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:779

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.ones((XBLOCK, XBLOCK), dtype=torch.float16, device="cuda")

template:807

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:817

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:880

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:881

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros((M, N), device="cuda", dtype=torch.float16)

template:882

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((128, 16), dtype=torch.float16, device='cuda')

template:1428

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device='cuda', dtype=elem_type)

template:1486

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device='cuda', dtype=elem_type)

template:1487

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device='cuda', dtype=elem_type) - 0.5

template:1547

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device='cuda', dtype=elem_type) - 0.5

template:1548

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

def test_amd_mfma_scaled(M, N, K, a_type, b_type, has_scale, device='cuda'):

template:1578

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(THREADS_PER_WARP * num_warps, device="cuda", dtype=torch.float32)

template:1691

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(THREADS_PER_WARP * num_warps, device="cuda", dtype=torch.float32)

template:1712

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:1722

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

s = torch.randn((64, 128), dtype=torch.float32, device="cuda")

template:1817

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((64, 128), dtype=torch.float16, device="cuda")

template:1927

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((128, 128), dtype=torch.float16, device="cuda")

template:1928

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.randn((64, 128), dtype=torch.float32, device="cuda")

template:1929

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randint(0, 100, (XBLOCK, YBLOCK), dtype=torch.int32, device="cuda")

template:1972

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.rand((XBLOCK, YBLOCK), dtype=torch.float32, device="cuda")

template:2001

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.arange(M * N, device="cuda").reshape(M, N).to(torch.int32)

template:2049

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty(1, dtype=torch.int32, device="cuda")

template:2079

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.arange(64, device="cuda").to(torch.int32)

template:2100

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.arange(m * n, device="cuda").reshape(m, n).to(torch.int32)

template:2153

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.zeros((slice_m, slice_n), dtype=torch.int32, device="cuda")

template:2154

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.rand(shape, dtype=torch.float32, device="cuda")

template:2201

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.rand(shape, dtype=torch.float32, device="cuda")

template:2202

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.rand(shape, dtype=torch.float32, device="cuda")

template:2203

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty(shape, dtype=torch.float32, device="cuda")

template:2204

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((BLOCK), dtype=elem_type, device="cuda")

template:2231

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

torch_ref = origin_a + torch.ones((BLOCK, ), device='cuda', dtype=torch.bfloat16)

template:2235

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((B, B), dtype=dtype, device="cuda")

template:2272

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((B, B), dtype=dtype, device="cuda")

template:2273

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.randn((B, B), dtype=dtype, device="cuda")

template:2274

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((B, B), dtype=dtype, device="cuda")

template:2275

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.rand((B, B), dtype=torch.float32, device="cuda")

template:2300

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.rand((B, B), dtype=torch.float32, device="cuda")

template:2301

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.rand((B, B), dtype=torch.float32, device="cuda")

template:2302

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((B, B), dtype=torch.float32, device="cuda")

template:2303

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.rand((BATCH, B, B), dtype=torch.float32, device="cuda")

template:2331

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.rand((BATCH, B, B), dtype=torch.float32, device="cuda")

template:2332

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.rand((BATCH, B, B), dtype=torch.float32, device="cuda")

template:2333

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((BATCH, B, B), dtype=torch.float32, device="cuda")

template:2334

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randint(-100, 100, (2 * XBLOCK, ), device="cuda", dtype=torch.int32)

template:2379

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty(XBLOCK, device="cuda", dtype=torch.int32)

template:2380

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), dtype=torch.float32, device="cuda")

template:2459

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randint(20, 40, (M, K), dtype=torch.uint8, device="cuda").view(torch.float8_e5m2)

template:2460

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randint(20, 40, (K, N), dtype=torch.uint8, device="cuda").view(torch.float8_e5m2)

template:2461

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.randint(64, 130, (M, K // 32), dtype=torch.uint8, device="cuda")

template:2462

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.randint(64, 130, (N, K // 32), dtype=torch.uint8, device="cuda")

template:2463

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), dtype=torch.float32, device="cuda")

template:2579

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.ones((M, K // scale_vec_size), dtype=torch.float32, device="cuda").to(torch.float8_e4m3fn)

template:2581

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.ones((N, K // scale_vec_size), dtype=torch.float32, device="cuda").to(torch.float8_e4m3fn)

template:2582

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.full((M, K // scale_vec_size), 127, dtype=torch.uint8, device="cuda")

template:2592

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_mx = MXFP4Tensor(size=(M, K), device="cuda").random()

template:2594

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.randint(64, 130, (M, K // scale_vec_size), dtype=torch.uint8, device="cuda")

template:2598

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randint(20, 40, (M, K), dtype=torch.uint8, device="cuda").view(a_torch_dtype)

template:2600

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.full((N, K // scale_vec_size), 127, dtype=torch.uint8, device="cuda")

template:2605

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_mx = MXFP4Tensor(size=(N, K), device="cuda").random()

template:2607

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.randint(64, 130, (N, K // scale_vec_size), dtype=torch.uint8, device="cuda")

template:2613

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randint(20, 40, (K, N), dtype=torch.uint8, device="cuda").view(b_torch_dtype)

template:2615

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((xnumel, ynumel), device="cuda")

template:2659

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ref = torch.maximum(torch.sin(input), torch.tensor(0.0, device="cuda"))

template:2661

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.ones((xnumel, ynumel), device="cuda")

template:2703

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input_buffer = (torch.randn((M, N), device="cuda") * 100).to(dtype)

template:2759

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output_buffer = torch.zeros((M, N), device="cuda", dtype=dtype)

template:2760

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:2782

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = torch.device("cuda")

template:2824

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(64, dtype=torch.int32, device="cuda").reshape(2, 32)

template:2888

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty(cta_tile * num_ctas, dtype=torch.int32, device="cuda")

template:2976

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

offsets = torch.arange(out.numel(), dtype=torch.int32, device="cuda")

template:2991

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(4 * 32, dtype=torch.int32, device="cuda").reshape(4, 32)

template:3050

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

values = torch.arange(2 * 32, dtype=torch.int32, device="cuda").reshape(2, 32) + 1000

template:3051

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

result = torch.empty((2, 32), dtype=torch.int32, device="cuda")

template:3054

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(4 * 32, dtype=torch.int32, device="cuda").reshape(4, 32)

template:3136

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((2, 32), dtype=torch.int32, device="cuda")

template:3137

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3202

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3439

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3529

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3563

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3656

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3733

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3817

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:3907

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4016

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4117

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4207

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4281

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4374

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = torch.device("cuda")

template:4475

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input_tensor = torch.randn(M, N, dtype=torch.float32, device="cuda")

template:4605

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

red_output = torch.empty(M, dtype=torch.float32, device="cuda")

template:4615

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

dev_props = torch.cuda.get_device_properties("cuda")

template:4676

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

dev_props = torch.cuda.get_device_properties("cuda")

template:4676

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

was_launched = torch.zeros([grid], dtype=torch.bool, device="cuda")

template:4681

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

is_cancelled = torch.zeros([grid], dtype=torch.bool, device="cuda")

template:4682

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

program_ids = torch.zeros([grid], dtype=torch.int32, device="cuda")

template:4683

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=dtype)

template:4715

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

base = MXFP4Tensor(size=(MN, K), device="cuda").random()

template:4724

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scale = MXScaleTensor(size=(MN, K // VEC_SIZE), device="cuda").random(low=1 / 128, high=2.0)

template:4725

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gluon/test_fpsan.py· 135

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_blackwell, is_cuda, is_hip, is_hip_cdna3, is_hip_cdna4, is_hip_gfx1250, is_hopper, is_interpreter

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_blackwell_ultra

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.ampere import mma_v2

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import hopper

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if device != "cuda":

template:35

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not torch.cuda.is_available():

template:43

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

storage = torch.tensor(bits, device="cuda", dtype=torch_storage_dtype)

template:213

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

"cuda": [

template:462

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

"cuda": [

template:478

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

"cuda": [

template:491

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

"cuda": [

template:500

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return "cuda"

template:512

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn((N, N), dtype=torch.float32, device="cuda")

template:636

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:661

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:663

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:664

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:687

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:689

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:690

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:726

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:728

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:729

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:730

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:753

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:755

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:756

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:757

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x[:len(nan_bits)] = torch.from_numpy(nan_bits.copy()).to(device="cuda")

template:761

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

lo = torch.from_numpy(lo_np).to(device="cuda")

template:772

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

hi = torch.from_numpy(hi_np).to(device="cuda")

template:773

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:774

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:808

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:810

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:811

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:814

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.tensor(x_bits, dtype=torch.int32, device="cuda")

template:966

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:967

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int64, device="cuda")

template:1004

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1026

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1028

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1029

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_add = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1030

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_mul = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1031

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_add = torch.empty((n_elements, ), dtype=torch.int64, device="cuda")

template:1059

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1093

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1095

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_exp = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1096

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_exp2 = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1097

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1120

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1122

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_neg = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1123

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_recip = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1124

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1148

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1150

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1151

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

lhs = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1152

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

rhs = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1153

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.tensor(x_bits, dtype=torch.int32, device="cuda")

template:1206

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1207

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1290

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1292

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1293

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1294

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1322

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1324

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1325

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

z = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1326

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1327

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1361

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1363

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1364

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1365

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1423

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1425

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1426

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

z = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1427

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1428

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1468

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**31), 2**31 - 1, (n_elements, ), dtype=torch.int32, device="cuda", generator=g)

template:1470

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x[:3] = torch.tensor(special_f32_bits, dtype=torch.int32, device="cuda")

template:1472

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1473

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

g = torch.Generator(device="cuda")

template:1507

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(-(2**15), 2**15 - 1, (n_elements, ), dtype=torch.int16, device="cuda", generator=g)

template:1509

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x[:3] = torch.tensor(special_f16_bits, dtype=torch.int16, device="cuda")

template:1512

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((n_elements, ), dtype=torch.int32, device="cuda")

template:1513

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] < 9 and "e4m3" in (type_a, type_b):

template:1843

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capability = torch.cuda.get_device_capability()[0]

template:1902

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] < 9 and "e4m3" in (type_a, type_b):

template:1951

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.int32)

template:2041

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.int32)

template:2042

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.tensor(c_bits, device="cuda", dtype=torch.int32)

template:2043

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((BATCH_SIZE, B, B), device="cuda", dtype=torch.int32)

template:2044

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int32)

template:2130

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.uint8)

template:2171

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.uint8)

template:2172

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.tensor(a_scale_bits, device="cuda", dtype=torch.uint8)

template:2173

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.tensor(b_scale_bits, device="cuda", dtype=torch.uint8)

template:2174

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda",

template:2178

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda",

template:2182

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((B, B), device="cuda", dtype=torch.int32)

template:2189

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.int32)

template:2399

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.int32)

template:2400

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.tensor(c_bits, device="cuda", dtype=torch.int32)

template:2401

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), device="cuda", dtype=torch.int32)

template:2402

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.uint8)

template:2514

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.uint8).view(_float_dtype_info(type_a)[4])

template:2516

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.uint8)

template:2518

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.uint8).view(_float_dtype_info(type_b)[4])

template:2520

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.tensor(a_scale_bits, device="cuda", dtype=torch.uint8).view(torch.float8_e4m3fn)

template:2522

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.tensor(b_scale_bits, device="cuda", dtype=torch.uint8).view(torch.float8_e4m3fn)

template:2523

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.tensor(a_scale_bits, device="cuda", dtype=torch.int8)

template:2526

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.tensor(b_scale_bits, device="cuda", dtype=torch.int8)

template:2527

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.tensor(c_bits, device="cuda", dtype=torch.int32)

template:2529

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((m, n), device="cuda", dtype=torch.int32)

template:2530

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.tensor(a_bits, device="cuda", dtype=torch.uint8).view(torch.float8_e5m2)

template:2642

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.tensor(b_bits, device="cuda", dtype=torch.uint8).view(torch.float8_e5m2)

template:2643

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a_scale = torch.tensor(a_scale_bits, device="cuda", dtype=torch.int8)

template:2644

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b_scale = torch.tensor(b_scale_bits, device="cuda", dtype=torch.int8)

template:2645

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.tensor(c_bits, device="cuda", dtype=torch.int32)

template:2646

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), device="cuda", dtype=torch.int32)

template:2647

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.tensor(x_bits, device="cuda", dtype=torch.int32)

template:2698

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((B, 32), device="cuda", dtype=torch.int32)

template:2699

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((K, M, N), dtype=torch.float32, device="cuda")

template:2947

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c1 = torch.empty((K, ), dtype=torch.float32).to('cuda')

template:2948

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c2 = torch.empty((K, ), dtype=torch.float32).to('cuda')

template:2949

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

pattern = torch.tensor([1e20, 1.0, -1e20, 1.0], dtype=torch.float32, device="cuda")

template:2978

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

reduce_out = torch.empty((1, ), dtype=torch.float32, device="cuda")

template:2980

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

loop_out = torch.empty((1, ), dtype=torch.float32, device="cuda")

template:2981

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.tensor(input_bits, dtype=torch.int32, device="cuda")

template:3016

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((block, ), dtype=torch.int32, device="cuda")

template:3017

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gluon/test_frontend.py· 22

Triton dependency

from triton.backends.compiler import GPUTarget

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import blackwell

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia import hopper

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import cluster

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import mbarrier, tma, TensorMemoryLayout, TensorMemoryScalesLayout, async_copy

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd import _layouts as amd_layouts

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.cdna4 import async_copy as cdna4_async_copy

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import async_copy as gfx1250_async_copy

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import mbarrier as gfx1250_mbarrier

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import cluster as gfx1250_cluster

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import (

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.extra import libdevice

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._filecheck import filecheck_test, run_parser

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import MockTensor

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.errors import CompilationError, CompileTimeAssertionFailure

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

BLACKWELL_TARGET = GPUTarget("cuda", 100, 32)

template:34

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

HOPPER_TARGET = GPUTarget("cuda", 90, 32)

template:35

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

AMPERE_TARGET = GPUTarget("cuda", 80, 32)

template:36

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gluon/test_layout_format_view.py· 4

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.randn(512, device="cuda")

template:214

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gluon/test_layout.py· 1

Triton dependency

from triton.experimental.gluon import language as ttgl

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/gluon/test_lowerings.py· 9

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_blackwell, is_cuda, is_hip, is_hopper_or_newer, get_hip_lds_size

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import make_cga_layout

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import PartitionedSharedLayout

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import TensorMemoryLayout, allocate_tensor_memory

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.randint(-128, 128, (rows, cols), dtype=torch.int16, device="cuda")

template:1450

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input_tensor = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:2260

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/gsan/test_allocator.py· 21

Triton dependency

from triton._internal_testing import is_cuda, run_in_process

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan import ShareableHandleType, configure, create_mem_pool, freeze_config

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._allocator import (

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._testing_utils import global_state, shadow_tensor_for

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._utils import uint8_cuda_tensor_from_ptr

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

device = torch.cuda.current_device()

template:38

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:62

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:77

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:134

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.device_count() < 2, reason="requires at least two CUDA devices")

template:172

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.device_count() < 2, reason="requires at least two CUDA devices")

template:179

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.device_count() < 2, reason="requires at least two CUDA devices")

template:204

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:252

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:263

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:283

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.use_mem_pool(pool):

template:289

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

real = torch.empty(4096, dtype=torch.uint8, device="cuda")

template:290

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:315

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:321

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:344

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:369

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/gsan/test_gsan_failures.py· 51

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_blackwell, is_cuda, run_in_process

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan import create_mem_pool

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._testing_utils import atomic_poll

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:222

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

with torch.cuda.use_mem_pool(pool):

template:231

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:239

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:240

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:241

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:247

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:248

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:249

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:255

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:256

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:257

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:263

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ready = torch.zeros(1, dtype=torch.int32, device="cuda")

template:264

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:277

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((m_size, padded_n), dtype=torch.int32, device="cuda")

template:278

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:280

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((m_size, padded_n), dtype=torch.int32, device="cuda")

template:294

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:300

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((padded_m, padded_n), dtype=torch.int32, device="cuda")

template:316

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = torch.tensor(x_offsets_values, dtype=torch.int32, device="cuda")

template:318

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros((block_x, block_y), dtype=torch.int32, device="cuda")

template:320

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:321

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((padded_m, padded_n), dtype=torch.int32, device="cuda")

template:338

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = torch.tensor(x_offsets_values, dtype=torch.int32, device="cuda")

template:340

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

src = torch.arange(1, block_x * block_y + 1, dtype=torch.int32, device="cuda").reshape(block_x, block_y)

template:342

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:343

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:344

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag = torch.zeros((1, 16), dtype=torch.int32, device="cuda")

template:351

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:353

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:354

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:355

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:361

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flags = torch.zeros(1, dtype=torch.int32, device="cuda")

template:362

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:363

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:364

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:379

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag = torch.zeros(1, dtype=torch.int32, device="cuda")

template:380

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:381

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:395

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag0 = torch.zeros(1, dtype=torch.int32, device="cuda")

template:396

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag1 = torch.zeros(1, dtype=torch.int32, device="cuda")

template:397

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:398

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:399

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if torch.cuda.device_count() < 1:

template:423

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires Hopper or newer")

template:492

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/gsan/test_gsan.py· 66

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.ampere import async_copy

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_blackwell, is_cuda, is_ampere_or_newer, is_hopper_or_newer

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan import create_mem_pool

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gsan_testing import AtomicScope, SHADOW_GRANULARITY_BYTES, ScalarClock

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._testing_utils import (atomic_poll, load_one_i32, shadow_cell_from_address, store_one_i32,

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

with torch.cuda.use_mem_pool(pool):

template:23

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:108

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(1, dtype=torch.int32, device="cuda")

template:109

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected = torch.arange(256, dtype=torch.int32, device="cuda")

template:157

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.full((256, ), -1, dtype=torch.int32, device="cuda")

template:159

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:161

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

out = torch.full((256, ), -1, dtype=torch.int32, device="cuda")

template:190

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:194

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:265

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:277

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(1, dtype=torch.int32, device="cuda")

template:278

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = torch.ones(1, dtype=dtype, device="cuda")

template:293

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:302

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.ones(1, dtype=torch.bool, device="cuda")

template:303

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:316

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag = torch.zeros(1, dtype=torch.int32, device="cuda")

template:317

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:318

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:321

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros(1, dtype=torch.int32, device="cuda")

template:332

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(1, dtype=torch.int32, device="cuda")

template:333

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:349

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flags = torch.zeros(1, dtype=torch.int32, device="cuda")

template:350

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:351

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:361

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:375

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag0 = torch.zeros(1, dtype=torch.int32, device="cuda")

template:376

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

flag1 = torch.zeros(1, dtype=torch.int32, device="cuda")

template:377

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.full((1, ), -1, dtype=torch.int32, device="cuda")

template:378

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:389

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

payload = torch.zeros(num_writers, dtype=torch.int32, device="cuda")

template:430

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:432

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.full((num_writers, ), -1, dtype=torch.int32, device="cuda")

template:433

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:442

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

expected = torch.arange(1000, 1000 + num_writers, dtype=torch.int32, device="cuda")

template:444

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

payload = torch.zeros(1, dtype=torch.int32, device="cuda")

template:479

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

counter = torch.zeros(1, dtype=torch.int32, device="cuda")

template:480

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ready = torch.zeros(1, dtype=torch.int32, device="cuda")

template:481

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:483

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros(size, dtype=torch.int32, device="cuda")

template:523

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scratch = torch.zeros(size, dtype=torch.int32, device="cuda")

template:524

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:529

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

inp = torch.arange(padded, dtype=torch.float32, device="cuda")

template:672

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((padded_m, padded_n), dtype=torch.int32, device="cuda")

template:701

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:707

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x_offsets = torch.tensor([1, 3, 5, 7, 9, 10, 11, 13], dtype=torch.int32, device="cuda")

template:729

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.arange(padded_m * padded_n, dtype=torch.int32, device="cuda").reshape(padded_m, padded_n)

template:730

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((block_x, block_y), dtype=torch.int32, device="cuda")

template:733

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:740

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x_offsets = torch.tensor([1, 3, 5, 7, 9, 10, 11, 13], dtype=torch.int32, device="cuda")

template:757

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target_storage = torch.zeros((padded_m, padded_n), dtype=torch.int32, device="cuda")

template:758

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

src = torch.arange(1, block_x * block_y + 1, dtype=torch.int32, device="cuda").reshape(block_x, block_y)

template:761

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:768

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability()[0] < 9, reason="Requires Hopper or newer")

template:777

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

target = torch.zeros((block_x, block_y), dtype=torch.int32, device="cuda")

template:781

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

src = torch.arange(1, block_y + 1, dtype=torch.int32, device="cuda").reshape(block_x, block_y)

template:782

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:787

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/gsan/test_symmetric_memory.py· 30

Triton dependency

import triton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, run_in_process

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan import symmetric_memory

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._allocator import get_runtime_state_layout

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._testing_utils import atomic_poll, shadow_cell_from_address, shadow_tensor_for, SHADOW_GRANULARITY_BYTES

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._utils import uint8_cuda_tensor_from_ptr

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.set_device(dev)

template:70

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:119

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:139

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:150

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:192

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:207

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:236

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:261

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:268

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:293

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:305

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:314

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:333

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:385

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:406

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 3:

template:421

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:436

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:451

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:466

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:480

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:556

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(dev)

template:567

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:578

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/gsan/test_utils.py· 4

Triton dependency

from triton._internal_testing import is_cuda

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._utils import uint8_cuda_tensor_from_ptr

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device = torch.device("cuda:1" if torch.cuda.device_count() > 1 else "cuda:0")

template:10

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

device = torch.device("cuda:1" if torch.cuda.device_count() > 1 else "cuda:0")

template:10

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/microbenchmark/launch_overhead.py· 10

Triton dependency

import triton

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.synchronize()

template:45

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:49

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:58

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:62

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:74

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

targs = [TensorDescriptor.from_tensor(torch.zeros(1, 16, device="cuda"), block_shape=[1, 16]) for _ in range(5)]

template:84

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

targs = [torch.zeros(1, device="cuda") for _ in range(5)]

template:86

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/regression/test_cast_matmul.py· 4

Triton dependency

import triton

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_cdna3, is_cuda, is_hip

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

cc = torch.cuda.get_device_capability(0)

template:19

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/regression/test_functional_regressions.py· 2

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/cuda/test_libdevice_cuda.py· 15

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra import libdevice

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not torch.cuda.is_available():

template:44

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.randn((100,), dtype=getattr(torch, dtype_str), device="cuda")

template:50

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.randint(-(2**31), 2**31 - 1, (n_elements,), dtype=torch.int32, device="cuda", generator=generator)

template:161

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not is_cuda() or not torch.cuda.is_available():

template:168

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

generator = torch.Generator(device="cuda")

template:174

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not is_cuda() or not torch.cuda.is_available():

template:193

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

generator = torch.Generator(device="cuda")

template:199

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not is_cuda() or not torch.cuda.is_available():

template:217

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

generator = torch.Generator(device="cuda")

template:223

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not is_cuda() or not torch.cuda.is_available():

template:242

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

generator = torch.Generator(device="cuda")

template:248

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/cuda/test_mixed_io.py· 7

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

output = torch.empty(SIZE, device='cuda', dtype=dtype)

template:40

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(SIZE, device='cuda', dtype=dtype)

template:41

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randn(SIZE, device='cuda', dtype=dtype)

template:42

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn((BLOCK_M, BLOCK_N), device='cuda', dtype=dtype)

template:74

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.empty((BLOCK_M, ), device='cuda', dtype=dtype)

template:75

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/cuda/test_tensor_descriptor_cuda.py· 4

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import requires_tma

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device = "cuda"

template:15

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/cuda/test_tma_descriptor.py· 13

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.ragged_tma import create_ragged_descriptor, atomic_add_ragged, load_ragged, store_ragged

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not torch.cuda.is_available() or not torch.cuda.get_device_capability()[0] >= 9:

template:12

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:16

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not torch.cuda.is_available() or not torch.cuda.get_device_capability()[0] >= 9:

template:30

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:34

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not torch.cuda.is_available() or not torch.cuda.get_device_capability()[0] >= 9:

template:77

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

src1 = torch.randn((1024, 80), dtype=torch.float32, device="cuda").to(dtype)

template:84

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

src2 = torch.randn((1024, 80), dtype=torch.float32, device="cuda").to(dtype)

template:85

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ref = torch.randn((1024, 80), dtype=torch.float32, device="cuda").to(dtype)

template:86

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:134

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/cuda/test_tma_store_gemm.py· 6

Triton dependency

import triton

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

a = torch.randn((K, M), device='cuda', dtype=torch.float16).T

template:68

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device='cuda', dtype=torch.float16)

template:70

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((N, K), device='cuda', dtype=torch.float16).T

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device='cuda', dtype=torch.float16)

template:74

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/instrumentation/test_gpuhello.py· 2

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/print_helper.py· 2

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_annotations.py· 2

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_block_pointer.py· 2

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_compile_errors.py· 5

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.errors import CompilationError, CompileTimeAssertionFailure

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna4

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

cc = torch.cuda.get_device_capability(0)

template:357

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_compile_only.py· 12

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import ASTSource

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

target=GPUTarget("cuda", 100, 32))

template:17

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

k = triton.compile(str(temp_file), target=GPUTarget("cuda", 90, 32))

template:44

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

target = GPUTarget("cuda", 100, 32)

template:67

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

constexprs={}), target=GPUTarget("cuda", 100, 32))

template:97

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

"i32"}, constexprs={}), target=GPUTarget("cuda", 100, 32))

template:157

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

}, constexprs={"BLOCK_M": 128, "BLOCK_N": 128, "BLOCK_K": 64}), target=GPUTarget("cuda", 100, 32))

template:209

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

triton.compile(src, target=GPUTarget("cuda", 90, 32))

template:279

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

triton.compile(src, target=GPUTarget("cuda", 80, 32))

template:280

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/language/test_conversions.py· 8

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna2, is_hip_cdna3, is_hip_cdna4, is_hip_rdna3, is_hip_rdna4, is_hip_gfx1250

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if ((src_dtype == 'float8e4nv' and torch.cuda.get_device_capability(0) < (8, 9))

template:282

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if src_dtype != 'float32' and torch.cuda.get_device_capability(0) < (9, 0):

template:341

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if dst_dtype in ('float8e5', 'float8e4nv') and rounding == 'rtne' and torch.cuda.get_device_capability(0) < (9, 0):

template:344

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if src_dtype != 'float32' and torch.cuda.get_device_capability(0) < (9, 0):

template:377

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if dst_dtype in ('float8e5', 'float8e4nv') and rounding == 'rtne' and torch.cuda.get_device_capability(0) < (9, 0):

template:380

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_decorator.py· 2

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_frontend.py· 4

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._filecheck import filecheck_test, run_filecheck_test, run_parser

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.errors import CompilationError

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_libdevice.py· 4

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra import libdevice

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra.libdevice import fast_dividef as my_fast_dividef

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_matmul.py· 24

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna3, is_hip_cdna4, is_hip_cdna, is_hip_gfx1250

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if NUM_CTAS > 1 and (not is_cuda() or torch.cuda.get_device_capability()[0] < 9):

template:126

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if dtype_src_str == "float8e5" and device == "cuda" and torch.cuda.get_device_capability()[0] < 9:

template:136

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if dtype_src_str == "float8e5" and device == "cuda" and torch.cuda.get_device_capability()[0] < 9:

template:136

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if (device == "cuda" and torch.cuda.get_device_capability()[0] == 10 and NUM_STAGES > 1 and BLOCK_M % 64 == 0

template:186

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if (device == "cuda" and torch.cuda.get_device_capability()[0] == 10 and NUM_STAGES > 1 and BLOCK_M % 64 == 0

template:186

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] < 8:

template:201

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if (device == "cuda" and torch.cuda.get_device_capability()[0] == 10 and BLOCK_M % 64 == 0 and BLOCK_N % 8 == 0

template:327

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if (device == "cuda" and torch.cuda.get_device_capability()[0] == 10 and BLOCK_M % 64 == 0 and BLOCK_N % 8 == 0

template:327

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] < 10:

template:396

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] == 12:

template:443

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(is_cuda() and torch.cuda.get_device_capability()[0] in [10, 11],

template:661

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

v = MXFP4Tensor(size=(dim0, dim1), device="cuda").random()

template:726

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

@pytest.mark.skipif(is_hip() or torch.cuda.get_device_capability()[0] != 10, reason="Requires compute capability == 10")

template:790

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(is_hip() or torch.cuda.get_device_capability()[0] != 10, reason="Requires compute capability == 10")

template:864

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(is_hip() or torch.cuda.get_device_capability()[0] != 10, reason="Requires compute capability == 10")

template:929

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if scale_type == "float8_e4m3fn" and torch.cuda.get_device_capability()[0] < 9:

template:1043

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if BLOCK_N == 256 and BLOCK_K == 256 and torch.cuda.get_device_capability()[0] < 9:

template:1045

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] in (10, 12) and not nvfp4_fallback:

template:1107

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] != 10:

template:1201

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] < 10:

template:1366

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] == 12:

template:1436

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_module.py· 1

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_mxfp.py· 1

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_pipeliner.py· 13

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hopper_or_newer, is_hip_cdna, is_hip_cdna2, is_hip

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:13

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:256

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if torch.cuda.get_device_capability()[0] == 9:

template:288

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

elif torch.cuda.get_device_capability()[0] == 10:

template:292

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] == 10:

template:302

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

cc = torch.cuda.get_device_capability()

template:314

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(torch.cuda.get_device_capability()[0] != 10,

template:518

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:523

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:531

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:531

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_random.py· 2

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_reproducer.py· 1

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_standard.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_subprocess.py· 2

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_interpreter

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_tensor_descriptor.py· 22

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hopper, is_sm12x, is_interpreter, numpy_random, to_triton, unwrap_tensor, tma_dtypes, to_numpy

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna3

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import CompilationError

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:20

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:64

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:261

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:326

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:623

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability(0)[0] >= 9:

template:665

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability(0)[0] in (9, 10):

template:746

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:854

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:957

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and (capability := torch.cuda.get_device_capability(0)[0]) in (9, 10):

template:959

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if BLOCK_K < K and is_cuda() and torch.cuda.get_device_capability(0)[0] != 10:

template:1322

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

is_native_gather = is_cuda() and torch.cuda.get_device_capability()[0] >= 10

template:1447

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

is_native = is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:1556

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:1643

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:1752

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/language/test_tuple.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/language/test_warp_specialization.py· 43

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip, is_hopper, is_blackwell

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not is_hip() and torch.cuda.is_available() and torch.cuda.get_device_capability()[0] in [9, 10, 11]:

template:10

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import nvidia

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

cublas_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:12

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.empty(2, dtype=torch.int32, device='cuda')

template:51

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.arange(128 * 64, dtype=torch.float32, device='cuda').reshape(128, 64)

template:119

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.arange(1024, dtype=torch.int32, device='cuda')

template:180

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty(4, dtype=torch.int32, device='cuda')

template:181

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:285

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:292

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:403

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:403

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:405

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:412

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

q = torch.randn((M, HEAD_DIM), device="cuda").to(dtype)

template:520

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

k = torch.randn((N, HEAD_DIM), device="cuda").to(dtype)

template:521

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

v = torch.randn((N, HEAD_DIM), device="cuda").to(dtype)

template:522

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

acc_ref = torch.empty((M, HEAD_DIM), dtype=dtype, device="cuda")

template:524

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

l_i_ref = torch.empty((M, ), dtype=dtype, device="cuda")

template:525

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

m_i_ref = torch.empty((M, ), dtype=dtype, device="cuda")

template:526

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

acc = torch.empty((M, HEAD_DIM), dtype=dtype, device="cuda")

template:527

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

l_i = torch.empty((M, ), dtype=dtype, device="cuda")

template:528

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

m_i = torch.empty((M, ), dtype=dtype, device="cuda")

template:529

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

q = torch.randn((M, HEAD_DIM), device="cuda").to(dtype)

template:620

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

k = torch.randn((N, HEAD_DIM), device="cuda").to(dtype)

template:621

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

v = torch.randn((N, HEAD_DIM), device="cuda").to(dtype)

template:622

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

acc_ref = torch.empty((M, HEAD_DIM), dtype=dtype, device="cuda")

template:624

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

l_i_ref = torch.empty((M, ), dtype=dtype, device="cuda")

template:625

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

m_i_ref = torch.empty((M, ), dtype=dtype, device="cuda")

template:626

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

acc = torch.empty((M, HEAD_DIM), dtype=dtype, device="cuda")

template:627

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

l_i = torch.empty((M, ), dtype=dtype, device="cuda")

template:628

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

m_i = torch.empty((M, ), dtype=dtype, device="cuda")

template:629

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty((M, N), device="cuda", dtype=A.dtype)

template:733

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

d_a_ptrs = torch.tensor(A_addrs, device="cuda")

template:740

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

d_b_ptrs = torch.tensor(B_addrs, device="cuda")

template:741

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

d_c_ptrs = torch.tensor(C_addrs, device="cuda")

template:742

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

d_g_lds = torch.tensor(g_lds, dtype=torch.int32, device="cuda")

template:743

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:746

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.rand((M, K), device="cuda", dtype=torch.float16)

template:769

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.rand((K, N), device="cuda", dtype=torch.float16)

template:770

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/plugins/custom_ops.py· 5

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import builtin

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.code_generator import flatten_values_to_ir

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/plugins/custom_stages.py· 1

Triton dependency

from triton._C.libtriton import ir, passes

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/plugins/override_helper.py· 3

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/plugins/test_plugin.py· 3

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/no_torch_dispatch_example.py· 4

Triton dependency

import triton

template:41

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:42

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia

template:43

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:44

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_autotune_listener.py· 3

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import JITFunction

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_bindings.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_blaslt.py· 8

Triton dependency

from triton._internal_testing import is_cuda, is_hip, is_hip_cdna3, is_hip_cdna4

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 10

template:8

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import nvidia as vendor

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if dtype == torch.float8_e4m3fn and torch.cuda.get_device_capability()[0] < 9:

template:20

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import amd as vendor

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia

template:78

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia

template:149

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_build.py· 2

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.build import compile_module_from_src

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_cache_determinism.py· 2

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_cache.py· 5

Triton dependency

import triton

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.cache import FileCacheManager, RemoteCacheManager

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

return torch.cuda.get_device_capability()

template:277

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/runtime/test_compilation_listener.py· 5

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.knobs import CompileTimes

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.compiler import ASTSource, IRSource

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_driver.py· 6

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.driver import GPUDriver, expand_signature, wrap_handle_tensordesc_impl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

driver = SimpleNamespace(get_active_torch_device=lambda: "cuda:0", get_device_interface=lambda: device_interface)

template:62

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

assert device_interface.default_stream_arg == "cuda:0"

template:67

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

assert zeros_calls == [(16, torch.int8, "cuda:0")]

template:69

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/runtime/test_interpreter.py· 1

Triton dependency

from triton._C.libtriton import interpreter as _interpreter

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_launch.py· 4

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.interpreter import _implicit_cvt

template:236

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_no_torch_dispatch.py· 2

Triton dependency

from triton._internal_testing import is_cuda

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not is_cuda() and torch.cuda.get_device_capability()[0] >= 9:

template:12

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/test/unit/runtime/test_specialize.py· 9

Triton dependency

from triton._C.libtriton import native_specialize_impl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import MockTensor, JITCallable

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._utils import canonicalize_dtype

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.nvidia.compiler import CUDABackend

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.amd.compiler import HIPBackend

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language import constexpr

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor as GluonTensorDescriptor

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import NVMMASharedLayout

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/runtime/test_subproc.py· 3

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import ASTSource

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_debug_dump.py· 2

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_debug.py· 3

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import run_in_process

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_debuginfo.py· 2

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_filecheck.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._filecheck import run_filecheck_test

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_link.py· 5

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra import libdevice

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import llvm

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.ones((1, ), device="cuda")

template:36

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/test_perf_warning.py· 6

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

capability = torch.cuda.get_device_capability()

template:24

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

.cuda() tensor/module move

i = torch.empty(64 * 64, dtype=torch.float32).cuda()

template:178

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

o = torch.empty(64 * 64, dtype=torch.float32).cuda()

template:179

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

python/test/unit/test_stages_inspection.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/test_utils.py· 1

Triton dependency

from triton._utils import is_power_of_two, validate_block_shape

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/tools/test_aot.py· 7

Triton dependency

import triton

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda, is_hip

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.nvidia.driver import include_dirs, library_dirs

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return ["cuda"]

template:19

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.backends.amd.driver import include_dirs, _get_path_to_hip_runtime_dylib

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

target = GPUTarget("hip", "gfx942", 64) if is_hip() else GPUTarget("cuda", 80, 32)

template:553

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/tools/test_disasm.py· 5

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.tools.disasm as disasm

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if not triton.runtime.driver.active.get_current_target().backend == "cuda":

template:10

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.empty(1, dtype=torch.int32, device='cuda')

template:17

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/test/unit/tools/test_irsource.py· 3

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import IRSource, make_backend

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/tools/test_linear_layout.py· 1

Triton dependency

from triton.tools import LinearLayout

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/tools/test_slice_kernel.py· 6

Triton dependency

from triton.tools.triton_to_gluon_translator.slice_kernel import RewriteSpec, get_reference, slice_kernel

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.target import TranslatorTarget

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.slice_kernel import slice_kernel as new_slice_kernel

template:921

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.translator import translate_paths

template:922

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.translator import convert_triton_to_gluon

template:923

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import convert_host_descriptor

template:924

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/tools/test_stable_toposort.py· 2

Triton dependency

from triton.tools.triton_to_gluon_translator.ordered_set import ordered_set

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.stable_toposort import stable_toposort

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/test/unit/tools/test_triton_to_gluon.py· 45

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.translator import convert_triton_to_gluon

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.target import TranslatorTarget

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import (

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.target_info import current_target

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.amd_helpers import convert_host_descriptor

template:33

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import convert_host_descriptor

template:35

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

target = TranslatorTarget(f"sm{t.arch}" if t.backend == "cuda" else t.arch)

template:41

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(n, device="cuda", dtype=torch.float32)

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randn(n, device="cuda", dtype=torch.float32)

template:73

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:105

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:106

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty((M, N), device="cuda", dtype=torch.float32)

template:109

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:242

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:314

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:377

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.zeros((M, N), device="cuda", dtype=torch.float16)

template:447

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y_ref = torch.zeros((M, N), device="cuda", dtype=torch.float16)

template:454

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.ones((M, N), device="cuda", dtype=torch.float16) * 3.0

template:471

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.zeros((M, N), device="cuda", dtype=torch.float16)

template:472

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y_ref = torch.zeros((M, N), device="cuda", dtype=torch.float16)

template:481

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn((M, N), device="cuda", dtype=torch.float16)

template:510

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(n, device="cuda", dtype=torch.float32)

template:544

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randn(n, device="cuda", dtype=torch.float32)

template:545

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(2 * n, device="cuda", dtype=torch.float32)

template:573

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.arange(0, block, device="cuda", dtype=torch.int32)

template:598

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.arange(-block, 0, device="cuda", dtype=torch.int32)

template:599

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((2 * block, ), device="cuda", dtype=torch.int32)

template:600

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((1, ), device="cuda", dtype=torch.int32)

template:622

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(block, device="cuda", dtype=torch.float32)

template:643

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_max = torch.empty((block // 2, ), device="cuda", dtype=torch.float32)

template:644

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_min = torch.empty((block // 2, ), device="cuda", dtype=torch.float32)

template:645

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty(num_threads, dtype=torch.int32, device="cuda")

template:667

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ref = torch.zeros((block, ), device="cuda")

template:685

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros((block, ), device="cuda")

template:688

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(BLOCK, device="cuda", dtype=torch.float32)

template:709

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.randn(BLOCK, device="cuda", dtype=torch.float32)

template:710

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty(2 * BLOCK, device="cuda", dtype=torch.float32)

template:711

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.empty(size, dtype=torch.uint8, device="cuda")

template:734

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(X * Y, device="cuda", dtype=torch.float16).reshape(X, Y)

template:739

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

idx = torch.tensor([0, 2, 4, 6, 1, 3, 5, 7], device="cuda", dtype=torch.int32)

template:740

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros((X, Y), device="cuda", dtype=torch.float16)

template:741

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/bench/bench_dense_matmul.py· 6

Triton dependency

import triton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.synchronize(device)

template:176

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(device)

template:186

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(args.device)

template:207

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = torch.device("cuda", args.device)

template:208

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/bench/bench_mlp.py· 7

Triton dependency

import triton.profiler as proton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

dev = torch.cuda.current_device()

template:104

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

assert dev == rank, f"{torch.cuda.get_current_device()=}, {rank=}"

template:105

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:198

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:207

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(torch.distributed.get_rank())

template:222

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

has_native_mx4 = torch.cuda.get_device_capability(0)[0] >= 10 or get_cdna_version() == 4

template:246

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/conftest.py· 5

Device string "cuda"

parser.addoption("--device", action="store", default="cuda")

template:7

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:37

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:48

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id % torch.cuda.device_count())

template:60

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/test_distributed.py· 11

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.testing import cuda_graph_without_gc

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.set_device(dev)

template:70

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if not torch.cuda.is_available():

template:81

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < n_gpus:

template:83

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

pytest.skip(f"requires up to {n_gpus} CUDA devices, found {torch.cuda.device_count()}")

template:84

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:182

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

dev = torch.cuda.current_device()

template:251

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:312

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:313

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.stream(stream):

template:314

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/test_matmul_details/test_opt_flags_nvidia.py· 15

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_cuda

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if device != "cuda" or not torch.cuda.is_available() or not is_cuda():

template:57

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if device != "cuda" or not torch.cuda.is_available() or not is_cuda():

template:57

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] != 9:

template:59

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if device != "cuda" or not torch.cuda.is_available() or not is_cuda():

template:117

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if device != "cuda" or not torch.cuda.is_available() or not is_cuda():

template:117

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] != 9:

template:119

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if device != "cuda" or not torch.cuda.is_available():

template:164

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if device != "cuda" or not torch.cuda.is_available():

template:164

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] < 10:

template:166

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if device != "cuda" or not torch.cuda.is_available():

template:184

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if device != "cuda" or not torch.cuda.is_available():

template:184

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] < 10:

template:186

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/test_matmul.py· 5

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hopper

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

device_capability = torch.cuda.get_device_capability()[0]

template:336

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_hip() or torch.cuda.get_device_capability()[0] < 10:

template:406

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if not is_cuda() or torch.cuda.get_device_capability()[0] < 10:

template:634

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/test_mxfp.py· 9

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.manual_seed(0)

template:61

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if "float8" in src_dtype and (is_cuda() and torch.cuda.get_device_capability()[0] < 9):

template:157

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if "float8" in src_dtype and (is_cuda() and torch.cuda.get_device_capability()[0] < 9):

template:174

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

or scale_dtype == torch.float8_e4m3fn) and (is_cuda() and torch.cuda.get_device_capability()[0] < 9):

template:254

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.randn(*shape, dtype=src_dtype, device="cuda")

template:295

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(*shape, dtype=torch.bfloat16, device="cuda").to(src_quant_dtype)

template:311

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_scale = torch.randint(0, 256, scale_shape, device="cuda", dtype=torch.uint8)

template:313

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_reduce.py· 10

Triton dependency

from triton.testing import do_bench

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability() < (9, 0):

template:69

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:75

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:140

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if not torch.cuda.is_available() or not is_cuda():

template:157

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] < 9:

template:159

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = "cuda"

template:163

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:184

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_specialize.py· 4

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/tests/test_tensor_details/test_layout_hopper.py· 7

Triton dependency

from triton._internal_testing import is_cuda

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.randint(0, 256, shape, dtype=torch.uint8, device="cuda")

template:25

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(0, 256, shape, dtype=torch.uint8, device="cuda")

template:82

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.manual_seed(0)

template:141

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.randn(shape, dtype=torch.bfloat16, device="cuda")

template:144

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_tensor.py· 6

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device = "cuda"

template:165

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:180

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:205

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:239

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_topk.py· 11

Triton dependency

import triton.profiler as proton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.testing import cuda_graph_without_gc

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device = "cuda"

template:17

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

logits = torch.full((n_rows, n_experts), -1, dtype=storage_dtype, device="cuda").view(dtype)

template:45

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected_indices = torch.arange(k, dtype=torch.int16, device="cuda").expand(n_rows, k)

template:49

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.set_device(rank)

template:61

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:70

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:71

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.stream(stream):

template:72

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:75

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:80

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/triton_kernels/compaction_details/_masked_compaction.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/distributed.py· 2

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/matmul_details/_common.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/matmul_details/_matmul.py· 2

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/matmul_details/_p_matmul.py· 3

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.ragged_tma import load_ragged, store_ragged

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/matmul_details/opt_flags_details/opt_flags_amd.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

n_cu = torch.cuda.get_device_properties(0).multi_processor_count

template:11

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/triton_kernels/matmul_details/opt_flags_details/opt_flags_nvidia.py· 3

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

device_props = torch.cuda.get_device_properties(0)

template:101

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device_props = torch.cuda.get_device_properties(0)

template:160

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/triton_kernels/matmul_details/opt_flags.py· 6

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

n_cu = torch.cuda.get_device_properties(0).multi_processor_count

template:120

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

and torch.cuda.get_device_capability()[0] >= 10

template:229

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if block_m == 64 and precision_config.c_mx_scale is not None and rhs_dtype == FP4 and torch.cuda.get_device_capability()[0] >= 10:

template:234

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

n_sms = torch.cuda.get_device_properties(0).multi_processor_count

template:250

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if backend == "cuda":

template:517

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/triton_kernels/matmul.py· 4

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if triton.runtime.driver.active.get_current_target().backend != "cuda":

template:146

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if ragged_dimension == "K" and torch.cuda.get_device_capability()[0] < 9:

template:450

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

out = torch.matmul(round_x(a[batch, idx, :], torch.arange(lo, hi, device="cuda")).to(compute_dtype),

template:896

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/triton_kernels/meta.py· 1

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/numerics_details/flexpoint.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/numerics_details/mxfp_details/_downcast_to_mxfp.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/numerics_details/mxfp_details/_upcast_from_mxfp.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/numerics_details/mxfp.py· 2

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/reduce.py· 4

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra import libdevice

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

and torch.cuda.get_device_capability()[0] >= 9

template:181

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/triton_kernels/roofline.py· 5

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia, amd

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler import viewer

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

buf = torch.empty(n_bytes, device="cuda", dtype=torch.uint8)

template:89

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

def get_blas_tflops(dtype, workspace_size=32 * 1024 * 1024, device="cuda"):

template:135

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/triton_kernels/specialize.py· 1

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/swiglu_details/_swiglu.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/swiglu.py· 1

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/target_info.py· 4

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.target_info import (

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

return torch.cuda.get_device_properties(0).multi_processor_count

template:74

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/triton_kernels/tensor_details/bitmatrix_details/sum_bitmatrix_rows.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/bitmatrix.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/layout_details/blackwell_scale.py· 2

Triton dependency

import triton

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/layout_details/cdna4_scale.py· 2

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/layout_details/gfx1250_scale.py· 2

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/layout_details/hopper_scale.py· 2

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/layout_details/hopper_value.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor_details/ragged_tensor.py· 2

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/tensor.py· 2

Triton dependency

from triton.tools.ragged_tma import create_ragged_descriptor

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/topk_details/_topk_backward.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/topk_details/_topk_forward.py· 2

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton_kernels/triton_kernels/topk.py· 1

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/_filecheck.py· 7

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import ASTSource, make_backend

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon._runtime import GluonASTSource

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import create_function_from_signature

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

stub_target = GPUTarget("cuda", 100, 32)

template:19

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton/backends/driver.py· 6

Triton dependency

from triton._utils import find_paths_if

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import make_tensordesc_args

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

self.get_device_capability = torch.cuda.get_device_capability

template:164

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

self.get_current_stream = lambda idx: torch.cuda.current_stream(idx).cuda_stream

template:169

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

self.get_current_device = torch.cuda.current_device

template:170

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

self.set_current_device = torch.cuda.set_device

template:171

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton/compiler/code_generator.py· 2

Triton dependency

from triton.experimental.gluon.language._semantic import GluonSemantic

template:294

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.semantic import TritonSemantic

template:298

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/__init__.py· 1

Triton dependency

from triton import must_use_result, aggregate

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/_runtime.py· 7

Triton dependency

from triton.compiler.compiler import ASTSource

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import Language

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import JITFunction, constexpr_function

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.compiler import make_backend

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.code_generator import ast_to_ttir

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

is_cuda = options.backend_name == "cuda"

template:36

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton/experimental/gluon/amd/gfx1250.py· 3

Triton dependency

from triton._utils import validate_block_shape

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import PaddedSharedLayout, SwizzledSharedLayout

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import PartitionedSharedLayout

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/_core.py· 4

Triton dependency

from triton._C.libtriton.gluon_ir import GluonOpBuilder

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language.core as tl_core

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import (

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/_layouts.py· 3

Triton dependency

from triton.language.core import _unwrap_if_constexpr, _unwrap_shape, constexpr_type

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import constexpr_function

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import gluon_ir

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/_math.py· 1

Triton dependency

import triton.language.math as tl_math

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/_semantic.py· 5

Triton dependency

from triton.language.semantic import TritonSemantic

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import GluonOpBuilder, compute_tmem_reg_layout

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.code_generator import flatten_values_to_ir, unflatten_ir_values

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:384

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/_standard.py· 3

Triton dependency

from triton.runtime.jit import JITFunction

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language.standard as tl_standard

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/_layouts.py· 2

Triton dependency

from triton.language.core import _unwrap_if_constexpr

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import DistributedLayout

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/_ops.py· 3

Triton dependency

from triton import knobs

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import _core as ttgl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._semantic import _check

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/cdna3/__init__.py· 3

Triton dependency

from triton import knobs

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import _core as ttgl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/cdna4/__init__.py· 2

Triton dependency

from triton.runtime.jit import constexpr_function

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import (

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/__init__.py· 2

Triton dependency

from triton.runtime.jit import constexpr_function

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import get_amd_wmma_scale_layout as _get_wmma_scale_layout

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/_layouts.py· 4

Triton dependency

from triton.language.core import _unwrap_if_constexpr

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import constexpr_function

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import PaddedSharedLayout, SharedLayout

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd._layouts import AMDWMMALayout

template:138

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/async_copy.py· 1

Triton dependency

from triton.experimental.gluon.language._layouts import DistributedLayout

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/cluster.py· 1

Triton dependency

from triton.experimental.gluon.language._core import builtin

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/mbarrier.py· 3

Triton dependency

import triton.experimental.gluon.language._core as ttgl

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import SwizzledSharedLayout

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, _unwrap_if_constexpr

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/gfx1250/tdm.py· 6

Triton dependency

import triton.experimental.gluon.language._core as ttgl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import PaddedSharedLayout, SwizzledSharedLayout

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import PartitionedSharedLayout

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, _unwrap_if_constexpr

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C import ir

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import shared_memory_descriptor

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/amd/slice.py· 2

Triton dependency

from triton.experimental.gluon.language import _core as ttgl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._semantic import _check

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/extra/__init__.py· 1

Triton dependency

from triton.language.extra import libdevice

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/ampere/__init__.py· 3

Triton dependency

from triton import knobs

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import _core as ttgl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import DotOperandLayout, NVMMADistributedLayout

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/ampere/async_copy.py· 1

Triton dependency

from triton._C.libtriton import ir

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/ampere/mbarrier.py· 4

Triton dependency

import triton.experimental.gluon.language as ttgl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon._runtime import constexpr_function, jit

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import SwizzledSharedLayout

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, _unwrap_if_constexpr

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/blackwell/__init__.py· 7

Triton dependency

from triton.runtime.jit import constexpr_function

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import _core as ttgl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, base_type, base_value, _unwrap_if_constexpr

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._semantic import _check, _compute_tmem_reg_layout

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton._C.libtriton.gluon_ir as gluon_ir

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import GluonOpBuilder

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/blackwell/clc.py· 4

Triton dependency

import triton.experimental.gluon.language._core as gl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, tensor, shared_memory_descriptor, base_value, base_type

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import GluonOpBuilder

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/blackwell/float2.py· 3

Triton dependency

from triton.experimental.gluon import aggregate

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import _core as ttgl, _standard as stdlib

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon._runtime import constexpr_function, jit

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/blackwell/tma.py· 3

Triton dependency

import triton.experimental.gluon.language._core as ttgl

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper.tma import (

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/hopper/__init__.py· 2

Triton dependency

from triton.compiler.code_generator import unflatten_ir_values

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/hopper/cluster.py· 1

Triton dependency

from triton.experimental.gluon.language._core import builtin, _unwrap_if_constexpr

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/language/nvidia/hopper/tma.py· 5

Triton dependency

from triton.language.core import base_type, base_value

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language._core as ttgl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import NVMMASharedLayout

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._core import builtin, _unwrap_if_constexpr

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C import ir

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gluon/nvidia/hopper.py· 3

Triton dependency

from triton._utils import validate_block_shape, canonicalize_dtype, get_primitive_bitwidth

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._layouts import NVMMASharedLayout

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gsan/_allocator.py· 4

Triton dependency

from triton.runtime import driver as runtime_driver

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.build import compile_module_from_file

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if runtime_driver.active.get_current_target().backend != "cuda":

template:23

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.backends.nvidia.driver import library_dirs, include_dirs

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gsan/_stream_sync.py· 2

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gsan/_testing_utils.py· 7

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gsan_testing import thread_state_address, SHADOW_GRANULARITY_BYTES, PER_DEVICE_STATE_STRIDE_BYTES, GLOBAL_STATE_SIZE_BYTES, shadow_cell_address, thread_state_stride_bytes, SHA

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

device_index = torch.cuda.current_device()

template:27

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device_index = torch.cuda.current_device()

template:38

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device_index = torch.cuda.current_device()

template:49

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device_index = torch.cuda.current_device()

template:63

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton/experimental/gsan/_testing.py· 2

Triton dependency

from triton._C.libtriton import gsan_testing as _gsan_testing

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gsan_testing import (

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/experimental/gsan/src/GSanLibrary.cu· 1

Custom CUDA kernels (.cu/.cuh)

CUDA kernel source

templatefile

Hand-written .cu/.cuh kernels compile only with nvcc. AMD's HIPify tools translate the vast majority of CUDA C++ to HIP automatically.

RecommendRun hipify-perl over the .cu/.cuh sources and build with hipcc.

python/triton/experimental/gsan/src/Hash.cuh· 1

Custom CUDA kernels (.cu/.cuh)

CUDA kernel source

templatefile

Hand-written .cu/.cuh kernels compile only with nvcc. AMD's HIPify tools translate the vast majority of CUDA C++ to HIP automatically.

RecommendRun hipify-perl over the .cu/.cuh sources and build with hipcc.

python/triton/language/__init__.py· 4

Triton dependency

from triton.experimental.gluon.language._layouts import NVMMASharedLayout, PaddedSharedLayout, SwizzledSharedLayout

template:334

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper.tma import tensor_descriptor_type as nvidia_tensor_descriptor_type

template:335

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper.tma import tensor_descriptor_im2col_type as nvidia_tensor_descriptor_im2col_type

template:336

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250.tdm import tensor_descriptor_type as amd_tensor_descriptor_type

template:337

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/language/core.py· 1

Triton dependency

from triton.compiler.code_generator import _apply_to_tuple_values

template:1590

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/language/semantic.py· 2

Triton dependency

from triton.runtime import driver

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return (target.backend == "cuda" and target.arch >= 90)

template:1101

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton/language/target_info.py· 4

Triton dependency

from triton.runtime import driver

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import constexpr_function

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target is not None and target.backend == "cuda"

template:22

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if target is None or target.backend != "cuda":

template:33

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton/runtime/autotuner.py· 3

Triton dependency

from triton._C.libtriton import get_cache_invalidating_env_vars

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.testing

template:118

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler.compiler import make_backend

template:181

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/runtime/cache.py· 1

Triton dependency

from triton import __version__, knobs

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/runtime/interpreter.py· 5

Triton dependency

import triton

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.semantic import TritonSemantic

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import KernelInterface

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/runtime/jit.py· 7

Triton dependency

from triton.backends import BaseBackend

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import get_cache_invalidating_env_vars, native_specialize_impl, ir

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language.core as core

template:278

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import constexpr

template:531

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import constexpr_type

template:555

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:826

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import _unwrap_if_constexpr, constexpr

template:1154

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/testing.py· 23

torch.cuda API usage

with torch.cuda.graph(*args, **kwargs) as graph:

template:75

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

import triton.profiler as proton

template:84

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

with torch.cuda.stream(torch.cuda.Stream()):

template:138

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start_event = torch.cuda.Event(enable_timing=True)

template:152

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

end_event = torch.cuda.Event(enable_timing=True)

template:153

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:158

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:167

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:174

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start_event = torch.cuda.Event(enable_timing=True)

template:179

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

end_event = torch.cuda.Event(enable_timing=True)

template:180

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:184

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if target.backend != "cuda":

template:213

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

with torch.cuda.stream(torch.cuda.Stream()):

template:219

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start_event = torch.cuda.Event(enable_timing=True)

template:227

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

end_event = torch.cuda.Event(enable_timing=True)

template:228

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:233

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:243

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:253

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:258

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:662

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capability = torch.cuda.get_device_capability(device)

template:665

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device = torch.cuda.current_device()

template:747

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capability = torch.cuda.get_device_capability()

template:750

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton/tools/__init__.py· 1

Triton dependency

from triton._C.libtriton.linear_layout import LinearLayout

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/compile.py· 2

Triton dependency

import triton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.backends

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/disasm.py· 1

Triton dependency

from triton import knobs

template:79

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/gsan.py· 3

Triton dependency

import triton

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gsan._allocator import create_mem_pool

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

with torch.cuda.use_mem_pool(create_mem_pool()), \

template:57

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton/tools/ragged_tma.py· 3

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/tensor_descriptor.py· 1

Triton dependency

from triton._utils import validate_block_shape, canonicalize_dtype

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/__init__.py· 2

Triton dependency

from triton.tools.triton_to_gluon_translator.slice_kernel import (

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.translator import (

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/amd_helpers.py· 10

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import wmma as amd_wmma

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import tdm as amd_tdm

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.cdna3 import mfma as amd_mfma

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.target_info import current_target

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import * # noqa: F401,F403

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import (

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:347

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/blackwell_helpers.py· 9

Triton dependency

from triton.experimental import gluon

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import fence_async_shared, mbarrier, tma

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import tma as tma_blackwell

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import * # noqa: F401,F403

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import (

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import * # noqa: F401,F403

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import (

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/common_helpers.py· 3

Triton dependency

from triton.experimental import gluon

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.target_info import current_target # noqa: F401

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/hopper_helpers.py· 7

Triton dependency

from triton.experimental import gluon

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import (

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import * # noqa: F401,F403

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import (

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import * # noqa: F401,F403

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.nvidia_helpers import (

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/nvidia_helpers.py· 7

Triton dependency

from triton.experimental import gluon

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.ampere import mma_v2

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import fence_async_shared, mbarrier, tma

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import * # noqa: F401,F403

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.common_helpers import (

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:169

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/slice_kernel.py· 11

Triton dependency

import triton # type: ignore[import-untyped]

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import language as tl # type: ignore[import-untyped]

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import JITCallable, JITFunction # type: ignore[import-untyped]

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.ragged_tma import create_ragged_descriptor # type: ignore[import-untyped]

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor # type: ignore[import-untyped]

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.inline_helpers import defs as inline_helper_defs

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.ordered_set import ordered_set

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.scoped_dict import scoped_dict

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.stable_toposort import stable_toposort

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.target import TranslatorTarget

template:29

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.translator import translate_kernels

template:772

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/stable_toposort.py· 1

Triton dependency

from triton.tools.triton_to_gluon_translator.ordered_set import ordered_set

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/triton/tools/triton_to_gluon_translator/translator.py· 13

Triton dependency

import triton.language as tl # type: ignore[import-untyped]

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import JITCallable, JITFunction # type: ignore[import-untyped]

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.ordered_set import ordered_set

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.scoped_dict import scoped_dict

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.slice_kernel import (

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.target import TranslatorTarget

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.triton_to_gluon_translator.stable_toposort import stable_toposort

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl # type: ignore[import-untyped]

template:39

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

if (tl_cuda := getattr(tl.extra, "cuda", None)) is not None:

template:85

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton

template:102

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:103

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:115

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:116

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/tutorials/01-vector-add.py· 2

Triton dependency

import triton

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/tutorials/02-fused-softmax.py· 3

Triton dependency

import triton

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime import driver

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/tutorials/03-matrix-multiplication.py· 3

Triton dependency

import triton

template:154

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:155

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:161

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/04-low-memory-dropout.py· 2

Triton dependency

import triton

template:38

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:39

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/tutorials/05-layer-norm.py· 3

Triton dependency

import triton

template:34

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:35

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

NVIDIA Apex dependency

import apex

template:40

Apex fused optimizers/AMP are CUDA-specific. ROCm PyTorch ships native AMP (torch.cuda.amp / torch.amp) covering most uses.

RecommendReplace Apex AMP with native torch.amp; use ROCm apex for fused ops.

python/tutorials/06-fused-attention.py· 10

Triton dependency

import triton

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:32

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:36

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 10

template:40

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] == 9

template:44

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return not (is_cuda() and torch.cuda.get_device_capability()[0] == 9 and BLOCK_M * BLOCK_N < 128 * 128

template:152

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:546

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

FlashAttention dependency

from flash_attn.flash_attn_interface import \

template:694

FlashAttention has an official ROCm/CK implementation. Swapping the wheel (or using PyTorch SDPA) is mechanical.

RecommendInstall the ROCm FlashAttention build or fall back to torch SDPA.

python/tutorials/07-extern-functions.py· 4

Triton dependency

import triton

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra import libdevice

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/08-grouped-gemm.py· 7

Triton dependency

import triton

template:32

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:33

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:39

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:43

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.cuda.get_device_properties("cuda").multi_processor_count

template:48

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return torch.cuda.get_device_properties("cuda").multi_processor_count

template:48

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:362

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/09-persistent-matmul.py· 24

Triton dependency

import triton

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:29

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:36

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton._C.libtriton import nvidia

template:44

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:45

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton._C.libtriton import amd

template:48

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:49

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:60

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return torch.cuda.get_device_capability()[0] == 9

template:64

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:68

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:350

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:350

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:459

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:459

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:583

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

NUM_SMS = torch.cuda.get_device_properties("cuda").multi_processor_count

template:583

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:587

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16).to(dtype)

template:657

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16).to(dtype)

template:658

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16).to(dtype)

template:694

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16).to(dtype)

template:695

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.profiler.viewer as proton_viewer

template:720

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

python/tutorials/10-block-scaled-matmul.py· 20

Triton dependency

import triton

template:123

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:124

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:125

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:126

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:127

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:131

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return (is_cuda() and torch.cuda.get_device_capability()[0] in [10, 11]) or is_hip_cdna4()

template:140

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if is_cuda() and torch.cuda.get_device_capability()[0] in [10, 11]:

template:143

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import nvidia

template:144

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

cublas_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:145

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((M, N), dtype=dtype_dst, device="cuda")

template:238

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((M, N), dtype=torch.float16, device="cuda")

template:307

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((M, N), dtype=torch.float16, device="cuda")

template:315

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

device = "cuda"

template:332

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

import triton.profiler.viewer as proton_viewer

template:493

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = MXFP4Tensor(size=(M, K), device="cuda").random()

template:614

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w = MXFP4Tensor(size=(N, K), device="cuda").random()

template:615

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_scales = torch.randint(124, 128, (K // 32, M), dtype=torch.uint8, device="cuda")

template:617

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_scales = torch.randint(124, 128, (K // 32, N), dtype=torch.uint8, device="cuda")

template:618

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

triton_out = torch.empty((M, N), device="cuda")

template:684

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/11-programmatic-dependent-launch.py· 8

Triton dependency

import triton

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return triton.runtime.driver.active.get_current_target().backend == "cuda"

template:19

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return is_cuda() and torch.cuda.get_device_capability()[0] >= 9

template:23

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.rand(n_elements, device="cuda", dtype=torch.float32)

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(n_elements, device="cuda", dtype=torch.float32)

template:73

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda", dtype=torch.float32)

template:97

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda", dtype=torch.float32)

template:98

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/01-intro.py· 6

Triton dependency

import triton

template:41

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:42

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:43

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

input = torch.tensor([42.0], device="cuda")

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:106

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:148

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/02-layouts.py· 14

Triton dependency

import triton

template:142

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:144

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:145

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:224

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:235

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((xnumel, ynumel), device="cuda")

template:500

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((xnumel, ynumel), device="cuda")

template:520

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((xnumel, ynumel), device="cuda")

template:596

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((32 * 1024, 32 * 1024), device="cuda")

template:642

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((input.shape[1], input.shape[0]), device="cuda").T

template:645

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((ynumel, xnumel), device="cuda").T

template:760

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((xnumel, ynumel), device="cuda")

template:762

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((ynumel, xnumel), device="cuda").T

template:764

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((xnumel, ynumel), device="cuda")

template:766

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/03-async-copy.py· 19

Triton dependency

import triton

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.ampere import async_copy as cp

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 8

template:26

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 8

template:26

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:73

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn(xnumel, ynumel, device="cuda")

template:131

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn(xnumel, ynumel, device="cuda")

template:132

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty_like(a, device="cuda")

template:133

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn(xnumel, ynumel, device="cuda")

template:197

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn(xnumel, ynumel, device="cuda")

template:198

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty_like(a, device="cuda")

template:199

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(xnumel, ynumel, device="cuda")

template:215

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(xnumel, ynumel, device="cuda")

template:216

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty_like(A, device="cuda")

template:217

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn(xnumel, ynumel, device="cuda")

template:351

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn(xnumel, ynumel, device="cuda")

template:352

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty_like(a, device="cuda")

template:353

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/04-tma.py· 18

Triton dependency

import triton

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:30

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import tma, mbarrier, fence_async_shared

template:31

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:39

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:39

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

message = torch.full((MESSAGE_SIZE, ), -1, dtype=torch.int32, device="cuda")

template:166

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

ready = torch.zeros(1, dtype=torch.int32, device="cuda")

template:167

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.full((MESSAGE_SIZE, ), -1, dtype=torch.int32, device="cuda")

template:168

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected = torch.arange(MESSAGE_SIZE, dtype=torch.int32, device="cuda") + 1000

template:181

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn(xnumel, device="cuda")

template:207

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn(xnumel, ynumel, device="cuda")

template:359

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn(xnumel, ynumel, device="cuda")

template:360

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty_like(a, device="cuda")

template:361

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(xnumel, ynumel, device="cuda")

template:374

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(xnumel, ynumel, device="cuda")

template:375

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty_like(A, device="cuda")

template:376

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/05-wgmma.py· 22

Triton dependency

import triton

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import (

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 9

template:34

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 9

template:34

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:229

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:230

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.randn(M, N, device="cuda", dtype=torch.float32)

template:231

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:245

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:246

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.randn(M, N, device="cuda", dtype=torch.float32)

template:247

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:406

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn((N, K) if TRANSPOSE_B else (K, N), device="cuda", dtype=torch.float16)

template:407

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:408

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:487

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:488

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:489

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:602

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:603

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:604

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/06-tcgen05.py· 20

Triton dependency

import triton

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:36

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:36

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

input = torch.randn(M, N, dtype=torch.float32, device="cuda")

template:135

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:278

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:279

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.randn(M, N, device="cuda", dtype=torch.float32)

template:280

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:383

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn((N, K) if TRANSPOSE_B else (K, N), device="cuda", dtype=torch.float16)

template:384

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:385

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:406

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:407

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:408

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:627

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:628

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:629

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/07-persistence.py· 33

Triton dependency

import triton

template:29

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:34

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:35

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:37

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import (

template:38

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:46

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if torch.cuda.is_available():

template:54

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton._C.libtriton import nvidia

template:55

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

cublas_workspace = torch.empty(32 * 1024 * 1024, device="cuda", dtype=torch.uint8)

template:56

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:66

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:66

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.get_device_capability()[0] == 9:

template:162

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

elif torch.cuda.get_device_capability()[0] == 10:

template:164

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:271

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:272

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:273

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:285

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:286

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:287

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

is_hopper = torch.cuda.get_device_capability()[0] == 9

template:292

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:423

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:423

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:440

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:441

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:442

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:740

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:740

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:756

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:757

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:758

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:777

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:783

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:784

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/09-tma-gather-scatter.py· 27

Triton dependency

import triton

template:44

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon as gluon

template:46

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:47

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir, gluon_ir

template:48

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:50

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (tma, mbarrier, fence_async_shared)

template:51

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:56

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:56

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

out = torch.empty((BLOCK_X, BLOCK_Y), dtype=input.dtype, device="cuda")

template:287

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((X_MAX, Y_MAX), dtype=dtype, device="cuda")

template:302

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = torch.linspace(-X_MAX, 2 * X_MAX, BLOCK_X, dtype=torch.int32, device="cuda")

template:304

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = x_offsets[torch.randperm(BLOCK_X, device="cuda")]

template:306

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

lo_zeros = torch.zeros(BLOCK_X, y_lo - y_offset, dtype=dtype, device="cuda")

template:317

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

hi_zeros = torch.zeros(BLOCK_X, y_offset + BLOCK_Y - y_hi, dtype=dtype, device="cuda")

template:318

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

input = torch.randn((X_MAX, Y_MAX), dtype=dtype, device="cuda")

template:419

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = torch.linspace(0, 2 * X_MAX, BLOCK_X, dtype=torch.int32, device="cuda")

template:423

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_offsets = x_offsets[torch.randperm(BLOCK_X, device="cuda")]

template:425

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

src = torch.randn((BLOCK_X, BLOCK_Y), dtype=dtype, device="cuda")

template:427

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), dtype=X.dtype, device="cuda")

template:596

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:610

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:610

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

X_gather_indx = torch.arange(0, M, dtype=torch.int32, device="cuda")

template:627

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

shfl = torch.randperm(M, device="cuda")

template:628

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out_scatter_indx = torch.arange(0, M, dtype=torch.int32, device="cuda")

template:632

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

shfl = torch.randperm(M, device="cuda")

template:633

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

X = torch.randn(M, K, dtype=torch.bfloat16, device="cuda")

template:636

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

W = torch.randn(K, N, dtype=torch.bfloat16, device="cuda")

template:637

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/10-tcgen05-copy.py· 14

Triton dependency

import triton

template:81

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon as gluon

template:83

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:84

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:85

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:86

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:101

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:101

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

input = torch.randn(M, N, dtype=dtype, device="cuda")

template:153

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

D = torch.empty((M, N), dtype=C.dtype, device="cuda")

template:386

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:388

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:388

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, dtype=dtype, device="cuda")

template:402

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, dtype=dtype, device="cuda")

template:403

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.randn(M, N, dtype=torch.float32, device="cuda")

template:404

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/11-tcgen05-mma-scaled.py· 14

Triton dependency

import triton

template:65

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon as gluon

template:67

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:68

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:70

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:71

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:72

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:88

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:88

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=dtype)

template:259

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

base = MXFP4Tensor(size=(MN, K), device="cuda").random()

template:310

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scale = MXScaleTensor(size=(MN, K // VEC_SIZE), device="cuda").random(low=1 / 128, high=2.0)

template:311

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

scales = torch.empty(M, K, device="cuda", dtype=torch.uint8)

template:883

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:1471

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

num_sms = torch.cuda.get_device_properties("cuda").multi_processor_count

template:1471

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/tutorials/gluon/12-cluster-launch-control.py· 17

Triton dependency

import triton

template:28

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:32

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:33

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.blackwell import TensorDescriptor

template:34

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import tma, mbarrier, fence_async_shared, clc

template:35

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

return torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 10

template:39

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

dev_props = torch.cuda.get_device_properties(A.device)

template:199

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device='cuda', dtype=torch.float16)

template:211

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device='cuda', dtype=torch.float16)

template:212

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device='cuda', dtype=torch.float16)

template:213

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

props = torch.cuda.get_device_properties(0)

template:231

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device='cuda', dtype=torch.float16)

template:237

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device='cuda', dtype=torch.float16)

template:238

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device='cuda', dtype=torch.float16)

template:239

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A_test = torch.randn(1024, 1024, device='cuda', dtype=torch.float16)

template:259

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B_test = torch.randn(1024, 1024, device='cuda', dtype=torch.float16)

template:260

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:264

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/tutorials/gluon/13-conv-im2col.py· 19

Triton dependency

import triton

template:65

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:66

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:67

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as ttgl

template:68

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor, TensorDescriptorIm2Col

template:70

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import fence_async_shared, mbarrier, tma

template:71

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

inp = torch.arange(1, 17, device="cuda", dtype=torch.float32).unsqueeze(1).repeat(1, 32).reshape(1, 4, 4, 32)

template:276

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(16, 32, device="cuda", dtype=torch.float32)

template:277

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected = torch.tensor([0, 0, 0, 0, 0, 1, 2, 3, 0, 5, 6, 7, 0, 9, 10, 11], device="cuda", dtype=torch.float32)

template:403

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(1, 33, device="cuda", dtype=torch.float32).unsqueeze(1).repeat(1, 32).reshape(2, 4, 4, 32)

template:584

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(16, 32, device="cuda", dtype=torch.float32)

template:585

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected = torch.tensor([8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], device="cuda",

template:614

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.arange(1, 33, device="cuda", dtype=torch.float32).unsqueeze(1).repeat(1, 32).reshape(2, 4, 4, 32)

template:714

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.zeros(16, 32, device="cuda", dtype=torch.float32)

template:715

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

expected = torch.tensor([7, 0, 9, 10, 11, 0, 0, 0, 0, 0, 17, 18, 19, 0, 21, 22], device="cuda", dtype=torch.float32)

template:745

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_nhwc = torch.randn(N, H, W, Ci, device="cuda", dtype=torch.float16)

template:1164

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_co_r_s_ci = torch.randn(Co, R, S, Ci, device="cuda", dtype=torch.float16)

template:1165

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x_nhwc = torch.randn(N, H, W, Ci, device="cuda", dtype=torch.float16)

template:1221

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

w_co_r_s_ci = torch.randn(Co, R, S, Ci, device="cuda", dtype=torch.float16)

template:1222

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/14-multicta.py· 26

Triton dependency

import triton

template:69

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:71

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:72

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import (

template:73

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import mbarrier, tma

template:82

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:83

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

if not torch.cuda.is_available():

template:90

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:93

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] >= 9

template:93

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if not torch.cuda.is_available():

template:97

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:100

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 10

template:100

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.randn((M, N), device="cuda", dtype=torch.float32)

template:187

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.empty((M, N), device="cuda", dtype=torch.float32).uniform_(-1, 1)

template:212

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:417

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:418

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty((M, N), device="cuda", dtype=torch.float16)

template:419

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.randn((M, N), device="cuda", dtype=torch.float16)

template:531

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

out = torch.empty((M, N), device="cuda", dtype=torch.float16)

template:613

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:639

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:640

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:1144

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:1145

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty((M, N), device="cuda", dtype=torch.float16)

template:1167

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

A = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:1170

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:1171

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/tutorials/gluon/conftest.py· 2

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/backend/compiler.py· 4

Triton dependency

from triton.backends.compiler import BaseBackend, GPUTarget, Language

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir, passes, llvm, amd

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.extra.hip import libdevice

template:195

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/backend/driver.py· 11

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.driver import GPUDriver, decompose_descriptor, expand_signature, wrap_handle_tensordesc_impl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime import _allocation

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.build import compile_module_from_src

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

return torch.cuda

template:383

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

return torch.cuda.is_available() and (torch.version.hip is not None)

template:389

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.device("cuda", self.get_current_device())

template:406

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.testing import do_bench

template:409

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(int(cache_size // 4), dtype=torch.int, device='cuda')

template:417

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/amd/language/hip/libdevice.py· 1

Triton dependency

from triton.language import core

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/language/hip/utils.py· 1

Triton dependency

from triton.language import core

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/examples/gluon/f16_fa_gfx1250.py· 10

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

mid_o = torch.zeros((BATCH, NUM_Q_HEADS, split_factor, BLOCK_M, HEAD_SZ), dtype=torch.float32).cuda()

template:925

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

mid_l = torch.zeros((BATCH, NUM_Q_HEADS, split_factor, BLOCK_M), dtype=torch.float32).cuda()

template:926

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

mid_m = torch.full((BATCH, NUM_Q_HEADS, split_factor, BLOCK_M), float("-inf"), dtype=torch.float32).cuda()

template:927

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

q = q.cuda()

template:992

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

k = k.cuda()

template:993

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

v = v.cuda()

template:994

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

o = o.cuda()

template:995

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:1002

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

third_party/amd/python/examples/gluon/f16_gemm_common_gfx1250.py· 2

Triton dependency

from triton.experimental import gluon

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/examples/gluon/f16_gemm_gfx1250.py· 16

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import make_cga_layout

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

a_device = a.cuda()

template:455

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:456

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:457

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:608

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:609

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:610

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:954

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:955

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:956

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:1031

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:1032

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:1033

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/examples/gluon/f16_gemm_streamk_gfx1250.py· 7

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

a_device = a.cuda()

template:1167

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:1168

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:1169

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

p_device = p.cuda()

template:1170

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/examples/gluon/f16_gemm_warp_pipeline_gfx1250.py· 9

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

a_device = a.cuda()

template:308

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:309

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:310

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:362

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:363

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:364

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/examples/gluon/moe_gfx1250.py· 7

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import tdm

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import _aggregate as aggregate

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

device = 'cuda'

template:1399

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

dev = 'cuda'

template:1494

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/examples/gluon/moe_utils/misc.py· 4

Triton dependency

from triton.experimental import gluon

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.jit import JITFunction

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon._runtime import GluonJITFunction, jit

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/examples/gluon/moe_utils/specialize.py· 2

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon._runtime import GluonJITFunction

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/examples/gluon/mxfp_fa_gfx1250.py· 22

Triton dependency

import triton

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import cdiv

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import PropagateNan

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language import expand_dims

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd import warp_pipeline_stage

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import wmma_scaled

template:23

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import tdm

template:24

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import buffer_load, buffer_store

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import get_wmma_scale_layout

template:26

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import cluster

template:27

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

q = q.cuda()

template:2862

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

k = k.cuda()

template:2863

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

v = v.cuda()

template:2864

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

q_scale = q_scale.cuda()

template:2866

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

k_scale = k_scale.cuda()

template:2867

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

v_scale = v_scale.cuda()

template:2868

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

o = o.cuda()

template:2869

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

l = l.cuda()

template:2870

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

m = m.cuda()

template:2871

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/examples/gluon/mxfp_gemm_gfx1250.py· 18

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import tdm

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import async_copy as cp

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

c_d = torch.zeros(M, N, dtype=torch.float32).cuda()

template:1615

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_d = a.data.contiguous().cuda()

template:1616

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.T.contiguous().cuda()

template:1618

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.contiguous().cuda()

template:1620

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_scale_d = a_scale.cuda()

template:1622

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_scale_d = b_scale.cuda()

template:1625

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_d = torch.zeros(M, N, dtype=torch.float32).cuda()

template:1777

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_d = a.data.contiguous().cuda()

template:1778

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.T.contiguous().cuda()

template:1780

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.contiguous().cuda()

template:1782

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_scale_d = a_scale.cuda()

template:1784

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_scale_d = b_scale.cuda()

template:1787

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/address_sanitizer_helper.py· 4

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.rand(size, device='cuda')

template:6

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device='cuda')

template:7

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/gfx1250_consan_helper.py· 31

Triton dependency

from triton import knobs

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime._allocation import set_profile_allocator

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:21

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((XBLOCK, ), device="cuda", dtype=torch.float16)

template:229

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((XBLOCK, ), device="cuda", dtype=torch.float16)

template:276

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((XBLOCK, ), device="cuda", dtype=torch.float16)

template:339

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((XBLOCK, ), device="cuda", dtype=torch.float16)

template:387

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

output = torch.empty((XBLOCK, ), device="cuda", dtype=torch.float16)

template:441

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input = input.cuda()

template:476

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = output.cuda()

template:478

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:519

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:520

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:521

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:563

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:564

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:592

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:620

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:651

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:652

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:687

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:688

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:724

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:725

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:726

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, ), dtype=torch.float16).cuda()

template:768

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, ), dtype=torch.float16).cuda()

template:808

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:847

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

input_t = torch.randn((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:889

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, XBLOCK), dtype=torch.float16).cuda()

template:890

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/test_address_sanitizer.py· 1

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_convert_op_permlane_swap.py· 2

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_cdna4, is_hip_gfx1250, to_triton, numpy_random

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_extract_slice_concat_op.py· 2

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_f16_gemm_tdm.py· 7

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_gfx1250

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

z = torch.empty(M, N, dtype=torch.float32).cuda()

template:72

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

x = torch.randn(M, K, dtype=torch.float16).cuda()

template:89

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

y = torch.randn(K, N, dtype=torch.float16).cuda()

template:90

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/test_gluon_gfx1250_consan.py· 1

Triton dependency

from triton._internal_testing import is_hip_gfx1250

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_gluon_gfx1250.py· 135

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_gfx1250, str_to_triton_dtype, numpy_random, to_triton, unwrap_tensor, float_dtypes, int_dtypes, uint_dtypes

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXFP4Tensor, MXScaleTensor

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd.gfx1250 import get_wmma_scale_layout, PartitionedSharedLayout, _valid_dtype_combinations

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton.gluon_ir import make_cga_layout

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

y = torch.empty((BLOCK_M, BLOCK_K), dtype=torch.bfloat16, device="cuda")

template:166

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

pgm = scaled_upcast_fp4_kernel[(1, )](x.cuda(), scale.cuda(), y, BLOCK_M, BLOCK_K, num_warps=4)

template:168

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.empty((BLOCK_M, BLOCK_K), dtype=torch.bfloat16, device="cuda")

template:200

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

pgm = scaled_upcast_fp8_kernel[(1, )](x.cuda(), scale.cuda(), y, BLOCK_M, BLOCK_K, num_warps=4)

template:202

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:239

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:240

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:241

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:372

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:373

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:374

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:680

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:681

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:682

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:850

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:851

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_device = c.cuda()

template:852

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a, a_scale = a.cuda(), a_scale.cuda()

template:1004

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b, b_scale = b.cuda(), b_scale.cuda()

template:1005

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c = torch.zeros((M, N), dtype=torch.float32).cuda()

template:1013

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a, a_scale = a.cuda(), a_scale.cuda()

template:1114

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b, b_scale = b.cuda(), b_scale.cuda()

template:1115

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c = torch.zeros((M, N), dtype=torch.float32).cuda()

template:1116

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a, a_scale = a.cuda(), a_scale.cuda()

template:1206

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b, b_scale = b.cuda(), b_scale.cuda()

template:1207

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c = torch.zeros((B, M, N), dtype=torch.float32).cuda()

template:1209

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

x = torch.randint(20, 40, (M, K // DIV_FACTOR_A), dtype=torch.uint8).cuda()

template:1341

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

y = torch.randint(20, 40, (K // DIV_FACTOR_B, N), dtype=torch.uint8).cuda()

template:1342

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_x = torch.randint(min_scale, max_scale + 1, (M, K // scale_factor), dtype=torch.uint8).cuda()

template:1347

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_y = torch.randint(min_scale, max_scale + 1, (N, K // scale_factor), dtype=torch.uint8).cuda()

template:1348

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_x = torch.randint(20, 40, [M, K // scale_factor], dtype=torch.uint8).view(torch.float8_e4m3fn).cuda()

template:1350

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_y = torch.randint(20, 40, [N, K // scale_factor], dtype=torch.uint8).view(torch.float8_e4m3fn).cuda()

template:1351

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

finite = torch.arange(x.numel(), dtype=torch.uint8).cuda().reshape_as(x) % mask

template:1360

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

z = torch.zeros((M, N), dtype=torch.float32).cuda()

template:1368

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

z_ref = torch.zeros((M, N), dtype=torch.float32).cuda()

template:1380

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:1574

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:1575

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:1697

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:1698

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:1813

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_device = out.cuda()

template:1814

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:1881

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp = inp.cuda()

template:1932

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out = out.cuda()

template:1933

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp = inp.cuda()

template:2008

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out = out.cuda()

template:2009

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp.base = inp.base.cuda()

template:2116

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp = inp.cuda()

template:2118

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_handle = inp.cuda()

template:2201

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:2212

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c_d = torch.zeros(M, N, dtype=torch.float32).cuda()

template:2404

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_d = a.data.contiguous().cuda()

template:2405

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.contiguous().cuda()

template:2406

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_scale_d = a_scale.cuda()

template:2407

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_scale_d = b_scale.cuda()

template:2408

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:2481

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

cluster_load_and_write_back_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N, blocked_layout,

template:2482

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:2549

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

run_kernel = lambda: async_load_and_write_back_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N,

template:2553

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

run_kernel = lambda: async_copy_mbarrier_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N,

template:2556

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:2602

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

async_load_and_write_back_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N, blocked_layout, shared_layout,

template:2603

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a = a.data.contiguous().cuda()

template:2755

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b = b.data.contiguous().cuda()

template:2756

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_a = scale_a.cuda()

template:2764

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

scale_b = scale_b.cuda()

template:2765

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

c = torch.zeros((M, N), dtype=torch.float32).cuda()

template:2769

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:2923

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:2924

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:2965

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:2966

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = torch.randint(0x0, 0xFFFF, (16, 64), dtype=torch.uint16).cuda()

template:2996

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

tdm_load_negative_offset_kernel[(1, )](a.cuda(), b_device)

template:2997

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.runtime._allocation import set_profile_allocator

template:3021

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:3024

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, ), dtype=torch.float16).cuda()

template:3063

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.runtime._allocation import set_profile_allocator

template:3092

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:3095

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

output = torch.empty((XBLOCK, ), dtype=torch.float16).cuda()

template:3151

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.runtime._allocation import set_profile_allocator

template:3181

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:3184

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:3235

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:3236

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton.runtime._allocation import set_profile_allocator

template:3273

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(size, device="cuda", dtype=torch.int8)

template:3276

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device = a.cuda()

template:3331

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_device = b.cuda()

template:3332

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:3440

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

ws_async_copy_mbarrier_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N, shared_layout,

template:3442

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_handle = out.cuda()

template:3532

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

run_kernel = lambda: async_store_and_write_back_kernel[grid](a.cuda(), out_handle, M, N, BLOCK_M, BLOCK_N,

template:3534

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_d = a.cuda()

template:3566

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:3567

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:3614

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

.cuda() tensor/module move

inp_d = inp.cuda()

template:3747

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:3748

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = dst_row_indices.cuda()

template:3749

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:3851

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:3852

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = dst_row_indices.cuda()

template:3853

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:3919

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:3920

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = dst_row_indices.cuda()

template:3921

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:3993

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:3994

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = dst_row_indices.cuda()

template:3995

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4202

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4203

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = src_row_indices.cuda()

template:4204

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4257

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4258

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = src_row_indices.cuda()

template:4259

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4363

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4364

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = src_row_indices.cuda()

template:4365

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4519

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4520

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = src_row_indices.cuda()

template:4521

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4590

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4591

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = dst_row_indices.cuda()

template:4592

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

inp_d = inp.cuda()

template:4624

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

out_d = out.cuda()

template:4625

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

indices_d = src_row_indices.cuda()

template:4626

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

src = torch.rand((N, ), dtype=torch.float16).cuda()

template:4694

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

dst = torch.empty((N, ), dtype=torch.float16).cuda()

template:4695

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_device, b_device, c_device = a.cuda(), b.cuda(), c.cuda()

template:4790

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/test_link_hsaco_error_message.py· 2

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import amd

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_llvm_fn_attrs.py· 2

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_mxfp_gemm_tdm.py· 11

Triton dependency

import triton

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.mxfp import MXScaleTensor, MXFP4Tensor

template:21

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_gfx1250

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

def init_data(dtype: str, d0: int, d1: int, device: str = 'cuda'):

template:241

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_d = a.data.contiguous().cuda()

template:309

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_d = b.data.contiguous().cuda()

template:310

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

a_scale_d = a_scale_input.cuda()

template:311

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b_scale_d = b_scale_input.cuda()

template:312

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c_d = torch.zeros(M, N, dtype=torch.float32, device='cuda')

template:313

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:335

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

third_party/amd/python/test/test_packed_f32_arith.py· 2

Triton dependency

import triton

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_pointer_optimization.py· 3

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_scalarize_packed_fops.py· 1

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/amd/python/test/test_tdm_copy.py· 10

Triton dependency

import triton

template:91

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:92

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip_gfx1250

template:93

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:94

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as ttgl

template:95

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

.cuda() tensor/module move

a = a_cpu.cuda()

template:355

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

b = b_cpu.cuda()

template:356

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty((M, N), dtype=torch.int32, device="cuda")

template:357

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

.cuda() tensor/module move

src = src_cpu.cuda()

template:430

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

c = torch.empty((BLOCK_M, BLOCK_N), dtype=torch.int32, device="cuda")

template:431

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/test_warp_pipeline_gfx9.py· 6

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gluon.language as gl

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.amd import warp_pipeline_stage

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/nvidia/backend/driver.py· 13

Triton dependency

import triton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import knobs

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime.build import compile_module_from_file

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime import _allocation

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.compiler import GPUTarget

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends.driver import GPUDriver, decompose_descriptor, expand_signature, wrap_handle_tensordesc_impl

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gsan._allocator as gsan_allocator

template:325

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.experimental.gsan._stream_sync as gsan_stream_sync

template:335

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return GPUTarget("cuda", capability, warp_size)

template:372

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

return torch.device("cuda", self.get_current_device())

template:376

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return torch.cuda

template:380

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Triton dependency

from triton.testing import do_bench

template:390

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return torch.empty(int(cache_size // 4), dtype=torch.int, device='cuda')

template:400

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/nvidia/language/cuda/gdc.py· 1

Triton dependency

from triton.language import core

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/nvidia/language/cuda/libdevice.py· 1

Triton dependency

from triton.language import core

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/nvidia/language/cuda/utils.py· 1

Triton dependency

from triton.language import core

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/__init__.py· 1

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/context.py· 1

Triton dependency

from triton._C.libproton import proton as libproton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/data.py· 1

Triton dependency

from triton._C.libproton import proton as libproton # type: ignore

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/hooks/hook.py· 2

Triton dependency

from triton.compiler import LazyDict

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.knobs as knobs

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/hooks/instrumentation.py· 13

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import ir as triton_ir

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import proton as triton_proton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import amd as triton_amd

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import nvidia as triton_nvidia

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import passes as triton_passes

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libproton import proton as libproton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.compiler import LazyDict

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.runtime._allocation import set_profile_allocator, NullAllocator

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.backends import backends

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

buffer = torch.zeros((aligned_size, ), dtype=torch.uint8, device="cuda")

template:42

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if backend == "cuda":

template:122

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if target["backend"] == "cuda":

template:285

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/proton/hooks/launch.py· 2

Triton dependency

from triton.compiler import LazyDict

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libproton import proton as libproton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/language.py· 5

Triton dependency

from triton.language import core as tl

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.core import builtin

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import proton as triton_proton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.language.semantic import TritonSemantic

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language._semantic import GluonSemantic

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/metric.py· 5

Triton dependency

from triton._C.libproton import proton as libproton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.runtime.driver as driver

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton import MockTensor

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/mode.py· 1

Triton dependency

from triton._C.libtriton import proton as triton_proton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/profile.py· 3

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libproton import proton as libproton # type: ignore

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._C.libtriton import getenv # type: ignore

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/proton.py· 1

Triton dependency

from triton._C.libproton import proton as libproton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/scope.py· 1

Triton dependency

from triton._C.libproton import proton as libproton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/state.py· 1

Triton dependency

from triton._C.libproton import proton as libproton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/proton/viewer.py· 3

Triton dependency

from triton.profiler.state import COMPUTE_METADATA_SCOPE_NAME

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.metric import FLOPS_WIDTHS

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler import specs

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/conftest.py· 2

Device string "cuda"

parser.addoption("--device", action="store", default="cuda")

template:5

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Triton dependency

from triton._internal_testing import _fresh_knobs_impl

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/helper_kernels.py· 2

Triton dependency

import triton.language as tl

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton

template:2

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/helper.py· 4

Triton dependency

import triton.profiler as proton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

a = torch.zeros(1, device="cuda")

template:10

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((32, 32), device="cuda", dtype=torch.float16)

template:20

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((32, 32), device="cuda", dtype=torch.float16)

template:21

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/test/override_helper.py· 3

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/reproducers/cupti_graph_replay_heap_growth.py· 15

Triton dependency

import triton

template:697

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:698

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:699

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.testing import cuda_graph_without_gc

template:700

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

torch.cuda.set_device(args.device)

template:702

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream(device=device)

template:704

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:705

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:730

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.empty_cache()

template:731

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.reset_peak_memory_stats(device)

template:732

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:734

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:738

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

selected_cupti_dir = blackwell_dir if target.backend == "cuda" and target.arch >= 100 else generic_dir

template:749

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:814

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:860

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

third_party/proton/test/test_api.py· 6

Triton dependency

import triton.profiler as proton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.hooks.hook import HookManager

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.hooks.launch import LaunchHook

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.hooks.instrumentation import InstrumentationHook

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.metric import transform_tensor_metrics

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/test_instrumentation.py· 42

Triton dependency

import triton

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler.language as pl

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.blackwell import clc

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import mbarrier

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import (

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.tools.tensor_descriptor import TensorDescriptor

template:25

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.tensor([2], device="cuda", dtype=torch.float32)

template:72

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:125

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:126

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:237

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:238

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:294

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:295

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:362

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:363

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:408

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:409

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:491

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:492

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16).to(torch.float8_e4m3fn)

template:598

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16).to(torch.float8_e4m3fn)

template:599

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.ones((1024, ), device="cuda", dtype=torch.float32)

template:637

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:684

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:685

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.zeros(BLOCK_SIZE, device="cuda", dtype=torch.float32)

template:724

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:798

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:799

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:861

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:862

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.rand(size, device="cuda")

template:920

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand(size, device="cuda")

template:921

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

@pytest.mark.skipif(not is_cuda() or torch.cuda.get_device_capability(0)[0] < 10, reason="Requires Blackwell")

template:957

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

num_tiles = torch.cuda.get_device_properties(0).multi_processor_count * 8

template:996

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

x = torch.rand((n_elements, ), device="cuda", dtype=torch.float32)

template:999

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

y = torch.rand((n_elements, ), device="cuda", dtype=torch.float32)

template:1000

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

if num_ctas == 2 and (not is_cuda() or torch.cuda.get_device_capability(0)[0] not in (9, 10)):

template:1046

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

return torch.empty(size, dtype=torch.int8, device="cuda")

template:1073

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

inp = torch.randn((M, N), device="cuda", dtype=torch.float32)

template:1080

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/test/test_lib.py· 3

Triton dependency

import triton._C.libproton.proton as libproton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.profile import _select_backend

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

selected_profiler = libproton.select_profiler_from_triton_backend("cuda")

template:101

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/test/test_profile.py· 70

Triton dependency

import triton

template:7

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:15

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler.hooks.launch as proton_launch

template:16

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.state import COMPUTE_METADATA_SCOPE_NAME

template:17

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler.viewer as viewer

template:18

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton._internal_testing import is_hip, is_cuda, is_blackwell

template:19

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.testing import cuda_graph_without_gc

template:20

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

torch.cuda API usage

stream = torch.cuda.Stream()

template:92

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:93

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:116

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:178

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:179

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:201

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

inactive_graph = torch.cuda.CUDAGraph()

template:206

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

profiled_graph = torch.cuda.CUDAGraph()

template:210

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:218

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:223

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:247

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:248

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:262

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:303

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:304

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:328

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:372

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:373

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:389

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

capture_stream = torch.cuda.Stream()

template:439

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

side_stream = torch.cuda.Stream()

template:440

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(capture_stream)

template:441

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:518

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:520

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

graph = torch.cuda.CUDAGraph()

template:522

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start_event = torch.cuda.Event()

template:523

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.stream(side_stream):

template:528

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:537

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:1031

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1032

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

graph_foo = torch.cuda.CUDAGraph()

template:1069

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

graph_bar = torch.cuda.CUDAGraph()

template:1079

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:1257

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1258

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(torch.device(device))

template:1270

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:1286

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

streams = [torch.cuda.Stream(device=device_obj) for _ in range(2)]

template:1366

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(device_obj)

template:1370

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.stream(stream):

template:1376

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.nvtx.range_push("nvtx_range0")

template:1446

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.nvtx.range_push("nvtx_range1")

template:1447

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.nvtx.range_pop()

template:1449

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.nvtx.range_pop()

template:1450

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

graph = torch.cuda.CUDAGraph()

template:1569

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:1600

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1601

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

d = torch.arange(4, device="cuda")

template:1622

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:1633

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

stream = torch.cuda.Stream()

template:1690

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1691

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:1707

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

if torch.cuda.device_count() < 2:

template:1743

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.device(device):

template:1749

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

streams.append(torch.cuda.Stream(device=device))

template:1750

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.device(device):

template:1777

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1778

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:1782

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

with torch.cuda.device(device):

template:1789

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_stream(stream)

template:1790

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:1898

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.empty_cache()

template:1899

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

g = torch.cuda.CUDAGraph()

template:1902

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

third_party/proton/test/test_viewer.py· 2

Triton dependency

from triton.profiler.viewer import get_min_time_flops, get_min_time_bytes, read, format_frames, derive_metrics, filter_frames, parse, apply_diff_profile

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.state import COMPUTE_METADATA_SCOPE_NAME

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/test/unittest/util/trace_gen.py· 4

Triton dependency

import triton

template:1

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler.language as pl

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.hooks import InstrumentationHook

template:6

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/tutorials/dynamic-net.py· 3

Triton dependency

import triton.profiler as proton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

x = torch.linspace(-math.pi, math.pi, 2000, device="cuda")

template:51

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

model = DynamicNet().to("cuda")

template:55

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/tutorials/intra_kernel/example_dsl.py· 13

Triton dependency

import triton

template:8

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:9

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:10

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler.language as pl

template:11

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental import gluon

template:12

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon import language as gl

template:13

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.language.nvidia.hopper import (

template:14

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.experimental.gluon.nvidia.hopper import TensorDescriptor

template:22

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 9

template:31

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

return target.backend == "cuda" and torch.cuda.get_device_capability()[0] == 9

template:31

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

A = torch.randn(M, K, device="cuda", dtype=torch.float16)

template:293

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

B = torch.randn(K, N, device="cuda", dtype=torch.float16)

template:294

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

C = torch.empty(M, N, device="cuda", dtype=torch.float16)

template:295

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/proton/tutorials/intra_kernel/example_override.py· 4

Triton dependency

import triton

template:35

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:36

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:37

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

from triton.profiler.mode import Default

template:38

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

third_party/proton/tutorials/matmul.py· 5

Triton dependency

import triton

template:3

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.language as tl

template:4

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Triton dependency

import triton.profiler as proton

template:5

OpenAI Triton has an AMD backend. Kernels usually run on ROCm with a matching Triton build; occasional tuning is needed.

RecommendInstall the ROCm-enabled Triton build.

Device string "cuda"

a = torch.randn((M, K), device="cuda", dtype=torch.float16)

template:262

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

b = torch.randn((K, N), device="cuda", dtype=torch.float16)

template:263

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/bench/bench_matmul_metadata.py· 7

torch.cuda API usage

torch.cuda.synchronize(device)

template:77

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start_event = torch.cuda.Event(enable_timing=True)

template:79

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

end_event = torch.cuda.Event(enable_timing=True)

template:80

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(device)

template:87

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(device)

template:108

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.set_device(args.device)

template:139

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = torch.device("cuda", args.device)

template:140

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/bench/bench_reduce.py· 6

Device string "cuda"

x = torch.randn((k, s0, s1), device="cuda", dtype=torch.float32)

template:19

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize()

template:23

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

start = torch.cuda.Event(enable_timing=True)

template:26

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

end = torch.cuda.Event(enable_timing=True)

template:27

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize()

template:33

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

cache_killer = torch.empty(n_elements, device="cuda", dtype=torch.float32)

template:56

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_matmul_details/test_opt_flags_split_k.py· 1

Device string "cuda"

fake_target = types.SimpleNamespace(backend="cuda", arch=100)

template:76

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_matmul_metadata.py· 6

torch.cuda API usage

@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required")

template:49

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = torch.device("cuda")

template:59

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize(device)

template:104

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required")

template:117

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

device = torch.device("cuda")

template:119

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

torch.cuda.synchronize(device)

template:142

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

python/triton_kernels/tests/test_tensor_details/test_layout_blackwell.py· 7

Device string "cuda"

x = torch.randint(0, 256, shape, dtype=torch.uint8, device="cuda")

template:80

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randint(0, 256, (2, 16, 1024), dtype=torch.uint8, device="cuda")[..., ::2]

template:88

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(shape, device="cuda", dtype=torch.float32)

template:107

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(shape, device="cuda", dtype=torch.float32)

template:116

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn(shape, device="cuda", dtype=torch.float32)

template:127

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

slice_sizes = torch.tensor(slice_sizes, device="cuda", dtype=torch.int32)

template:143

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

x = torch.randn((m, k), device="cuda", dtype=torch.float32)

template:146

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_tensor_details/test_layout_cdna4.py· 1

Device string "cuda"

x = torch.randint(0, 256, shape, dtype=torch.uint8, device="cuda")

template:34

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/tests/test_tensor_details/test_layout_gfx1250.py· 1

.cuda() tensor/module move

x = torch.randint(0, 256, shape, dtype=torch.uint8).cuda()

template:34

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

RecommendNo change required on ROCm PyTorch.

python/triton_kernels/triton_kernels/testing.py· 2

torch.cuda API usage

torch.cuda.empty_cache()

template:113

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

def make_slice_sizes(n_slices, total_size, device="cuda"):

template:241

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

python/triton/experimental/gsan/symmetric_memory.py· 11

Device string "cuda"

dev = torch.device("cuda", torch.cuda.current_device())

template:60

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

dev = torch.device("cuda", torch.cuda.current_device())

template:60

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if dev.type != "cuda":

template:63

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

device_index = torch.cuda.current_device() if dev.index is None else dev.index

template:65

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

dev = torch.device("cuda", device_index)

template:66

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

torch.cuda API usage

with torch.cuda.use_mem_pool(_get_mem_pool()):

template:68

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

device_ranks={torch.cuda.current_device(): dist.get_rank(process_group)},

template:83

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(self._device_index)

template:219

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

torch.cuda API usage

torch.cuda.synchronize(self._device_index)

template:222

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

RecommendNo change required. Install the ROCm build of PyTorch (pip install torch --index-url https://download.pytorch.org/whl/rocm6.1).

Device string "cuda"

if tensor.device.type != "cuda":

template:302

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

Device string "cuda"

if meta["device_type"] != "cuda":

template:383

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.

third_party/amd/python/test/conftest.py· 1

Device string "cuda"

parser.addoption("--device", action="store", default="cuda")

template:5

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

RecommendNo change required on ROCm PyTorch.