pytorch/examples

torch.cuda.set_device is compatible with ROCm through PyTorch's HIP compatibility layer — the cuda namespace is aliased to hip at runtime, so this call works as-is on AMD Instinct GPUs. No source change is strictly required for functional correctness. If full namespace portability is desired, a conditional or device-agnostic wrapper could be introduced, but it is not necessary for standard PyTorch ROCm stacks.

PyTorch on ROCm provides a compatibility layer that maps torch.cuda APIs to HIP devices, so this code will typically run unmodified. No direct source change is strictly required for ROCm, though device visibility can also be managed via the HIP_VISIBLE_DEVICES or CUDA_VISIBLE_DEVICES environment variables.

torch.cuda.device_count() works as-is on ROCm because PyTorch's HIP layer exposes the torch.cuda namespace as a compatibility shim, so no functional change is required. However, for cross-vendor portability you may prefer a device-agnostic guard so the code degrades gracefully on non-CUDA/HIP builds.

torch.cuda.set_device is supported on ROCm via PyTorch's CUDA-compatibility namespace, which maps to hipSetDevice under the hood, so this line will function as-is. No source change is required for correctness, though the call remains semantically tied to the CUDA namespace rather than a device-agnostic alternative.

PyTorch's ROCm build provides a drop-in compatibility layer for the torch.cuda namespace, so torch.cuda.set_device works natively on AMD Instinct GPUs without code changes. Device visibility should instead be managed via the HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES environment variables.

PyTorch's ROCm backend transparently maps the torch.cuda namespace to HIP, so torch.cuda.current_device() functions correctly without modification. While strict device-agnostic code might use torch.device('cuda') directly for FSDP initialization, this specific API call does not block ROCm migration.

PyTorch's ROCm implementation aliases the torch.cuda module to HIP, meaning torch.cuda.memory_allocated() works out-of-the-box on AMD Instinct GPUs without requiring manual intervention. This allows existing CUDA-based memory tracking logic to remain intact during migration. No code changes are necessary for this specific API call.

torch.cuda.memoryreserved() is CUDA-specific; on ROCm, the equivalent is torch.amd.memoryreserved(). PyTorch ROCm builds do alias torch.cuda for compatibility, but switching to torch.amd makes the ROCm dependency explicit and avoids confusion in mixed environments.

torch.cuda.isbf16supported() is generally functional under ROCm because PyTorch aliases torch.cuda to the HIP runtime, but it is not guaranteed to reflect AMD Instinct capabilities correctly in all versions. For portability and clarity, guard the check with torch.version.hip or use a device-agnostic capability check.

The .cuda() calls hardcode the CUDA backend and reduce portability across ROCm/HIP environments. While PyTorch+ROCm maps .cuda() to HIP at runtime, the recommended migration is to use a configurable device (e.g., torch.device from an env/config) so the code is backend-agnostic and testable on AMD Instinct GPUs.

The .cuda() call hardcodes the CUDA backend and should be replaced with a configurable device reference so the same code path works on AMD Instinct GPUs under ROCm. In PyTorch ROCm builds, the literal string "cuda" still maps to HIP devices, but parameterizing the device avoids backend-specific assumptions and improves portability.

The .cuda() call hardcodes an NVIDIA-specific device and should be replaced with a device-agnostic pattern. On ROCm, PyTorch maps .cuda() to HIP internally, but best practice is to use a configurable device string so the code is portable across CUDA and ROCm backends.

The .cuda() call hardcodes the device to CUDA and should be replaced with a device-agnostic pattern for ROCm portability. On AMD Instinct GPUs, PyTorch ROCm builds map .cuda() to HIP internally, but using .to(device) with a configurable device variable is the recommended migration approach.

The .cuda() call hardcodes an NVIDIA device, preventing portability to AMD Instinct GPUs. Replace it with a device-agnostic pattern (e.g., a device variable or self.states.to(self.device)) so the same code path works on ROCm. This is a Bucket A item: low-risk, mechanical replacement.

The .cuda() call hardcodes the CUDA backend and will fail or behave unexpectedly on AMD Instinct GPUs under ROCm. Migrate to a device-agnostic pattern using a configurable device variable so the same code path works on both CUDA and ROCm runtimes.

The .cuda() call hardcodes the CUDA device and will break or behave unexpectedly on ROCm unless the HIP compatibility layer is active. Best practice is to use a device-agnostic pattern such as .to(device) where device is resolved at runtime, making the code portable across CUDA and ROCm backends.

PyTorch on ROCm maps "cuda:0" to the first AMD Instinct device, so this may work as-is, but hardcoding the string reduces portability across CUDA and ROCm environments. Advisory: replace with a configurable device string (e.g., derived from torch.cuda.is_available() or an env var) so the code is backend-agnostic.

The hardcoded device string "cuda:1" should be reviewed for ROCm migration. On PyTorch ROCm builds, "cuda" device strings are typically remapped to HIP internally, so this may work as-is, but for explicit clarity and portability it is advisable to use a ROCm-aware device string.

PyTorch on ROCm still reports device.type as 'cuda' because HIP reuses the CUDA namespace, so this check will functionally work on AMD Instinct GPUs without modification. However, for code clarity and future portability across CUDA and ROCm backends, an explicit comment or a portable helper is advisable.

On ROCm, PyTorch's HIP backend typically still reports device.type as 'cuda' due to namespace compatibility, so this check may work as-is. However, for explicit ROCm portability and clarity, the check should also handle 'hip' device type or use a union check to avoid silent failures if the device string changes.

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

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

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

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

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

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

.cuda() on tensors and modules is honoured by ROCm PyTorch and moves data to the AMD GPU. No change needed.

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

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

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

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

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

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

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

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