# ROCm documentation > Note: ROCm documentation is split across multiple projects. In addition to this file, each project publishes its own `llms.txt` and `llms-full.txt` under `https:///projects//en/latest/`. ## Docs - [Release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html) - [Transition guide](https://rocm.docs.amd.com/en/latest/about/transition-guide-TheRock.html) - [What is ROCm?](https://rocm.docs.amd.com/en/latest/about/what-is-rocm.html): Learn what ROCm is – AMD open software stack for GPU programming, including runtimes, compilers, libraries, and tools for Linux and Windows. - [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) - [Install ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html): How to install AMD ROCm for Instinct GPUs, Radeon GPUs, and Ryzen AI APUs - [Prerequisites](https://rocm.docs.amd.com/en/latest/install/redirect/_prerequisites.html) - [Installation](https://rocm.docs.amd.com/en/latest/install/redirect/_install.html) - [Post-installation](https://rocm.docs.amd.com/en/latest/install/redirect/_post-install.html) - [Uninstalling](https://rocm.docs.amd.com/en/latest/install/redirect/_uninstall.html) - [ROCm Runfile Installer](https://rocm.docs.amd.com/en/latest/install/rocm-runfile-installer.html): How to use the ROCm Runfile Installer - [Build ROCm from source](https://rocm.docs.amd.com/en/latest/install/build-from-source.html): Learn how to build the ROCm Core SDK from source using TheRock. Includes references to environment setup guides for Ubuntu 24.04 and Windows 11, plus links to official instructions and compatibility guidance. - [Install ROCm packages using Spack](https://rocm.docs.amd.com/en/latest/install/spack.html): How to use Spack to install ROCm. - [Install ROCm with ASAN](https://rocm.docs.amd.com/en/latest/install/asan.html): How to install AMD ROCm with AddressSanitizer (ASAN) instrumentation for AMD Instinct GPUs - [Docker containers](https://rocm.docs.amd.com/en/latest/install/docker-containers.html): Running ROCm workloads in Docker containers on AMD GPUs - [Install AI frameworks](https://rocm.docs.amd.com/en/latest/ai-ecosystem.html) - [PyTorch](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html) - [JAX](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/jax/install.html) - [vLLM](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/vllm.html) - [SGLang](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/sglang.html) - [ROCm Core SDK](https://rocm.docs.amd.com/en/latest/components/core.html): AMD ROCm Core SDK - list of libraries and tools - [Math and compute libraries](https://rocm.docs.amd.com/en/latest/components/math-and-compute-libs.html): AMD ROCm math and compute libraries for GPU-accelerated linear algebra, FFTs, random number generation, and deep learning. - [Composable Kernel](https://rocm.docs.amd.com/projects/composable_kernel/en/latest) - [hipBLAS](https://rocm.docs.amd.com/projects/hipBLAS/en/latest) - [hipBLASLt](https://rocm.docs.amd.com/projects/hipBLASLt/en/latest) - [hipCUB](https://rocm.docs.amd.com/projects/hipCUB/en/latest) - [hipFFT](https://rocm.docs.amd.com/projects/hipFFT/en/latest) - [hipRAND](https://rocm.docs.amd.com/projects/hipRAND/en/latest) - [hipSOLVER](https://rocm.docs.amd.com/projects/hipSOLVER/en/latest) - [hipSPARSE](https://rocm.docs.amd.com/projects/hipSPARSE/en/latest) - [hipSPARSELt](https://rocm.docs.amd.com/projects/hipSPARSELt/en/latest) - [libhipcxx](https://rocm.docs.amd.com/projects/libhipcxx/en/latest/index.html) - [MIOpen](https://rocm.docs.amd.com/projects/MIOpen/en/latest) - [rocBLAS](https://rocm.docs.amd.com/projects/rocBLAS/en/latest) - [rocFFT](https://rocm.docs.amd.com/projects/rocFFT/en/latest) - [rocPRIM](https://rocm.docs.amd.com/projects/rocPRIM/en/latest) - [rocRAND](https://rocm.docs.amd.com/projects/rocRAND/en/latest) - [rocSOLVER](https://rocm.docs.amd.com/projects/rocSOLVER/en/latest) - [rocSPARSE](https://rocm.docs.amd.com/projects/rocSPARSE/en/latest) - [rocThrust](https://rocm.docs.amd.com/projects/rocThrust/en/latest) - [rocWMMA](https://rocm.docs.amd.com/projects/rocWMMA/en/latest) - [Communication libraries](https://rocm.docs.amd.com/en/latest/components/communication-libs.html): AMD ROCm communication libraries for multi-GPU and multi-node collective and peer-to-peer communication. - [RCCL](https://rocm.docs.amd.com/projects/rccl/en/latest) - [rocSHMEM](https://rocm.docs.amd.com/projects/rocSHMEM/en/latest) - [Media and vision libraries](https://rocm.docs.amd.com/en/latest/components/media-libs.html): AMD ROCm media libraries for GPU-accelerated video decoding and image processing. - [rocDecode](https://rocm.docs.amd.com/projects/rocDecode/en/latest) - [rocJPEG](https://rocm.docs.amd.com/projects/rocJPEG/en/latest) - [RPP](https://rocm.docs.amd.com/projects/rpp/en/latest) - [Storage libraries](https://rocm.docs.amd.com/en/latest/components/storage-libs.html): AMD ROCm storage libraries - [hipFile](https://rocm.docs.amd.com/projects/hipFile/en/latest) - [Threading libraries](https://rocm.docs.amd.com/en/latest/components/threading-libs.html): AMD ROCm threading libraries - [hipThreads](https://rocm.docs.amd.com/projects/hipThreads/en/latest) - [Runtime and compilers](https://rocm.docs.amd.com/en/latest/components/runtimes-and-compilers.html): AMD ROCm runtimes and compilers for GPU application development, including HIP, HIPIFY, and LLVM. - [HIP](https://rocm.docs.amd.com/projects/HIP/en/latest) - [HIPIFY](https://rocm.docs.amd.com/projects/HIPIFY/en/latest) - [LLVM](https://rocm.docs.amd.com/projects/llvm-project/en/latest) - [Profiling and debugging tools](https://rocm.docs.amd.com/en/latest/components/profilers-and-debuggers.html): AMD ROCm profiling and debugging tools for GPU application performance analysis and fault diagnosis. - [ROCm Compute Profiler (rocprofiler-compute)](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest) - [ROCm Systems Profiler (rocprofiler-systems)](https://rocm.docs.amd.com/projects/rocprofiler-systems/en/latest) - [ROCprofiler-SDK](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/latest) - [ROCdbgapi](https://rocm.docs.amd.com/projects/ROCdbgapi/en/latest) - [ROCm Debugger (ROCgdb)](https://rocm.docs.amd.com/projects/ROCgdb/en/latest) - [ROCR Debug Agent](https://rocm.docs.amd.com/projects/rocr_debug_agent/en/latest) - [Control and monitoring tools](https://rocm.docs.amd.com/en/latest/components/control-and-monitoring-tools.html): AMD ROCm control and monitoring tools for inspecting and managing AMD GPU hardware state. - [AMD SMI](https://rocm.docs.amd.com/projects/amdsmi/en/latest) - [ROCm Data Center Tool (RDC)](https://rocm.docs.amd.com/projects/rdc/en/latest) - [rocminfo](https://rocm.docs.amd.com/projects/rocminfo/en/latest) - [ROCm HPC SDK](https://rocm.docs.amd.com/en/latest/components/hpc-sdk/index.html): Learn how to use AMD ROCm for high-performance computing (HPC). - [Install HPC SDK](https://rocm.docs.amd.com/en/latest/components/hpc-sdk/install.html): Install ROCm to run high-performance computing (HPC) workloads. - [ROCm Extras](https://rocm.docs.amd.com/en/latest/components/extras.html): AMD ROCm Extras - list of tools and test suites - [ROCm Validation Suite (RVS)](https://rocm.docs.amd.com/projects/ROCmValidationSuite/en/latest/index.html) - [TransferBench](https://rocm.docs.amd.com/projects/TransferBench/en/latest/index.html) - [ROCm Optiq](https://rocm.docs.amd.com/projects/roc-optiq/en/latest/index.html) - [AI Developer Hub](https://rocm.docs.amd.com/projects/ai-developer-hub/en/latest/) - [ROCm examples](https://github.com/ROCm/rocm-examples/tree/release/therock-10.0) - [AMD GPU specifications](https://rocm.docs.amd.com/en/latest/reference/gpu-specs.html): AMD Instinct™ GPU, AMD Radeon PRO™, and AMD Radeon™ GPU architecture information - [AMD GPU architectures](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/index.html) - [MI350 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350.html): Learn about the AMD Instinct MI350 Series microarchitecture based on AMD CDNA4. - [CDNA4 ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/amd-instinct-cdna4-instruction-set-architecture.pdf) - [CDNA4 white paper](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/white-papers/amd-cdna-4-architecture-whitepaper.pdf) - [Instinct MI350 Series performance counters](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350-performance-counters.html): MI355 Series performance counters and metrics - [MI300 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300.html): Learn about the AMD Instinct MI300 Series architecture. - [CDNA3 ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/amd-instinct-mi300-cdna3-instruction-set-architecture.pdf) - [CDNA3 white paper](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/white-papers/amd-cdna-3-white-paper.pdf) - [Instinct MI300 and MI200 Series performance counters](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300-mi200-performance-counters.html): MI300 and MI200 Series performance counters and metrics - [MI250 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi250.html): Learn about the AMD Instinct MI250 Series architecture. - [CDNA2 ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/instinct-mi200-cdna2-instruction-set-architecture.pdf) - [CDNA2 white paper](https://www.amd.com/content/dam/amd/en/documents/instinct-business-docs/white-papers/amd-cdna2-white-paper.pdf) - [MI100 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi100.html): Learn about the AMD Instinct MI100 Series architecture. - [CDNA1 ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/instinct-mi100-cdna1-shader-instruction-set-architecture.pdf) - [CDNA1 white paper](https://www.amd.com/content/dam/amd/en/documents/instinct-business-docs/white-papers/amd-cdna-white-paper.pdf) - [RDNA architecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/rdna.html): Overview of AMD RDNA architecture documentation and ISA references for Radeon and Ryzen GPUs. - [RDNA 4 ISA reference](https://gpuopen.com/download/rdna4-instruction-set-architecture.pdf) - [RDNA 3.5 ISA reference](https://gpuopen.com/download/rdna35_instruction_set_architecture.pdf) - [RDNA 3 ISA reference](https://gpuopen.com/download/rdna3-shader-instruction-set-architecture-feb-2023.pdf) - [RDNA 2 ISA reference](https://gpuopen.com/download/rdna2-shader-instruction-set-architecture.pdf) - [RDNA ISA reference](https://gpuopen.com/download/RDNA_Shader_ISA_25September2020.pdf) - [GCN and Vega architectures](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/gcn-vega.html): ISA references for AMD GCN and Vega GPU architectures. - [Vega 7nm (Instinct MI50) ISA reference](https://www.amd.com/system/files/TechDocs/vega-7nm-shader-instruction-set-architecture.pdf) - [Vega (Instinct MI25) ISA reference](https://www.amd.com/system/files/TechDocs/vega-shader-instruction-set-architecture.pdf) - [GCN 3 ISA reference](https://www.amd.com/system/files/TechDocs/gcn3-instruction-set-architecture.pdf) - [AMD GPU system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/index.html): Learn about AMD hardware optimization for HPC-specific and workstation workloads. - [AMD Instinct GPUs](https://rocm.docs.amd.com/en/latest/reference/system-optimization/cdna.html): System optimization guides for AMD Instinct CDNA GPUs. - [AMD MI355X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi355x.html) - [AMD MI350X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi350x.html) - [AMD MI325X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi325x.html) - [AMD MI300X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi300x.html) - [AMD MI300A](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi300a.html) - [AMD MI250 / MI250X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi250.html) - [AMD MI210](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi210.html) - [AMD MI100](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi100.html) - [AMD Radeon and Ryzen GPUs](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna.html): System optimization guides for AMD Radeon and Ryzen RDNA GPUs. - [RDNA3.5](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna3-5.html): System optimization of AMD RDNA3.5 Ryzen APUs (gfx1150/gfx1151/gfx1152) systems. Learn about VRAM, GTT, TTM tuning, shared memory configuration, and required Linux kernel support. - [RDNA2](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna2.html): Learn about system settings and performance tuning for RDNA2-based GPUs. - [Common system settings](https://rocm.docs.amd.com/en/latest/reference/system-optimization/common.html): Common system settings for AMD GPUs including GPU isolation and BAR access configuration. - [GPU isolation techniques](https://rocm.docs.amd.com/en/latest/reference/system-optimization/gpu-isolation.html) - [BAR access limits](https://rocm.docs.amd.com/en/latest/reference/system-optimization/bar-access-limits.html): Learn about BAR configuration in AMD GPUs and ways to troubleshoot physical addressing limit - [AMD GPU and ROCm components data types and precision support](https://rocm.docs.amd.com/en/latest/reference/precision-support.html): Supported data types of AMD GPUs and libraries in ROCm. - [ROCm libraries graph-safe support](https://rocm.docs.amd.com/en/latest/reference/graph-safe-support.html): This page lists supported graph safe ROCm libraries. - [AMD GPU atomics operation support](https://rocm.docs.amd.com/en/latest/reference/gpu-atomics-operation.html): AMD Instinct GPU, AMD Radeon PRO, and AMD Radeon GPU atomics operations information - [ROCm environment variables](https://rocm.docs.amd.com/en/latest/reference/environment-variables/index.html): Environment variables reference - [Set the number of CUs](https://rocm.docs.amd.com/en/latest/reference/environment-variables/setting-cus.html): Setting the number of CUs - [AMD GPU programming on ROCm](https://rocm.docs.amd.com/en/latest/reference/hip-programming.html): HIP programming - [Contributing to the ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html) - [ROCm documentation toolchain](https://rocm.docs.amd.com/en/latest/contribute/toolchain.html) - [Building documentation](https://rocm.docs.amd.com/en/latest/contribute/building.html) - [Providing feedback about the ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/feedback.html) - [ROCm licenses](https://rocm.docs.amd.com/en/latest/about/license.html) --- Source: https://rocm.docs.amd.com/en/latest/index.html # AMD ROCm ROCm is AMD’s open-source GPU computing platform: an end‑to‑end ecosystem of compilers, runtimes, and libraries for AI, HPC, and domain‑specific workloads. It is open source, cross‑platform (Linux and Windows), and optimized for AMD Instinct™, AMD Radeon™, and AMD Ryzen™ AI devices. The foundational libraries, runtimes, and tools for GPU computing on AMD hardware — math and compute libraries, communication primitives, HIP runtime, profiling and debugging tools, and more. - [Install the ROCm Core SDK](https://rocm.docs.amd.com/en/latest/install/rocm.html) - [ROCm 10.1.0 compatibility](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) [Go to Core SDK docs](https://rocm.docs.amd.com/en/latest/about/release-notes.html) Full-stack documentation and recipes to deploy AI workloads on AMD GPUs using popular ROCm-enabled frameworks. - Deep learning frameworks - [PyTorch](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html) - [JAX](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/jax/install.html) - Inference - [vLLM](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/vllm.html) - [SGLang](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/sglang.html) [Go to AI Ecosystem docs](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/index.html) Deployment and operations guidance for AMD Instinct GPUs at scale, including AMD GPU Driver installation, cluster management, GPU partitioning, monitoring, virtualization, cloud deployments, and containers. - [AMD GPU Driver (amdgpu)](https://instinct.docs.amd.com/projects/amdgpu-docs/en/latest/) - [Network Operator (Kubernetes)](https://instinct.docs.amd.com/projects/network-operator/en/latest/overview.html) [Go to GPU Systems docs](https://instinct.docs.amd.com) Open-source collections of ROCm-accelerated libraries for building high-performance domain-specific applications. - [ROCm Data Science](https://rocm.docs.amd.com/projects/rocm-ds/en/latest/index.html) - [ROCm Finance](https://rocm.docs.amd.com/projects/rocm-finance/en/latest/index.html) - [ROCm Life Science](https://rocm.docs.amd.com/projects/rocm-ls/en/latest/index.html) - [ROCm LLMExt](https://rocm.docs.amd.com/projects/rocm-llmext/en/latest/index.html) - [ROCm Simulation](https://rocm.docs.amd.com/projects/rocm-simulation/en/latest/index.html) --- Source: https://rocm.docs.amd.com/en/latest/about/release-notes.html # ROCm Core SDK 10.1.0 release notes These release notes describe notable changes since the previous ROCm release. - [Release highlights]() - [AMD hardware support]() - [Operating system support]() - [Installation updates]() - [Kernel driver and firmware bundle support]() - [GPU virtualization support]() - [GPU partitioning support]() - [AI ecosystem support]() - [ROCm Core SDK components]() - [ROCm breaking changes]() - [ROCm known issues]() - [ROCm resolved issues]() #### NOTE Since ROCm 7.14, ROCm uses [TheRock](https://github.com/ROCm/TheRock) as its build and release system. For more information, see the [transition guide](https://rocm.docs.amd.com/en/latest/about/transition-guide-TheRock.html). ## Release highlights This release focuses on AI inference, developer tooling, and profiling across AMD Instinct™, Radeon™, and Ryzen™ AI platforms. Highlights include expanded GPU, OS, and virtualization support, new AI framework versions, the addition of new components, new HIP APIs and performance improvements, profiler usability and performance improvements, and updates to math, sparse, and storage libraries. ### Platform and hardware support This release expands GPU, operating system, and virtualization support. #### Expanded AMD GPU support ROCm 10.1.0 adds support for [AMD Radeon AI PRO R9600](https://www.amd.com/en/products/graphics/workstations/radeon-ai-pro/ai-9000-series/amd-radeon-ai-pro-r9600.html) GPUs. For the complete list of supported AMD hardware, see [AMD hardware support](). #### Operating system support update ROCm 10.1.0 adds support for: * Ubuntu 26.04.1 (kernel: 7.0 [GA]) for AMD Instinct, Radeon, and Ryzen GPUs. * Ubuntu 24.04.5: * kernel: 6.8 [GA] for AMD Instinct GPUs. * kernel: 7.0 [HWE] for AMD Radeon and Ryzen GPUs. The updated support replaces the support for Ubuntu 26.04 and Ubuntu 24.04.4 respectively. For the full list of supported Linux distributions, see [Operating system support](). #### Expanded GPU virtualization support for Instinct and Radeon GPUs ROCm 10.1.0 adds support for the following virtualization configurations on AMD Instinct and Radeon GPUs: **Instinct** * On AMD Instinct MI355X and MI350X: * KVM SR-IOV Ubuntu 26.04 host OS with Ubuntu 26.04 guest OS. * On AMD Instinct MI350P: * ESXi SR-IOV VMware ESXi 9.1 host OS and Ubuntu 24.04 guest OS. * On AMD Instinct MI325X: * KVM SR-IOV Ubuntu 26.04 host OS with Ubuntu 26.04 guest OS. * KVM SR-IOV RHEL 9.4 host OS with Ubuntu 24.04 and RHEL 9.4 guest OS. * On AMD Instinct MI300X: * KVM SR-IOV Ubuntu 26.04 host OS with Ubuntu 26.04 guest OS. * On AMD Instinct MI210: * KVM SR-IOV Ubuntu 26.04 host OS with Ubuntu 26.04 guest OS. **Radeon** * On AMD Radeon PRO V710: * KVM SR-IOV Ubuntu 26.04 host OS with Ubuntu 26.04, Ubuntu 24.04, RHEL 10.2, and RHEL 9.6 guest OS. * KVM SR-IOV Ubuntu 24.04 host OS with RHEL 10.2 guest OS. Supported Single Root I/O Virtualization (SR-IOV) configurations require the [AMD GPU Virtualization Driver (GIM) 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K). For details, see [GPU virtualization support](). #### GPU partitioning support update GPU partitioning support remains unchanged in this release. For details, see [GPU partitioning support](). ### AI inference and frameworks This release enables support for the following frameworks: * PyTorch 2.14.0 * JAX 0.11.1 * vLLM 0.29.0 * SGLang 0.5.18 * MIGraphX 2.18 The updated framework support replaces the previous PyTorch 2.11.0, JAX 0.10.0, vLLM 0.27.0, SGLang 0.5.15, and MIGraphX 2.17 support. This release drops support for TensorFlow 2.19.1. For details, see [AI ecosystem support](). ### Runtime and compilers #### HIP feature highlights The following are notable enhancements to HIP: ##### HIP supports hipExtHostRegisterCoarseGrained on Windows HIP now honors the `hipExtHostRegisterCoarseGrained` flag passed to `hipHostRegister` on Windows for APUs with unified memory, giving device kernels correct results for atomic operations on host-pinned memory. Previously, host-registered memory on Windows was always treated as coarse-grain regardless of the flag; fine-grain (uncached) is now the correct default, with coarse-grain available only when explicitly requested. ##### HIP adds host-NUMA virtual memory support HIP virtual memory management APIs now support `hipMemLocationTypeHostNuma` and `hipMemLocationTypeHostNumaCurrent` in `hipMemCreate`, allocating pinned memory backed by real host memory on a specified NUMA node instead of a GPU-pool substitute. This benefits NUMA-aware workloads, including collective-communication libraries such as RCCL, that need pinned host memory to stay local to a specific NUMA node. The full VMM lifecycle (create, reserve, map, set access, and teardown) is supported for these allocations on Linux systems with NUMA-capable, VMM-capable GPUs. ##### ROCr Runtime extends virtual memory management to host memory ROCr Runtime virtual memory management APIs (`hsa_amd_vmem_handle_create`, `hsa_amd_vmem_map`, and `hsa_amd_vmem_set_access`) now support CPU memory pools in addition to GPU agents, enabling the full create, reserve, map, set-access, and teardown lifecycle for host-pool virtual memory handles. This includes inter-process sharing of both host-pool and device-pool handles, letting multiple processes map the same GPU-accessible host memory without falling back to workarounds like `/dev/shm`. For more information, see the [HIP section]() in the ROCm component changelogs. ### Profiling and debugging tools #### ROCgdb \_\_builtin_verbose_trap improvement ROCgdb now automatically presents the diagnostic inline frame generated by Clang’s `__builtin_verbose_trap` in backtraces, for both AMD64 and AMDGPU targets. Previously, after the trap fired, the reported frame sat outside that inline frame, hiding the category and message strings the built-in carried. Recovering them required manually rewinding the program counter. Backtraces following a verbose trap now show `__clang_trap_msg$$` as frame #0 automatically. #### ROCprofiler-SDK feature highlights The following are notable enhancements to ROCprofiler-SDK: ##### Kernel replay feature (Beta) ROCprofiler-SDK introduces kernel replay, which re-executes each individual dispatch once per counter group within a single application run. Before replaying, the SDK snapshots every tracked coarse-grained device allocation owned by the dispatching agent, plus discovered module-scope device variables, and restores that snapshot between passes so every group observes identical captured inputs. GPU hardware limits how many performance counters can be collected in a single kernel execution. Previously, application replay worked around this by re-launching the entire application once per counter group, multiplying startup overhead and producing metrics derived from non-simultaneous samples. With kernel replay, the SDK snapshots tracked device allocations and module-scope variables before each replay and restores them between passes, so every group sees identical inputs. Dispatches that require no replay opt out at no cost. Kernel replay is exposed as its own callback tracing domain (`ROCPROFILER_CALLBACK_TRACING_KERNEL_REPLAY`) and is available to custom ROCprofiler-SDK tools without going through `rocprofv3`. In `rocprofv3`, use `--replay-mode kernel` with the `--kernel-replay-beta-enabled` opt-in flag: ```bash rocprofv3 --pmc SQ_WAVES GRBM_COUNT --pmc GRBM_GUI_ACTIVE --replay-mode kernel --kernel-replay-beta-enabled -- ``` #### NOTE * **Known limitations:** `--replay-mode kernel` requires `--pmc` and the beta opt-in flag, and collects counters only. Cannot be combined with `--att`, PC sampling, or `--spm`, and `rocprofv3` rejects those combinations — counter groups are the only thing that changes between passes, so any other service would stay enabled across all passes and report every kernel once per pass. There is no pass-count flag so the number of passes is the number of `--pmc` groups collectable on the dispatch’s GPU agent. * **Beta Risk:** Applications whose kernels depend on state outside tracked device allocations and module-scope device variables might not replay faithfully; prefer application replay in those cases. ##### HIP event tracing ROCprofiler-SDK and `rocprofv3` add GPU-side barrier tracing for HIP events. `hipEventRecord` and `hipStreamWaitEvent` are now traced as first-class activity, making it possible to see where a stream is actually blocked waiting on an event rather than inferring it from surrounding API calls. The SDK exposes new tracing kinds `ROCPROFILER_CALLBACK_TRACING_HIP_EVENT` and `ROCPROFILER_BUFFER_TRACING_HIP_EVENT`, with the operation enum `rocprofiler_hip_event_operation_t` (`RECORD`, `WAIT`). In `rocprofv3`, HIP event tracing is enabled with the `--hip-event-trace` flag, and is automatically enabled by `--hip-trace` and `--hip-runtime-trace`. Records are emitted to the JSON and rocpd output formats; use `rocpd convert` to produce CSV or Perfetto output from the database. The rocpd schema is bumped to 3.0.4 with a new `rocpd_hip_event` table and a `hip_events` data view. ##### On-demand tool configuration and initialization ROCprofiler-SDK now supports enabling and disabling profiler tools at any point during application execution, not just at startup or within a narrow initialization window. The profilers built into AI frameworks are the primary beneficiaries. PyTorch’s Kineto backend and Triton’s Proton profiler activate mid-session, after the interpreter, HIP, HSA, and often the model itself have already initialized. Previously, late attachment was partially supported but tools could not reliably configure after another tool had already done so, and runtime interception could not be undone. Both restrictions are now lifted. Four changes enable this: * **Repeated and late configuration:** A tool can now call `rocprofiler_force_configure` after one or more other tools have already configured ROCprofiler-SDK, rather than being rejected because configuration was already complete. * **Reversible runtime interception:** All intercepted runtime domains (HIP, HSA, ROCTx/marker, RCCL, rocDecode, rocJpeg, rocSHMEM, and hipFile) now support a table restore operation, so interception can be installed, removed, and reinstalled while the application runs. * **Symbol visibility for re-propagation:** `librocprofiler-register.so` is now opened explicitly with `RTLD_GLOBAL | RTLD_NOLOAD`, and `rocprofiler_register_invoke_all_registrations` is resolved from that handle instead of the global symbol namespace. Late registration therefore works in processes where `rocprofiler-register` was loaded privately. This happens when it arrives as a dependency of a Python extension module, the typical loading path for AI framework profilers. * **Pointer-stable internal registries:** The buffer and internal task-group registries move to chunked, pointer-stable containers with pre-reserved capacity, so references held by already-configured tools remain valid when a new tool registers mid-run and grows those registries. #### NOTE **Known limitation:** During another tool’s initialization, there is a brief window where previously configured tools might not receive records from application background threads. ##### Signal handling update ROCprofiler-SDK now runs signal-triggered finalization on a dedicated worker thread instead of inside the signal handler itself, where the allocation, locking, and I/O it requires are not async-signal-safe. A second signal arriving during the flush is held until the flush completes, and the process then terminates normally. `rocprofv3` also preserves the first signal disposition the application installed, including `SIG_IGN`, so the application sees its own signal behavior as though the profiler were not present, and it re-raises the signal only after child processes are reaped. `SIGABRT` can’t be deferred, so that path waits for the flush to finish before returning into `abort()`. The wait is bounded by `ROCPROF_ABORT_FLUSH_TIMEOUT_SECONDS` (default 10 seconds; a value ≤ 0 waits indefinitely). Finalizing inside the signal handler previously caused three failure modes: * A hang when the signal interrupted a thread already holding a lock the flush needed. * Truncated output when a second signal arrived mid-flush (a chained application handler re-raising, or a second Ctrl+C). * An unkillable process that left GPU child processes running and required a manual kill. Re-raising before reaping also previously deadlocked multi-process applications, such as tensor-parallel inference servers whose workers exit only when told to by the main process. Opting out: Applications that coordinate their own shutdown can disable the handlers entirely with `disable-signal-handlers` and rely on the normal `atexit` path instead. ##### Dynamic live attach improvements `rocprofv3` attach (`rocattach`) is now more robust in deployments where the host and target don’t share an identical view of the filesystem: * Falls back to GNU Build ID validation when device and inode don’t match, so a library that’s the same build but reached through a different mount or path is still recognized. * Recognizes SONAMEs and equivalent library paths instead of requiring an exact path match. * No longer propagates the host’s `rocprofiler-register` library path into the target process, which previously pointed the target at a library that might not exist or match on its side. Combined with the container-aware symbol resolution delivered in ROCm 10.0.0, these changes let host-to-container and mismatched-path attach work without manually copying `.so` files into the target environment. ##### PC sampling improvements ROCprofiler-SDK has the following enhancements to the PC sampling feature: * The PC sampling buffer size is increased on AMD Instinct MI300 and MI350 Series GPUs, reducing sample loss on high-rate sampling runs. * Fixed microsecond sampling intervals being incorrectly clamped by the cycle-interval clamp, so microsecond-denominated intervals are now honored as specified. * Corrected the set of valid stochastic sampling intervals reported to users, so `rocprofv3-avail` and the SDK no longer advertise intervals the hardware doesn’t accept. #### NOTE The larger buffer size applies only to AMD Instinct MI300 and MI350 Series GPUs. Other architectures keep the existing buffer size. ##### hipFile statistics API support ROCprofiler-SDK adds support for the hipFile statistics API, synchronizing the profiler ABI with the hipFile stats dispatch entries. This lets tools report aggregate storage I/O statistics alongside the per-call hipFile trace records already available. ##### Advanced Thread Trace (ATT) improvements ROCprofiler-SDK has the following enhancements to the ATT feature: * `rocprofv3` now honors `ROCPROF_ATT_LIBRARY_PATH` when locating the thread trace decoder library, instead of scanning from `/`. * The decoder library is resolved by its versioned SONAME (`.so.`), falling back to the unversioned name. * `rocprof-trace-decoder` gains a version query, letting tools check decoder compatibility at runtime. * Fixed gfx12 occupancy mode, and added a no-detail command-line option for lower-volume ATT collection. * The ATT completion callback now stays active after a marker-driven pause, so `roctxProfilerPause`/`roctxProfilerResume` cycles no longer drop the trailing portion of a trace. ##### Output format and rocpd improvements ROCprofiler-SDK has the following improvements for output format and `rocpd`: * Perfetto event names are now cached for static interning, reducing the cost of Perfetto output generation on large traces. * Perfetto buffer size limits are now validated up front, producing a clear error instead of a late failure when an out-of-range size is requested. * `rocpd` Python modules are backward compatible with databases produced by earlier releases. * `otf2` and `pandas` are now imported locally inside `rocpd`, so the tool no longer requires those packages for unrelated operations. * `rocpd` marker regions are now named after the ROCTx message rather than a generic label, so ROCTx ranges are identifiable in the database and in converted output. * `rocprofv3` no longer silently adds `rocpd` to an output format explicitly requested by the caller. ##### Quality and stability improvements This release includes a range of quality and stability fixes across ROCprofiler-SDK and `rocprofv3`: * **PyTorch co-existence:** A ROCprofiler-SDK bundled inside PyTorch no longer initializes alongside `rocprofv3`. Previously, two tools subscribing to code object tracing in the same process caused `rocprofv3` to crash during output generation, blocking profiling of PyTorch and Triton workloads through ROCm Compute Profiler. * **SPM race condition:** Fixed a race in the Streaming Performance Monitor collection path. * **OMPT trace abort:** Fixed the issue of `--ompt-trace` aborting the profiled application. * **Code object finalize:** `code_object::finalize()` is now serialized with the destroy mutex, closing a shutdown race. * **Host function IDs:** Host function IDs are now assigned once per symbol, eliminating duplicate identities for the same function. * **HIP API coverage:** Added tracing and stringification support for newly introduced HIP APIs, including `hipDeviceGetLuid` and `hipInitDevice`. For more information, see the [ROCprofiler-SDK section]() in the ROCm component changelogs. #### ROCm Compute Profiler feature highlights The following are notable enhancements to the ROCm Compute Profiler (rocprofiler-compute): ##### Roofline enhancement * The standalone roofline report is now a fully interactive HTML page. You can isolate a single kernel or a single roof, select several kernels at once, and switch the arithmetic intensity axis between cache levels, instead of reading one static plot where every kernel shares the same marker. * Roofline benchmarking and analysis are supported on AMD Ryzen AI APUs with Gorgon Point (gfx1153) integrated graphics. Peak values are now measured on this hardware instead of reported as N/A. For details, see [Analyzing with the CLI](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/how-to/analyze/cli.html) and [Supported accelerators](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/reference/compatible-accelerators.html). ##### PC sampling improvement * PC sampling analysis now reports results per kernel. Running `rocprof-compute analyze --output-format csv` writes each kernel’s disassembly to its own folder, with the sample and stall counts on every instruction and the source file the kernel was compiled from saved beside it. The same data is available from the analysis database. * PC sampling supports workloads that span several processes. Each process writes its own results file, so processes no longer overwrite each other, and a single analysis run reports all of them together with the owning process identified. For details, see [Using PC sampling in ROCm Compute Profiler](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/how-to/pc_sampling.html). ##### Profiling output update * Profiling always writes the `rocpd` output format, which was already the default. The CSV output backend and the `--format-rocprof-output` option have been removed. Workloads captured with the CSV backend by an earlier release must be profiled again before they can be analyzed. * Profiling artifacts are considerably smaller. Counter data is highly redundant and is now compressed as it is written. Profile mode also streams counter data to disk instead of holding it in memory, which lowers peak memory use on large workloads. For details, see [Profile mode](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/how-to/profile/mode.html). ##### Profiler documentation update Added a guide for profiling vLLM workloads, including the caveats that apply to inference servers. For details, see [Profile vLLM workloads](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/docs-10.1.0/how-to/profile/mode.html#profile-vllm-workloads). For more information, see the [ROCm Compute Profiler section]() in the ROCm component changelogs. #### ROCm Systems Profiler feature highlights The following are notable enhancements to ROCm Systems Profiler: ##### rocpd is now the default output format When no output format is specified, profiling data is emitted as a rocpd SQLite database (`rocpd.db`). Perfetto (`.proto`) output is still available and must now be explicitly enabled via `--output-format proto`. For more information, see the [ROCm Profiling Data (rocpd) output](https://rocm.docs.amd.com/projects/rocprofiler-systems/en/latest/how-to/understanding-rocprof-sys-output.html#rocm-profiling-data-rocpd-output). ##### Removed the deprecated rocprof-sys-user library and its C APIs `rocprof-sys-user` library and its C APIs (`rocprofsys_user_*`, ``) have been removed, including the `user` find_package component, the `examples/user-api example`, the Python `rocprofsys.user` submodule, and the associated pytest coverage. Use ROCTx (`rocprofiler-sdk-roctx`) for general-purpose manual instrumentation (starting and stopping tracing, named regions) instead. See [examples/roctx](https://github.com/ROCm/rocm-systems/blob/docs/10.1.0/projects/rocprofiler-systems/examples/roctx/roctx.cpp) for usage. For more information, see the [ROCm Systems Profiler section]() in the ROCm component changelogs. ### Control and monitoring tools #### AMD SMI feature highlights The following are notable changes to AMD SMI: ##### AMD SMI WSL2 support (Technical preview) AMD SMI adds a backend as a technical preview feature for reporting GPU telemetry under Windows Subsystem for Linux 2 (WSL2), extending discovery and monitoring to WSL2 environments for the first time. * **Discovery and monitoring only:** AMD SMI detects AMD GPUs and reports available telemetry, including temperature, power, memory usage, utilization, clock speeds, board, and ASIC identifiers, and driver and firmware versions, to the extent the environment exposes it. Management and configuration actions are not available, matching AMD SMI’s existing behavior on Windows. * **Some categories are unavailable under WSL2:** Because WSL2 reaches the GPU through the Windows display driver rather than native Linux DRM/sysfs, several categories are reported as unsupported rather than failing: CPU/ESMI, NIC, switch, fabric, ECC, and partition queries, along with per-process GPU usage (`amd-smi` process). * **Graceful fallback:** When a metric can’t be read, or no AMD GPU is present, AMD SMI reports it as unavailable and continues rather than crashing or hanging. * **Documented capability differences:** A published guide covers prerequisites and the full set of capabilities that differ between native Linux and WSL2. For more details, refer to [Using AMD SMI under WSL](https://rocm.docs.amd.com/projects/amdsmi/en/docs-10.1.0/how-to/amdsmi-wsl-mode.html). ### Libraries #### Component addition to ROCm Core SDK The following components have now been added to the ROCm Core SDK: ##### hipThreads GPU concurrency library added ROCm 10.1.0 introduces hipThreads to the ROCm Core SDK under the ROCm Threading libraries. hipThreads helps developers accelerate existing CPU-threaded code on GPUs without a full ROCm or CUDA rewrite. It is designed for applications with parallel CPU workloads that can benefit from GPU execution, but where the effort of moving to a full GPU programming model is not justified. By bringing familiar C++ threading concepts to GPUs, hipThreads provides a lower-friction path to incremental GPU acceleration on Linux and Windows. For more information, see the [hipThreads documentation](https://rocm.docs.amd.com/projects/hipThreads/en/docs-10.1.0/). ##### libhipcxx C++ Standard Library for HIP added ROCm 10.1.0 introduces libhipcxx to the ROCm Core SDK, joining rocPRIM, rocThrust, and hipCUB in the ROCm math and compute libraries. libhipcxx is the C++ Standard Library for HIP, bringing Standard Library features such as atomics, type traits, and containers to both host and device code, so you can use familiar C++ types directly in HIP kernels without writing your own device-side implementations. See the [libhipcxx documentation](https://rocm.docs.amd.com/projects/libhipcxx/en/docs-10.1.0/index.html) to get started. ##### RPP computer vision library added ROCm 10.1.0 introduces RPP (ROCm Performance Primitives) to the ROCm Core SDK, joining rocDecode and rocJPEG in the ROCm media and vision libraries. RPP is a high-performance computer vision library that provides GPU-accelerated 2D image and 3D image (voxel) augmentations, as well as other miscellaneous augmentations and primitives, for AI training and inference data pipelines. RPP is supported on Linux with AMD Instinct and Radeon GPUs. See the [RPP documentation](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) to get started. #### hipFFT and rocFFT feature highlights The following are notable enhancements to hipFFT and rocFFT: ##### hipFFT expands single-process multi-device support hipFFT’s single-process, multi-device plans now behave consistently across all supported backends: * **Batched transforms:** All batched transforms are supported in-place and out-of-place, across all devices. * **Unbatched multi-dimensional transforms:** In-place unbatched, multi-dimensional transforms are now supported across devices. * **Consistent data distribution:** Plans created with `hipfftMakePlan2d`, `hipfftMakePlan3d`, and `hipfftMakePlanMany` now use the same data decomposition regardless of backend, removing a source of inconsistent results for multi-device workflows. Multi-device, unbatched one-dimensional transforms are not yet supported. ##### hipFFT and rocFFT add JIT callbacks hipFFT and rocFFT now compile load/store callbacks just-in-time (JIT) into their own kernels, letting the FFT library optimize the combined callback and transform code — something the previous function-pointer callback APIs prevented. * **hipFFT:** Call `hipfftXtSetJITCallback` after `hipfftCreate` and before initializing the plan with a `MakePlan` function. This deprecates `hipfftXtSetCallback` and `hipfftXtClearCallback`, and isn’t yet compatible with multi-GPU transforms. * **rocFFT:** Configure callbacks with `rocfft_plan_description_set_load_callback` / `_store_callback` during plan creation, and supply per-execution data pointers with `rocfft_execution_info_set_load_callback_data` / `_store_callback_data`. This deprecates `rocfft_execution_info_set_load_callback` / `_store_callback`, and isn’t yet compatible with transforms that also specify fields or bricks. #### hipFile adds async fastpath, batch I/O, and stats APIs hipFile adds three capabilities for AMD Infinity Storage: * **Fastpath backend for Async I/O:** `hipFileReadAsync()` and `hipFileWriteAsync()` now support the fastpath backend, letting asynchronous storage to GPU I/O requests run on a HIP stream without host bounce-buffer copies that are relevant for frameworks like LMCache. Note that async fastpath operations do not currently retry on the fallback backend if the fastpath fails in this release. Async fastpath fallback support coming in a subsequent release. * **Batch I/O:** Batch IO API operations are now fully supported using an internal thread pool that is relevant for frameworks like NIXL. * **Stats API:** `hipFileGetStatsL1/L2/L3()` return progressively detailed I/O statistics. L1 gives basic I/O and operation counts, L2 adds I/O size histograms, L3 adds per-GPU breakdowns, giving ROCprofiler-SDK and other tools visibility into hipFile I/O behavior. #### hipSPARSE and rocSPARSE feature highlights The following are notable enhancements to hipSPARSE and rocSPARSE: ##### rocSPARSE and hipSPARSE add batched SDDMM support rocSPARSE and hipSPARSE now support batched SDDMM (sampled dense-dense matrix multiplication), computing many independent SDDMM problems in a single call instead of one at a time, reducing per-call overhead for workloads that process many small problems together. * **Broadcast modes:** Four batching patterns are supported, letting either or both dense operands (A, B) be shared across the batch or vary per batch index — configured with `hipsparseDnMatSetStridedBatch` (hipSPARSE) or `rocsparse_dnmat_set_strided_batch` (rocSPARSE). * **Format coverage:** rocSPARSE supports CSR, CSC, COO, COO AoS, and ELL formats (via `rocsparse_csr_set_strided_batch` and equivalents); hipSPARSE currently supports CSR only (via `hipsparseCsrSetStridedBatch`). ##### hipSPARSE adds generic SpGEAM API hipSPARSE now provides a generic API for sparse matrix-matrix addition, computing C = alpha × op(A) + beta × op(B) for CSR matrices on both AMD and CUDA backends, backed by the new `rocsparse_spgeam` routine on ROCm. * **New entry points:** * `hipsparseSpGEAM_createDescr` / `hipsparseSpGEAM_destroyDescr` create and destroy an operation descriptor (`hipsparseSpGEAMDescr_t`). * `hipsparseSpGEAM_bufferSize` queries the required workspace; `hipsparseSpGEAM_nnz` computes C’s row offsets and non-zero count. * `hipsparseSpGEAM` computes the final values and sorted column indices. * **Supported types:** `HIP_R_32F`, `HIP_R_64F`, `HIP_C_32F`, and `HIP_C_64F` compute types, with 32-bit and 64-bit index types (A, B, and C must share the same index type). * **Constraints and error handling:** Only CSR format and non-transpose operations are supported — transpose operations and non-CSR formats now return a well-defined error (`HIPSPARSE_STATUS_NOT_SUPPORTED`) instead of the silently-accepted-but-incorrect transpose behavior on the ROCm backend in prior releases. A zero alpha or beta collapses C’s sparsity pattern to that of the other operand; both zero produce an empty C. ##### SpMM non-zero split batching in rocSPARSE rocSPARSE SpMM now supports batched computation with the non-zero split algorithm (`rocsparse_spmm_alg_csr_nnz_split`), letting workloads that select this algorithm batch multiple independent SpMM operations into a single call instead of launching them individually. Previously, only the default row split algorithm supported batched computation. ##### rocSPARSE optimizes Level 2/3 routines for RDNA4 rocSPARSE Level 2 (SpMV) and Level 3 (SpMM) routines now use wave32-aware launch and geometry tuning on RDNA4 (gfx1201) GPUs, improving throughput with no change to numerical results and no change to wave64 (CDNA) behavior. **Tuned routines:** CSR SpMV (adaptive, nnz-split, and long-row-balanced paths), COO and ELL SpMV, BSR/BSRX SpMV, `gemvi`, `gemmi`, and blocked-ELL SpMM (`bellmm`). ##### rocSPARSE ELL format triangular solve support rocSPARSE now supports the ELL (ELLPACK) sparse matrix format in its triangular solve routines (`rocsparse_spsv` and `rocsparse_sptrsv`), joining the existing CSR and CSC support. Matrices already stored in ELL format can run triangular solve directly, without first converting to CSR or CSC. Transposed and conjugate-transposed operations are not yet supported for the ELL format. #### hipSOLVER and rocSOLVER feature highlights The following are notable enhancements to hipSOLVER and rocSOLVER: ##### hipSOLVER fixes and extends 64-bit APIs hipSOLVER adds a 64-bit-compatible `hipsolverDnXlarft` function (with a corresponding `hipsolverDnXlarft_bufferSize` buffer-size query), backed by a new `LARFT_64` routine in rocSOLVER. Separately, `hipsolverDnXpotrs` is fixed to call its 64-bit `potrs` implementation instead of silently falling back to the 32-bit routine, correcting results for calls made through the 64-bit API on large matrices. ##### rocSOLVER improves Hermitian eigensolver performance rocSOLVER now offers a 2-stage reduction to tridiagonal form for the Hermitian and symmetric eigensolvers (HEEVD/SYEVD) and their generalized counterparts (HEGVD/SYGVD), moving more of the computation to Level 3 BLAS operations. Improved performance compared to the previous SYEVD implementation was observed for large matrices (n > 11,000) on AMD Instinct MI300X GPUs. ##### rocSOLVER adds Cholesky QR factorization rocSOLVER now offers Cholesky QR (CHOLQR) as an alternative to Householder-based QR factorization (GEQRF), offering a faster path to computing the QR decomposition of a matrix. CHOLQR and its 64-bit counterpart CHOLQR_64 are available in standard, batched, and strided_batched forms, with selectable algorithm variants that trade some speed for improved numerical stability on ill-conditioned matrices. ## AMD hardware support The following table lists supported AMD Instinct GPUs, Radeon GPUs, and Ryzen APUs. Each supported device is listed with its corresponding GPU microarchitecture and LLVM target. #### NOTE If your GPU is not listed, it might be community-enabled through TheRock nightly builds. For more information, see [TheRock supported GPUs](https://github.com/ROCm/TheRock/blob/main/SUPPORTED_GPUS.md). For installation guidance, see [TheRock releases](https://github.com/ROCm/TheRock/blob/main/RELEASES.md). **Instinct** | Device series | Device | LLVM target | Architecture | |---------------------------|---------------------------------------------------------|---------------|----------------| | AMD Instinct MI350 Series | Instinct MI355X
Instinct MI350X
Instinct MI350P | gfx950 | CDNA 4 | | AMD Instinct MI300 Series | Instinct MI325X
Instinct MI300X
Instinct MI300A | gfx942 | CDNA 3 | | AMD Instinct MI200 Series | Instinct MI250X
Instinct MI250
Instinct MI210 | gfx90a | CDNA 2 | | AMD Instinct MI100 Series | Instinct MI100 | gfx908 | CDNA | **Radeon** | Device series | Device | LLVM target | Architecture | |--------------------------------|-----------------------------------------------------------------------------------------------------------|---------------|----------------| | AMD Radeon AI PRO R9000 Series | Radeon AI PRO R9700S
Radeon AI PRO R9700
Radeon AI PRO R9600D
Radeon AI PRO R9600 | gfx1201 | RDNA 4 | | AMD Radeon RX 9000 Series | Radeon RX 9070 XT
Radeon RX 9070 GRE
Radeon RX 9070 | gfx1201 | RDNA 4 | | AMD Radeon RX 9000 Series | Radeon RX 9060 XT LP
Radeon RX 9060 XT
Radeon RX 9060
Radeon RX 9050
Radeon RX 9050 (4GB) | gfx1200 | RDNA 4 | | AMD Radeon PRO W7000 Series | Radeon PRO W7900 Dual Slot
Radeon PRO W7900
Radeon PRO W7800 48GB
Radeon PRO W7800 | gfx1100 | RDNA 3 | | AMD Radeon PRO W7000 Series | Radeon PRO W7700 | gfx1101 | RDNA 3 | | AMD Radeon RX 7000 Series | Radeon RX 7900 XTX
Radeon RX 7900 XT
Radeon RX 7900 GRE | gfx1100 | RDNA 3 | | AMD Radeon RX 7000 Series | Radeon RX 7800 XT
Radeon RX 7700 XT
Radeon RX 7700 | gfx1101 | RDNA 3 | | AMD Radeon RX 7000 Series | Radeon RX 7600 | gfx1102 | RDNA 3 | | AMD Radeon PRO V Series | Radeon PRO V710 | gfx1101 | RDNA 3 | | AMD Radeon PRO V Series | Radeon PRO V620 | gfx1030 | RDNA 2 | | AMD Radeon PRO W6000 Series | Radeon PRO W6800 | gfx1030 | RDNA 2 | **Ryzen** | Device series | Device | LLVM target / codename | Architecture | |---------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------|----------------| | AMD Ryzen AI Max PRO 400 Series | Ryzen AI Max+ PRO 495 (Radeon 8065S)
Ryzen AI Max PRO 490 (Radeon 8050S)
Ryzen AI Max PRO 485 (Radeon 8050S) | gfx1151Gorgon Halo | RDNA 3.5 | | AMD Ryzen AI Max PRO 300 Series | Ryzen AI Max+ PRO 395 (Radeon 8060S)
Ryzen AI Max PRO 390 (Radeon 8050S)
Ryzen AI Max PRO 385 (Radeon 8050S)
Ryzen AI Max PRO 380 (Radeon 8040S) | gfx1151Strix Halo | RDNA 3.5 | | AMD Ryzen AI Max 300 Series | Ryzen AI Max+ 395 (Radeon 8060S)
Ryzen AI Max+ 392 (Radeon 8060S)
Ryzen AI Max+ 388 (Radeon 8060S)
Ryzen AI Max 390 (Radeon 8050S)
Ryzen AI Max 385 (Radeon 8050S) | gfx1151Strix Halo | RDNA 3.5 | | AMD Ryzen AI PRO 400 Series | Ryzen AI 9 HX PRO 475 (Radeon 890M)
Ryzen AI 9 HX PRO 470 (Radeon 890M)
Ryzen AI 9 PRO 465 (Radeon 880M) | gfx1150Gorgon Point | RDNA 3.5 | | AMD Ryzen AI PRO 400 Series | Ryzen AI 7 PRO 450 (Radeon 860M)
Ryzen AI 5 PRO 440 (Radeon 840M) | gfx1152Gorgon Point | RDNA 3.5 | | AMD Ryzen AI PRO 400 Series | Ryzen AI 5 PRO 435 (Radeon 840M) | gfx1153Gorgon Point | RDNA 3.5 | | AMD Ryzen AI 400 Series | Ryzen AI 9 HX 475 (Radeon 890M)
Ryzen AI 9 HX 470 (Radeon 890M)
Ryzen AI 9 465 (Radeon 880M) | gfx1150Gorgon Point | RDNA 3.5 | | AMD Ryzen AI 400 Series | Ryzen AI 7 450 (Radeon 860M) | gfx1152Gorgon Point | RDNA 3.5 | | AMD Ryzen AI 400 Series | Ryzen AI 5 435 (Radeon 840M)
Ryzen AI 5 430 (Radeon 840M)
Ryzen AI 7 445 (Radeon 840M) | gfx1153Gorgon Point | RDNA 3.5 | | AMD Ryzen AI PRO 300 Series | Ryzen AI 9 HX PRO 375 (Radeon 890M)
Ryzen AI 9 HX PRO 370 (Radeon 890M) | gfx1150Strix Point | RDNA 3.5 | | AMD Ryzen AI PRO 300 Series | Ryzen AI 7 PRO 350 (Radeon 860M)
Ryzen AI 5 PRO 340 (Radeon 840M) | gfx1152Krackan Point | RDNA 3.5 | | AMD Ryzen AI 300 Series | Ryzen AI 9 HX 375 (Radeon 890M)
Ryzen AI 9 HX 370 (Radeon 890M)
Ryzen AI 9 365 (Radeon 880M) | gfx1150Strix Point | RDNA 3.5 | | AMD Ryzen AI 300 Series | Ryzen AI 7 350 (Radeon 860M)
Ryzen AI 7 345 (Radeon 840M)
Ryzen AI 5 340 (Radeon 840M)
Ryzen AI 5 330 (Radeon 820M) | gfx1152Krackan Point | RDNA 3.5 | | AMD Ryzen PRO 200 Series | Ryzen 7 PRO 250 (Radeon 780M)
Ryzen 5 PRO 230 (Radeon 760M)
Ryzen 5 PRO 220 (Radeon 740M)
Ryzen 5 PRO 215 (Radeon 740M)
Ryzen 3 PRO 210 (Radeon 740M) | gfx1103Hawk Point | RDNA 3 | | AMD Ryzen 200 Series | Ryzen 9 270 (Radeon 780M)
Ryzen 7 260 (Radeon 780M)
Ryzen 7 250 (Radeon 780M)
Ryzen 5 240 (Radeon 760M)
Ryzen 5 230 (Radeon 760M)
Ryzen 5 220 (Radeon 740M)
Ryzen 3 210 (Radeon 740M) | gfx1103Hawk Point | RDNA 3 | ## Operating system support ROCm supports the following Linux distributions and Microsoft Windows versions. If you’re running ROCm on Linux, ensure your system is using a supported kernel version. #### IMPORTANT The following table is a general overview of supported operating systems. Actual support might vary by AMD GPU or APU. Use the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) to verify support for your specific setup before installation. **Instinct** | Linux distribution | Supported versions | Linux kernel version | |-------------------------------------|----------------------|------------------------| | Ubuntu | 26.04.1 | GA 7.0 | | Ubuntu | 24.04.5 | GA 6.8 | | Ubuntu | 22.04.5 | GA 5.15 | | Debian | 13 | 6.12 | | Debian | 12 | 6.1.0 | | Red Hat Enterprise Linux (RHEL) | 10.2 | 6.12.0-211 | | Red Hat Enterprise Linux (RHEL) | 10.0 | 6.12.0-55 | | Red Hat Enterprise Linux (RHEL) | 9.8 | 5.14.0-687 | | Red Hat Enterprise Linux (RHEL) | 9.6 | 5.14.0-570 | | Red Hat Enterprise Linux (RHEL) | 9.4 | 5.14.0-427 | | Red Hat Enterprise Linux (RHEL) | 8.10 | 4.18.0-553 | | Oracle Linux | 10 | UEK 8.1 | | Oracle Linux | 9 | UEK 8 | | Oracle Linux | 8 | UEK 7 | | SUSE Linux Enterprise Server (SLES) | 16.0 | 6.12 | | SUSE Linux Enterprise Server (SLES) | 15.7 | 6.4.0-150700.51 | | Rocky Linux | 9 | 5.14.0-570 | **Radeon** | Operating system | Supported versions | Linux kernel version | |---------------------------------|----------------------|------------------------| | Ubuntu | 26.04.1 | GA 7.0 | | Ubuntu | 24.04.5 | HWE 7.0 | | Ubuntu | 22.04.5 | HWE 6.8 | | Red Hat Enterprise Linux (RHEL) | 10.2 | 6.12.0-211 | | Red Hat Enterprise Linux (RHEL) | 9.8 | 5.14.0-687 | | Windows | 11 25H2 | — | **Ryzen** | Operating system | Supported versions | Linux kernel version | |--------------------|----------------------|------------------------| | Ubuntu | 26.04.1 | GA 7.0 | | Ubuntu | 24.04.5 | HWE 7.0 | | Windows | 11 25H2 | — | ## Installation updates ### WSL2 support now included in TheRock artifacts (Technical preview) You can now run ROCm workloads on Windows through Windows Subsystem for Linux 2 (WSL2), for the first time in TheRock builds of ROCm. Previously, enabling WSL2 required building `librocdxg` from source; TheRock now ships it as part of its artifacts, so the WSL2 driver interface is available out of the box. The ROCr runtime automatically detects a WSL2 environment by checking for the `/dev/dxg` device and loads `librocdxg` accordingly, so no manual configuration is required in the common case. To disable auto-detection, set the `HSA_ENABLE_DXG_DETECTION` environment variable to 0 (the default is 1). For details, see the [ROCR-Runtime environment variables](https://rocm.docs.amd.com/en/latest/reference/environment-variables/index.html#rocr-runtime-environment-variables) reference. This technical preview launch targets Ubuntu through `.deb` packages and Python wheels; RPM packages are not in scope. Profiling, debugging, and KFD-dependent tooling are not supported in WSL2 at launch. For details on issues identified with the initial support for WSL2, refer to [ROCm known issues](). ### Runfile installer update ROCm 10.1.0 fixes minor issues in the Runfile Installer. ## Kernel driver and firmware bundle support ROCm requires a coordinated stack of compatible firmware, driver, and user-space components. Maintaining version alignment between these layers ensures correct GPU operation and performance, especially for AMD data center products. While AMD publishes the AMD GPU driver and ROCm user space components, your server OEM (original equipment manufacturer) or infrastructure provider distributes the firmware packages. AMD supplies those firmware images (platform level data model (PLDM) bundles), which the OEM integrates and distributes. **Instinct** | AMD device | PLDM Bundle (Firmware) | Linux driver | |-----------------|----------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Instinct MI355X | 01.26.01.03 (or later)
01.26.00.02 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI350X | 01.26.01.03 (or later)
01.26.00.02 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI350P | BKC12.0 (IFWI PRD1000A) or later
IFWI 00189939 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI325X | 01.26.01.03 (or later)
01.25.06.08 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI300X | 01.26.00.04 (or later)
01.25.06.05 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI300A | PI100D
PI100C | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI250X | Maintenance update (MU) 5 with IFWI 75 (or later) | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI250 | Maintenance update (MU) 5 with IFWI 75 (or later) | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI210 | Maintenance update (MU) 5 with IFWI 75 (or later) | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | | Instinct MI100 | VBIOS D3430401-037 | AMD GPU Driver (amdgpu)
31.60.0
31.50.0
31.40.1
31.40.0
31.30.0
31.20.0
31.10.0
30.30.3
30.30.2
30.30.1
30.30.0
30.20.1
30.20.0
30.10.2 | **Radeon** | Linux driver | Windows driver | |-------------------------------------------------|-----------------------------------------------------------------------------------------| | AMD GPU Driver (amdgpu)
31.60.0
31.50.0 | AMD Software: Adrenalin Edition
26.10.41.05
Windows CDE CPR driver
26.10.48 | **Ryzen** | Linux driver | Windows driver | |------------------------------------------------------------------|-----------------------------------------------------------------------------------------| | Ubuntu 26.04.1: GA 7.0 Kernel
Ubuntu 24.04.5: HWE 7.0 Kernel | AMD Software: Adrenalin Edition
26.10.41.05
Windows CDE CPR driver
26.10.48 | ## GPU virtualization support AMD Instinct and Radeon GPUs support virtualization in the following configurations. Supported SR-IOV configurations require the AMD GPU Virtualization Driver (GIM) 9.3.0.K—see the [AMD Instinct Virtualization Driver documentation](https://instinct.docs.amd.com/projects/virt-drv/en/mainline-9.3.0.k/) for more information. **Instinct** | AMD GPU | Hypervisor | Virtualization technology | Virtualization driver | Host OS | Guest OS | VF per GPU - Compute Mode - Memory Mode | |-----------------|--------------|-----------------------------|-------------------------|-----------------|--------------|--------------------------------------------------------------| | Instinct MI355X | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI355X | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI355X | KVM | Passthrough | — | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI355X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI355X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1
2[\*] - DPX - NPS2
8[\*] - CPX - NPS2 | | Instinct MI355X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 10.0 | 1 - SPX - NPS1 | | Instinct MI355X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 9.6 | 1 - SPX - NPS1 | | Instinct MI355X | ESXi | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | Passthrough | — | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1
2[\*] - DPX - NPS2
8[\*] - CPX - NPS2 | | Instinct MI350X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 10.0 | 1 - SPX - NPS1 | | Instinct MI350X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 9.6 | 1 - SPX - NPS1 | | Instinct MI350X | ESXi | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI350P | KVM | Passthrough | — | Debian 13 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI350P | ESXi | Passthrough | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI350P | ESXi | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | Passthrough | — | Ubuntu 24.04 | RHEL 9.4 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | Passthrough | — | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | Passthrough | — | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 10.2 | RHEL 10.2 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI325X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | Ubuntu 24.04 | RHEL 9.4 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | ESXi 8 U3 | Ubuntu 24.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | Passthrough | — | ESXi 8 U3 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1
8[\*] - CPX - NPS4 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 10.2 | RHEL 10.2 | 1 - SPX - NPS1 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1
8[\*] - CPX - NPS4 | | Instinct MI300X | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | Ubuntu 24.04 | 1 - SPX - NPS1
8[\*] - CPX - NPS4 | | Instinct MI210 | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | N/A | | Instinct MI210 | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | N/A | | Instinct MI210 | KVM | Passthrough | — | Ubuntu 22.04 | Ubuntu 22.04 | N/A | | Instinct MI210 | KVM | Passthrough | — | RHEL 9.4 | Ubuntu 22.04 | N/A | | Instinct MI210 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | N/A | | Instinct MI210 | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | Ubuntu 22.04 | N/A | | Instinct MI210 | KVM | SR-IOV | GIM 9.3.0.K | RHEL 9.4 | RHEL 9.4 | N/A | **Radeon** | AMD GPU | Hypervisor | Virtualization technology | Virtualization driver | Host OS | Guest OS | VF per GPU - Compute Mode - Memory Mode | |----------------------|--------------|-----------------------------|-------------------------|--------------|--------------|-------------------------------------------| | Radeon AI PRO R9700S | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | N/A | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 26.04 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | Ubuntu 24.04 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | RHEL 10.2 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 26.04 | RHEL 9.6 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | Ubuntu 24.04 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 10.2 | 1 to 12 | | Radeon PRO V710 | KVM | SR-IOV | GIM 9.3.0.K | Ubuntu 24.04 | RHEL 9.6 | 1 to 12 | ## GPU partitioning support The following compute partition and NUMA-per-socket (NPS) configurations are available on AMD Instinct GPUs in bare-metal deployments. | Deployment | Device | Compute partition mode | Memory partition mode | |--------------|----------------------------------|--------------------------|-------------------------| | Bare metal | Instinct MI355X, Instinct MI350X | SPX | NPS1 | | Bare metal | Instinct MI355X, Instinct MI350X | DPX | NPS2 | | Bare metal | Instinct MI355X, Instinct MI350X | CPX | NPS2 | | Bare metal | Instinct MI355X, Instinct MI350X | QPX | NPS2 | | Bare metal | Instinct MI350P | SPX | NPS1 | | Bare metal | Instinct MI350P | DPX | NPS1 | | Bare metal | Instinct MI350P | CPX | NPS1 | | Bare metal | Instinct MI325X | SPX | NPS1 | | Bare metal | Instinct MI300X | SPX | NPS1 | | Bare metal | Instinct MI300X | DPX | NPS2 | | Bare metal | Instinct MI300X | CPX | NPS4 | The following configurations are available on AMD Instinct GPUs in passthrough deployments. | Deployment | Device | Compute partition mode | Memory partition mode | |------------------|--------------------------------------------------------------------|--------------------------|-------------------------| | KVM Passthrough | Instinct MI355X, Instinct MI350X, Instinct MI325X, Instinct MI300X | SPX | NPS1 | | ESXi Passthrough | Instinct MI350P, Instinct MI300X | SPX | NPS1 | The following configurations are available on AMD Instinct GPUs in SR-IOV deployments. See [GPU virtualization support](#release-virtualization-support) for driver support information. | Deployment | Device | VFs per GPU | Compute partition mode | Memory partition mode | |--------------|----------------------------------|---------------|--------------------------|-------------------------| | KVM SR-IOV | Instinct MI355X, Instinct MI350X | 1 | SPX | NPS1 | | KVM SR-IOV | Instinct MI355X, Instinct MI350X | 2[\*] | DPX | NPS2 | | KVM SR-IOV | Instinct MI355X, Instinct MI350X | 8[\*] | CPX | NPS2 | | KVM SR-IOV | Instinct MI325X | 1 | SPX | NPS1 | | KVM SR-IOV | Instinct MI300X | 1 | SPX | NPS1 | | KVM SR-IOV | Instinct MI300X | 8[\*] | CPX | NPS4 | | ESXi SR-IOV | Instinct MI355X, Instinct MI350X | 1 | SPX | NPS1 | See the [AMD GPU partitioning](https://instinct.docs.amd.com/projects/amdgpu-docs/en/latest/gpu-partitioning/index.html) topic in the AMD GPU Driver documentation to learn more. ## AI ecosystem support ROCm 10.1.0 provides optimized support for popular deep learning frameworks and AI inference engines. The following table lists supported frameworks and libraries, their compatible operating systems, and validated versions. #### IMPORTANT The following table is a general overview of supported frameworks and AI inference engines. Actual support might vary by AMD GPU or APU. Use the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) to verify support for your specific setup. | Framework | Supported versions | Supported OS | Supported Python versions | |--------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------| | PyTorch | 2.14.0 | Linux | 3.14, 3.13, 3.12, 3.11, 3.10 | | PyTorch | 2.14.0 | Windows | 3.14, 3.13, 3.12, 3.11 | | PyTorch | 2.13.0, 2.12.0
(Instinct GPUs only) | Linux | 3.14, 3.13, 3.12, 3.11, 3.10 | | JAX | 0.11.1
(gfx950, gfx942, gfx90a,
gfx1200, gfx1201, gfx1100,
gfx1101, gfx1102 GPUs only) | Linux | 3.14, 3.13, 3.12 | | JAX | 0.11.0
(gfx950, gfx942, gfx90a GPUs only) | Linux | 3.14, 3.13, 3.12 | | JAX | 0.10.2
(gfx950, gfx942, gfx90a GPUs only) | Linux | 3.14, 3.13, 3.12, 3.11 | | vLLM | 0.29.0
(gfx950, gfx942, gfx1200,
gfx1201, gfx1100, gfx1101,
gfx1102, gfx1152, gfx1151,
gfx1150 GPUs only) | Linux | 3.14 (requires PyTorch 2.13.0) | | SGLang | 0.5.18
(gfx950, gfx942, gfx1200,
gfx1201, gfx1100, gfx1101, gfx1102 GPUs only) | Linux | 3.14 (requires PyTorch 2.13.0) | | TensorFlow | 2.21
(gfx950, gfx942, gfx1200,
gfx1201, gfx1100, gfx1101,
gfx1102 GPUs only) | Linux | 3.12 | | TensorFlow | 2.20
(gfx950, gfx942 GPUs only) | Linux | 3.12 | | ONNX Runtime | 1.29.0
(gfx950, gfx942, gfx90a,
gfx1200, gfx1201, gfx1100,
gfx1101, gfx1102, gfx1153,
gfx1152, gfx1151, gfx1150 GPUs only) | Linux | 3.12 | | MIGraphX | 2.18
(gfx950, gfx942, gfx90a,
gfx1200, gfx1201, gfx1100,
gfx1101, gfx1102, gfx1153,
gfx1152, gfx1151, gfx1150 GPUs only) | Linux | 3.12 | ## ROCm Core SDK components The following table lists core tools and libraries included in the ROCm 10.1.0 release. #### IMPORTANT The following table is a general overview of ROCm Core SDK components. Actual support for these libraries and tools can vary by GPU and OS. Use the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) to verify support for your specific setup. | Component group | Component name | Version | Supported platforms | | |-------------------------------|-----------------------|-----------------|---------------------------------------------------------------------------------------------------------------------|----| | Math and compute libraries | Composable Kernel | 1.2.0 ⇒ 1.3.0 | Linux/Windows · Instinct/Radeon | | | Math and compute libraries | hipBLAS | 3.6.0 ⇒ 3.7.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipBLASLt | 1.4.1 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipCUB | 4.6.0 ⇒ 4.7.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipFFT | 1.0.25 ⇒ 1.0.26 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipRAND | 3.4.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipSOLVER | 3.6.0 ⇒ 3.7.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipSPARSE | 4.7.0 ⇒ 4.8.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | hipSPARSELt | 0.2.9 | Linux/Windows · Instinct (gfx950/gfx942) | | | Math and compute libraries | libhipcxx | 3.0.2 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | MIOpen | 3.6.0 ⇒ 3.6.1 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocBLAS | 5.6.0 ⇒ 5.7.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocFFT | 1.0.39 ⇒ 1.0.40 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocPRIM | 4.6.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocRAND | 5.0.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocSOLVER | 3.36.0 ⇒ 3.37.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocSPARSE | 5.0.0 ⇒ 5.1.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocThrust | 4.6.0 ⇒ 4.7.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Math and compute libraries | rocWMMA | 2.2.1 | Linux/Windows · Instinct/Radeon/Ryzen | | | Communication libraries | RCCL | 2.30.7 | Linux · Instinct/Radeon/Ryzen | | | Communication libraries | rocSHMEM | 3.6.0 ⇒ 3.7.0 | Linux · Instinct/Radeon (gfx950/gfx942/gfx90a/gfx1201/gfx1200/gfx1100/gfx1101 (except AMD Radeon PRO V710)/gfx1102) | | | Media and vision libraries | rocDecode | 1.9.0 ⇒ 1.10.0 | Linux · Instinct/Radeon/Ryzen (gfx1150/gfx1151/gfx1152/gfx1153) | | | Media and vision libraries | rocJPEG | 1.7.0 ⇒ 1.10.0 | Linux · Instinct/Radeon/Ryzen (gfx1150/gfx1151/gfx1152/gfx1153) | | | Media and vision libraries | RPP | 3.2.0 | Linux · Instinct/Radeon/Ryzen (gfx1150/gfx1151/gfx1152/gfx1153) | | | Storage libraries | hipFile | 0.4.0 ⇒ 0.5.0 | Linux · Instinct | | | Threading libraries | hipThreads | 1.0.0 | Linux/Windows · Radeon/Ryzen | | | Runtimes and compilers | HIP | 7.15.0 ⇒ 7.16.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Runtimes and compilers | HIPIFY | 10.0.0 ⇒ 10.1.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Runtimes and compilers | LLVM | 24.0.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Runtimes and compilers | ROCr Runtime | 1.21.0 | Linux · Instinct/Radeon/Ryzen | | | Runtimes and compilers | SPIRV-LLVM-Translator | 24.0.0 | Linux/Windows · Instinct/Radeon/Ryzen | | | Profiling and debugging tools | ROCdbgapi | 0.80.0 | Linux · Instinct/Radeon | | | Profiling and debugging tools | ROCgdb | 16.3 ⇒ 16.3 | Linux · Instinct/Radeon | | | Profiling and debugging tools | ROCm Compute Profiler | 3.8.0 ⇒ 3.9.0 | Linux · Instinct/Ryzen (gfx1150 (Strix Point only)/gfx1151/gfx1152 (Krackan Point only)/gfx1153) | | | Profiling and debugging tools | ROCm Systems Profiler | 1.8.0 ⇒ 1.9.0 | Linux · Instinct/Radeon/Ryzen (gfx1150 (Strix Point only)/gfx1151/gfx1152 (Krackan Point only)) | | | Profiling and debugging tools | ROCprofiler-SDK | 1.3.5 ⇒ 1.4.1 | Linux · Instinct/Radeon/Ryzen (gfx1150/gfx1151/gfx1152/gfx1153) | | | Profiling and debugging tools | ROCr Debug Agent | 2.1.0 ⇒ 2.2.0 | Linux · Instinct/Radeon | | | Control and monitoring tools | AMD SMI | 27.0.0 ⇒ 27.1.0 | Linux · Instinct/Radeon | | | Control and monitoring tools | ROCm Data Center Tool | 1.3.1 ⇒ 1.3.1 | Linux · Instinct | | | Control and monitoring tools | rocminfo | 1.0.0 | Linux · Instinct/Radeon/Ryzen | | ### ROCm component changelogs The following sections describe key changes to ROCm Core SDK components. #### NOTE For a historical overview of ROCm component updates, see the [ROCm consolidated changelog](https://rocm.docs.amd.com/en/latest/release/changelog.html). #### **AMD SMI** (27.1.0) ##### Added - **Exposed `BOOT_FIRMWARE` field in `amd-smi static --ifwi` output**. - The `boot_firmware` value returned by `amdsmi_get_gpu_vbios_info()` now appears under the `IFWI` section alongside `NAME`, `BUILD_DATE`, `PART_NUMBER` and `VERSION` (`--vbios` remains available as a legacy alias). - **An experimental, opt-in WSL (WDDM/dxg) GPU backend**. - Built only with `-DENABLE_WSL_BACKEND=ON` (off by default); native builds and packages are unchanged. - Reads GPU telemetry through `librocdxg`; queries with no WDDM equivalent return `AMDSMI_STATUS_NOT_SUPPORTED`. See [Using AMD SMI under WSL](https://rocm.docs.amd.com/projects/amdsmi/en/latest/how-to/amdsmi-wsl-mode.html). - **UALoE-backed physical accelerator ID and tray info**. - `physical_acc_id` added to `amdsmi_asic_info_t` and `amdsmi_enumeration_info_t`, populated by `amdsmi_get_gpu_asic_info()` and `amdsmi_get_gpu_enumeration_info()`. - New node-scoped `amdsmi_get_tray_info()` reports compute tray type and accelerator count via `amdsmi_tray_info_t` and `amdsmi_compute_tray_type_t`. - Without an active UALoE session these report `AMDSMI_STATUS_NOT_SUPPORTED`, or `UINT32_MAX` for `physical_acc_id`. - CLI: `amd-smi static --asic` and `amd-smi list --enumeration` show `PHYSICAL_ACC_ID`; new `amd-smi node --tray`/`-T` prints tray type and accelerator count. - **`CACHE_ACRONYM` and `TOTAL_CACHE_SIZE` to `amd-smi metric --cache`**. - Each `CACHE_` entry now reports a short type label (`L1D`, `L1I`, `L2`, `L3`) and the total size across all instances at that level. - **`chip_rev_id` and `external_rev_id` to `amdsmi_get_gpu_asic_info()`**. - Reports the amdgpu `chip_rev` and `external_rev` values from the `AMDGPU_INFO_DEV_INFO` DRM query, both distinct from `rev_id`, which is the PCI config-space revision. `external_rev_id` is family-scoped, so interpret it alongside `device_id`. - Exposed under the same names in the Python `amdsmi_get_gpu_asic_info()` dictionary and in `amd-smi static --asic`. The C fields report `0xFFFFFFFF` when unsupported; Python and the CLI render that as `N/A`. - ABI-preserving: the fields take two `uint32_t` slots from `amdsmi_asic_info_t.reserved`, which shrinks from 17 to 15 entries. The structure size and all other field offsets are unchanged. ##### Changed - **`amdsmi_get_clock_info()` now returns `AMDSMI_STATUS_INPUT_OUT_OF_BOUNDS` for clock values that exceed `INT_MAX`**. - Such values were previously narrowed to a negative number and returned as data. - **Expanded `amdsmi_gpu_block_t` enum with 20 new RAS IP blocks**. - Added blocks: from `AMDSMI_GPU_BLOCK_MMSCH` to `AMDSMI_GPU_BLOCK_UCIE_PCS` at bit positions 19-38. - Updated `AMDSMI_GPU_BLOCK_LAST` to `AMDSMI_GPU_BLOCK_UCIE_PCS`. - **A section with no entries now renders as `SECTION: N/A` in human-readable CLI output**. - It previously printed a bare `SECTION:` header with nothing beneath it, which read as truncated output. For `SWITCH_ERRORS` this also hid data: a block the driver reported as `N/A` became an empty header. - Affects sections that list a variable number of entries: `PORTS` and `RDMA_DEVICES` for an AI-NIC, the per-block counters under `NIC_ERRORS` and `SWITCH_ERRORS`, and `FREQUENCY_LEVELS` in `amd-smi static --clock`. Sections with a fixed set of fields already print `N/A` per field and are unaffected. - `--json`, `--csv`, and the table-based subcommands (`monitor`, `partition`, `topology`, `xgmi`, and the default no-argument output) are unchanged. - **`container_name` in process info now reports the full container ID**. - Previously only the first 16 characters were reported. The value is now the complete 64-character ID that `docker inspect`, `docker ps --no-trunc` and Kubernetes tooling use, so process output can be matched against them directly. - Nested LXC containers now report the outer container name rather than `/`. - **`amd_smi/impl/amd_smi_cper.h` and `example/amd_smi_cper.cc` are no longer installed in the dev package**. - Both functions the header declares are C++ symbols, which the version script’s `amdsmi_*` export glob does not match, so including the header only ever led to a link error. It joins the `_test` and WSL impl headers that are already build-only. - The example is the one shipped file that included that header, so it went with it rather than being left unbuildable against an install tree. ##### Resolved issues - **Fixed `rsmi_dev_reg_table_get()` failing on register-state images that contain no SMN entries**. - The loop-back test ran before the SMN and instance counters reached zero, so an image with no SMN entries re-entered the loop and read past the end of the image; the call then returned an error for a well-formed file. - **Fixed an out-of-bounds write when a GPU’s NUMA or local CPU list names a CPU beyond the bitmask**. - `get_bitmask_from_numa_node()` and `get_bitmask_from_local_cpulist()` indexed the bitmask with the parsed CPU number without checking it against the allocated word count. Ranges are now clamped to the bitmask, and negative entries are skipped. - **Fixed `vram_bit_width` never being reported as `N/A`**. - The unavailable-value check compared a `uint32_t` field against `UINT64_MAX`, which can never match, so an unknown bit width was logged as `4294967295`. - **Fixed an out-of-bounds read in the DRM example’s RAS block listing**. - `amd_smi_drm_example.cc` iterated every `amdsmi_gpu_block_t` value but indexed a 14-entry name array, so every block from `AMDSMI_GPU_BLOCK_MCA` onward read past the end of the array and printed a garbage label. The list now covers all 39 blocks and the lookup is bounds-checked. - **Fixed `amd-smi ras --afid --folder --json` emitting nothing when no CPER files are readable**. - When every `.cper` file in the folder was skipped (e.g. rejected as a symlink), the JSON path printed empty output, so consumers feeding stdout to `json.loads` failed with `Expecting value: line 1 column 1 (char 0)`. It now emits `[]` for that case, matching the `--cper --json` contract. - **Fixed an uninitialized processor index that let the CPU and Core APIs read an unrelated CPU socket**. - Passing a GPU, NIC, or switch handle to a CPU or Core API could return another socket’s telemetry with `AMDSMI_STATUS_SUCCESS`. Such handles are now rejected. Calls that pass a CPU or Core handle are unaffected. - **Fixed `amd-smi metric` printing nothing for a section requested by name on APUs**. - APUs do not expose the discrete-GPU sensors, so those sections are dropped from the default dump. The same suppression applied to an explicitly named section, leaving `amd-smi metric --energy` printing only the GPU header and exiting 0, with no key at all in `--json` and `--csv` output. - `--energy`, `--ecc-blocks`, `--overdrive`, `--xgmi-err`, `--pcie`, `--voltage-curve`, `--voltage` and `--fan` now report `N/A` when named explicitly. The default `amd-smi metric` dump is unchanged. - **Fixed `amdsmi_get_clock_info()` reporting an unavailable clock as `65535` instead of `N/A`**. - `amdsmi_clk_info_t.clk` is a `uint32_t`, but the GFX, MEM, SOC, VCLK, and DCLK domains copied the raw `uint16_t` value straight from the GPU metrics table, so the 16-bit unavailable marker surfaced as the literal reading `65535` MHz. The `DF` domain already returned the 32-bit marker. - All domains now report an unavailable clock as `UINT32_MAX`, which the Python interface maps to `N/A`. The field is documented accordingly. - **Fixed `amd-smi metric --usage` reporting APU IPU read/write bandwidth without a unit**. - `APU_AVERAGE_IPU_READS` and `APU_AVERAGE_IPU_WRITES` printed bare numbers while the adjacent DRAM counters carried `MB/s`. All four bandwidth counters now report `MB/s`, and the header documents the unit for each. - **Fixed `amd-smi static --vram` reporting `GDDR7` for LPDDR5 unified memory on APUs (e.g. gfx117x)**. - `AMDSMI_VRAM_TYPE__MAX` aliases the highest real memory type (`LPDDR5`), so a genuine LPDDR5 reading was matched by the `__MAX` special case and mislabeled `GDDR7`. It is now correctly reported as `LPDDR5`. - **Fixed `container_name` in process info being wrong, missing, or crashing `amd-smi`**. - `amd-smi process --sort-by-pid` could abort with `terminate called after throwing an instance of 'std::out_of_range'` when any GPU process ran in a cgroup whose path ended in `docker` or `lxc`. - Processes in containerd, CRI-O and Podman containers reported no container at all, including Kubernetes pods. They are now identified under either cgroup driver. - Processes that were not in a container could be reported as if they were, for example anything running under the Docker daemon’s own `docker.service`. - Containers managed by LXC 3 or later, or by LXD, under systemd are now identified. - A process started from a path of 256 characters or more could report a corrupted process name. - **Fixed out-of-bounds reads and writes when parsing malformed CPER records**. - The ring reader now drops a record whose `record_length` is smaller than a CPER header; such a record was previously copied and then had a product serial number written past the end of the caller’s buffer. `amdsmi_get_afids_from_cper` likewise returns `AMDSMI_STATUS_UNEXPECTED_SIZE` for an undersized `buf_size` instead of reading header fields the caller never supplied. - A section descriptor’s `fru_id` and `fru_text` are now logged only up to their declared width, and a crashdump section’s registers are copied into an aligned buffer before decoding. Neither field carries a terminator, and the section can sit at an unaligned record-supplied offset. - A non-standard error section whose `reg_arr_size` exceeds the fixed 128-byte register dump, and a record whose `error_severity` overflows the severity mask, are now rejected. Both previously read or matched outside the record; in boot context (`reg_ctx_type` 9) any AFID derived from the over-long register read is gone. - **Fixed `amd-smi metric --clock` reporting FCLK `MAX_CLK` as 0 MHz**. - The FCLK range came from `pp_od_clk_voltage`, which on some GPUs has no FCLK section, leaving the parsed maximum at 0. It now falls back to `pp_dpm_fclk` (and likewise `pp_dpm_sclk`/`pp_dpm_mclk`) when the overdrive file omits a domain. - **Fixed `amd-smi set -L/--clk-limit max ` not enforcing caps that fall between clock levels**. - For `mclk` and `fclk` ONLY, which expose a discrete DPM table, the requested `max` is now rounded down to the nearest selectable clock level, so the enforced limit never exceeds the requested value. - `sclk` supports a continuous frequency range, so its requested `max` is honored exactly (e.g. `600` enforces a limit of 600MHz) and is not snapped. - **Fixed AI-NICs disappearing from `amd-smi` when the RDMA driver is unavailable**. - Discovery treated a missing RDMA device list as a fatal error for the whole NIC, so a host with `ionic_rdma` blacklisted (or otherwise not loaded) dropped the NIC entirely and reported no AI-NIC at all. - The NIC is now enumerated with an empty `rdma_dev`. - `amdsmi_get_nic_rdma_dev_info()` returns `AMDSMI_STATUS_SUCCESS` with `num_rdma_dev` set to 0. - `amd-smi static` reports `RDMA_DEVICES: N/A` instead of omitting the device. All other NIC information is reported as usual. - **Fixed `amdsmi_get_gpu_asic_info()` reporting `rev_id` as a real revision when it is not available**. - The WSL backend returned success with a zeroed structure, so `rev_id` read as `0x0`, and where it did report the not-supported value Python rendered it as the raw `0xffffffff`. Python and the CLI now render it as `N/A`. - `amdsmi_asic_info_t` is now reset through one shared initializer used by every backend, so a field a backend cannot supply keeps its not-supported value rather than a plausible zero. ##### Upcoming changes - **UUIDs will be replaced by CUIDs in an upcoming version**. - UUIDs will soon be replaced with Component Unified IDs (CUIDs). These CUIDs will be consistent across various AMD tools and products so users will be able to definitively identify their devices regardless of what tool they’re using. - `amdsmi_get_gpu_device_cuid` has been added as an API for this upcoming change but will remain disabled until full support from the amdgpu driver is available. - The CLI `list` output and GPU selection now report the CUID in place of the UUID when a CUID is available, and fall back to the UUID otherwise. #### **Composable Kernel** (1.3.0) ##### Added * Support for building Composable Kernel for the target-agnostic SPIR-V target (`amdgcnspirv`), which is compiled to native code at run time. * Grouped convolution forward, backward data, and backward weight instances for gfx1250. * A wavelet GEMM pipeline for convolution forward that specializes waves into separate load and math roles to reduce VALU contention. * A batched contraction kernel with multiple ABD support to CK Tile. * CK Tile dispatcher support for more GEMM operators, including weight preshuffle GEMM, batched GEMM, batched contraction, grouped A-quantized and AB-quantized GEMM, grouped row-column and tensor quantized GEMM, and block scale quantized GEMM. * gfx1250 support to the CK Tile dispatcher GEMM operators, covering universal, grouped, multiple D, multiple ABD, batched, batched contraction, and grouped quantized GEMM. * gfx1250 WMMA instance support to the CK backend for PyTorch Inductor, covering universal GEMM, batched GEMM, and grouped convolution forward. * The tanh approximation of GELU to the XDL two-stage MoE GEMM epilogue. * Double-precision buffer atomic add support on gfx1250. ##### Changed * Disabled the large tensor XDL grouped convolution backward weight instances on gfx1250, where they could produce intermittent memory access faults. * Changed the ck4inductor instance enumerators to emit a deduplicated, deterministically ordered instance list. ##### Optimized * Improved FMHA forward performance for head dimension 128 on gfx11 and gfx12 targets by retuning tile selection. * Improved FMHA forward performance on gfx1250 for bf16 and fp16 head dimension 128 by padding the LDS layout in the qr_tdm pipeline. * Improved memory coalescing of microscaling (MX) scale loads on gfx1250 by unifying the scale16 layout with scale32. ##### Resolved issues * Fixed a 32-bit integer overflow in the tensor descriptor element space size that caused undersized workspace allocation and out-of-bounds writes in grouped convolution backward weight for large tensors. * Fixed grouped convolution forward rejecting valid problem sizes because the implicit GEMM view was subject to the 2 GB logical GEMM size limit. * Fixed incorrect results in grouped convolution backward data and XDL GEMM kernels caused by an invalid `__restrict__` qualifier on LDS pointers. * Fixed incorrect accumulation in atomic and split-K kernels on gfx1250 by issuing buffer atomic adds with device scope coherence. * Fixed memory faults in FMHA batch prefill with a paged KV cache when the page size is a single token. * Fixed the softmax sink gradient shape in the FMHA backward kernel and corrected sliding window progression when the attention sink is enabled. * Fixed incorrect results in microscaling (MX) XDL GEMM and B preshuffle kernels when the B operand is more densely packed than A, such as FP8 by FP4. * Fixed intermittent incorrect results in microscaling (MX) GEMM on gfx1250 caused by missing LDS read ordering in the double-buffered pipeline. * Fixed incorrect results in FP8 block scale weight preshuffle GEMM and MoE GEMM on gfx1250 caused by an invalid preshuffle layout and a hardcoded wave size. * Fixed incorrect results in FP4 weight preshuffle quantized GEMM caused by mismatched packed element granularity between the host B preshuffle and the device B tile distribution. * Fixed incorrect results in the B preshuffle dequantized GEMM pipeline caused by the C transpose setting being ignored. * Fixed incorrect results from the CK Tile compute v3 intrawave GEMM pipeline with eight-warp block arrangements on gfx1250. * Fixed out-of-bounds asynchronous loads in the CK Tile compute async WMMA GEMM pipeline caused by a missing element validity check. * Fixed accuracy loss in the bf16 fast GELU element-wise operation on gfx1250 by using the non-native implementation. * Fixed a build failure caused by the compiler change from vector to ext_vector types. * Fixed a CMake failure when building instance libraries for multiple offload targets. * Fixed an unspecified minimum blocks per compute unit value being passed to the compiler. * Fixed the CK Tile dispatcher code generator and its ctypes bindings failing to build. #### **HIP** (7.16.0) ##### Added * New HIP APIs: - Device Management: Support for the following APIs for parity with corresponding CUDA APIs. * `hipDeviceGetLuid` returns the locally unique identifier (LUID) and device node mask for the specified device. * `hipInitDevice` initializes the runtime state for the specified device without making it the current device for the calling thread. It also applies the requested flags and ensures the device’s default stream is created. * New HIP device attribute: - `hipDeviceAttributeHostAllocDmaBufSupported` is now supported, enabling host-allocated buffer sharing. * Support for host-NUMA virtual memory management (VMM) in `hipMemCreate()` and related VMM APIs. These APIs now support `hipMemLocationTypeHostNuma` and `hipMemLocationTypeHostNumaCurrent`, enabling allocations backed by physical host memory on the selected NUMA node. Previously, support was limited to GPU VMM pools with deferred host access. This enhancement aligns HIP behavior with the corresponding CUDA APIs and expands support for NUMA-aware memory allocation. * Support for coarse-grained memory coherency on Windows. In supported Windows configurations, applications can now use unified memory to reduce memory footprint by eliminating unnecessary host-device data copies. Components interacting with the device can directly access host memory pointers and enable coarse-grained memory coherency by registering and pinning the associated host allocations using `hipHostRegister()` with the `hipExtHostRegisterCoarseGrained` flag. This provides behavior on Windows that is consistent with the existing Linux implementation while improving memory efficiency. ##### Resolved issues * On Windows, HIP runtime now correctly handles non-P2P data transfers between GPUs and coordinates multi-GPU kernel execution. It eliminates deadlocks and invalid values in multi-process workloads and resolves issues observed when running LLMs on multi-GPU Windows configurations. * Resolved an out-of-memory issue affecting certain AMD APUs, such as Strix Halo, on Windows when loading LLMs that could exceed dedicated graphics memory and spill into shared memory. The HIP runtime now correctly uses the full unified memory pool available on high-memory APUs, enabling system RAM to be dynamically allocated as graphics memory. This enhancement improves memory utilization and supports the execution of larger AI models on affected APU platforms. * Fixed a memory leak in the HIP/HSA runtime that could occur during stream and signal creation on certain GPUs. The issue was triggered by `hipStreamCreate()`, resulting in allocated signal objects not being properly released. The HIP/HSA runtime now correctly releases allocated signal objects during stream destruction and runtime cleanup, eliminating the memory leak and improving resource management. ##### Known issues * Under WSL2 (Windows Subsystem for Linux 2), GPU device-side memory faults might not be reported correctly and can result in the process hanging. #### **hipBLAS** (3.7.0) ##### Added * Level 3 grouped batched GEMM functions `hipblasSgemmGroupedBatched`, `hipblasDgemmGroupedBatched`, `hipblasGemmGroupedBatchedEx`, and `hipblasGemmGroupedBatchedExWithFlags` for both C and FORTRAN, including ILP64 API (`_64` name suffix). #### **hipCUB** (4.7.0) ##### Changed * Benchmarking now uses primbench for its benchmarks instead of Google Benchmark. * See [primbench/README.md](https://github.com/ROCm/rocm-libraries/blob/develop/shared/primbench/README.md) for its documentation. #### **hipFFT** (1.0.26) ##### Added * Support for the `amdgcnspirv` architecture in client programs, so that they are functional even on gfx architectures for which they have not been explicitly compiled. * `hipfftXtSetWorkArea` API for setting work areas on single-process, multi-device plans. * Implemented `hipfftXtSetJITCallback` API, to allow for user-defined device functions to be called when loading input or storing output of a transform. These callback functions are specified after a plan is allocated with `hipfftCreate` but before the plan is initialized with one of the `MakePlan` functions. The backend FFT library will Just-In-Time (JIT) compile the code into its own kernels. On AMD platforms, the device function is provided as SPIR-V. On CUDA platforms, the device function is provided as LTO-IR fatbin. These APIs are not currently compatible with multi-GPU transforms. This support will be added in a future release of hipFFT. ##### Changed * Modified the rocFFT backend’s implementation details of hipFFT so that cuFFT backend’s behavior is matched for single-process, multi-device plans configured via `hipfftMakePlan{2,3}d` and `hipfftMakePlanMany`, with respect to data distribution within descriptors. Behaviors are now aligned for unbatched multi-dimensional transforms (in-place only) and all batched transforms (in-place and out-of-place). Multi-device, unbatched one-dimensional transforms remain unimplemented pending further analyses of the exact behavior(s) to be matched. ##### Resolved issues * Fixed a hang when creating a plan with a zero length or zero batch. These now return `HIPFFT_INVALID_SIZE`. * `hipfftGetSize*` work area estimates now account for the plan’s pre-initialization state (e.g. multi-device configuration) instead of ignoring it. ##### Upcoming changes * The `hipfftXtSetCallback` and `hipfftXtClearCallback` APIs are now deprecated and will be removed in a future release. They allow for specifying callbacks as device function pointers at plan execution time, but rocFFT cannot optimize the combined code. Instead, users should specify JIT callbacks with `hipfftXtSetJITCallback` before initializing the plan. #### **hipFile** (0.5.0) ##### Added * A Stats API for querying hipFile I/O statistics. `hipFileGetStatsL1()`, `hipFileGetStatsL2()`, and `hipFileGetStatsL3()` return progressively more detailed counters: basic I/O and operation counts (Level 1), I/O size histograms (Level 2), and per-GPU statistics (Level 3). * `ais-check` now detects SR-IOV virtual function (VF) GPUs via `amd-smi` and warns when one is present. hipFile’s fastpath is only supported on GPU physical functions (PFs); on a VF, I/O falls back to the compatibility path. The check is skipped if `amd-smi` is unavailable. * `hipFileReadAsync()` and `hipFileWriteAsync()` now support the AIS fastpath backend, enabling asynchronous GPU-direct I/O enqueued on a HIP stream. Transparent async backend failover to the slowpath is not currently supported for async fastpath operations. * Batch operations now execute on an internal thread pool, enabling batch API support on the AMD backend. Together with async fastpath support, this resolves the 0.3.0 limitation where batch and async API calls were unsupported on the AMD backend. * The `HIPFILE_ASYNC_BUFFER_SIZE` environment variable to control the size of the host bounce buffer used for asynchronous fallback I/O. The default size is 16 MiB; setting it to `0` uses the default. ##### Changed * The synchronous fallback I/O path now sets the active HIP device to the buffer’s GPU before `hipMemcpy` and restores the caller’s device afterward, fixing copies that could run against the wrong device context. * Asynchronous fallback I/O now reuses a single per-stream bounce buffer, splitting large transfers into chunks that fit the buffer, to reduce the memory footprint of asynchronous workloads. ##### Resolved issues * Corrected CMake ROCm path detection so out-of-tree builds locate the correct ROCm installation. ##### Known issues * Asynchronous operations that use the fastpath backend will not retry on the fallback backend. If asynchronous operations have proper alignment, they now run on the fastpath backend. If the fastpath device lookup fails or the P2P DMA transfer is not supported between the devices, the asynchronous operation will now fail. #### **hipSOLVER** (3.7.0) ##### Added * Compatibility-only functions for larft: * `hipsolverDnXlarft_bufferSize` * `hipsolverDnXlarft` ##### Resolved issues * Fixed `hipsolverDnXpotrs` calling 32-bit potrs instead of 64-bit potrs. #### **hipSPARSE** (4.8.0) ##### Added * The generic API routines `hipsparseSpGEAM_createDescr`, `hipsparseSpGEAM_destroyDescr`, `hipsparseSpGEAM_bufferSize`, `hipsparseSpGEAM_nnz`, and `hipsparseSpGEAM` for sparse matrix-matrix addition (`C = alpha * op(A) + beta * op(B)`), along with the `hipsparseSpGEAMDescr_t` type and the `hipsparseSpGEAMAlg_t` algorithm enum, to match the cuSPARSE 13.3 generic `SpGEAM` API. * Batched support to `hipsparseSDDMM` for CSR format. #### **hipThreads** (1.0.0) ##### Added * `std::thread`-style concurrency primitives that run inside GPU kernels. `hip::wthread`, `hip::mutex`, `hip::lock_guard`, and `hip::condition_variable`, along with cooperative `pseudo_*` variants, mirror the C++ standard-library concurrency API. * A persistent scheduler kernel that accepts work from both the host and the device, with multi-fiber (SIMD width) execution so a single unit of work can run across multiple GPU lanes. * Runtime-tunable scheduling. Scheduler concurrency can be configured at runtime through the `HIPTHREADS_VCORES_PER_WGP` environment variable to match your GPU and workload. * Cross-platform build and tooling. A CMake build with native HIP language support, a lit-based test suite, and example projects. All are supported on Linux and Windows. #### **libhipcxx** (3.0.2) ##### Added * libhipcxx is included in the ROCm Core SDK and is built with TheRock. * ``, backported to C++14. * ``, backported to C++14. * ``, backported to C++14. C++20 concepts are usable in C++14 and C++17 through existing SFINAE techniques. * Structured bindings for `cuda::std::tuple`, `cuda::std::pair`, and `cuda::std::array`. * Experimental `{async_}resource_ref`. * Support for Clang 15. * Support for using `lerp` in device code. ##### Changed * Advanced the version to 2.1 with no breaking changes, aligning with Thrust and CUB as the three libraries move toward a unified CUDA C++ Core Libraries (CCCL) repository. * Updated the atomics backend to be compatible with `atomic_ref`. * Modularized ``, ``, ``, and ``. ##### Resolved issues * Fixed errors in `atomic` with small aggregates and enum classes. * Corrected CMake install rules. * Fixed several issues discovered through tests added for host-only translation units. #### **MIOpen** (3.6.1) ##### Added * Support for building kernels with debug symbols. Set `MIOPEN_DEBUG_SYMBOLS_KERNEL=1` to add debug symbols. * [BatchNorm] Implements Welford’s algorithm for calculating variance in FwdTrainSpatial variant 1 * [RNN] Added a fused single-layer LSTM forward-inference kernel, gated behind `MIOPEN_DEBUG_RNN_FUSED_INFERENCE` (disabled by default). * [Conv] Added a naive reference kernel enabling 3D INT8 forward convolution. * [Conv] Added the `ConvHipConv` solver backed by vendored hipconv kernels. * [Conv] Added float8 vector type support and deduplicated the shared math kernels. * [Conv] Added validated gfx1151 and gfx1200 (Navi) SystemDBs so immediate-mode lookups use tuned entries instead of generic heuristics. * [Conv] Added `MIOPEN_DEBUG_DISABLE_SYSTEM_DB` and `MIOPEN_DEBUG_DISABLE_USER_DB` runtime environment variables to disable the system and user databases. * [Conv] Enabled Composable Kernel (CK) depthwise convolution on RDNA wave32 GPUs. ##### Changed * [Conv] Pruned ASM-GTC NHWC entries from the gfx908, gfx90a, gfx942, and gfx950 system find-databases for shapes the new large-tensor guard rejects, so immediate-mode lookups no longer resolve to a solver that is gated off at runtime. This removes 12,907 entries across the six databases, 4,668 of them rank-1, and empties 81 keys. * [Conv] Enabled the Winograd Rage RxS f2x3 solver on gfx950 and updated the gfx942 kernels to v4_6_1/v4_9_1. * [Conv] Updated the 3D AI heuristics (solver selection) for gfx942 and gfx950. ##### Removed * Removed disabled convolution solver `ConvCkIgemmFwdV6r1DlopsNchw`, `ConvHipImplicitGemmBwdDataV1R1Xdlops`, and `ConvHipImplicitGemmBwdDataV4R1`. ##### Optimized * [Conv] Use a single GEMM for point (1x1) output convolutions in all three directions (forward, backward-data, and backward-weights) for both 2D and 3D. * [Conv] Optimized the naive backward-data convolution kernel by widening its workgroup to 1024 threads. ##### Resolved issues * [Conv] Fixed silently incorrect results from the grouped backward-weights CK xdlops solver when a tensor’s element extent exceeds INT_MAX but its individual lengths and strides still fit int32; such problems now use a large-tensor (int64) CK instance instead of overflowing int32 indexing. * [Conv] Fixed a HIPRTC compilation failure in the ConvDepthwiseFwd3D (gfx942/gfx950) FP16/BFP16 solver. * [BatchNorm] Fixed MIOpen#3900 by implementing Welford’s algorithm in FwdTrainSpatial variant 1 * [Conv] Fixed a batch-split miscalculation that produced incorrect results for large backward-weights (WrW) tensors. * [Conv] Fixed a convolution failure on XNACK-unsupported gfx9 APUs (gfx902, gfx909, gfx90c). * [BatchNorm] Fixed a device heap-buffer-overflow in the forward spatial `FinalMeanVariance` kernel. * [Conv] Fixed incorrect `SetNextValue` polarity in deterministic mode for the grouped backward-data and backward-weights CK solvers. * [LRN][LayerNorm] Fixed grid alignment and out-of-bounds thread access on gfx1250. * [Conv] Removed stale gfx950 grouped backward-weights SystemDB entries that caused suboptimal solver selection. * [Conv][Windows] Fixed system-database path resolution to use the MIOpen module location. * Fixed JSON performance logs (`MIOPEN_PERFORMANCE_LOGS`) dropping the last solver evaluated during Find, so naive convolution solvers are no longer omitted. * Fixed a build failure when compiling against GCC 15’s libstdc++ under C++20. #### **RCCL** (2.30.7) ##### Added * Communicator suspend and resume (`ncclCommSuspend`, `ncclCommResume`, `ncclCommMemStats`), which releases the dynamic GPU memory of an idle communicator and reacquires it later without destroying the communicator. * accl-profiler profiler plugin for per-collective timing decomposition (`ACCL_PROFILER_OUTPUT_DIR`, `ACCL_PROFILER_MIN_SIZE_BYTES`). * DDA `AllReduce` and `AllGather` on the gfx1250 fabric path in both LL and LL128 protocols. `AllReduce` adds one-shot and two-shot tiers per protocol, AllGather one tier each. Gated by `RCCL_DDA_ENABLE` and `RCCL_DDA_LL`, both default on. * An experimental gfx1250 Tensor Data Mover path for copy-shaped SIMPLE-protocol transfers. All collectives can reach it, but reduction collectives only qualify on slices that carry no reduction operation. Excluded from the default build: it requires `--enable-tdm-simple` at build time and `RCCL_TDM_SIMPLE_ENABLE=1` at runtime. Reduction into LDS staging buffers and double buffering are not yet implemented. * `install.sh --all_unrolls` (`-DBUILD_ALL_UNROLLS=ON`) to generate every unroll factor (1, 2, 4, 8, 16, 32) for the targeted GPU architecture(s), for measuring unroll factors that the default per-arch matrix does not build. The flag also drops the per-architecture pin, so such a build accepts every `RCCL_UNROLL_FACTOR` value on any targeted architecture. * The strict `--enable-full-coverage` install flag for unified host + device LLVM source-based code coverage. It requires `--debug`, the device linker, and ROCm 7.15 or newer. The test runner uses the CMake-level `ENABLE_FULL_COVERAGE=AUTO` mode, which falls back to host-only coverage when device instrumentation is unavailable. * Enabled the Copy-Engine profiler path (`ncclProfiler_v6`): Copy-Engine events are emitted for CE collectives, and the example profiler plugin reports them. ##### Changed * Raised the default channel count on single-node gfx1250 to 256 for both collectives and P2P. The count is still clamped by the GPU CU count and by `NCCL_MAX_NCHANNELS` / `NCCL_MAX_CTAS` / `NCCL_MAX_P2P_NCHANNELS`. Multi-node gfx1250 keeps the 64-channel cap on the NET path. `RCCL_SATURATE_P2P_NCHANNELS` now defaults to on for gfx1250 so the per-peer channel count tiles the larger pool; set it to `0` to restore the previous behavior. * Narrowed unroll-factor kernel generation: gfx1250 local builds now generate only unroll 32, its runtime default, instead of 8/16/32, and a multi-arch build generates 1/2/4/32 instead of all six factors. This cuts the multi-arch kernel count by roughly a third; use `--all_unrolls` to build 8 and 16. * Capped DDA fabric SIMPLE kernels by each GPU’s CU count and use the clique-wide minimum so every rank launches matching barrier blocks. `RCCL_DDA_FABRIC_MAXBLOCKS` can lower this cap but cannot raise it; invalid, nonpositive, and excessive values now produce diagnostics. * Raised `kDdaMaxNranks` from 72 to 144, extending DDA fabric path support to larger DPX cliques. ##### Resolved issues * `NCCL_MAX_P2P_NCHANNELS` opt-in is now detected from the environment rather than from the parameter value. The value defaults to `MAXCHANNELS`, so every unset run was treated as an opt-in past the historical `4*CHANNEL_LIMIT` (64) bound. As a result, P2P channels on non-gfx1250 architectures were limited only by the collective channel count, and the gfx950 (MI350) multi-node P2P caps never applied. Set `NCCL_MAX_P2P_NCHANNELS` explicitly to restore a higher bound. * Fixed `ncclConfig_t::maxP2pPeers` and `NCCL_P2P_MAX_PEERS` having no effect. The field was plumbed through configuration parsing, validation, the version gate, the communicator-size cap and the rank exchange, but the resolved `comm->p2pMaxPeers` was never read: the NCCL consumer sits inside `ncclTopoComputeP2pChannels`, which RCCL rewrites, so the NCCL 2.30.4 sync landed the producer without the consumer. Both P2P per-peer channel heuristics, the `RCCL_SATURATE_P2P_NCHANNELS` tiling and the multi-node per-peer reduction, now divide by `maxP2pPeers` instead of the full rank count, so limiting the number of concurrent P2P peers raises the number of channels each of those peers receives. Library behavior is unchanged when the knob is left unset, where `maxP2pPeers` resolves to the communicator size. Note that rccl-tests `sendrecv_perf` sets `maxP2pPeers = 2` through the communicator config, so its per-peer channel count, and therefore its reported bandwidth, does change. Two `NCCL_ENV` log lines also named the variable `NCCL_MAX_P2P_PEERS`; the variable is, and always was, `NCCL_P2P_MAX_PEERS`. * Fixed `NCCL_CHECK_MODE` having no effect. `commAlloc` reset `comm->checkMode` from the deprecated `NCCL_CHECK_POINTERS` after `NCCL_CHECK_MODE` had already been parsed, so `DEBUG_LOCAL` was only reachable through the deprecated variable and `DEBUG_GLOBAL`, which validates symmetric buffer registration across ranks, was unreachable entirely. * `RCCL_UNROLL_FACTOR` is now rejected when the requested unroll factor’s device functions were not compiled for the running architecture, instead of being accepted and then dispatching into an empty device function table. Unroll factor 32 is compiled for gfx1250 only, but a multi-arch build reported every unroll factor as available, so requesting it on another GPU crashed on the device. That value now fails communicator initialization with a warning naming the architecture, and the default selection falls back to the highest unroll factor actually compiled for the GPU rather than trusting the heuristic’s choice. The WarpSpeed auto-tuner’s preference for unroll factor 2 is subject to the same check, so it no longer replaces a validated unroll factor with one this build cannot dispatch. gfx1250 is unaffected and still defaults to 32. * Fixed the per-unroll device function tables being misaligned in multi-arch builds. The LL128 `SendRecv` kernel was skipped for unrolls 8/16/32, so every function after `SendRecv` in those tables sat one index below the id the host had computed from the unroll-1 ordering, and the last entry of the host lookup table was dropped. `AlltoAllPivot`, `AlltoAllGda`, `AlltoAllvGda` and `AllGatherV` were affected on gfx1250. * Fixed the AMD SMI fabric ABI guard rejecting the layout amd_smi 27.x introduced, which broke the RCCL build outright. The fabric payload union gained a second member, enlarging `amdsmi_fabric_info_t` without moving the v1 fields RCCL reads. RCCL now recognizes that layout, identifies the loaded runtime by how much of the probe buffer it writes, and falls back to the sysfs fabric backend on a 27.x runtime rather than reading a payload it does not model. Fabric topology on such a runtime therefore comes from sysfs, and RCCL warns once per process when it makes that switch. * Fixed gfx1250 LL and LL128 comm-FIFO hangs on sibling DPX partitions. The FIFO store now uses system-scope b128 (`RCCL_LL_FIFO_SYS_SCOPE`) alongside the existing system-scope load, preventing hangs at slot reuse starting from the 9th collective operation. * Fixed DDA fabric AllToAll validation race by staging send data into scratch with a host-launched `cudaMemcpyAsync` before the peer exchange kernel. * Fixed DDA fabric barrier publication race causing sporadic validation errors by using release-acquire semantics on the prologue barrier. ##### Known issues * On gfx90a (MI210/MI250/MI250X) with ROCm 7.14 or later, per-launch scratch-memory reclaim in the runtime degrades RCCL performance. Set `HSA_NO_SCRATCH_RECLAIM=1` to restore performance. * Collectives that select the RCCL DDA path are not traced by the profiler plugins. `RCCL_DDA_ENABLE=0` can be used to route the collectives through the instrumented path while profiling. #### **rocBLAS** (5.7.0) ##### Added * Level 3 grouped batched GEMM functions `rocblas_sgemm_grouped_batched`, `rocblas_dgemm_grouped_batched`, and `rocblas_gemm_grouped_batched_ex` for both C and FORTRAN, including ILP64 API (`_64` name suffix). ##### Changed * On gfx950, Level 3 `gemm`, `gemm_ex`, and the functions that internally use GEMM, for single- and double-precision now default to the hipBLASLt backend instead of Tensile. Complex types on gfx950 still default to Tensile. `ROCBLAS_USE_HIPBLASLT` continues to force or disable the hipBLASLt backend. ##### Optimized * Improved the performance of Level 3 `gemm` for the problem sizes where `m == 1` or `n == 1` and `batch_count == 1` by using `gemv` kernels, previously applied only in `gemm_ex`. On gfx11 the per-precision heuristics guarding this path are also bypassed, except for the `1x1` case. * Improved the performance of Level 2 `gemv` non-transposed (`TransA == N`) for the problem sizes where `m` is small and `n` is large by splitting the reduction across the grid, as the transposed case already does. ##### Resolved issues * Fix incorrect per-batch `alpha`/`beta` values on the ILP64 (`_64`) path for batched and strided-batched `scal` (including `_ex`), `ger`, `geru`, `gerc`, `syr`, `symv`, `hemv`, `sbmv`, and `spmv` when `rocblas_set_batch_alpha_stride` or `rocblas_set_batch_beta_stride` is set in device pointer mode. The 64-bit launchers passed an unoffset scalar pointer into each batch chunk, and `scal` also advanced `alpha` by the vector-length chunk instead of the batch index, so later batches used the wrong scalars. * Fix out-of-bounds workspace access in Level 3 batched and strided-batched `syrk` and `herk` on gfx90a and gfx942 with `batch_count` greater than 65536, `k` of at least 500, and `n` below an internal per-architecture threshold, where the GEMM-only path advanced its workspace pointer cumulatively on each pass of the batch sweep and so wrote past the end of the workspace. This could corrupt memory past a workspace supplied through `rocblas_set_workspace` or, when the device memory pool was sized to the requirement reported by a size query, fault, or return incorrect results. The ILP64 (`_64`) forms were unaffected. * Fix incorrect results from Level 1 `dot` and `dotc` batched and strided-batched forms, including their `_ex` forms, when `batch_count` is greater than 65535. Every batch item at index 65535 and beyond reduced an empty range and returned zero. The ILP64 (`_64`) forms were unaffected, as they chunk the batch dimension below that limit. * Fix incorrect results from Level 3 batched and strided-batched `trsm` on the small left-side device path when `batch_count` is greater than 65535 and each batch item has a distinct `A` pointer. Threads that finished the first grid pass left the kernel, so later passes could not reload `A`. Also fix Level 3 `trmm` out-of-place when `batch_count` is greater than 65535 and a per-batch `alpha` of zero caused the kernel to skip remaining batches. The ILP64 (`_64`) forms were unaffected, as they chunk the batch dimension below that limit. * Fix the hipBLASLt backend returning `rocblas_status_internal_error` when an explicit GEMM solution index is unsupported. The call now returns `rocblas_status_invalid_value`, matching Tensile. * Fix `ROCBLAS_TENSILE_GEMM_OVERRIDE_PATH` ignoring the solution indices reported by `rocblas_gemm_ex_get_solutions` and `rocblas-gemm-tune`. Tensile solutions are reported as negative indices and were previously discarded when loading an override file, leaving the default kernel selection in place. Raw positive Tensile indices in existing override files are still honored after this fix. An entry which names no Tensile solution is skipped with a warning instead of failing the other overrides in the file. * Fix `rocblas-gemm-tune` skipped best solution reporting when it came from the Tensile backend. Problems whose fastest kernel belongs to neither backend, such as the internal gemv kernel, remain unreported as no index can name them. * Fix a process hang on Windows exit when profile logging is enabled (`ROCBLAS_LAYER` bit 2, for example `ROCBLAS_LAYER=4`). The profile dump waited on a worker thread that the loader had already terminated during `DLL_PROCESS_DETACH`. #### **rocDecode** (1.10.0) ##### Added * Support for explicitly loading `librocm_sysdeps_va` via `dlopen`, ensuring complete isolation from the system `libva` library. ##### Resolved issues * Resolved vendored `libva` link issue in samples without extra env vars. #### **rocFFT** (1.0.40) ##### Added * Support for the `amdgcnspirv` architecture in client programs, so that they are functional even on gfx architectures for which they have not been explicitly compiled. * Implemented `rocfft_plan_description_set_load_callback` and `rocfft_plan_description_set_store_callback` APIs, to allow for user-defined device functions to be called when loading input or storing output of a transform. These callback functions are specified during plan creation and allow rocFFT to Just-In-Time (JIT) compile the code into rocFFT’s own kernels. Also implemented `rocfft_execution_info_set_load_callback_data` and `rocfft_execution_info_set_store_callback_data` APIs to allow specifying the data pointers for these callbacks, which may differ on each execution. These APIs are not currently compatible with transforms that have fields or bricks also specified on the same plan description. This support will be added in a future release of rocFFT. * Support for very large FFTs on gfx1250. ##### Resolved issues * Addressed a cache-reuse issue with RCCL communicators by giving each communicator its own set of streams. * Fixed multi-dimensional real transforms returning wrong results when a complex transform that shares the same internal 2D kernel had been planned earlier in the process and its plan was still alive. A real transform’s kernel needs extra twiddle values for its fused real pre/post-processing step, but the 2D twiddle table cache key did not distinguish the two, so the real transform could be handed the complex transform’s shorter table. * Fixed `rocfft_plan_create` hanging when given a zero FFT length, zero batch, or zero dimensions; these now return `rocfft_status_invalid_dimensions` or `rocfft_status_invalid_arg_value`. * Fixed `rocfft_execution_info_set_stream` to derive the device from the stream itself instead of assuming the current device. * Fixed a potential issue where rocFFT could terminate the calling process if a HIP module failed to load during plan creation. ##### Known issues * Function pointer callbacks specified via `rocfft_execution_info_set_load_callback` or `rocfft_execution_info_set_store_callback` are not functional on gfx1250 and `rocfft_execute` will fail in this case. ##### Upcoming changes * The `rocfft_execution_info_set_load_callback` and `rocfft_execution_info_set_store_callback` APIs are now deprecated and will be removed in a future release. They allow for specifying callbacks as device function pointers at plan execution time, but rocFFT cannot optimize the combined code. Instead, users should specify JIT callbacks on plan descriptions. #### **rocJPEG** (1.10.0) ##### Added * `rocJpegDecodeBatchedAsync` and `rocJpegDecodeBatchedSync` APIs to support asynchronous batched JPEG decoding. * Support for explicitly loading librocm_sysdeps_va via dlopen, ensuring complete isolation from the system `libva` library. #### **ROCm Compute Profiler** (3.9.0) ##### Added * GPU benchmarking and roofline profiling and analysis support for gfx1153 hardware. * Per-kernel PC sampling analysis. * `rocprof-compute analyze --output-format csv` writes each kernel’s disassembly under `per_kernel_pc_sampling/`, with the sample and stall counts on every instruction and the source it was compiled from. * The analysis database records the same per-instruction data, so `--output-format db` can be queried for it. * Multi-process PC sampling across profile and analyze modes. * Profile mode writes one PID-prefixed `_ps_file_results.json` per process. * Analyze mode reports every process in a single run, with a `pid` column identifying each one. * Redesigned the standalone roofline HTML to improve user experience and interactivity. * A profile-mode warning reporting the active compute and memory partition modes on partition-capable accelerators, noting that analysis derives logical XCD, L2 channel, and HBM channel counts from them. * [Profile vLLM workloads](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/docs-10.1.0/how-to/profile/mode.html#profile-vllm-workloads) guide for profiling vLLM workloads and its caveats. ##### Changed * Renamed the PC sampling analysis output: `pc_sampling.csv` is now `pc_sampling_summary.csv`, and the `compute_pc_sampling_view` view is now `compute_pc_sampling_summary_view`. * ML API tracing options (`--torch-trace`/`--triton-trace`/`--ml-api-trace`) are no longer allowed with PC-sampling-only profiling; the run now fails with an error telling the user to drop the ML API tracing flag or add a counter block, since without counters there is nothing to correlate the markers against. ##### Removed * Removed the CSV profile output backend and the `--format-rocprof-output` profile mode option. Profiling now always uses the `rocpd` output format, which was already the default. * Removed the `--join-type` profile mode option, which only affected the CSV output format. * Removed analyze support for workloads produced by the CSV profile backend. Such workloads are now rejected with an error telling you to re-profile with a current release. ##### Optimized * Reduced profile-mode peak memory when writing counter data on large workloads. * Profile mode now gzip-compresses large counter CSV artifacts to reduce workload directory size. ##### Resolved issues * Corrected the VGPR allocation label from `RVGPRseq` to `VGPRs` in gfx9 memory charts #### **ROCm Data Center Tool** (1.3.1) ##### Removed - Removed the unused `GetBlockNameStr()` test helper and its GPU block name map. Nothing called it, and its `static_assert` on `AMDSMI_GPU_BLOCK_LAST` broke the RDC build whenever AMD SMI added an IP block. ##### Resolved issues - `RDC_FI_GPU_MEMORY_CUR_BANDWIDTH` no longer reports zero under DMA or copy-only memory traffic on GPUs whose instantaneous UMC activity does not reflect DMA transfers. It now derives memory activity from the `mem_activity_acc` accumulator over firmware time, and falls back to the instantaneous `umc_activity` reading when the accumulator or firmware timestamp is unavailable. - `RDC_FI_ECC_CORRECT_TOTAL`, `RDC_FI_ECC_UNCORRECT_TOTAL`, and `RDC_FI_ECC_DEFERRED_TOTAL` no longer hang when AMD SMI defines GPU blocks above bit 31. The block iteration used a 32-bit counter that wrapped to zero instead of terminating. #### **ROCm Debugger (ROCgdb)** (16.3) ##### Added * For AMD64 and AMDGPU targets, ROCgdb now displays backtrace information for Clang’s `__builtin_verbose_trap`. The debug information emitted by the compiler describes the category and message arguments passed to the built-in as a call to an inlined function, and ROCgdb presents it as the context of frame `#0: #0 ... __clang_trap_msg$$ () at ...` * Support for the gfx1103 GPU architecture. ##### Changed * Improved `maint print address-spaces` command to display properties of address spaces supported by an architecture. For each address space, print its name, DWARF id, address size, null address, and access class. * The “catch hiperr” feature is now exposed to MI too, with a new `-catch-hiperr` command and related fields in `*stopped` records. See the “HIP Runtime Error” subsection of the “GDB/MI Catchpoint Commands” section in the [ROCgdb manual](https://rocm.docs.amd.com/projects/ROCgdb/en/latest/ROCgdb/gdb/doc/gdb/GDB_002fMI-Catchpoint-Commands.html). #### **ROCm Systems Profiler** (1.9.0) ##### Changed - **rocpd is now the default output format.** When no output format is specified, profiling data is emitted as a rocpd SQLite database (`rocpd.db`). Perfetto (`.proto`) output must now be explicitly enabled via `--output-format proto`. Requires ROCProfiler-SDK 1.0.0 or later (ROCm 7.0.0+). - `ROCPROFSYS_PROFILE` (timemory backend) now defaults to `false`, since rocpd replaces Perfetto as the primary trace output. - All built-in presets that perform tracing (`--balanced`, `--detailed`, `--sys-trace`, `--runtime-trace`, `--trace-gpu`, `--trace-hpc`, `--trace-hw-counters`, `--trace-openmp`, `--workload-trace`) now produce a rocpd database by default, because rocpd is the new library default. The `--profile-only` and `--profile-mpi` presets explicitly disable rocpd output to preserve their lightweight, flat-profile-only character. - `ROCPROFSYS_SAMPLING_GPUS` is now restricted by the GPUs the ROCm runtime exposes via `ROCR_VISIBLE_DEVICES` / `HIP_VISIBLE_DEVICES`. - The `trace-hpc` preset now enables flat profiling (`ROCPROFSYS_FLAT_PROFILE`) by default. Pass `--profile` to get a call-stack-based profile instead. - `rocprof-sys-python` no longer accepts abbreviated long options (for example, `--conf` for `--config`). Spell out the full option name. ##### Removed - Removed the `ROCPROFSYS_BUILD_SQLITE3` CMake option and the in-tree SQLite3/rocpd storage backend. This is now handled by profiler-hub. - Removed the deprecated `rocprof-sys-user` library and its C API (`rocprofsys_user_*`, ``), including the `user` find_package component, the `examples/user-api` example, the Python `rocprofsys.user` submodule, and the associated pytest coverage. Use ROCTx (`rocprofiler-sdk-roctx`) for general-purpose manual instrumentation (starting/stopping tracing, named regions) instead; see `examples/roctx` for usage. - Causal profiling’s `ROCPROFSYS_CAUSAL_PROGRESS`/`ROCPROFSYS_CAUSAL_BEGIN`/ `ROCPROFSYS_CAUSAL_END` macros are unaffected at the source level: they now run on a new, minimal `rocprof-sys-causal-api` library instead of the removed general-purpose user API. Existing causal profiling code does not need to be edited, but it must be rebuilt against the new headers and library, and projects that requested the old component via `find_package(rocprofiler-systems COMPONENTS user)` must change that to `COMPONENTS causal-api`. The `user` component no longer exists, so requesting it now fails at configure time. ##### Resolved issues - Fixed `rocprof-sys-python` ignoring the `-c`/`--config` flag. The configuration file is now applied to `ROCPROFSYS_CONFIG_FILE` before the profiler bindings are loaded, so its settings take effect. A configuration file already named by `ROCPROFSYS_CONFIG_FILE` is preserved, and the one given on the command line is appended to it. - Pausing sampling now stops the underlying per-thread timers instead of only discarding the samples they produce. Previously a paused sampler kept delivering timer signals, so the profiled application’s sleeps were still interrupted throughout a window in which no data was being collected. - `ROCPROFSYS_TRACE_DELAY`/`ROCPROFSYS_TRACE_DURATION` now actually gate GPU context startup, producing a real gap in cached GPU/rocpd data. Previously they only suppressed downstream category emission. For GPU-only tracing with no marker domain or trace region configured, the configured delay had no effect at all on when GPU data collection actually began. #### **ROCprofiler-SDK** (1.4.1) ##### Added **API:** - Advanced Thread Trace (ATT) support in the live attach workflow: - On attach, the SDK registers for code-object iteration and creation callbacks so thread trace operates correctly on code objects that were loaded before the attach occurred. - Makes ATT usable on already-running production workloads without an application restart. - Experimental SQTT quick scan mode for thread trace, enabled through a new CMake flag: - Collects thread trace data without packet insertion or HSA signal manipulation, removing the queue interception overhead required by the standard ATT path. - Individual kernels can be traced without serialization, and the path is independent of the ROCm runtime version. - Experimental: intended to validate the new collection path and to enable out-of-process thread trace and long-kernel tracing in future releases. - HIP event tracing: GPU-side barrier tracing for `hipEventRecord` and `hipStreamWaitEvent`: - New tracing kinds `ROCPROFILER_CALLBACK_TRACING_HIP_EVENT` and `ROCPROFILER_BUFFER_TRACING_HIP_EVENT` with operation enum `rocprofiler_hip_event_operation_t` (RECORD, WAIT). - New `--hip-event-trace` CLI flag, automatically enabled by `--hip-trace` and `--hip-runtime-trace`. - rocpd schema bumped to 3.0.4 with new `rocpd_hip_event` table and `hip_events` data view. **rocprof-trace-decoder:** - Python API for decoding Advanced Thread Trace (ATT) / SQTT data directly from Python, without writing a C++ consumer: - Wraps the decoder library and exposes thread trace decoding as a first-class Python interface, with samples demonstrating common workflows. - Useful for analysis scripts, Jupyter notebooks, and custom profiling tools that process ATT output programmatically. - Decoder integration tests have been migrated to Python, simplifying test authoring and making it easier for downstream tools to validate their trace-decoding pipelines. ##### Resolved issues - Fixed `rocprofv3` crashing during output generation when a second tool subscribed to code object tracing in the same process, which blocked profiling PyTorch and Triton workloads through rocprofiler-compute. - Fixed `rocprofv3` hanging instead of exiting when a fatal signal arrives while it is already handling one, for example when output generation aborts. It previously left GPU child processes running and required killing the process manually. #### **ROCr Debug Agent** (2.2.0) ##### Added - The `--output` and `--save-code-objects` options now support ‘%’ format tokens to produce the output file names. The `%p`, `%h`, `%t`, `%e`, `%u`, `%g` and `%%` tokens are supported. #### **rocSHMEM** (3.7.0) ##### Added * New APIs: * `rocshmem_tile_{min, max, sum}_reduce{_wave}{_wg}` variants for the IPC backend * `rocshmem_ctx_tile_{min, max, sum}_reduce{_wave}{_wg}` variants for the IPC backend * Tile RMA and collectives support for GDA backend. * `--num_wf` argument to functional test harness for runtime wavefront size detection on architectures with wave size 32 (gfx1100, gfx1201, gfx1250). * LTO inline-remarks comparison toolset and interactive resource-usage dashboards under `scripts/analysis/`. * Optimized device API wrappers to remove double-indirection in cross-TU calls, enabling more reliable LTO inlining. * Reduced IPC RMA latency by caching the symmetric heap base and size in device constant memory, removing hot-path heap metadata loads in `ipcPeerPtr()`. ##### Changed * **Breaking build-system change**: The five compile-time CMake options `USE_HEAP_DEVICE_FINEGRAIN`, `USE_HEAP_DEVICE_UNCACHED`, `USE_HEAP_DEVICE_COARSEGRAIN`, `USE_HEAP_DEVICE_VMM_POSIX`, and `USE_HEAP_DEVICE_VMM_FABRIC` have been removed. Heap allocator selection is now a runtime decision via the environment variable: ```default ROCSHMEM_HEAP_ALLOCATOR_TYPE= ``` The default is architecture-dependent: `finegrained` for gfx1100/gfx1201, `uncached` for all other targets. The VMM allocator sources are now compiled unconditionally (when ROCm ≥ 7.2 / AMD SMI fabric handle support is detected) rather than behind build flags. ##### Resolved issues * Fixed `reduce_wg` and `reduce_wave` operations producing incorrect results for some scenarios * Fixed compilation of rocSHMEM when using clang++ instead of hipcc * Fixed team-relative PE rank computation in GDA alltoallv * Fixed `USE_SDMA=ON` builds failing for GDA+IPC with messages > 128 B * Fixed libverbs/libmlx5 discovery using `.so.1` versioned symlinks in GDA backend * Fixed Broadcom NIC (bnxt) dmabuf CQ/SQ creation * Fixed ASan build: correct string size for socket, exclude libhsa #### **rocSOLVER** (3.37.0) ##### Added * 2-stage reduction to tridiagonal in the Hermitian eigensolver (SYEVD/HEEVD) and generalized Hermitian eigensolver (SYGVD/HEGVD). * Cholesky QR methods for computing the QR factorization of a tall rectangular matrix - CHOLQR (with batched and strided_batched versions) - CHOLQR_64 (with batched and strided_batched versions) * Hessenberg reduction auxiliary routine * LAHR2 * 64-bit APIs for existing functions: - LARFT_64 ##### Optimized * Improved the performance of sygst/hegst. #### **rocSPARSE** (5.1.0) ##### Added * The `rocsparse_spmat_scale` generic routine for sparse matrix scaling (`C = alpha * A`). It writes to `C` `alpha` times the values of `A` and does not copy the sparsity pattern (`C` is assumed to already have the same sparsity pattern as `A`). `alpha` is passed as a self-describing scalar dense vector descriptor that can reside in host or device memory, so no temporary storage buffer is required. In-place operation (`C == A`) is supported. COO, COO AoS, CSR, CSC, BSR, ELL, Blocked ELL, and SELL formats are supported. * The `rocsparse_dnvec_descr_create_scalar` auxiliary routine, which creates a size-one dense vector descriptor for a host or device scalar. * Batched support to the SpMM algorithm `rocsparse_spmm_alg_csr_nnz_split` and `rocsparse_spmm_alg_csr_merge_path`. * `rocsparse_sddmm` batched support to CSR, CSC, COO, COO AoS, and ELL formats. * ELL format support to `rocsparse_spsv` and `rocsparse_sptrsv`. * The `rocsparse_solve_mode` enum (`triangular`, `diagonal`) and the `rocsparse_diagonal_modifier` enum (`none`, `absolute`) to enable diagonal-only solves in `rocsparse_sptrsv` and `rocsparse_sptrsm`, together with the `rocsparse_sptrsv_input_solve_mode` / `rocsparse_sptrsm_input_solve_mode` and `rocsparse_sptrsv_input_diagonal_modifier` / `rocsparse_sptrsm_input_diagonal_modifier` set-input values. The modifier selects the function applied to each diagonal value (`d` or `|d|`). CSR and CSC formats are supported. ##### Optimized * Optimized architecture-aware launch configurations for RDNA (wave32) and CDNA (wave64) GPUs, improving performance and performance portability for several sparse level 2 and level 3 routines without algorithmic or numerical changes. Affected routines include `rocsparse_spmv` for the CSR adaptive, nnz-split, and LRB algorithms, the COO (SoA and AoS) formats, and the ELL format (`rocsparse_Xellmv`); `rocsparse_Xbsrmv`; `rocsparse_Xbsrxmv`; `rocsparse_Xgemvi`; `rocsparse_Xgemmi`; and `rocsparse_spmm` with the blocked-ELL format. ##### Resolved issues * Fixed an integer overflow in `rocsparse_prune_dense2csr_by_percentage` and `rocsparse_prune_csr2csr_by_percentage`, which computed the matrix element count in 32-bit arithmetic. For matrices with more than `INT32_MAX` (~2.1 billion) elements the count overflowed to a negative value, resulting in out-of-bounds pointer construction and an invalid kernel launch grid. The element count is now computed in 64-bit arithmetic. * Fixed `rocsparse_spmm` with the segmented COO, atomic COO, segmented-atomic COO, and row-split CSR algorithms, which failed with `hipErrorInvalidConfiguration` for batch counts exceeding 65535 because the batch dimension of the kernel launch grid exceeded the maximum supported grid dimension. * Fixed an out-of-bounds write caused by an incorrectly sized temporary buffer in the CSR-to-CSC conversion performed by `rocsparse_sparse_to_sparse` when the row pointer and column index types differ (for example, 64-bit row pointers with 32-bit column indices). * Fixed an issue with `rocsparse_spmm` when using the nnz-split algorithm with the CSR or CSC format. The operation produced incorrect results because the segmented-block-reduction helper had shared-memory pointer parameters marked `__restrict__`, while threads in the block must read values written by other threads. The `__restrict__` attribute has now been removed. #### **rocThrust** (4.7.0) ##### Changed * rocThrust now searches for an existing SQLite3 system library first by default. SQLITE_USE_SYSTEM_PACKAGE can be set to OFF to force a local download of SQLite3. The minimum required version of SQLite3 is 3.51.3. * Updated the mechanism in which rocThrust looks for and includes libhipcxx to be compliant with libhipcxx packaging changes in ROCm 10.1.0. #### **RPP** (3.2.0) ##### Added * RPP is included in the ROCm Core SDK and is built with TheRock. * Single-image processing support for 8 kernels (Brightness, Blend, Box Filter, Crop, Flip, Gaussian Filter, Median Filter, Resize Nearest Neighbor) to match performance with OpenCV. * Runtime backend selection parameter (`RppBackend executionBackend`) for all RPP tensor API functions. * Backend tracking in `rppHandle_t` to store backend type (HOST or HIP). * `RPP_ERROR_HIP_LAUNCH` error type for reporting HIP kernel launch errors. * `rpp_BACKEND_TYPE` and `rpp_AUDIO_AUGMENTATIONS_SUPPORT` variables to the RPP CMake package configuration. ##### Changed * All RPP tensor API functions now use a single function signature. * Updated all test suite calls to use the unified API with a backend parameter. * Enhanced layout validation for image augmentations within the unified API. * Test suite dependency on TurboJPEG removed. The test suite now uses `.rgb` files as input. * OpenCV and pandas are now optional dependencies for the test suite. * `CMakeLists.txt` updated to remove batch PD references. * Updated the test suite to use `rpp_BACKEND_TYPE` and `rpp_AUDIO_AUGMENTATIONS_SUPPORT` from the RPP CMake package configuration instead of header parsing. * `find_package(rpp)` now automatically passes public include directories to the target link interface. ##### Removed * BatchPD legacy support. * `LEGACY_SUPPORT` compilation flag and all code enclosed within it. * OpenCL backend support. * Batch PD test suite and installation. ## ROCm breaking changes ### ROCm SMI is removed from the standard build ROCm SMI (rocm-smi-lib) is deprecated and, starting with this release, is no longer built or installed as part of the standard `ROCm/TheRock` build. Use the AMD SMI library and its `amd-smi` CLI as the supported replacement. ## ROCm known issues ROCm known issues are noted on [GitHub](https://github.com/ROCm/TheRock/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22Verified%20Issue%22). These issues will be fixed in a future ROCm release. For known issues related to individual components, review the [ROCm component changelogs](). ### Hugging Face model training throughput might regress for specific models on AMD Instinct MI350X When you run Hugging Face BERT, RoBERTa-large, DistilBERT-base, or GPT-2 training workloads on AMD Instinct MI350X (gfx950) GPUs, you might observe 6–22% longer training wall-clock time than expected. BERT and DistilBERT-base training are affected whether or not DeepSpeed ZeRO stage 0 is used. RoBERTa-large and GPT-2 training are affected only when using DeepSpeed ZeRO stage 0. See [GitHub issue #8878](https://github.com/ROCm/TheRock/issues/8878). #### NOTE The impact of this issue was initially reported in ROCm 10.0.0 and is partially addressed in ROCm 10.1.0 for other Hugging Face model configurations. See the [ROCm 10.1.0 resolved issues]() entry for details. ### amd-smi event command might stop responding indefinitely on WSL Running the `amd-smi event` subcommand on Windows Subsystem for Linux (WSL) might cause the process to stop responding, requiring manual intervention to terminate it. Note that the event subcommand is not supported on WSL. As a workaround, avoid running `amd-smi event` on WSL. If the command is run accidentally, terminate the process manually using `Ctrl+C` (twice) or use: ```bash kill -9 ``` See [GitHub issue #8787](https://github.com/ROCm/TheRock/issues/8787). ### Some GPU workloads on WSL2 might stop responding for certain device-side executions Some GPU workloads running on WSL2 might stop responding when they encounter certain device-side execution conditions, such as HIP device-side assertions or OpenCL device-side enqueues. In these situations, the GPU workload stops making progress, but the host application might remain active while waiting for completion, causing the application to become unresponsive until it is manually terminated. This issue may be observed on AMD Radeon GPUs, such as the Radeon RX 7900 XTX, when running under WSL2. Most HIP and OpenCL workloads are not affected. The issue is limited to workloads that trigger the affected execution paths. As a workaround, you can manually terminate the affected process and restart the application. For OpenCL workloads, avoid using device-side enqueue on WSL2 when possible. See [GitHub issue #8791](https://github.com/ROCm/TheRock/issues/8791). ### RCCL allreduce operations using the LL protocol might produce incorrect results on AMD Instinct MI350 Series GPUs Multi-GPU workloads relying on RCCL collective communications might produce incorrect results during `allreduce` operations when the Low Latency (LL) protocol is active. The issue has been observed to affect AMD Instinct MI350 Series GPUs. Affected workloads include distributed training and inference jobs where data correctness across GPUs cannot be guaranteed under this protocol. As a workaround, set the following environment variable to restrict RCCL to protocols that are known to produce correct results: ```bash export NCCL_PROTO=LL128,Simple ``` See [GitHub issue #8792](https://github.com/ROCm/TheRock/issues/8792). ### Valgrind workloads might stop responding on WSL2 with high system RAM Running workloads under Valgrind on WSL2 might stop responding during ROCm runtime initialization on AMD Radeon GPUs, such as the AMD Radeon RX 9060, on systems with a large amount of system RAM. This happens because WSL reserves GPU address space upfront in a way that can collide with Valgrind’s reserved memory range as system RAM grows. As a workaround, if Valgrind must be used on WSL2, limit the RAM available to the WSL instance to below approximately 36 GB (for example, using the `.wslconfig` `memory=` setting). Try lowering it more if the issue persists. Workloads that don’t use Valgrind are unaffected. See [GitHub issue #8793](https://github.com/ROCm/TheRock/issues/8793). ### RAS error injection and query are unavailable on AMD Instinct MI350P GPUs On AMD Instinct MI350P GPUs, the RAS error injection and query interfaces (used to validate error-handling paths, for example with the amdgpuras tool) are not supported in ROCm 10.1.0. Injection commands fail, and query commands report that the block doesn’t support querying. This affects only manual RAS error injection and query tooling. Normal GPU reliability features such as ECC detection and error recovery during regular operation are not affected. See [GitHub issue #8794](https://github.com/ROCm/TheRock/issues/8794). ### ComfyUI workloads might show lower performance on Radeon Pro W7900 GPUs ComfyUI-based AI workloads running on Radeon Pro W7900 GPUs might experience lower performance compared to previous ROCm releases. Impacted workloads include image and video generation models such as Stable Diffusion, Wan, and LTX. See [GitHub issue #8842](https://github.com/ROCm/TheRock/issues/8842). ### Device-to-device hipMemcpyAsync might fail on AMD Instinct MI200 Series GPUs On AMD Instinct MI200 Series GPUs, device-to-device `hipMemcpyAsync` copies that use the DMA engine path (for example, with the `hipMemcpyDeviceToDeviceNoCU` flag) might fail without changing the destination buffer and reporting an error. This happens because the copy path selects an SDMA engine without properly validating which engines are actually usable for that GPU pair, so the transfer can target an engine that never completes the write. Although this issue was validated on PCIe-connected systems, the root cause is topology-agnostic and might also affect xGMI-linked systems. As a workaround, use `hipMemcpyDeviceToDevice` (without `NoCU`), which copies through compute units instead of DMA and is not affected. See [GitHub issue #8843](https://github.com/ROCm/TheRock/issues/8843). ### Multi-application workloads might experience an intermittent GPU page fault on some Instinct GPUs Running multiple concurrent applications with high GPU memory-transfer activity, including SDMA-driven copies and SDMA engine stalls, might intermittently trigger a GPU page fault on some Instinct GPUs. When this happens, the affected job stops responding and must be restarted. In some cases, the GPU queue does not recover until a timeout of about 15 minutes expires, and the kernel log reports a retry page fault. The issue is more likely to occur when GPU memory is already under pressure from a recently run workload. See [GitHub issue #8844](https://github.com/ROCm/TheRock/issues/8844). ### vLLM server restarts might fail with out-of-memory errors on AMD Instinct MI350X and MI300X GPUs When you restart a vLLM server for a large, distributed model using tensor parallelism (for example, `-tp 8`) on AMD Instinct MI350X and MI300X GPUs, the new server might fail to start with an out-of-memory error: ```bash ValueError: Free memory on device cuda:N is less than desired GPU memory utilization Exception: Server failed to start ``` This happens when the GPU driver fails or delays in fully releasing memory from the previous server process. If the next server starts before that memory is released, it finds less free GPU memory than it requires and fails to start. Smaller tensor-parallel configurations and single-server runs are generally not affected. The issue is identified with larger, distributed models that use most of the available GPU memory. As a workaround, confirm that the previous process has fully released GPU memory before starting the next server. For example, you can use `rocm-smi --showmeminfo vram` or `amd-smi` to check the process release status. If `ps` still shows `VLLM::Worker_TP` processes from the earlier server, terminate them before starting the next one. See [GitHub issue #9052](https://github.com/ROCm/TheRock/issues/9052). ## ROCm resolved issues The following notable issues have been fixed in ROCm 10.1.0. ### PyTorch training and fine-tuning workloads might experience GPU resets or crashes on some Radeon GPUs Previously, PyTorch training and fine-tuning workloads using Llama-Factory or Unsloth could experience GPU resets or application crashes on some AMD Radeon graphics products, such as the Radeon RX 9070 Series and Radeon AI PRO R9700. See [GitHub issue #7699](https://github.com/ROCm/TheRock/issues/7699). ### Hugging Face model training throughput for specific models is restored on AMD Instinct MI350X ROCm 10.1.0 restores Hugging Face model training throughput to previous levels for BART, DiT (Diffusion Transformers), GPT-2, and Llama 2 70B Chat workloads on AMD Instinct MI350X (gfx950) GPUs, recovering the 9–25% throughput loss reported in the ROCm 10.0.0 known issues. The regression was caused by AOTriton 0.13b selecting a suboptimal flash-attention backward kernel instead of the faster 3-kernel split implementation used in AOTriton 0.11.2b. This kernel selection is corrected for these models in ROCm 10.1.0. See [GitHub issue #7696](https://github.com/ROCm/TheRock/issues/7696). #### NOTE BERT and DistilBERT-base training continue to be affected in ROCm 10.1.0 with or without DeepSpeed, along with GPT-2 and RoBERTa-large training that use DeepSpeed ZeRO stage 0. See the [ROCm 10.1.0 known issues]() for current status and workarounds. --- Source: https://rocm.docs.amd.com/en/latest/about/transition-guide-TheRock.html # Transition guide from legacy ROCm release stream The [ROCm Core SDK](https://rocm.docs.amd.com/en/latest/index.html#rocm-core-sdk) is built on TheRock, AMD’s new build system. The transition from the legacy ROCm release stream began with [ROCm Core SDK 7.14.0](https://rocm.docs.amd.com/en/docs-7.14.0/about/release-notes.html), the first production release. [ROCm 10.1.0](https://rocm.docs.amd.com/en/latest/about/release-notes.html) is the latest production release. For more on the transition, see [ROCm 7.14: TheRock Goes Production and Expands AMD’s AI Software Platform](https://rocm.blogs.amd.com/ecosystems-and-partners/rocm-7.14-blog/README.html). ## Major changes | Feature | ROCm Core SDK | ROCm legacy | Description | |------------------------|----------------------|---------------------------------------------------------|--------------------------------------------------------------------------------------------------| | Installation directory | /opt/rocm/core-10.1 | /opt/rocm-7.2/ | To support additional release streams downstream of the ROCm Core SDK. | | Package names | amdrocm-{component} | rocm-[$component] or roc[$component] or hip[$component] | Unique package prefix to avoid conflicts with upstream packages. | | Extras directory | /opt/rocm/extras-10/ | N/A | Shared install prefix scoped to each ROCm major version for projects built on the ROCm Core SDK. | ## Paths and linking For installations using your Linux distribution’s package manager, the `amdrocm` meta package configures `update-alternatives` and provides backward-compatible symlinks for `/opt/rocm/bin`, `/opt/rocm/lib`, and other `/opt/rocm/` directories. ## Installation formats ROCm Core SDK is available in the following distribution formats. For step-by-step installation instructions, see [Install ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html). | Format | Details | |--------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | DEB / RPM packages | System-wide install through your package manager (apt, dnf, or yum). The most familiar install path on a managed Linux system. Available from repo.amd.com. | | Tarball archives | Self-contained install that requires neither root nor a package manager, suited to HPC module systems and custom install locations. Archives follow the naming convention therock-dist-linux-{FAMILY}-{VERSION}.tar.gz (for example, therock-dist-linux-gfx110X-all-{VERSION}.tar.gz). For the {FAMILY} value for your GPU, see Architecture-specific packages available in ROCm 10.1.0.
Extract to any directory, then set PATH, LD_LIBRARY_PATH, and ROCM_PATH to point to the extracted location (default: /opt/rocm/core). Tarballs don't create symlinks or resolve dependencies.
Available from repo.amd.com. | | Python wheels | Install ROCm libraries directly into a virtual environment with pip, for Python-only workflows. Use the ROCm Python package index:
python -m pip install --index-url "rocm[libraries,devel]"
Framework wheels such as PyTorch, JAX, and vLLM are distributed separately. | | Runfile installer | Single-file guided installer with interactive and silent modes. Supports a custom install directory, automatic GPU detection, and optional driver installation. Use it when you want neither a package manager nor manual tarball extraction. | ### Choosing a format | If you need… | Use | |---------------------------------------------------------------------------------|------------------------| | Automatic updates and dependency tracking on bare metal | **DEB / RPM packages** | | A non-root install or multiple ROCm versions side by side | **Tarball** | | Only the Python interface to GPU-accelerated libraries in a virtual environment | **Wheel** | | A guided install without a package manager | **Runfile** | ## Software packages ROCm Core SDK packages are more consolidated than the legacy ROCm release stream. For example, hipBLAS and rocBLAS are now combined into one package, `amdrocm-blas`. The table below lists the packages, their contents, and the corresponding legacy packages. ### Linux packages available in ROCm 10.1.0 | ROCm Core SDK package | Package contents | ROCm legacy package | |-------------------------|----------------------------------------------------------------------|-----------------------------------------------------------------------------------| | amdrocm-amdsmi | amd-smi | amd-smi-lib, rocm-smi-lib | | amdrocm-llvm | amdclang++, hipcc, flang | rocm-llvm, rocm-llvm-dev, Fortran compiler (included in rocm-llvm OpenMP runtime) | | amdrocm-runtime | HIP, ROCR, runtime compilation | hip-runtime-amd, rocm-hip-runtime, rocm-language-runtime, hsa-rocr, comgr | | amdrocm-fft | rocFFT, hipFFT, hipFFTW | rocfft, hipfft | | amdrocm-blas | rocBLAS, hipBLAS, hipBLASLt, hipSPARSELt | rocblas, hipblas, hipblaslt, hipsparselt | | amdrocm-sparse | rocSPARSE, hipSPARSE | rocsparse, hipsparse | | amdrocm-hipfile | hipFile | — | | amdrocm-solver | rocSOLVER, hipSOLVER | rocsolver, hipsolver, rocalution | | amdrocm-dnn | hipDNN, MIOpen | miopen-hip | | amdrocm-rand | rocRAND, hipRAND | rocrand, hiprand | | amdrocm-ccl-dev / devel | rocPRIM, rocThrust, hipCUB, rocwmma, libhipcxx | rocprim, rocthrust, hipcub, rocwmma | | amdrocm-profiler | rocprofiler-systems, rocprofiler-compute, rocprofiler-sdk, roctracer | rocprofiler, rocprofiler-compute, rocprofiler-systems, rocprofiler-sdk, roctracer | | amdrocm-profiler-base | rocprofiler-sdk, roctracer | rocprofiler-register, roctracer, hsa-amd-aqlprofile | | amdrocm-base | rocminfo, rocm-core | rocm-core, rocminfo, rocm-cmake, half | | amdrocm-ck | Composable Kernel | composablekernel | | amdrocm-debugger | rocgdb, ROCdbgapi, ROCR Debug Agent | rocm-gdb, rocm-dbgapi, rocm-debug-agent | | amdrocm-hipify | HIPIFY | hipify-clang | | amdrocm-opencl | OpenCL runtime and ICD loader | rocm-opencl-runtime, rocm-opencl, hip-opencl | | amdrocm-decode | rocDecode | rocdecode | | amdrocm-jpeg | rocJPEG | rocjpeg | | amdrocm-rpp | ROCm Performance Primitives (RPP) | rpp | | amdrocm-thread | hipThreads | — | | amdrocm-rccl | rccl | rccl | | amdrocm-rocshmem | rocSHMEM | rocshmem | | amdrocm-rdc | ROCm Data Center Tool | rdc | | amdrocm-sysdeps | Bundled third-party dependencies (libdrm, libelf, numa, libVA) | System dependencies | Packages are offered in the following variants: - **For all supported GPUs:** Works across all GPUs supported by ROCm (for example, `apt install amdrocm-core-sdk10.1`). - **For a specific GPU architecture:** Smaller install size, but requires you to know the GPU installed in your system (for example, `apt install amdrocm-core-sdk10.1-gfx110x`). Installing all GPU architectures is not required. You can install packages for a specific architecture, multiple architectures side by side, or all supported GPU architectures. When redistributing software built on the ROCm Core SDK (for example, in container images), choose the all-architecture variant for broad hardware support. If disk footprint is a concern, use a single-architecture variant instead. ### Architecture-specific packages available in ROCm 10.1.0 Tarball archives use *family* names that differ from the deb/rpm package suffixes. The **Tarball family name** column maps each package suffix to its corresponding tarball family. | Architecture family | Package suffix | Tarball family name | Product name (not exhaustive) | |-----------------------|-------------------------------------------------|-----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | CDNA4 | -gfx950 | gfx950-dcgpu | AMD Instinct MI355X / MI350X | | CDNA3 | -gfx942 | gfx94X-dcgpu | AMD Instinct MI325X / MI300X / MI300A | | CDNA2 | -gfx90a | gfx90a | AMD Instinct MI250X / MI250 / MI210 | | CDNA | -gfx908 | — | AMD Instinct MI100 | | RDNA4 | -gfx1200
-gfx1201 | gfx120X-all | AMD Radeon RX 9070 / AMD Radeon RX 9060 / AMD Radeon RX 9070 XT / AMD Radeon RX 9060 XT / AMD Radeon RX 9070 GRE / AMD Radeon AI PRO R9700S / AMD Radeon AI PRO R9700 / AMD Radeon AI PRO R9600D / AMD Radeon RX 9060 XT LP | | RDNA3.5 | -gfx1150
-gfx1151
-gfx1152 | — | AMD Ryzen AI 9 465 / AMD Ryzen AI 9 365 / AMD Ryzen AI 9 HX 475 / AMD Ryzen AI 9 HX 470 / AMD Ryzen AI 9 HX 375 / AMD Ryzen AI 9 HX 370 / AMD Ryzen AI 9 PRO 465 / AMD Ryzen AI 9 PRO HX 475 / AMD Ryzen AI 9 PRO HX 470 / AMD Ryzen AI 9 HX PRO 375 / AMD Ryzen AI 9 HX PRO 370 / AMD Ryzen AI Max 390 / AMD Ryzen AI Max 385 / AMD Ryzen AI Max+ 395 / AMD Ryzen AI Max+ 392 / AMD Ryzen AI Max+ 388 / AMD Ryzen AI Max PRO 390 / AMD Ryzen AI Max PRO 385 / AMD Ryzen AI Max PRO 380 / AMD Ryzen AI Max+ PRO 395 / AMD Ryzen AI 7 450 / AMD Ryzen AI 7 350 / AMD Ryzen AI 7 345 / AMD Ryzen AI 5 340 / AMD Ryzen AI 5 330 / AMD Ryzen AI 7 PRO 450 / AMD Ryzen AI 5 PRO 440 / AMD Ryzen AI 7 PRO 350 / AMD Ryzen AI 5 PRO 340 | | RDNA3 | -gfx1100
-gfx1101
-gfx1102
-gfx1103 | gfx110X-all | AMD Radeon RX 7700 / AMD Radeon RX 7600 / AMD Radeon PRO V710 / AMD Radeon PRO W7900 / AMD Radeon PRO W7800 / AMD Radeon PRO W7700 / AMD Radeon RX 7900 XT / AMD Radeon RX 7800 XT / AMD Radeon RX 7700 XT / AMD Radeon RX 7700 XE / AMD Radeon RX 7900 XTX / AMD Radeon RX 7900 GRE / AMD Radeon PRO W7800 48GB / AMD Radeon PRO W7900 Dual Slot | | RDNA2 | -gfx1030 | — | AMD Radeon PRO V620 / AMD Radeon PRO W6800 | ## ROCm Core SDK component changes (moved or removed) ### Planned for future releases - ROCm-Extras: hipfort, rocPyDecode, rocAL, MIVisionX ### Moved to ROCm-Extras - ROCm Validation Suite - TransferBench - ROCm Optiq ### Moved to Standalone/ONNX - ONNX runtime ### Removed - [ROCm SMI](https://rocm.docs.amd.com/en/latest/about/release-notes.html#rocm-smi-deprecation) (replaced by AMD SMI) - ROCm Bandwidth Test (end-of-life as of the TheRock-based ROCm 7.14.0 release; use TransferBench or RVS instead) ## Notable package relocations - rocMLIR (now included in MIGraphX) - HIPCC (now included in `amdrocm-llvm`) - FLANG (now included in `amdrocm-llvm`) - ROCm CMake (now in `amdrocm-base`) - ROCTracer (now in `amdrocm-profiler-base`) - ROCProfiler (functionality in `amdrocm-profiler`) ## Components available in the ROCm Core SDK, ROCm-Extras, and Standalone/ONNX | | Category | Present | Absent/Moved | |-----------------|---------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------| | ROCm Core SDK | Math and compute libraries | CK, hipBLAS, hipBLASLt, hipCUB, hipFFT, hipRAND, hipSOLVER, hipSPARSE/SPARSELt, libhipcxx, MIOpen, rocBLAS, rocFFT, rocRAND, rocSOLVER, rocSPARSE, rocPRIM, rocThrust, rocWMMA | hipfort, rocALUTION | | ROCm Core SDK | Communication libraries | RCCL, rocSHMEM | — | | ROCm Core SDK | Media and vision libraries | rocDecode, rocJPEG, ROCm Performance Primitives (RPP) | rocPyDecode, rocAL, MIVisionX, MIGraphX, CK (moved to math and compute) | | ROCm Core SDK | Storage libraries | hipFile | — | | ROCm Core SDK | Threading libraries | hipThreads | — | | ROCm Core SDK | Runtime, compilers, build tools | HIP, HIPIFY, LLVM | HIPCC (moved to amdrocm-llvm), FLANG (moved to amdrocm-llvm), ROCm CMake (moved to amdrocm-base) | | ROCm Core SDK | Profiling and debugging tools | ROCm Compute Profiler, ROCm Systems Profiler, ROCprofiler-SDK, ROCdbgapi, ROCm Debugger, ROCR Debug Agent | ROCTracer (moved to amdrocm-profiler-base), ROCProfiler (functionality moved to amdrocm-profiler) | | ROCm Core SDK | Control and monitoring tools | AMD SMI, ROCm Data Center Tool, rocminfo | ROCm SMI (removed), ROCm Validation Suite, ROCm Bandwidth Test (removed) | | ROCm Extras | — | ROCm Validation Suite, TransferBench, ROCm Optiq | — | | Standalone/ONNX | — | rocMLIR, ONNX runtime | — | --- Source: https://rocm.docs.amd.com/en/latest/about/what-is-rocm.html # What is ROCm? ROCm is the AMD open software stack for GPU‑accelerated computing. It provides the tools needed to program AMD GPUs — including runtimes, compilers, performance and system utilities, and optimized math and compute libraries. The wider ROCm ecosystem includes ROCm‑enabled HPC applications and deep learning frameworks such as PyTorch. ROCm 10.1.0 is built through [TheRock](https://github.com/ROCm/TheRock), AMD’s open build and release system. TheRock replaces the previous monolithic release process with a modular workflow that makes ROCm components easier to build, integrate, and distribute. See the [release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html) for more information. ## ROCm Core SDK The ROCm Core SDK provides the foundational components that power the ROCm ecosystem — runtimes, compilers, math libraries, and system utilities for GPGPU computing. See [ROCm Core SDK components](https://rocm.docs.amd.com/en/latest/components/core.html) for more information. ## ROCm Extras ROCm Extra components are supplementary tools for benchmarking, validating, and managing ROCm deployments. These tools are not required for GPU application development but are useful for verifying hardware health, measuring system performance, and managing GPU fleets. For more information, see [ROCm Extra components](https://rocm.docs.amd.com/en/latest/components/extras.html). ## Get started * See the release notes – [ROCm Core SDK 10.1.0 release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html) – to learn about the latest changes and the current state of ROCm. * See the [ROCm 10.1.0 compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html#compat-matrix) – for system requirements and AMD hardware compatibility information. * Follow [Install AMD ROCm 10.1.0](https://rocm.docs.amd.com/en/latest/install/rocm.html) to set up ROCm on your system. ## ROCm handbook The [ROCm handbook](https://rocm-handbook.amd.com/en/latest/index.html) provides a unified, book-style reference for ROCm and HIP. It aggregates documentation from the ROCm portal into a structured format optimized for in-depth study and offline access in both PDF and HTML. It includes the following volumes: * [AMD ROCm Programming Guide](https://rocm-handbook.amd.com/projects/amd-rocm-programming-guide/en/latest/) * [AMD ROCm Optimization Guide](https://rocm-handbook.amd.com/projects/amd-rocm-optimization-guide/en/latest/) --- Source: https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html # ROCm 10.1.0 compatibility matrix To plan your ROCm 10.1.0 installation, use the following selector to view ROCm compatibility and system requirements information for your AMD hardware configuration and system environment. For installation instructions, see [Install AMD ROCm 10.1.0](https://rocm.docs.amd.com/en/latest/install/rocm.html). **fam=instinct fam=radeon fam=ryzen** **fam=instinct** **fam=radeon** **fam=ryzen** **fam=all** --- ## System requirements and information ROCm depends on a coordinated stack of compatible firmware, driver, and user space components. Maintaining version alignment between these layers ensures expected GPU operation and performance, especially for AMD data center products. This table lists GPU details followed by supported operating systems, kernel driver, and firmware versions. | AMD GPU series | [AMD Instinct MI350 Series](https://www.amd.com/en/products/accelerators/instinct/mi350.html) | [AMD Instinct MI300 Series](https://www.amd.com/en/products/accelerators/instinct/mi300.html) | [AMD Instinct MI200 Series](https://www.amd.com/en/products/accelerators/instinct/mi200.html) | [AMD Instinct MI100 Series](https://www.amd.com/en/products/accelerators/instinct/mi100.html) | | | | |-------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|------------------------|---------------------------------------------------|--------------------| | Architecture | CDNA 4 | CDNA 3 | CDNA 2 | CDNA | | | | | LLVM target | gfx950 | gfx942 | gfx90a | gfx908 | | | | | Supported Ubuntu versions | Ubuntu 26.04.1 (kernel: GA 7.0)

Ubuntu 24.04.5 (kernel: GA 6.8)

Ubuntu 22.04.5 (kernel: GA 5.15) | Ubuntu 26.04.1 (kernel: GA 7.0)

Ubuntu 24.04.5 (kernel: GA 6.8) | | | | | | | Supported Red Hat Enterprise Linux versions | RHEL 10.2 (kernel: 6.12.0-211)

RHEL 10.0 (kernel: 6.12.0-55)

RHEL 9.8 (kernel: 5.14.0-687)

RHEL 9.6 (kernel: 5.14.0-570)

RHEL 9.4 (kernel: 5.14.0-427)

RHEL 8.10 (kernel: 4.18.0-553) | RHEL 10.2 (kernel: 6.12.0-211)

RHEL 9.8 (kernel: 5.14.0-687)

RHEL 9.6 (kernel: 5.14.0-570) | RHEL 10.2 (kernel: 6.12.0-211)

RHEL 10.0 (kernel: 6.12.0-55)

RHEL 9.8 (kernel: 5.14.0-687)

RHEL 9.6 (kernel: 5.14.0-570)

RHEL 9.4 (kernel: 5.14.0-427) | | | | | | Supported Debian version | Debian 13 (kernel: 6.12)

Debian 12 (kernel: 6.1.0) | Debian 13 (kernel: 6.12) | Debian 12 (kernel: 6.1.0) | | | | | | Supported Oracle Linux versions | Oracle Linux 10 (kernel: UEK 8.1)

Oracle Linux 9 (kernel: UEK 8) | Oracle Linux 10 (kernel: UEK 8.1)

Oracle Linux 9 (kernel: UEK 8)

Oracle Linux 8 (kernel: UEK 7) | | | | | | | Supported Rocky Linux versions | Rocky Linux 9 (kernel: 5.14.0-570) | | | | | | | | Supported SUSE Linux Enterprise Server versions | SLES 16.0 (kernel: 6.12)

SLES 15.7 (kernel: 6.4.0-150700.51) | SLES 15.7 (kernel: 6.4.0-150700.51) | | | | | | | Supported AMD GPU Driver (amdgpu) versions | [31.60.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/documentation/release-notes.html)

[31.50.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.50.0/documentation/release-notes.html)

[31.40.1](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.40.1/documentation/release-notes.html)

[31.40.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.40.0/documentation/release-notes.html)

[31.30.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/31.30.0-preview/documentation/release-notes.html)

[31.20.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/31.20.0-preview/documentation/release-notes.html)

[31.10.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/31.10.0-preview/documentation/release-notes.html)

[30.30.3](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.30.3/documentation/release-notes.html)

[30.30.2](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.30.2/documentation/release-notes.html)

[30.30.1](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.30.1/documentation/release-notes.html)

[30.30.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.30.0/documentation/release-notes.html)

[30.20.1](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.20.1/documentation/release-notes.html)

[30.20.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.20.0/documentation/release-notes.html)

[30.10.2](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-30.10.2/documentation/release-notes.html) | | | | | | | | Supported PLDM bundle (firmware) versions | 01.26.01.03 (or later)

01.26.00.02 | BKC12.0 (IFWI PRD1000A) or later

IFWI 00189939 | 01.26.01.03 (or later)

01.25.06.08 | 01.26.00.04 (or later)

01.25.06.05 | PI100D

PI100C | Maintenance update (MU) 5 with IFWI 75 (or later) | VBIOS D3430401-037 | | AMD GPU series | [AMD Radeon AI PRO R9000 Series](https://www.amd.com/en/products/graphics/workstations/radeon-ai-pro.html#tabs-95fa144b96-item-b95ec9e1ca-tab) | [AMD Radeon RX 9000 Series](https://www.amd.com/en/products/graphics/desktops/radeon.html#tabs-ff9c5c3863-item-37fb38a236-tab) | [AMD Radeon PRO W7000 Series](https://www.amd.com/en/products/graphics/workstations/radeon-pro.html#tabs-990fdead92-item-20daa37284-tab) | [AMD Radeon RX 7000 Series](https://www.amd.com/en/products/graphics/desktops/radeon.html#tabs-ff9c5c3863-item-b55a56bf12-tab) | [AMD Radeon PRO V Series](https://www.amd.com/en/products/accelerators/radeon-pro.html) | [AMD Radeon PRO W6000 Series](https://www.amd.com/en/products/graphics/workstations/radeon-pro/w6800.html) | |--------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| | Architecture | RDNA 4 | RDNA 3 | RDNA 2 | | | | | LLVM target | gfx1201 | gfx1200 | gfx1100 | gfx1101 | gfx1102 | gfx1030 | | Supported Ubuntu versions | Ubuntu 26.04.1 (kernel: GA 7.0)

Ubuntu 24.04.5 (kernel: HWE 7.0)

Ubuntu 22.04.5 (kernel: HWE 6.8) | | | | | | | Supported RHEL versions | RHEL 10.2 (kernel: 6.12.0-211)

RHEL 9.8 (kernel: 5.14.0-687) | | | | | | | Supported Windows version | Windows 11 25H2 | | | | | | | Supported AMD GPU Driver (amdgpu) versions | [31.60.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/documentation/release-notes.html)

[31.50.0](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.50.0/documentation/release-notes.html) | | | | | | | Supported Adrenalin Driver version | [26.10.41.05](https://www.amd.com/en/resources/support-articles/release-notes/RN-RAD-ROCM-10-01.html) | | | | | | | Supported Windows CDE CPR driver version | 26.10.48 | | | | | | | AMD APU series | [AMD Ryzen AI Max PRO 400 Series](https://www.amd.com/en/products/processors/workstations/mobile.html#tabs-7f0c432fb2-item-296e08633e-tab) | [AMD Ryzen AI Max PRO 300 Series](https://www.amd.com/en/products/processors/workstations/mobile.html#tabs-7f0c432fb2-item-5116ab7a74-tab) | [AMD Ryzen AI Max 300 Series](https://www.amd.com/en/products/processors/laptop/ryzen.html#tabs-1181ea0b44-item-6ccfea5f65-tab) | [AMD Ryzen AI PRO 400 Series](https://www.amd.com/en/products/processors/laptop/ryzen-for-business.html#tabs-0d174caf43-item-87690677fc-tab) | [AMD Ryzen AI 400 Series](https://www.amd.com/en/products/processors/consumer/ryzen-ai.html#tabs-f556098628-item-808b56dca3-tab) | [AMD Ryzen AI PRO 300 Series](https://www.amd.com/en/products/processors/workstations/mobile.html#tabs-7f0c432fb2-item-387526c6cc-tab) | [AMD Ryzen AI 300 Series](https://www.amd.com/en/products/processors/consumer/ryzen-ai.html#tabs-f556098628-item-54e149d850-tab) | [AMD Ryzen PRO 200 Series](https://www.amd.com/en/products/processors/laptop/ryzen-for-business.html#tabs-0d174caf43-item-a8ec88d07e-tab) | [AMD Ryzen 200 Series](https://www.amd.com/en/products/processors/laptop/ryzen.html#tabs-1181ea0b44-item-895d56feed-tab) | | | | |------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------|-------------|-------------|-------------| | Graphics model (iGPU) | Radeon 8065S | Radeon 8050S | Radeon 8060S | Radeon 8040S | Radeon 890M | Radeon 880M | Radeon 860M | Radeon 840M | Radeon 820M | Radeon 780M | Radeon 760M | Radeon 740M | | Architecture | RDNA 3.5 | RDNA 3 | | | | | | | | | | | | LLVM target | gfx1151 | gfx1150 | gfx1152 | gfx1153 | gfx1103 | | | | | | | | | Codename | Gorgon Halo | Strix Halo | Gorgon Point | Strix Point | Krackan Point | Hawk Point | | | | | | | | Supported Ubuntu versions | 26.04.1 (kernel: GA 7.0)

24.04.5 (kernel: HWE 7.0) | | | | | | | | | | | | | Supported Windows version | Windows 11 25H2 | | | | | | | | | | | | | Supported kernel driver version | Inbox kernel driver in supported Ubuntu version | | | | | | | | | | | | | Supported Adrenalin Driver version | [26.10.41.05](https://www.amd.com/en/resources/support-articles/release-notes/RN-RAD-ROCM-10-01.html) | | | | | | | | | | | | | Supported Windows CDE CPR driver version | 26.10.48 | | | | | | | | | | | | For hardware specifications, see [AMD GPU specifications](https://rocm.docs.amd.com/en/latest/reference/gpu-specs.html#gpu-specs). --- **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi350p gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x gpu=amd-instinct-mi210 — GPU virtualization support** **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi350p gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x gpu=amd-instinct-mi210** Supported SR-IOV configurations require the GPU-IOV Module (GIM) driver 9.3.0.K – see the [AMD Instinct Virtualization Driver documentation](https://instinct.docs.amd.com/projects/virt-drv/en/mainline-9.3.0.k/) to get started. | Hypervisor | Virtualization technology | Virtualization driver | Host OS | Guest OS | VF per GPU – Compute Mode – Memory Mode | |--------------|---------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|-----------------|----------------|-------------------------------------------| | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1


2 [[\*]](#virt-multivf-note) - DPX - NPS2


8 [[\*]](#virt-multivf-note) - CPX - NPS2

| | | | | RHEL 10.0 | 1 - SPX - NPS1 | | | | | | RHEL 9.6 | 1 - SPX - NPS1 | | | | | | ESXi | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1


2 [[\*]](#virt-multivf-note) - DPX - NPS2


8 [[\*]](#virt-multivf-note) - CPX - NPS2

| | | | | RHEL 10.0 | 1 - SPX - NPS1 | | | | | | RHEL 9.6 | 1 - SPX - NPS1 | | | | | | ESXi | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | KVM | Passthrough | — | Debian 13 | Ubuntu 24.04 | 1 - SPX - NPS1 | | ESXi | Passthrough | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | SR-IOV | — | VMware ESXi 9.1 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | 1 - SPX - NPS1 | | | | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1 | | | | | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | RHEL 10.2 | RHEL 10.2 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | 1 - SPX - NPS1 | | | | | | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | 1 - SPX - NPS1 | | | | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1 | | | | | ESXi 8 U3 | Ubuntu 24.04 | 1 - SPX - NPS1 | | | | | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | 1 - SPX - NPS1 | | | Ubuntu 24.04 | Ubuntu 24.04 | 1 - SPX - NPS1


8 [[\*]](#virt-multivf-note) - CPX - NPS4

| | | | | Ubuntu 22.04 | Ubuntu 22.04 | 1 - SPX - NPS1 | | | | | RHEL 10.2 | RHEL 10.2 | 1 - SPX - NPS1 | | | | | RHEL 9.4 | RHEL 9.4 | 1 - SPX - NPS1


8 [[\*]](#virt-multivf-note) - CPX - NPS4

| | | | | RHEL 9.4 | Ubuntu 24.04 | 1 - SPX - NPS1


8 [[\*]](#virt-multivf-note) - CPX - NPS4

| | | | | KVM | Passthrough | — | Ubuntu 26.04 | Ubuntu 26.04 | N/A | | Ubuntu 24.04 | Ubuntu 24.04 | N/A | | | | | Ubuntu 22.04 | Ubuntu 22.04 | N/A | | | | | RHEL 9.4 | Ubuntu 22.04 | N/A | | | | | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | N/A | | | RHEL 9.4 | Ubuntu 22.04 | N/A | | | | | RHEL 9.4 | N/A | | | | | **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi300x** [\*] Multi-VF support requires a compatible firmware. See the [release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html#release-virtualization-support) for the full list of supported configurations. **gpu=amd-radeon-ai-pro-r9700s gpu=amd-radeon-pro-v710 — GPU virtualization support** **gpu=amd-radeon-ai-pro-r9700s gpu=amd-radeon-pro-v710** Supported SR-IOV configurations require the GPU-IOV Module (GIM) driver 9.3.0.K – see the [AMD Instinct Virtualization Driver documentation](https://instinct.docs.amd.com/projects/virt-drv/en/mainline-9.3.0.k/) to get started. | Hypervisor | Virtualization technology | Virtualization driver | Host OS | Guest OS | VF per GPU – Compute Mode – Memory Mode | |--------------|-----------------------------|---------------------------------------------------------------------------------|--------------|--------------|-------------------------------------------| | KVM | Passthrough | — | Ubuntu 24.04 | Ubuntu 24.04 | N/A | | KVM | SR-IOV | [GIM 9.3.0.K](https://github.com/amd/MxGPU-Virtualization/releases/tag/9.3.0.K) | Ubuntu 26.04 | Ubuntu 26.04 | 1 to 12 | | Ubuntu 24.04 | 1 to 12 | | | | | | RHEL 10.2 | 1 to 12 | | | | | | RHEL 9.6 | 1 to 12 | | | | | | Ubuntu 24.04 | Ubuntu 24.04 | 1 to 12 | | | | | RHEL 10.2 | 1 to 12 | | | | | | RHEL 9.6 | 1 to 12 | | | | | See the [release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html#release-virtualization-support) for the full list of supported configurations. --- **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi350p gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x — GPU partitioning support** AMD Instinct GPUs support compute and memory partitioning modes for bare-metal, passthrough, and SR-IOV deployments. **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi350p gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x** The following compute partition and NUMA-per-socket (NPS) configurations are available on AMD Instinct GPUs in bare-metal deployments. | Compute partition mode | Memory partition mode | |--------------------------|-------------------------| | SPX | NPS1 | | DPX | NPS2 | | CPX | NPS2 | | QPX | NPS2 | | SPX | NPS1 | | DPX | NPS1 | | CPX | NPS1 | | SPX | NPS1 | | SPX | NPS1 | | DPX | NPS2 | | CPX | NPS4 | **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x gpu=amd-instinct-mi350p gpu=amd-instinct-mi300x** The following configurations are available on AMD Instinct GPUs in passthrough deployments. | Deployment | Compute partition mode | Memory partition mode | |------------------|--------------------------|-------------------------| | KVM Passthrough | SPX | NPS1 | | ESXi Passthrough | SPX | NPS1 | **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi325x gpu=amd-instinct-mi300x gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x** The following configurations are available on AMD Instinct GPUs in SR-IOV deployments. See [GPU virtualization support](https://rocm.docs.amd.com/en/latest/about/release-notes.html#release-virtualization-support) for driver support information. | Deployment | VFs per GPU | Compute partition mode | Memory partition mode | |--------------|--------------------------------|--------------------------|-------------------------| | KVM SR-IOV | 1 | SPX | NPS1 | | KVM SR-IOV | 2 [[\*]](#sriov-multi-vf-note) | DPX | NPS2 | | KVM SR-IOV | 8 [[\*]](#sriov-multi-vf-note) | CPX | NPS2 | | KVM SR-IOV | 1 | SPX | NPS1 | | KVM SR-IOV | 1 | SPX | NPS1 | | KVM SR-IOV | 8 [[\*]](#sriov-multi-vf-note) | CPX | NPS4 | | ESXi SR-IOV | 1 | SPX | NPS1 | **gpu=amd-instinct-mi355x gpu=amd-instinct-mi350x gpu=amd-instinct-mi300x** [\*] Multi-VF support requires a compatible firmware. See the [release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html#release-virtualization-support) for the list of required firmware versions and supported configurations. --- ## ROCm Core SDK components The following table lists core components included in the ROCm 10.1.0 release. Expect future releases in this stream to expand the list of components. | Component group | Component name | | | | | | | | |--------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|----| | Control and monitoring tools | [AMD SMI 27.1.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/amdsmi) | | | | | | | | | [rocminfo 1.0.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocminfo) | | | | | | | | | | [ROCm Data Center Tool 1.3.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rdc) | | | | | | | | | | Math and compute libraries | [Composable Kernel 1.3.0](https://rocm.docs.amd.com/projects/composable_kernel/en/docs-10.1.0/) | | | | | | | | | [hipBLAS 3.7.0](https://rocm.docs.amd.com/projects/hipBLAS/en/docs-10.1.0/) | | | | | | | | | | [hipBLASLt 1.4.1](https://rocm.docs.amd.com/projects/hipBLASLt/en/docs-10.1.0/) | | | | | | | | | | [hipCUB 4.7.0](https://rocm.docs.amd.com/projects/hipCUB/en/docs-10.1.0/) | | | | | | | | | | [hipFFT 1.0.26](https://rocm.docs.amd.com/projects/hipFFT/en/docs-10.1.0/) | | | | | | | | | | [hipRAND 3.4.0](https://rocm.docs.amd.com/projects/hipRAND/en/docs-10.1.0/) | | | | | | | | | | [hipSOLVER 3.7.0](https://rocm.docs.amd.com/projects/hipSOLVER/en/docs-10.1.0/) | | | | | | | | | | [hipSPARSE 4.8.0](https://rocm.docs.amd.com/projects/hipSPARSE/en/docs-10.1.0/) | | | | | | | | | | [hipSPARSELt 0.2.9](https://rocm.docs.amd.com/projects/hipSPARSELt/en/docs-10.1.0/) | [hipSPARSELt 0.2.9](https://rocm.docs.amd.com/projects/hipSPARSELt/en/docs-10.1.0/) | | | | | | | | | [libhipcxx 3.0.2](https://github.com/ROCm/libhipcxx/tree/therock-10.1) | | | | | | | | | | [MIOpen 3.6.1](https://rocm.docs.amd.com/projects/MIOpen/en/docs-10.1.0/) | | | | | | | | | | [rocBLAS 5.7.0](https://rocm.docs.amd.com/projects/rocBLAS/en/docs-10.1.0/) | | | | | | | | | | [rocFFT 1.0.40](https://rocm.docs.amd.com/projects/rocFFT/en/docs-10.1.0/) | | | | | | | | | | [rocRAND 5.0.0](https://rocm.docs.amd.com/projects/rocRAND/en/docs-10.1.0/) | | | | | | | | | | [rocSOLVER 3.37.0](https://rocm.docs.amd.com/projects/rocSOLVER/en/docs-10.1.0/) | | | | | | | | | | [rocSPARSE 5.1.0](https://rocm.docs.amd.com/projects/rocSPARSE/en/docs-10.1.0/) | | | | | | | | | | [rocPRIM 4.6.0](https://rocm.docs.amd.com/projects/rocPRIM/en/docs-10.1.0/) | | | | | | | | | | [rocThrust 4.7.0](https://rocm.docs.amd.com/projects/rocThrust/en/docs-10.1.0/) | | | | | | | | | | [rocWMMA 2.2.1](https://rocm.docs.amd.com/projects/rocWMMA/en/docs-10.1.0/) | | | | | | | | | | Runtimes and compilers | [HIP 7.16.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/hip) | | | | | | | | | [HIPIFY 10.1.0](https://github.com/ROCm/HIPIFY/tree/therock-10.1) | | | | | | | | | | [LLVM 24.0.0](https://github.com/ROCm/llvm-project/tree/therock-10.1/amd) | | | | | | | | | | [ROCr Runtime 1.21.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocr-runtime) | | | | | | | | | | [SPIRV-LLVM-Translator 24.0.0](https://github.com/ROCm/SPIRV-LLVM-Translator/tree/therock-10.1) | | | | | | | | | | Storage libraries | [hipFile 0.5.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/hipfile) | | | | | | | | | Threading libraries | [hipThreads 1.0.0](https://rocm.docs.amd.com/projects/hipThreads/en/docs-10.1.0/) | | | | | | | | | Communication libraries | [RCCL 2.30.7](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rccl) | | | | | | | | | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | [rocSHMEM 3.7.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocshmem) | | | Profiling and debugging tools | [ROCdbgapi 0.80.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdbgapi) | | | | | | | | | [ROCgdb 16.3](https://github.com/ROCm/ROCgdb/tree/therock-10.1) | | | | | | | | | | [ROCm Compute Profiler 3.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-compute) | [ROCm Compute Profiler 3.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-compute) | [ROCm Compute Profiler 3.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-compute) | [ROCm Compute Profiler 3.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-compute) | [ROCm Compute Profiler 3.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-compute) | | | | | | [ROCm Systems Profiler 1.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-systems) | [ROCm Systems Profiler 1.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-systems) | [ROCm Systems Profiler 1.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-systems) | [ROCm Systems Profiler 1.9.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-systems) | | | | | | | [ROCprofiler-SDK 1.4.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-sdk) | [ROCprofiler-SDK 1.4.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-sdk) | [ROCprofiler-SDK 1.4.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-sdk) | [ROCprofiler-SDK 1.4.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-sdk) | [ROCprofiler-SDK 1.4.1](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocprofiler-sdk) | | | | | | [ROCr Debug Agent 2.2.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocr-debug-agent) | | | | | | | | | | Media and vision libraries | [rocDecode 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdecode) | [rocDecode 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdecode) | [rocDecode 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdecode) | [rocDecode 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdecode) | [rocDecode 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocdecode) | | | | | [rocJPEG 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocjpeg) | [rocJPEG 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocjpeg) | [rocJPEG 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocjpeg) | [rocJPEG 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocjpeg) | [rocJPEG 1.10.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/rocjpeg) | | | | | | [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) | [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) | [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) | [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) | [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) | | | | | | Component group | Component name | | |----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|----| | Math and compute libraries | [Composable Kernel 1.3.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/composablekernel) | | | [hipBLAS 3.7.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipblas) | | | | [hipBLASLt 1.4.1](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipblaslt) | | | | [hipCUB 4.7.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipcub) | | | | [hipFFT 1.0.26](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipfft) | | | | [hipRAND 3.4.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hiprand) | | | | [hipSOLVER 3.7.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipsolver) | | | | [hipSPARSE 4.8.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipsparse) | | | | [hipSPARSELt 0.2.9](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipsparselt) | [hipSPARSELt 0.2.9](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipsparselt) | | | [libhipcxx 3.0.2](https://github.com/ROCm/libhipcxx/tree/therock-10.1) | | | | [MIOpen 3.6.1](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/miopen) | | | | [rocBLAS 5.7.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocblas) | | | | [rocFFT 1.0.40](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocfft) | | | | [rocRAND 5.0.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocrand) | | | | [rocSOLVER 3.37.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocsolver) | | | | [rocSPARSE 5.1.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocsparse) | | | | [rocPRIM 4.6.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocprim) | | | | [rocThrust 4.7.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocthrust) | | | | [rocWMMA 2.2.1](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/rocwmma) | | | | Runtimes and compilers | [HIP 7.16.0](https://github.com/ROCm/rocm-systems/tree/therock-10.1/projects/hip) | | | [HIPIFY 10.1.0](https://github.com/ROCm/HIPIFY/tree/therock-10.1) | | | | [LLVM 24.0.0](https://github.com/ROCm/llvm-project/tree/therock-10.1/amd) | | | | [SPIRV-LLVM-Translator 24.0.0](https://github.com/ROCm/SPIRV-LLVM-Translator/tree/therock-10.1) | | | | Threading libraries | [hipThreads 1.0.0](https://github.com/ROCm/rocm-libraries/tree/therock-10.1/projects/hipthreads) | | --- ## AI ecosystem compatibility ROCm 10.1.0 provides optimized support for popular deep learning frameworks and AI inference engines. The following table lists supported frameworks and libraries, their validated versions, and compatible Python versions. | Framework | Supported versions | Python versions | | |--------------|------------------------|--------------------------------|------------------------------| | PyTorch | 2.14.0, 2.13.0, 2.12.0 | 2.14.0 | 3.14, 3.13, 3.12, 3.11, 3.10 | | PyTorch | 2.14.0 | 3.14, 3.13, 3.12, 3.11 | | | JAX | 0.11.1 | 3.14, 3.13, 3.12 | | | 0.11.0 | 3.14, 3.13, 3.12 | | | | 0.10.2 | 3.14, 3.13, 3.12, 3.11 | | | | vLLM | 0.29.0 | 3.14 (requires PyTorch 2.13.0) | | | SGLang | 0.5.18 | 3.14 (requires PyTorch 2.13.0) | | | TensorFlow | 2.21 | 3.12 | | | 2.20 | | | | | ONNX Runtime | 1.29.0 | 3.12 | | | MIGraphX | 2.18 | 3.12 | | --- Source: https://rocm.docs.amd.com/en/latest/install/rocm.html # Install AMD ROCm 10.1.0 --- Use the following selector to choose your installation method for your supported AMD GPU or APU and operating system. For system requirements and support information, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). To learn more about changes introduced in ROCm 10.1.0, see the [Release notes](https://rocm.docs.amd.com/en/latest/about/release-notes.html). #### NOTE If your GPU is not listed, it might be community-enabled through TheRock nightly builds. For more information, see [TheRock supported GPUs](https://github.com/ROCm/TheRock/blob/main/SUPPORTED_GPUS.md). For installation guidance, see [TheRock releases](https://github.com/ROCm/TheRock/blob/main/RELEASES.md). **fam=all fam=radeon fam=ryzen** **w=compute** **fam=instinct fam=radeon fam=ryzen** **fam=instinct** **fam=radeon** **fam=ryzen** **fam=all** **w=graphics** **os=ubuntu** **fam=instinct** **fam=radeon** **w=compute** **w=graphics** **fam=ryzen** **w=compute** **w=graphics** **fam=all** **w=compute** **w=graphics** **os=debian** **fam=instinct** **fam=all** **os=rhel** **fam=instinct** **fam=radeon** **w=compute** **w=graphics** **fam=all** **w=compute** **w=graphics** **os=oracle-linux** **fam=instinct** **fam=all** **os=rocky-linux** **fam=instinct** **fam=all** **os=sles** **fam=instinct** **fam=all** **os=windows** **fam=radeon** **w=compute** **w=graphics** **fam=ryzen** **w=compute** **w=graphics** **fam=all** **os=wsl** **w=graphics** **os=windows** **fam=instinct fam=radeon fam=ryzen** **w=compute** **fam=all** **fam=instinct fam=radeon fam=ryzen** --- **i=pkgman** **os=ubuntu** This installation method uses Ubuntu’s native package manager `apt` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **os=debian** This installation method uses Debian’s native package manager `apt` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **os=rhel** This installation method uses RHEL’s native package manager `dnf` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **os=oracle-linux** This installation method uses Oracle Linux’s native package manager `dnf` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **os=rocky-linux** This installation method uses Rocky Linux’s native package manager `dnf` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **os=sles** This installation method uses SLES’s native package manager `zypper` to install ROCm. This method suits standard system-wide installations where ROCm packages should be tracked, updated, and removed through system package workflows. **i=pip** The pip installation method provides ROCm components as Python wheel packages in a virtual environment. This method suits Python-focused development workflows that use an isolated, per-project ROCm environment managed with standard Python packaging tools. **i=tar** The tarball installation method provides ROCm as a self-contained installation from a pre-built archive. This method suits controlled or restricted environments requiring manual placement, updates, and removal outside the system package manager. **i=runfile** The ROCm Runfile Installer can install ROCm and/or the AMD GPU Driver (amdgpu) without using a native Linux package management system, making it ideal for systems with policy constraints or restricted environments. Network access is not needed for install as long as dependencies for ROCm and/or AMD GPU driver (amdgpu) are met. A single installer supports all GFX architectures, automates post-installation configuration, and offers an interactive command line TUI for guided setup. #### NOTE For detailed installation options and configuration, see [ROCm Runfile Installer](https://rocm.docs.amd.com/en/latest/install/rocm-runfile-installer.html). **i=amdgpu-install** Use the `amdgpu-install` script to install ROCm, the AMD GPU driver, graphics components, and other packages. It simplifies installation by automating GPU-specific and distro-specific package selection. The script also runs post-installation checks and installs an uninstallation script, allowing you to remove the entire ROCm stack with a single command. --- ## Prerequisites **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** **i=pkgman i=pip i=tar i=amdgpu-install** Before installing ROCm 10.1.0, ensure your system meets all prerequisites. This includes installing the required dependencies and configuring permissions for GPU access. To confirm that your system is supported, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). **i=runfile** Before installing ROCm 10.1.0, ensure your system meets all prerequisites. This includes installing the required dependencies. To confirm that your system is supported, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). **os=windows** Before installing ROCm 10.1.0, ensure your system meets all prerequisites. To confirm that your system is supported, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). **os=ubuntu os=debian os=rhel os=rocky-linux os=oracle-linux os=sles** **i=pkgman i=pip i=tar i=runfile** **os=windows — Prepare Windows for ROCm installation** 1. Remove any existing HIP SDK for Windows installations and other conflicting AMD graphics software. To uninstall the HIP SDK using the GUI, navigate to the following screen: * Control Panel > Programs > Uninstall a program 2. Disable the following Windows security features as they can interfere with ROCm functionality: * Turn off WDAG (Windows Defender Application Guard) * Control Panel > Programs > Programs and Features > Turn Windows features on or off > **Clear** “Microsoft Defender Application Guard” * Turn off SAC (Smart App Control) * Settings > Privacy & security > Windows Security > App & browser control > Smart App Control settings > **Off** **os=wsl** **ubuntu-ver=26.04.1 — Install WSL2 and Ubuntu 26.04** #### NOTE WSL support in ROCm 10.1.0 is provided as a **Technical Preview**. You might encounter [known issues](https://rocm.docs.amd.com/en/latest/about/release-notes.html#rocm-known-issues) that will be addressed in future releases. Install WSL2 and Ubuntu 26.04 on your Windows system. See [How to install Linux on Windows with WSL2 (Microsoft Learn)](https://learn.microsoft.com/en-us/windows/wsl/install) for instructions. Complete the following instructions in your WSL2 environment. **ubuntu-ver=24.04.5 — Install WSL2 and Ubuntu 24.04** #### NOTE WSL support in ROCm 10.1.0 is provided as a **Technical Preview**. You might encounter [known issues](https://rocm.docs.amd.com/en/latest/about/release-notes.html#rocm-known-issues) that will be addressed in future releases. Install WSL2 and Ubuntu 24.04 on your Windows system. See [How to install Linux on Windows with WSL2 (Microsoft Learn)](https://learn.microsoft.com/en-us/windows/wsl/install) for instructions. Complete the following instructions in your WSL2 environment. **ubuntu-ver=22.04.5 — Install WSL2 and Ubuntu 22.04** #### NOTE WSL support in ROCm 10.1.0 is provided as a **Technical Preview**. You might encounter [known issues](https://rocm.docs.amd.com/en/latest/about/release-notes.html#rocm-known-issues) that will be addressed in future releases. Install WSL2 and Ubuntu 22.04 on your Windows system. See [How to install Linux on Windows with WSL2 (Microsoft Learn)](https://learn.microsoft.com/en-us/windows/wsl/install) for instructions. Complete the following instructions in your WSL2 environment. **fam=ryzen** **i=pkgman i=pip i=tar** **os=ubuntu os=wsl** **ubuntu-ver=24.04.5 — Install the OEM kernel** Ryzen APUs (gfx1150, gfx1151, gfx1152, gfx1153, and gfx1103) require the OEM kernel 6.14 for Ubuntu 24.04. Use the following command to install it using `apt`. ```bash sudo apt update && sudo apt install linux-oem-24.04d ``` Reboot your system after installing the OEM kernel. **i=amdgpu-install** **os=ubuntu** **ubuntu-ver=24.04.5 — Install the OEM kernel** Ryzen APUs require the OEM kernel 6.14 or newer for Ubuntu 24.04. Use the following command to install it using `apt`. ```bash sudo apt update && sudo apt install linux-oem-24.04d ``` Reboot your system after installing the OEM kernel. **os=rhel — Register your Red Hat Enterprise Linux system** Register your Red Hat Enterprise Linux (RHEL) system to enable access to Red Hat repositories and ensure you’re able to download and install packages. Run the following command to register your system: **rhel-ver=10.2 rhel-ver=10.0** ```bash subscription-manager register --username --password ``` **rhel-ver=9.8 rhel-ver=9.6 rhel-ver=9.4 rhel-ver=8.10** ```bash subscription-manager register --username --password subscription-manager attach --auto ``` **os=sles — Register your SUSE Linux Enterprise Server system** Register your SUSE Linux Enterprise Server (SLES) system to enable access to SUSE repositories and ensure you’re able to download and install packages. Run the following command to register your system: ```bash sudo SUSEConnect -r ``` **os=rhel — Update your system** After registering your system, update RHEL to the latest packages. This is particularly important for newer hardware on older versions of RHEL. Run the following command to update your system: **rhel-ver=10.2** ```bash sudo dnf update --releasever=10.2 --exclude=\*release\* ``` **rhel-ver=10.0** ```bash sudo dnf update --releasever=10.0 --exclude=\*release\* ``` **rhel-ver=9.8** ```bash sudo dnf update --releasever=9.8 --exclude=\*release\* ``` **rhel-ver=9.6** ```bash sudo dnf update --releasever=9.6 --exclude=\*release\* ``` **rhel-ver=9.4** ```bash sudo dnf update --releasever=9.4 --exclude=\*release\* ``` **rhel-ver=8.10** ```bash sudo dnf update --releasever=8.10 --exclude=\*release\* ``` **os=sles — Update your system** After registering your system, update SLES to the latest available packages. This is particularly important for newer hardware on older versions of SLES. Run the following command to update your system: ```bash sudo zypper update ``` **i=amdgpu-install** **os=rhel — Add additional package repositories** ROCm installation packages depend on packages that aren’t included in the default package repositories. Use the following command to add the necessary repositories. **rhel-ver=10.2 rhel-ver=10.0** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-10.noarch.rpm sudo rpm -ivh epel-release-latest-10.noarch.rpm sudo dnf config-manager --enable codeready-builder-for-rhel-10-x86_64-rpms ``` **rhel-ver=9.8 rhel-ver=9.6 rhel-ver=9.4** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm sudo rpm -ivh epel-release-latest-9.noarch.rpm ``` ```bash sudo dnf config-manager --enable codeready-builder-for-rhel-9-x86_64-rpms ``` **i=pkgman** **os=oracle-linux — Update your system** Update Oracle Linux to the latest available packages. Run the following command to update your system: **oracle-linux-ver=10** ```bash sudo dnf update --releasever=10.2 --exclude=\*release\* ``` **oracle-linux-ver=9** ```bash sudo dnf update --releasever=9.8 --exclude=\*release\* ``` **oracle-linux-ver=8** ```bash sudo dnf update --releasever=8.10 --exclude=\*release\* ``` **os=rhel — Add additional package repositories** ROCm installation packages depend on packages that aren’t included in the default package repositories. Use the following command to add the necessary repositories. **rhel-ver=10.2 rhel-ver=10.0** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-10.noarch.rpm sudo rpm -ivh epel-release-latest-10.noarch.rpm sudo dnf config-manager --enable codeready-builder-for-rhel-10-x86_64-rpms ``` **rhel-ver=9.8 rhel-ver=9.6 rhel-ver=9.4** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm sudo rpm -ivh epel-release-latest-9.noarch.rpm ``` ```bash sudo dnf config-manager --enable codeready-builder-for-rhel-9-x86_64-rpms ``` **rhel-ver=8.10** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm sudo rpm -ivh epel-release-latest-8.noarch.rpm ``` ```bash sudo dnf config-manager --enable codeready-builder-for-rhel-8-x86_64-rpms ``` **os=oracle-linux — Add additional package repositories** ROCm installation packages depend on packages that aren’t included in the default package repositories. Use the following command to add the necessary repositories. **oracle-linux-ver=10** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-10.noarch.rpm sudo rpm -ivh epel-release-latest-10.noarch.rpm sudo crb enable ``` **oracle-linux-ver=9** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm sudo rpm -ivh epel-release-latest-9.noarch.rpm sudo crb enable ``` **oracle-linux-ver=8** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm sudo rpm -ivh epel-release-latest-8.noarch.rpm sudo crb enable ``` **os=rocky-linux — Add additional package repositories** ROCm installation packages depend on packages that aren’t included in the default package repositories. Use the following command to add the necessary repositories. **rocky-linux-ver=9** ```bash wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm sudo rpm -ivh epel-release-latest-9.noarch.rpm sudo crb enable ``` **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles os=wsl** **i=amdgpu-install — Install additional packages** Some ROCm tools require the `libatomic` and `libquadmath` libraries to run correctly. Install them using your distribution’s package manager. **os=ubuntu** ```bash sudo apt install libatomic1 libquadmath0 ``` **os=rhel** ```bash sudo dnf install libatomic libquadmath ``` **i=pkgman i=pip i=tar — Install additional packages** Some ROCm tools require the `libatomic` and `libquadmath` libraries to run correctly. Install them using your distribution’s package manager. **os=ubuntu os=debian** ```bash sudo apt install libatomic1 libquadmath0 ``` **fam=all** **ubuntu-ver=24.04.5** **os=wsl** ```bash sudo apt install libatomic1 libquadmath0 ``` **os=rhel os=oracle-linux os=rocky-linux** ```bash sudo dnf install libatomic libquadmath ``` **os=sles** ```bash sudo zypper install libatomic1 libquadmath0 ``` **i=pip** **os=ubuntu** **ubuntu-ver=26.04.1 — Install Python** Install a supported Python version. For example, to install Python 3.14, run the following command: ```bash sudo apt install python3.14 python3.14-venv ``` **ubuntu-ver=24.04.5 — Install Python** Install a supported Python version. For example, to install Python 3.12, run the following command: ```bash sudo apt install python3.12 python3.12-venv ``` **ubuntu-ver=22.04.5 — Install Python** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo apt install python3.11 python3.11-venv ``` **os=debian** **debian-ver=13 — Install Python** Install a supported Python version. For example, to install Python 3.13, run the following command: ```bash sudo apt install python3.13 python3.13-venv ``` **debian-ver=12 — Install Python** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo apt install python3.11 python3.11-venv ``` **os=rhel** **rhel-ver=10.2 rhel-ver=10.0 — Install Python** Install a supported Python version. For example, to install Python 3.12, run the following command: ```bash sudo dnf install python3.12 python3.12-pip ``` **rhel-ver=9.8 rhel-ver=9.6 rhel-ver=9.4 rhel-ver=9 rhel-ver=8.10 — Install Python** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo dnf install python3.11 python3.11-pip ``` **os=oracle-linux** **oracle-linux-ver=10 — Install Python** Install a supported Python version. For example, to install Python 3.12, run the following command: ```bash sudo dnf install python3.12 python3.12-pip ``` **oracle-linux-ver=9 oracle-linux-ver=8 — Install Python** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo dnf install python3.11 python3.11-pip ``` **os=rocky-linux — Install Python** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo dnf install python3.11 python3.11-pip ``` **os=sles — Install Python** **sles-ver=16.0** Install a supported Python version. For example, to install Python 3.13, run the following command: ```bash sudo zypper install python313 python313-pip ``` **sles-ver=15.7** Install a supported Python version. For example, to install Python 3.11, run the following command: ```bash sudo zypper install python311 python311-pip ``` **os=windows — Install Python** Install a supported Python version: 3.11, 3.12, 3.13, or 3.14. See [Python Releases for Windows](https://www.python.org/downloads/windows/) for installation details. **i=pkgman i=pip i=tar** **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles os=wsl — Configure permissions for GPU access** There are two primary methods for configuring GPU access for ROCm: group membership or udev rules. Each method has its own advantages. The choice depends on your specific requirements and system management preferences. If you’re working in a containerized environment, do this step on the host system, outside of the container. **Group membership** By default, GPU access is controlled by membership in the `video` and `render` Linux system groups. The `video` group traditionally handles video device access, while the `render` group manages GPU rendering through DRM render nodes. ```bash # Add the current user to the render and video groups sudo usermod -a -G render,video $LOGNAME ``` **udev rules** udev rules are a flexible, system-wide approach for managing device permissions, eliminating the need for user group management while allowing granular GPU access. To enable them and grant GPU access to all users, run the following command: ```bash sudo tee /etc/udev/rules.d/70-amdgpu.rules << EOF KERNEL=="kfd", GROUP="render", MODE="0666" SUBSYSTEM=="drm", KERNEL=="renderD*", GROUP="render", MODE="0666" EOF sudo udevadm control --reload-rules sudo udevadm trigger ``` #### NOTE To apply all settings, reboot your system. **i=amdgpu-install** **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles — Configure permissions for GPU access** There are two primary methods for configuring GPU access for ROCm: group membership or udev rules. Each method has its own advantages. The choice depends on your specific requirements and system management preferences. **Group membership** By default, GPU access is controlled by membership in the `video` and `render` Linux system groups. The `video` group traditionally handles video device access, while the `render` group manages GPU rendering through DRM render nodes. ```bash # Add the current user to the render and video groups sudo usermod -a -G render,video $LOGNAME ``` **udev rules** udev rules are a flexible, system-wide approach for managing device permissions, eliminating the need for user group management while allowing granular GPU access. To enable them and grant GPU access to all users, run the following command: ```bash sudo tee /etc/udev/rules.d/70-amdgpu.rules << EOF KERNEL=="kfd", GROUP="render", MODE="0666" SUBSYSTEM=="drm", KERNEL=="renderD*", GROUP="render", MODE="0666" EOF sudo udevadm control --reload-rules sudo udevadm trigger ``` #### NOTE To apply all settings, reboot your system. **i=runfile — Quick start** Download and launch the interactive installer to set up ROCm and/or the AMD GPU Driver with guided, step-by-step configuration. ```bash curl -fsSLO https://stable.repo.amd.com/rocm/core/linux-installers/rocm-installer-10.1.0-5.run && bash rocm-installer-10.1.0-5.run ``` **i=runfile — Configuration options** The following command line options are used to customize the runfile installer, including dependency handling and GPU access configuration. For recommended usage, go to [Installation](#rocm-install). **i=runfile — Dependencies** The runfile installer controls dependency installation via the `deps=` argument. | Command | Description | |-----------------|-------------------------------------------------| | `deps=install` | Installs all required packages | | `deps=list` | Lists all required packages | | `deps=validate` | Validates which required packages are installed | Specify the target after the dependency argument; for example: `deps=install rocm`. #### NOTE It is recommended to include `deps=install` if you’re not sure what dependencies are installed on your system. **i=runfile — GPU access** There are two primary methods of configuring GPU access for ROCm: group membership or udev rules. The choice depends on your specific requirements and system management preferences. The runfile installer sets GPU access at install time using the `gpu-access=` argument. | Argument | Method | |-------------------|-------------------------------------------------------------------------| | `gpu-access=user` | Group membership (adds the current user to the render and video groups) | | `gpu-access=all` | udev rules (configures system-wide GPU access) | --- ## Installation **os=ubuntu ubuntu-ver=24.04.5 ubuntu-ver=22.04.5 i=pkgman i=runfile** #### NOTE If you have ROCm 7.2.4 or older installed, please uninstall it before proceeding. **os=rhel rhel-ver=10.0 rhel-ver=9.6 rhel-ver=9.4 rhel-ver=8.10 i=pkgman i=runfile** #### NOTE If you have ROCm 7.2.4 or older installed, please uninstall it before proceeding. **os=sles sles-ver=15.7 i=pkgman i=runfile** #### NOTE If you have ROCm 7.2.4 or older installed, please uninstall it before proceeding. **os=debian os=oracle-linux os=rocky-linux os=windows i=pkgman i=runfile** #### NOTE If you have ROCm 7.2.4 or older installed, please uninstall it before proceeding. **os=windows** Before getting started, make sure you’ve completed the [Prerequisites](#rocm-prerequisites). For information about supported operating systems and compatible AMD devices, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). #### NOTE Do not replace or copy the ROCm compiler and runtime DLLs to System32 as this can cause conflicts. **i=runfile — Download the runfile installer** Use the following command to download the ROCm Runfile Installer. ```bash wget https://stable.repo.amd.com/rocm/core/linux-installers/rocm-installer-10.1.0-5.run ``` **i=amdgpu-install** **os=ubuntu os=rhel — Install the amdgpu-install script** Use the following commands to download and install the `amdgpu-install` script. **os=ubuntu** **ubuntu-ver=26.04.1** ```bash sudo apt update wget https://repo.radeon.com/amdgpu-install/31.60/ubuntu/resolute/amdgpu-install_31.60.316000-1_all.deb sudo apt install ./amdgpu-install_31.60.316000-1_all.deb ``` **ubuntu-ver=24.04.5** ```bash sudo apt update wget https://repo.radeon.com/amdgpu-install/31.60/ubuntu/noble/amdgpu-install_31.60.316000-1_all.deb sudo apt install ./amdgpu-install_31.60.316000-1_all.deb ``` **ubuntu-ver=22.04.5** ```bash sudo apt update wget https://repo.radeon.com/amdgpu-install/31.60/ubuntu/jammy/amdgpu-install_31.60.316000-1_all.deb sudo apt install ./amdgpu-install_31.60.316000-1_all.deb ``` **os=rhel** **rhel-ver=10.2** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/10.2/amdgpu-install-31.60.316000-1.el10.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el10.noarch.rpm ``` **rhel-ver=10.0** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/10.0/amdgpu-install-31.60.316000-1.el10.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el10.noarch.rpm ``` **rhel-ver=9.8** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/9.8/amdgpu-install-31.60.316000-1.el9.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el9.noarch.rpm ``` **rhel-ver=9.6** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/9.6/amdgpu-install-31.60.316000-1.el9.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el9.noarch.rpm ``` **rhel-ver=9.4** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/9.4/amdgpu-install-31.60.316000-1.el9.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el9.noarch.rpm ``` **rhel-ver=8.10** ```bash wget https://repo.radeon.com/amdgpu-install/31.60/rhel/8.10/amdgpu-install-31.60.316000-1.el8.noarch.rpm sudo dnf install ./amdgpu-install-31.60.316000-1.el8.noarch.rpm ``` **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** **i=pkgman i=pip i=tar** **fam=all — Install the kernel driver** For information about AMD GPU Driver (amdgpu) compatibility, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). **os=ubuntu** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [Ubuntu native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-ubuntu.html) in the AMD Instinct Data Center GPU Documentation. **ubuntu-ver=26.04.1** Supported Ryzen APUs require the inbox kernel driver included with Ubuntu 26.04. **ubuntu-ver=24.04.5** Supported Ryzen APUs require the inbox kernel driver included with Ubuntu 24.04.4. **os=debian** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [Debian native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-debian.html) in the AMD Instinct Data Center GPU Documentation. **os=rhel** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [RHEL native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-rhel.html) in the AMD Instinct Data Center GPU Documentation. **os=oracle-linux** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [Oracle Linux native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-ol.html) in the AMD Instinct Data Center GPU Documentation. **os=rocky-linux** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [Rocky Linux native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-rl.html) in the AMD Instinct Data Center GPU Documentation. **os=sles** For Instinct and Radeon devices, install the AMD GPU Driver (amdgpu). See [SLES native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-sles.html) in the AMD Instinct Data Center GPU Documentation. **fam=instinct fam=radeon — Install the kernel driver** For information about AMD GPU Driver (amdgpu) compatibility, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). **os=ubuntu** For instructions on installing the AMD GPU Driver (amdgpu), see [Ubuntu native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-ubuntu.html) in the AMD Instinct Data Center GPU Documentation. **os=debian** For instructions on installing the AMD GPU Driver (amdgpu), see [Debian native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-debian.html) in the AMD Instinct Data Center GPU Documentation. **os=rhel** For instructions on installing the AMD GPU Driver (amdgpu), see [RHEL native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-rhel.html) in the AMD Instinct Data Center GPU Documentation. **os=oracle-linux** For instructions on installing the AMD GPU Driver (amdgpu), see [Oracle Linux native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-ol.html) in the AMD Instinct Data Center GPU Documentation. **os=rocky-linux** For instructions on installing the AMD GPU Driver (amdgpu), see [Rocky Linux native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-rl.html) in the AMD Instinct Data Center GPU Documentation. **os=sles** For instructions on installing the AMD GPU Driver (amdgpu), see [SLES native installation](https://instinct.docs.amd.com/projects/amdgpu-docs/en/docs-31.60.0/install/detailed-install/package-manager/package-manager-sles.html) in the AMD Instinct Data Center GPU Documentation. **fam=ryzen** **os=ubuntu — About the kernel driver** **ubuntu-ver=26.04.1** Supported Ryzen APUs require the inbox kernel driver included with Ubuntu 26.04. **ubuntu-ver=24.04.5** Supported Ryzen APUs require the inbox kernel driver included with Ubuntu 24.04.4. **i=runfile — Install the kernel driver** For information about AMD GPU Driver (amdgpu) compatibility, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). ```bash bash rocm-installer-10.1.0-5.run deps=install amdgpu ``` #### NOTE Reboot your system after installing the AMD GPU Driver. **os=windows os=wsl — Install AMD Software: Adrenalin Edition** For details and the download link, see [https://www.amd.com/en/resources/support-articles/release-notes/RN-RAD-ROCM-10-01.html#Downloads](https://www.amd.com/en/resources/support-articles/release-notes/RN-RAD-ROCM-10-01.html#Downloads). ### Install ROCm Use the following instructions to install ROCm packages on your system. **i=pkgman — Register ROCm repositories** **os=ubuntu os=wsl** Register the ROCm repository with your system’s package manager. This lets you install and update ROCm packages using `apt`. **ubuntu-ver=26.04.1** **fam=all** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2604/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **fam=instinct fam=radeon fam=ryzen** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings # ROCm release signing key wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2604/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **ubuntu-ver=24.04.5** **fam=all** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2404/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **fam=instinct fam=radeon fam=ryzen** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings # ROCm release signing key wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2404/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **ubuntu-ver=22.04.5** **fam=all** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2204/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **fam=instinct fam=radeon fam=ryzen** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings # ROCm release signing key wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2204/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **os=debian** Register the ROCm repository with your system’s package manager. This enables you to install and update ROCm packages using `apt`. **debian-ver=13** **fam=all** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/debian13/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **fam=instinct fam=radeon fam=ryzen** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/debian13/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **debian-ver=12** **fam=all** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/debian12/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **fam=instinct fam=radeon fam=ryzen** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable.sources << EOF X-Repo-Id: amdrocm-stable Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages/debian12/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **os=rhel** Register the ROCm repository with your system’s package manager. This enables you to install and update ROCm packages using `dnf`. **rhel-ver=10.2 rhel-ver=10.0** **fam=all** ```bash sudo tee /etc/yum.repos.d/amdrocm-stable.repo < **i=pkgman — ROCm meta packages** Meta packages group related components and dependencies together, allowing you to install only what is necessary for your use case. The following table describes available ROCm meta packages: | Meta package name | Use case | Description | Contents | | | | | | | | | | | | | | | | | |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|-----------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------| | `amdrocm10.1-gfx950` | `amdrocm10.1-gfx942` | `amdrocm10.1-gfx90a` | `amdrocm10.1-gfx908` | `amdrocm10.1-gfx1201` | `amdrocm10.1-gfx1200` | `amdrocm10.1-gfx1100` | `amdrocm10.1-gfx1101` | `amdrocm10.1-gfx1102` | `amdrocm10.1-gfx1103` | `amdrocm10.1-gfx1030` | `amdrocm10.1-gfx1151` | `amdrocm10.1-gfx1150` | `amdrocm10.1-gfx1152` | `amdrocm10.1-gfx1153` | `amdrocm10.1` | ROCm Base | Core runtime environment.
Install this to run ROCm applications. | Runtimes, libraries, system control and monitoring tools, and other essential components. | | | **gfx=gfx950**

`amdrocm-core-dev10.1-gfx950`

**gfx=gfx942**

`amdrocm-core-dev10.1-gfx942`

**gfx=gfx90a**

`amdrocm-core-dev10.1-gfx90a`

**gfx=gfx908**

`amdrocm-core-dev10.1-gfx908`

**gfx=gfx1201**

`amdrocm-core-dev10.1-gfx1201`

**gfx=gfx1200**

`amdrocm-core-dev10.1-gfx1200`

**gfx=gfx1100**

`amdrocm-core-dev10.1-gfx1100`

**gfx=gfx1101**

`amdrocm-core-dev10.1-gfx1101`

**gfx=gfx1102**

`amdrocm-core-dev10.1-gfx1102`

**gfx=gfx1103**

`amdrocm-core-dev10.1-gfx1103`

**gfx=gfx1030**

`amdrocm-core-dev10.1-gfx1030`

**gfx=gfx1151**

`amdrocm-core-dev10.1-gfx1151`

**gfx=gfx1150**

`amdrocm-core-dev10.1-gfx1150`

**gfx=gfx1152**

`amdrocm-core-dev10.1-gfx1152`

**gfx=gfx1153**

`amdrocm-core-dev10.1-gfx1153`

**fam=all**

`amdrocm-core-dev10.1` | **gfx=gfx950**

`amdrocm-core-devel10.1-gfx950`

**gfx=gfx942**

`amdrocm-core-devel10.1-gfx942`

**gfx=gfx90a**

`amdrocm-core-devel10.1-gfx90a`

**gfx=gfx908**

`amdrocm-core-devel10.1-gfx908`

**gfx=gfx1201**

`amdrocm-core-devel10.1-gfx1201`

**gfx=gfx1200**

`amdrocm-core-devel10.1-gfx1200`

**gfx=gfx1100**

`amdrocm-core-devel10.1-gfx1100`

**gfx=gfx1101**

`amdrocm-core-devel10.1-gfx1101`

**gfx=gfx1102**

`amdrocm-core-devel10.1-gfx1102`

**gfx=gfx1103**

`amdrocm-core-devel10.1-gfx1103`

**gfx=gfx1030**

`amdrocm-core-devel10.1-gfx1030`

**gfx=gfx1151**

`amdrocm-core-devel10.1-gfx1151`

**gfx=gfx1150**

`amdrocm-core-devel10.1-gfx1150`

**gfx=gfx1152**

`amdrocm-core-devel10.1-gfx1152`

**gfx=gfx1153**

`amdrocm-core-devel10.1-gfx1153`

**fam=all**

`amdrocm-core-devel10.1` | ROCm Developer Essentials | Development environment.
Install this to build ROCm applications. | `amdrocm10.1-gfx950` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx942` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx90a` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx908` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1201` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1200` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1100` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1101` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1102` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1103` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1030` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1151` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1150` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1152` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1-gfx1153` plus compilers, CMake configurations, static library files, and headers. | `amdrocm10.1` plus compilers, CMake configurations, static library files, and headers. | | `amdrocm-developer-tools10.1` | ROCm Profiler | Install this to profile and optimize ROCm applications. | Profilers and related tools. | | | | | | | | | | | | | | | | | | `amdrocm-opencl10.1` | ROCm OpenCL | Install this to run OpenCL applications on ROCm. | Components needed to run OpenCL. | | | | | | | | | | | | | | | | | | `amdrocm-core-sdk10.1-gfx950` | `amdrocm-core-sdk10.1-gfx942` | `amdrocm-core-sdk10.1-gfx90a` | `amdrocm-core-sdk10.1-gfx908` | `amdrocm-core-sdk10.1-gfx1201` | `amdrocm-core-sdk10.1-gfx1200` | `amdrocm-core-sdk10.1-gfx1100` | `amdrocm-core-sdk10.1-gfx1101` | `amdrocm-core-sdk10.1-gfx1102` | `amdrocm-core-sdk10.1-gfx1103` | `amdrocm-core-sdk10.1-gfx1030` | `amdrocm-core-sdk10.1-gfx1151` | `amdrocm-core-sdk10.1-gfx1150` | `amdrocm-core-sdk10.1-gfx1152` | `amdrocm-core-sdk10.1-gfx1153` | `amdrocm-core-sdk10.1` | ROCm Full Suite | Install this if you need everything. | The complete ROCm Core SDK including runtimes, compilers, development tools, and dependencies. | | **os=wsl** #### NOTE The following are not supported on WSL2 in ROCm 10.1.0: - **Profiling**, including the tools in `amdrocm-developer-tools10.1` - **GPU debugging** – `rocgdb` and `rocm-debug-agent` require the KFD debug interface, which WSL2 does not provide - **KFD-dependent tooling** – tools that rely on `/dev/kfd` or amdgpu sysfs topology These packages can still be installed, but the capabilities above are unavailable. **i=amdgpu-install** **os=ubuntu os=rhel** **fam=radeon** #### WARNING Before proceeding, please enable “Above 4G Decoding” in your BIOS settings. Run the `amdgpu-install` script with the following `--usecase` arguments to install ROCm, graphics and amdgpu driver packages. ```bash sudo amdgpu-install --usecase=rocm,graphics --gfxversion=auto ``` **fam=ryzen** Run the `amdgpu-install` script with the following `--usecase` arguments to install ROCm packages. Ryzen APUs require the inbox kernel driver included with Ubuntu – to skip installing the AMD GPU driver, add `--no-dkms`. ```bash sudo amdgpu-install --usecase=rocm --gfxversion=auto --no-dkms ``` **fam=all** Run the `amdgpu-install` script with the following `--usecase` arguments to install ROCm and graphics packages. ```bash sudo amdgpu-install --usecase=rocm,graphics --gfxversion=all ``` Reboot your system after installing. **i=pip — Set up your Python virtual environment** Create and activate the Python virtual environment where you’ll install ROCm packages. **os=ubuntu** **ubuntu-ver=26.04.1** For example, to create and activate a Python 3.14 virtual environment, run the following command: ```bash python3.14 -m venv .venv source .venv/bin/activate ``` **ubuntu-ver=24.04.5** For example, to create and activate a Python 3.12 virtual environment, run the following command: ```bash python3.12 -m venv .venv source .venv/bin/activate ``` **ubuntu-ver=22.04.5** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=debian** **debian-ver=13** For example, to create and activate a Python 3.13 virtual environment, run the following command: ```bash python3.13 -m venv .venv source .venv/bin/activate ``` **debian-ver=12** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=rhel** **rhel-ver=10.2 rhel-ver=10.0** For example, to create and activate a Python 3.12 virtual environment, run the following command: ```bash python3.12 -m venv .venv source .venv/bin/activate ``` **rhel-ver=9.8 rhel-ver=9.6 rhel-ver=9.4 rhel-ver=8.10** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=oracle-linux** **oracle-linux-ver=10** For example, to create and activate a Python 3.12 virtual environment, run the following command: ```bash python3.12 -m venv .venv source .venv/bin/activate ``` **oracle-linux-ver=9** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **oracle-linux-ver=8** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=rocky-linux** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=sles** **sles-ver=16.0** For example, to create and activate a Python 3.13 virtual environment, run the following command: ```bash python3.13 -m venv .venv source .venv/bin/activate ``` **sles-ver=15.7** For example, to create and activate a Python 3.11 virtual environment, run the following command: ```bash python3.11 -m venv .venv source .venv/bin/activate ``` **os=windows** For example, to create and activate a Python 3.12 virtual environment, run the following command: ```bat py -3.12 -m venv .venv .venv\Scripts\activate ``` **i=pip — Install ROCm wheel packages** **fam=all** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-all]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx950** Use pip to install the ROCm libraries and development tools for your `gfx950` GPU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx950]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx942** Use pip to install the ROCm libraries and development tools for your `gfx942` device. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx942]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx90a** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx90a]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx908** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx908]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1201** Use pip to install the ROCm libraries and development tools for your `gfx1201` GPU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1201]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1200** Use pip to install the ROCm libraries and development tools for your `gfx1200` GPU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1200]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1100** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1100]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1101** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1101]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1102** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1102]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1103** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1103]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1030** Use pip to install the ROCm libraries and development tools. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1030]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1151** Use pip to install the ROCm libraries and development tools for your `gfx1151` Ryzen APU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1151]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1150** Use pip to install the ROCm libraries and development tools for your `gfx1150` Ryzen APU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1150]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **gfx=gfx1152** Use pip to install the ROCm libraries and development tools for your `gfx1152` Ryzen APU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1152]==10.1.0" ``` **gfx=gfx1153** Use pip to install the ROCm libraries and development tools for your `gfx1153` Ryzen APU. Run the following command: ```bash python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "rocm[libraries,device-gfx1153]==10.1.0" ``` The table below lists the available packages. Each bracketed name is an optional *extra* of the `rocm` meta package — combine the ones you need as a comma-separated list (for example, `rocm[libraries,devel]`). | Package | Contents | Use case | | | | | | | | | | | | | | | |-----------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|------------------------|--------------------|----------------------------------------------------|-----------------------------------------------------------------| | `rocm` | Core SDK: runtime, HIP, compiler, utility tools, and profiling SDK (rocprofiler-sdk, rocprofv3, roctx). | Required by all ROCm users. | | | | | | | | | | | | | | | | `rocm[libraries]` | Pre-built math and ML host libraries. | Required for ML frameworks such as PyTorch and JAX. | | | | | | | | | | | | | | | | `rocm[devel]` | Compilers, CMake configuration, headers, and static libraries. | Building ROCm applications. | | | | | | | | | | | | | | | | `rocm[device-gfx950]` | `rocm[device-gfx942]` | `rocm[device-gfx90a]` | `rocm[device-gfx908]` | `rocm[device-gfx1201]` | `rocm[device-gfx1200]` | `rocm[device-gfx1100]` | `rocm[device-gfx1101]` | `rocm[device-gfx1102]` | `rocm[device-gfx1103]` | `rocm[device-gfx1030]` | `rocm[device-gfx1151]` | `rocm[device-gfx1150]` | `rocm[device-gfx1152]` | `rocm[device-all]` | Pre-compiled GPU kernels for the specified target. | Required to run GPU workloads; installed alongside `libraries`. | | `rocm[profiler]` | Profiling tools: rocprofiler-systems and rocprofiler-compute. | Optional; analyzing and optimizing ROCm applications. | | | | | | | | | | | | | | | **i=tar — Create the installation directory** **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** Run the following command in your desired location to create your installation directory: ```bash mkdir therock-tarball && cd therock-tarball ``` #### IMPORTANT Subsequent commands assume you’re working with the `therock-tarball` directory. If you choose a different directory name, adjust the commands accordingly. **os=windows** Create the installation directory in `C:\TheRock\build`. For example, use the following command in your command prompt: ```bat mkdir C:\TheRock\build ``` #### IMPORTANT Subsequent commands assume you’re working with the `C:\TheRock\build` directory. If you choose a different directory name, adjust the commands accordingly. **i=tar — Download and unpack the tarball** **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** **fam=all** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-multiarch-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx950** Use the following commands to download and untar the ROCm tarball for your `gfx950` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx950-dcgpu-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx942** Use the following commands to download and untar the ROCm tarball for your `gfx942` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx94X-dcgpu-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx90a** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx90a-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx908** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx908-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1201 gfx=gfx1200** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx120X-all-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1100 gfx=gfx1101 gfx=gfx1102 gfx=gfx1103** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx110X-all-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1030** Use the following commands to download and untar the ROCm tarball. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx103X-all-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1151** Use the following commands to download and untar the ROCm tarball for your `gfx1151` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx1151-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1150** Use the following commands to download and untar the ROCm tarball for your `gfx1150` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx1150-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1152** Use the following commands to download and untar the ROCm tarball for your `gfx1152` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx1152-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx1153** Use the following commands to download and untar the ROCm tarball for your `gfx1153` GPU. ```bash wget https://stable.repo.amd.com/rocm/core/tarball/therock-dist-linux-gfx1153-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **os=windows** Download the tarball and extract the contents to `C:\TheRock\build`. Run the following commands in your command prompt: **fam=all** ```bat cd C:\TheRock curl -o therock-dist-windows-multiarch-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-multiarch-10.1.0.tar.gz tar -xzf therock-dist-windows-multiarch-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-multiarch-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-multiarch-10.1.0.tar.gz) **gfx=gfx1201 gfx=gfx1200** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx120X-all-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx120X-all-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx120X-all-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx120X-all-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx120X-all-10.1.0.tar.gz) **gfx=gfx1100 gfx=gfx1101 gfx=gfx1102 gfx=gfx1103** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx110X-all-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx110X-all-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx110X-all-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx110X-all-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx110X-all-10.1.0.tar.gz) **gfx=gfx1030** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx103X-all-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx103X-all-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx103X-all-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx103X-all-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx103X-all-10.1.0.tar.gz) **gfx=gfx1151** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx1151-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1151-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx1151-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx1151-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1151-10.1.0.tar.gz) **gfx=gfx1150** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx1150-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1150-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx1150-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx1150-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1150-10.1.0.tar.gz) **gfx=gfx1152** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx1152-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1152-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx1152-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx1152-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1152-10.1.0.tar.gz) **gfx=gfx1153** ```bat cd C:\TheRock curl -o therock-dist-windows-gfx1153-10.1.0.tar.gz https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1153-10.1.0.tar.gz tar -xzf therock-dist-windows-gfx1153-10.1.0.tar.gz -C build --strip-components=1 ``` - Download link: [therock-dist-windows-gfx1153-10.1.0.tar.gz](https://stable.repo.amd.com/rocm/core/tarball/therock-dist-windows-gfx1153-10.1.0.tar.gz) **i=runfile** Install the `core` ROCm components. See [ROCm meta components](#rocm-install-runfile-meta-components) for additional installation options. **fam=all** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=all gpu-access=user ``` **gfx=gfx950** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx950 gpu-access=user ``` **gfx=gfx942** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx942 gpu-access=user ``` **gfx=gfx90a** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx90a gpu-access=user ``` **gfx=gfx908** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx908 gpu-access=user ``` **gfx=gfx1201** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1201 gpu-access=user ``` **gfx=gfx1200** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1200 gpu-access=user ``` **gfx=gfx1100** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1100 gpu-access=user ``` **gfx=gfx1101** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1101 gpu-access=user ``` **gfx=gfx1102** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1102 gpu-access=user ``` **gfx=gfx1103** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1103 gpu-access=user ``` **gfx=gfx1030** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1030 gpu-access=user ``` **gfx=gfx1151** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1151 gpu-access=user ``` **gfx=gfx1150** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1150 gpu-access=user ``` **gfx=gfx1152** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1152 gpu-access=user ``` **gfx=gfx1153** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1153 gpu-access=user ``` **i=runfile — ROCm meta components** Meta components are similar to the meta packages used in the package manager installation method. They group related components and dependencies together, allowing you to install only what is necessary for your use case. The following table describes available ROCm meta components: | Meta component name | Use case | Description | Contents | |-----------------------|---------------------------|-------------------------------------------------------------------|------------------------------------------------------------------------------------------------| | `core` | ROCm Base | Core runtime environment. Install this to run ROCm applications. | Runtimes, libraries, system control and monitoring tools, and other essential components. | | `core-dev` | ROCm Developer Essentials | Development environment. Install this to build ROCm applications. | `core` plus compilers, CMake configurations, static library files, and headers. | | `dev-tools` | ROCm Profiler | Install this to profile and optimize ROCm applications. | Profilers and related tools. | | `opencl` | ROCm OpenCL | Install this to run OpenCL applications on ROCm. | Components needed to run OpenCL. | | `core-sdk` | ROCm Full Suite | Install this if you need everything. | The complete ROCm Core SDK including runtimes, compilers, development tools, and dependencies. | The default installation uses the core meta component. To select other components, add the `compo=` argument. For example, to install both `core` and `core-dev`: **gfx=gfx950** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx950 compo=core,core-dev gpu-access=user ``` **gfx=gfx942** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx942 compo=core,core-dev gpu-access=user ``` **gfx=gfx90a** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx90a compo=core,core-dev gpu-access=user ``` **gfx=gfx908** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx908 compo=core,core-dev gpu-access=user ``` **gfx=gfx1201** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1201 compo=core,core-dev gpu-access=user ``` **gfx=gfx1200** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1200 compo=core,core-dev gpu-access=user ``` **gfx=gfx1100** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1100 compo=core,core-dev gpu-access=user ``` **gfx=gfx1101** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1101 compo=core,core-dev gpu-access=user ``` **gfx=gfx1102** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1102 compo=core,core-dev gpu-access=user ``` **gfx=gfx1103** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1103 compo=core,core-dev gpu-access=user ``` **gfx=gfx1030** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1030 compo=core,core-dev gpu-access=user ``` **gfx=gfx1151** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1151 compo=core,core-dev gpu-access=user ``` **gfx=gfx1150** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1150 compo=core,core-dev gpu-access=user ``` **gfx=gfx1152** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1152 compo=core,core-dev gpu-access=user ``` **gfx=gfx1153** ```bash bash rocm-installer-10.1.0-5.run deps=install rocm gfx=gfx1153 compo=core,core-dev gpu-access=user ``` --- ## Post-installation After installing ROCm 10.1.0, complete these post-installation steps to complete your system configuration and validate the installation. **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** **i=tar — Configure your environment** Configure environment variables so that ROCm libraries and tools are available either to all users on the system or only to your user account. **System-wide setup** Create a profile script so that all users inherit the ROCm environment variables when they start a shell session. Make sure you’re in the `therock-tarball` directory before proceeding. ```bash # Configure ROCm PATH. Make sure you're in the therock-tarball directory before proceeding. ROCM_INSTALL_PATH=$(pwd)/install sudo tee /etc/profile.d/set-rocm-env.sh << EOF export ROCM_PATH=$ROCM_INSTALL_PATH export PATH=\$PATH:\$ROCM_PATH/bin export LD_LIBRARY_PATH=\$ROCM_PATH/lib EOF sudo chmod +x /etc/profile.d/set-rocm-env.sh source /etc/profile.d/set-rocm-env.sh ``` **User setup** Configure the ROCm environment for your user by updating your shell startup configuration file. Use the following commands to update your shell configuration file (`~/.bashrc` or `~/.profile`) and add ROCm to your PATH. Before proceeding, make sure you’re in the `therock-tarball` directory so the install path resolves correctly. **.bashrc** ```bash # Configure ROCm PATH. Make sure you're in the therock-tarball directory before proceeding. ROCM_INSTALL_PATH=$(pwd)/install tee --append ~/.bashrc << EOF # BEGIN ROCm environment configuration export ROCM_PATH=$ROCM_INSTALL_PATH export PATH=\$PATH:\$ROCM_PATH/bin export LD_LIBRARY_PATH=\$ROCM_PATH/lib # END ROCm environment configuration EOF source ~/.bashrc ``` **.profile** ```bash # Configure ROCm PATH. Make sure you're in the therock-tarball directory before proceeding. ROCM_INSTALL_PATH=$(pwd)/install tee --append ~/.profile << EOF # BEGIN ROCm environment configuration export ROCM_PATH=$ROCM_INSTALL_PATH export PATH=\$PATH:\$ROCM_PATH/bin export LD_LIBRARY_PATH=\$ROCM_PATH/lib # END ROCm environment configuration EOF source ~/.profile ``` **os=windows** **i=tar — Configure your environment** Configure environment variables so that ROCm libraries and tools are available on your Windows system. 1. **Run command prompt as an administrator** and set the following environment variables. ```bat setx HIP_DEVICE_LIB_PATH "C:\TheRock\build\lib\llvm\amdgcn\bitcode" /M setx HIP_PATH "C:\TheRock\build" /M setx HIP_PLATFORM "amd" /M setx LLVM_PATH "C:\TheRock\build\lib\llvm" /M ``` 2. Add the following paths into the PATH environment variable. ```bat setx PATH "%PATH%;C:\TheRock\build\bin;C:\TheRock\build\lib\llvm\bin" /M ``` 3. Open a new command prompt window for the environment variables to take effect. Run `set` to see the list of active variables. ```bat set ``` **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles — Verify your installation** Use the following ROCm tools to verify that ROCm is correctly installed and that your AMD devices are visible to the system. 1. Use `rocminfo` to list detected AMD GPUs and confirm that the ROCm runtimes and drivers are correctly installed and loaded. ```bash rocminfo ``` 2. Use the AMD SMI CLI `amd-smi` to validate system information. ```bash amd-smi version ``` **i=pip** 1. Inspect your installation in your Python environment and confirm that ROCm packages, including the `rocm-sdk` CLI, are available. ```bash pip freeze | grep rocm which rocm-sdk ls .venv/bin ``` **os=windows — Verify your installation** Use the following ROCm tools to verify that ROCm is correctly installed and that your AMD devices are visible to the system. **i=pip** 1. Use `hipinfo` to list detected AMD GPUs and confirm that the ROCm runtimes and drivers are correctly installed and loaded. ```bash hipinfo ``` 2. Inspect your installation in your Python environment and confirm that ROCm packages, including the `rocm-sdk` CLI, are available. ```bash pip freeze where rocm-sdk dir .venv\Scripts ``` **i=tar** Use `hipinfo` to list detected AMD GPUs and confirm that the ROCm runtimes and drivers are correctly installed and loaded. ```bash hipinfo ``` **os=wsl — Verify your installation** Use `rocminfo` to verify that ROCm is correctly installed and that your AMD devices are visible to the system. ```bash rocminfo ``` **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** **i=pip — Configure your environment** #### NOTE Follow this step only if you installed the `devel` package. Initialize the ROCm SDK. ```bash rocm-sdk init ``` **i=pip — Test your installation** Run the following commands from your Python virtual environment to confirm that the ROCm SDK is correctly configured and that basic checks complete successfully. ```bash rocm-sdk targets rocm-sdk test ``` To learn more about the `rocm-sdk` tool and to see example outputs, see [Using ROCm Python packages (TheRock)](https://github.com/ROCm/TheRock/blob/main/RELEASES.md#using-rocm-python-packages). **os=windows** **i=pip — Test your installation** Run the following commands from your Python virtual environment to confirm that the ROCm SDK is correctly configured and that basic checks complete successfully. ```bash rocm-sdk test ``` To learn more about the `rocm-sdk` tool and to see example outputs, see [Using ROCm Python packages (TheRock)](https://github.com/ROCm/TheRock/blob/main/RELEASES.md#using-rocm-python-packages). **i=pip** #### NOTE If you need to deactivate your Python virtual environment when finished, run: ```bash deactivate ``` #### NOTE **fam=all fam=instinct** To install deep learning frameworks, including [PyTorch](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html) and [JAX](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/jax/install.html), and get started with AI training and inference, see the [AI Ecosystem](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/) documentation portal. **fam=radeon fam=ryzen** To install deep learning frameworks, including [PyTorch](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html), and get started with AI training and inference, see the [AI Ecosystem](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/) documentation portal. **fam=ryzen** ROCm uses a shared system memory pool with Ryzen. To modify the shared memory configuration, see [Memory tuning (UMA carveout and GTT)](https://rocm.docs.amd.com/projects/amdsmi/en/develop/how-to/amdsmi-cli-tool.html#memory-tuning-uma-carveout-and-gtt). **fam=all fam=instinct** To learn about HPC libraries and applications, see [ROCm HPC SDK](https://rocm.docs.amd.com/en/latest/components/hpc-sdk/index.html). **fam=all fam=instinct fam=radeon** To learn about ROCm Extras, which include supplementary tools for benchmarking and validating, see [ROCm Extras](https://rocm.docs.amd.com/en/latest/components/extras.html). --- ## Uninstalling **i=pkgman** **os=wsl** 1. Use your package manager to remove the [installed packages](#rocm-install-rocm). **fam=all** ```bash sudo apt autoremove amdrocm10.1 ``` **gfx=gfx950** ```bash sudo apt autoremove amdrocm10.1-gfx950 ``` **gfx=gfx942** ```bash sudo apt autoremove amdrocm10.1-gfx942 ``` **gfx=gfx90a** ```bash sudo apt autoremove amdrocm10.1-gfx90a ``` **gfx=gfx908** ```bash sudo apt autoremove amdrocm10.1-gfx908 ``` **gfx=gfx1201** ```bash sudo apt autoremove amdrocm10.1-gfx1201 ``` **gfx=gfx1200** ```bash sudo apt autoremove amdrocm10.1-gfx1200 ``` **gfx=gfx1100** ```bash sudo apt autoremove amdrocm10.1-gfx1100 ``` **gfx=gfx1101** ```bash sudo apt autoremove amdrocm10.1-gfx1101 ``` **gfx=gfx1102** ```bash sudo apt autoremove amdrocm10.1-gfx1102 ``` **gfx=gfx1103** ```bash sudo apt autoremove amdrocm10.1-gfx1103 ``` **gfx=gfx1030** ```bash sudo apt autoremove amdrocm10.1-gfx1030 ``` **gfx=gfx1151** ```bash sudo apt autoremove amdrocm10.1-gfx1151 ``` **gfx=gfx1150** ```bash sudo apt autoremove amdrocm10.1-gfx1150 ``` **gfx=gfx1152** ```bash sudo apt autoremove amdrocm10.1-gfx1152 ``` **gfx=gfx1153** ```bash sudo apt autoremove amdrocm10.1-gfx1153 ``` 2. Remove ROCm repositories. ```bash # Remove ROCm repositories sudo rm /etc/apt/sources.list.d/amdrocm-stable.sources # Clear the cache and clean the system sudo rm -rf /var/cache/apt/* sudo apt clean sudo apt update ``` **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** 1. Use your package manager to remove the [installed packages](#rocm-install-rocm). **os=ubuntu os=debian** **fam=all** ```bash sudo apt autoremove amdrocm10.1 ``` **gfx=gfx950** ```bash sudo apt autoremove amdrocm10.1-gfx950 ``` **gfx=gfx942** ```bash sudo apt autoremove amdrocm10.1-gfx942 ``` **gfx=gfx90a** ```bash sudo apt autoremove amdrocm10.1-gfx90a ``` **gfx=gfx908** ```bash sudo apt autoremove amdrocm10.1-gfx908 ``` **gfx=gfx1201** ```bash sudo apt autoremove amdrocm10.1-gfx1201 ``` **gfx=gfx1200** ```bash sudo apt autoremove amdrocm10.1-gfx1200 ``` **gfx=gfx1100** ```bash sudo apt autoremove amdrocm10.1-gfx1100 ``` **gfx=gfx1101** ```bash sudo apt autoremove amdrocm10.1-gfx1101 ``` **gfx=gfx1102** ```bash sudo apt autoremove amdrocm10.1-gfx1102 ``` **gfx=gfx1103** ```bash sudo apt autoremove amdrocm10.1-gfx1103 ``` **gfx=gfx1030** ```bash sudo apt autoremove amdrocm10.1-gfx1030 ``` **gfx=gfx1151** ```bash sudo apt autoremove amdrocm10.1-gfx1151 ``` **gfx=gfx1150** ```bash sudo apt autoremove amdrocm10.1-gfx1150 ``` **gfx=gfx1152** ```bash sudo apt autoremove amdrocm10.1-gfx1152 ``` **gfx=gfx1153** ```bash sudo apt autoremove amdrocm10.1-gfx1153 ``` **os=rhel os=oracle-linux os=rocky-linux** **fam=all** ```bash sudo dnf remove amdrocm10.1 ``` **gfx=gfx950** ```bash sudo dnf remove amdrocm10.1-gfx950 ``` **gfx=gfx942** ```bash sudo dnf remove amdrocm10.1-gfx942 ``` **gfx=gfx90a** ```bash sudo dnf remove amdrocm10.1-gfx90a ``` **gfx=gfx908** ```bash sudo dnf remove amdrocm10.1-gfx908 ``` **gfx=gfx1201** ```bash sudo dnf remove amdrocm10.1-gfx1201 ``` **gfx=gfx1200** ```bash sudo dnf remove amdrocm10.1-gfx1200 ``` **gfx=gfx1100** ```bash sudo dnf remove amdrocm10.1-gfx1100 ``` **gfx=gfx1101** ```bash sudo dnf remove amdrocm10.1-gfx1101 ``` **gfx=gfx1102** ```bash sudo dnf remove amdrocm10.1-gfx1102 ``` **gfx=gfx1103** ```bash sudo dnf remove amdrocm10.1-gfx1103 ``` **gfx=gfx1030** ```bash sudo dnf remove amdrocm10.1-gfx1030 ``` **gfx=gfx1151** ```bash sudo dnf remove amdrocm10.1-gfx1151 ``` **gfx=gfx1150** ```bash sudo dnf remove amdrocm10.1-gfx1150 ``` **gfx=gfx1152** ```bash sudo dnf remove amdrocm10.1-gfx1152 ``` **gfx=gfx1153** ```bash sudo dnf remove amdrocm10.1-gfx1153 ``` **os=sles** ```bash sudo zypper remove amdrocm* ``` 2. Remove ROCm repositories. **os=ubuntu os=debian** ```bash # Remove ROCm repositories sudo rm -f /etc/apt/sources.list.d/amdrocm-stable.sources # Clear the cache and clean the system sudo rm -rf /var/cache/apt/* sudo apt clean sudo apt update ``` **os=rhel os=oracle-linux os=rocky-linux** ```bash # Remove ROCm repositories sudo rm -f /etc/yum.repos.d/amdrocm-stable.repo* # Clear the cache and clean the system sudo rm -rf /var/cache/dnf sudo dnf clean all ``` **os=sles** ```bash # Remove ROCm repositories sudo zypper removerepo "amdrocm-stable" # Clear the cache and clean the system sudo zypper clean --all sudo zypper refresh ``` **i=pip** 1. Clear the pip cache. **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** ```bash rm -rf ~/.cache/pip ``` **os=windows** ```bat pip cache purge ``` 2. Remove your local Python virtual environment. **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** ```bash rm -rf .venv ``` **os=windows** ```bat rmdir /s /q .venv ``` **i=tar** **os=ubuntu os=debian os=rhel os=oracle-linux os=rocky-linux os=sles** 1. To uninstall ROCm, remove your installation directory. #### IMPORTANT The following command assumes you’re working with the `therock-tarball` directory. If you chose a different directory name when [installing ROCm](#rocm-install), adjust the command accordingly. ```bash sudo rm -rf therock-tarball ``` 2. Remove your ROCm environment configuration from your system. **System-wide** If you opted for a [system-wide setup](#rocm-post-install-env) during the installation process, remove the ROCm environment variables. ```bash sudo rm -f /etc/profile.d/set-rocm-env.sh ``` **User** If you opted for a [user-specific setup](#rocm-post-install-env) during the installation process, remove the ROCm environment configuration block from your shell configuration file (`~/.bashrc` or `~/.profile`). **os=windows** 1. To uninstall ROCm, remove your installation directory. ```bat rmdir /s /q C:\TheRock ``` #### IMPORTANT This step assumes you’re working with the `C:\TheRock\build` directory. If you chose a different directory name when [installing ROCm](#rocm-install), adjust this step accordingly. 2. **Run command prompt as an administrator** and delete the following environment variables. ```bat setx HIP_DEVICE_LIB_PATH "" /M setx HIP_PATH "" /M setx HIP_PLATFORM "" /M setx LLVM_PATH "" /M ``` Remove the following paths from your PATH environment variable using your system settings GUI. Navigate to the following screen: * Control Panel > System and Security > Edit environment variables Edit the PATH variable and delete the following paths: * `C:\TheRock\build\bin` * `C:\TheRock\build\lib\llvm\bin` 3. To uninstall the Adrenalin Driver, see [Uninstall AMD Software](https://www.amd.com/en/resources/support-articles/faqs/RSX2-UNINSTALL.html). **i=runfile** 1. Use the following command to uninstall ROCm. **fam=all** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=all ``` **gfx=gfx950** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx950 ``` **gfx=gfx942** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx942 ``` **gfx=gfx90a** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx90a ``` **gfx=gfx908** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx908 ``` **gfx=gfx1201** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1201 ``` **gfx=gfx1200** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1200 ``` **gfx=gfx1100** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1100 ``` **gfx=gfx1101** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1101 ``` **gfx=gfx1102** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1102 ``` **gfx=gfx1103** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1103 ``` **gfx=gfx1030** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1030 ``` **gfx=gfx1151** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1151 ``` **gfx=gfx1150** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1150 ``` **gfx=gfx1152** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1152 ``` **gfx=gfx1153** ```bash bash rocm-installer-10.1.0-5.run uninstall-rocm gfx=gfx1153 ``` 2. Use the following command to uninstall the AMD GPU Driver (amdgpu). ```bash bash rocm-installer-10.1.0-5.run uninstall-amdgpu ``` **i=amdgpu-install** **os=ubuntu os=rhel** **fam=radeon** 1. Use `amdgpu-uninstall` to remove the [installed packages](#rocm-install-rocm). ```bash sudo amdgpu-uninstall ``` **fam=ryzen** 1. Use `amdgpu-uninstall` to remove the [installed packages](#rocm-install-rocm). ```bash sudo amdgpu-uninstall ``` **fam=all** 1. Use `amdgpu-uninstall` to remove the [installed packages](#rocm-install-rocm). ```bash sudo amdgpu-uninstall ``` 1. Remove ROCm repositories. **os=ubuntu** ```bash sudo apt purge amdgpu-install sudo apt autoremove # Clear the cache and clean the system sudo rm -rf /var/cache/apt/* sudo apt clean sudo apt update ``` **os=rhel** ```bash sudo dnf remove amdgpu-install # Clear the cache and clean the system sudo rm -rf /var/cache/dnf sudo dnf clean all ```








--- Source: https://rocm.docs.amd.com/en/latest/install/redirect/_prerequisites.html # Install AMD ROCm 10.1.0 ## Redirecting… #### IMPORTANT If you’re not redirected automatically, go to [Prerequisites](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-prerequisites). --- Source: https://rocm.docs.amd.com/en/latest/install/redirect/_install.html # Install AMD ROCm 10.1.0 ## Redirecting… #### IMPORTANT If you’re not redirected automatically, go to [Installation](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-install). --- Source: https://rocm.docs.amd.com/en/latest/install/redirect/_post-install.html # Install AMD ROCm 10.1.0 ## Redirecting… #### IMPORTANT If you’re not redirected automatically, go to [Post-installation](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-post-install). --- Source: https://rocm.docs.amd.com/en/latest/install/redirect/_uninstall.html # Install AMD ROCm 10.1.0 ## Redirecting… #### IMPORTANT If you’re not redirected automatically, go to [Uninstalling](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-uninstall). --- Source: https://rocm.docs.amd.com/en/latest/install/rocm-runfile-installer.html # ROCm Runfile Installer The ROCm Runfile Installer installs ROCm, the AMD GPU Driver, or a combination of the two on a system with or without network or internet access. Unlike all other installation methods, the ROCm Runfile Installer can install ROCm and the AMD GPU Driver without using a native Linux package management system. The key advantage of using the ROCm Runfile Installer is its offline installation support. Many system environments have network or internet access restrictions, making installation via normal package management difficult. Furthermore, some installation environments might also have general restrictions on package management usage. Therefore, the ROCm Runfile Installer lets you perform a completely self-contained ROCm software installation. The ROCm Runfile Installer includes these features: * An optional easy-to-use user interface for configuring the installation * An optional command line interface for the installation * Offline (air-gapped) ROCm and AMD GPU Driver installation (requires the prior installation of dependencies) * Packageless ROCm and AMD GPU Driver install without native package management * A single self-contained installer for all supported Linux distributions * Multi-architecture GPU support with selective installation and uninstall * Flexible component selection (core, development tools, SDK, OpenCL) * Graphics support option for Mesa/OpenGL workloads * Configurable installation location for the ROCm install ## Prerequisites The ROCm Runfile Installer requires the following configuration: * Installation of dependency requirements for the ROCm runtime * Installation of dependency requirements for the AMD GPU Driver (optional) * Sufficient storage space for the installation (100 GB of free space recommended) * A supported Linux distribution ## Dependency requirements The ROCm Runfile installer has a specific set of dependent OS-based packages that must be pre-installed on the system before you can use ROCm after the installation. The installer can print a list of the OS packages that are missing dependencies. It can also auto-install dependencies if apt/dnf/zypper is configured to use standard network connections or an air-gapped source or mirror. Optionally when installing the OS, an air-gapped system may get these dependencies from the OS ISO files or other network installation technologies. ### Dependency list You can determine the dependent packages from the ROCm Runfile Installer [Pre-Install Configuration Settings](#pre-install-configuration-settings) menu in the GUI or from the command line by using the `deps=list rocm` argument for ROCm or the `deps=list amdgpu` argument for the AMD GPU Driver (see [Dependency options](#dependency-options)). This list, which indicates all packages required for the ROCm runtime or the AMD GPU Driver, is displayed and saved to a file named `deps_list.txt` in the root `rocm-installer` directory. The `deps_list.txt` file is not directly usable by the package manager. The file lists the packages per line indicating the name of the package or versioning required to meet the dependency requirement. Some dependencies might show multiple packages separated by the `|` symbol, meaning that any package from the list satisfies the package dependency. For example, the `libgcc-dev` dependency might be `libgcc-5-dev | libgcc-7-dev`, meaning that either `libgcc-5-dev` or `libgcc-7-dev` can be installed to satisfy the corresponding dependency. ### Dependency installation You can choose to automatically install via ROCm Runfile Installer or manually install the dependency list (`deps_list.txt`) as part of the pre-installation stage for ROCm or the AMD GPU Driver. * **Auto-installation** of the dependency list is handled by using the **Install Dependencies** option of the [Pre-Install Configuration Settings](#pre-install-configuration-settings) menu in the GUI or from the command line using the `deps=install rocm` or `deps=install amdgpu` argument (see [Dependency options](#dependency-options)). For runfile auto-install of dependencies, OS-based repositories must be properly configured for package manager usage by the installer either via standard internet connectivity or an air-gapped setup for offline installation. * **Manual installation** of the dependency list require users or system administrators separately install the OS packages listed in `deps_list.txt`. ## Supported Linux distributions The ROCm Runfile Installer supports the following Linux distributions and versions: * Ubuntu: 22.04, 24.04, 26.04 * RHEL: 8.10, 9.4, 9.6, 9.8, 10.0, 10.2 * SLES: 15.7, 16.0 * Debian: 12, 13 * Oracle Linux: 8.10, 9.8, 10.2 * Rocky Linux: 9.8 #### IMPORTANT The new ROCm runfile installer is a universal installer that supports all listed distributions from a single `.run` file. There is no need to download distribution-specific builds as was required in previous versions. ## Getting started The ROCm Runfile Installer is distributed as a self-extracting `.run` file. To install ROCm, launch the installer from any directory on the system. ### Downloading the ROCm Runfile Installer Download the ROCm Runfile Installer from [stable.repo.amd.com](https://stable.repo.amd.com/rocm/core/linux-installers/) using the following command: ```shell wget https://stable.repo.amd.com/rocm/core/linux-installers/ ``` Substitute the installer `.run` filename for the following placeholder: ```shell = The installer .run file ``` For example, to download the ROCm 10.1 Runfile Installer: ```shell wget https://stable.repo.amd.com/rocm/core/linux-installers/rocm-installer-10.1.0-5.run ``` ### Running the ROCm Runfile Installer After downloading the ROCm Runfile Installer, run it from a terminal using [GUI install](#gui-install) or [Command line install](#command-line-install). See the sections below for more details. You can obtain help, version, architecture, or component information using the following installer `.run` file argument options: ```shell bash rocm-installer-10.1.0-5.run help bash rocm-installer-10.1.0-5.run version bash rocm-installer-10.1.0-5.run buildinfo bash rocm-installer-10.1.0-5.run gfx=list bash rocm-installer-10.1.0-5.run compo=list ``` The `help`, `version`, `buildinfo`, `gfx=list`, and `compo=list` commands run without extracting the installer contents. For all other argument options, or if no arguments are specified, the installer `.run` file self-extracts to the current working directory where the `.run` file is executing. The self-extraction process creates a new directory named `rocm-installer` containing the content and tools required for the installation. The `rocm-installer` directory also includes a `logs` directory for recording the installation process. For more information, see [Log files](#log-files) below. #### NOTE The installer self-extraction process might take a significant amount of time due to the size of the installer content and the decompression process. ## Install methods The ROCm Runfile Installer provides two methods for running the ROCm installation: * [GUI install](#gui-install): The GUI installation includes a visual interface for configuring the installation, letting you specify the pre- and post-installation requirements. In addition, the GUI provides feedback and guidance for setting up the installation. This method is recommended for new and intermediate installer users. * [Command line install](#command-line-install): The command line interface installation method provides a direct terminal-based approach for configuring and running the installation. This method is recommended for more advanced installer users and automation scenarios. ## GUI install Launch the GUI-based installation of the ROCm Runfile Installer from the terminal command line without arguments as follows: ```shell bash rocm-installer-10.1.0-5.run ``` ### GUI Use the Runfile Installer GUI to configure the installation, from the pre- to post-install options. Starting from the **Main** menu, the user interface contains multiple menus and sub-menus for each stage of the installation process. #### Main menu The **Main** menu is the installation starting point. ![The Main user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-main-menu-1.png) #### Pre-Install Configuration Settings menu The **Pre-Install Configuration Settings** menu is an optional menu used to configure pre-installation requirements before installation. The pre-installation settings relate to the dependent libraries and packages required by the ROCm runtime or the AMD GPU Driver. ![The Pre-Install Configuration user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-preinstall-menu-2.png) * **File** **File** displays the location of the `deps_list.txt` file. This file is based on the combination of selected dependencies using the **ROCm**, **Driver**, and **Graphics** checkboxes and either **Display Dependencies** or **Validate Dependencies**. If **Display Dependencies** is selected, `deps_list.txt` includes a list of all required dependencies. If **Validate Dependencies** is selected, `deps_list.txt` contains only the missing dependencies on the system that still require installation. The **File** field is initially blank until **Display Dependencies** or **Validate Dependencies** is selected. Use the **Install Dependencies** to install the required dependencies on the system. * **ROCm** / **Driver** The **ROCm** and **Driver** checkboxes are used to select which dependencies you want to display, validate, or install. * **Graphics** The **Graphics** checkbox enables mixed graphics and compute support for Mesa/OpenGL workloads. This is an option for non-Instinct GPUs such as AMD Radeon or Ryzen GPUs/APUs. When checked, the installer includes the `amdgpu-lib` package. * **Display Dependencies** **Display Dependencies** lists all required (Debian or RPM) packages that must be pre-installed on the system. These packages are required by ROCm or the AMD GPU Driver being installed by a particular ROCm Runfile Installer version. #### NOTE The required packages are listed in the `deps_list.txt` file and can be installed separately from the ROCm Runfile Installer. * **Validate Dependencies** **Validate Dependencies** verifies which required packages are currently installed on the system where ROCm or the AMD GPU Driver is being installed. It displays which packages from the required packages list are missing. #### NOTE The missing packages are listed in the `deps_list.txt` file. * **Install Dependencies** If the installer is running on the system where ROCm or the AMD GPU Driver will be installed, you can choose to install any missing dependencies using the **Install Dependencies** option. #### NOTE **Install Dependencies** is only intended for a system with network or internet access. For offline installation using the ROCm Runfile Installer, you must manually install the required packages. For more details, see the [Dependency requirements](#dependency-requirements) section. #### ROCm Options menu The **ROCm Options** menu can include or exclude ROCm from the installation and provides access to device/architecture and component selection. ![The ROCm Options user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-rocm-menu-3.png) * **Install ROCm** This field indicates whether to include ROCm components in the installation. If this field is set to `yes`, ROCm installation is enabled and the Runfile Installer searches for any existing ROCm installations at the currently set **ROCm Install Path**. If a previous ROCm installation is detected, the **Uninstall ROCm** field becomes selectable. * **ROCm Device** This submenu allows you to select which GPU architectures to install. You can choose specific architectures (gfx942, gfx1100, gfx950, and so on), multiple architectures, or all available architectures. The installer will list the currently auto-detected GPU and associated architecture by default. ![The ROCm Device user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-rocm-device-3a.png) * **ROCm Components** This submenu allows you to select which ROCm component categories to install: * **core**: Core ROCm components * **core-dev**: Core development components * **dev-tools**: Developer tools * **core-sdk**: Core SDK components * **opencl**: OpenCL runtime ![The ROCm Components user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-rocm-components-3b.png) * **ROCm Install Path** If **Install ROCm** is set to `yes`, the **ROCm Install Path** field can set the full path to the directory where ROCm will be installed. The default location is `/opt`, which results in a `/opt/rocm/core-x.y.z` installation. When **ROCm Install Path** is set to a new path, the installer validates the new directory location. If the directory exists, the ROCm installation can proceed. If an invalid location is specified, the ROCm installation will not be allowed. * **Uninstall ROCm** This field is only available if previous Runfile ROCm installations are discovered on the system where ROCm is being installed, based on the currently selected **ROCm Install Path** location. The installer only lists previous installation locations that are on the current install path. If any installation locations are present on this path, they can be selected for uninstall. The installer indicates the type of installation as follows: * **P** (Package manager): Package manager installation that matches the ROCm version for the Runfile Installer. In this case, uninstall is not allowed. * **C** (Runfile conflict): Runfile installation that matches the ROCm version for the Runfile Installer. The conflicting installation can be uninstalled. * **R** (Runfile): Runfile installation that differs from the ROCm version for the Runfile Installer. The installation can be uninstalled. **Uninstall ROCm** is for a single ROCm instance at a time and is only available for Runfile installs. Package manager installs of ROCm cannot be uninstalled by the Runfile installer and must be uninstalled manually using the package management application. #### NOTE For multi-architecture installs from the current **ROCm Install Path**, the GUI interface will uninstall all architectures. To uninstall specific GPU architectures, use the command line interface for uninstall. ![The ROCm Uninstall user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-rocm-menu-uninstall-3c.png) #### Driver Options menu The **Driver Options** menu can include or exclude the AMD GPU Driver from the installation. ![The Driver Options user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-driver-menu-4.png) * **Install Driver** This field indicates whether to include the AMD GPU Driver in the installation. If this field is set to `yes`, AMD GPU Driver installation is enabled. When this field is enabled, the system is searched for any existing AMD GPU Driver installations. If a previous AMD GPU Driver installation is detected, the **Uninstall Driver** field becomes selectable. #### NOTE The AMD GPU Driver is installed for the currently running Linux kernel version. To install the AMD GPU Driver for a different kernel, reboot to the specific Linux kernel and reinstall the AMD GPU Driver using the runfile. * **Start on install** If the **Start on install** option is enabled, the Runfile installer uses `modprobe` to automatically launch the AMD GPU Driver after installation. If a pre-existing AMD GPU Driver is already loaded on the system, the new driver will not start. This option can be useful for installing the driver on a system where the GPU device is newer and not yet natively supported as part of the upstream GPU driver for the Linux distribution. * **Uninstall Driver** This field is only available if a previous Runfile install of the AMD GPU Driver is discovered on the install system. If a Runfile installation of the AMD GPU Driver is detected, select **Uninstall Driver** to remove it. Package manager installs of the AMD GPU Driver cannot be uninstalled by the Runfile installer and must be uninstalled manually using the package management application. #### Post-Install Options menu Use the **Post-Install Options** menu to optionally enable additional setup and configuration items after the initial ROCm install. ![The Post-Install Options user interface menu for the ROCm Runfile Installer](install/images/rocm-runfile-postinstall-menu-5.png) * **Set GPU access permissions** This section sets the GPU access permissions after the ROCm installation. Typically, any ROCm component using the GPU and requiring access to GPU resources needs to set the access permission. For ROCm, GPU access is controlled by membership in the `video` and `render` groups. Membership and access to GPU resources can be set using one of two methods. * **Add video,render group** If the **Add video,render group** field is enabled, the current `$USER` is added to the groups and will be granted GPU access. * **Add udev rule** If the **Add udev rule** field is enabled, GPU access is granted to all users on the system. #### NOTE It’s **recommended** that you enable one of the GPU access options for using ROCm. Only one method for adding GPU access can be selected. * **Post ROCm setup** When this option is enabled, the ROCm post-install setup is performed. This includes configuring symbolic links and other system requirements for using ROCm and the ROCm runtime. This option is enabled by default for ROCm installations. #### NOTE It’s recommended that you enable the **Post ROCm setup** to guarantee proper functioning of the ROCm components and applications. However, advanced users who understand the ROCm setup might want to disable this option so they can control the post-installation ROCm setup for their specific environment. ### Using the GUI Start the ROCm Runfile Installer user interface from the terminal and launch the **Main** menu. While navigating through the user interface menus, use the **Done** option to return to the previous menu. Some menus have a **Help** option to display more information about the elements within the current menu. Follow these steps to install ROCm and the AMD GPU Driver: 1. **(Optional)** Install dependencies: 1. Enter the **Pre-Install Configuration** menu. 2. Select the **ROCm** checkbox, **Driver** checkbox, or both to specify the dependency type. 3. **(Optional)** Select the **Graphics** checkbox if you need graphics support for Mesa/OpenGL workloads. 4. If using the installer to install missing required dependencies, select **Install Dependencies**. To manually install the required dependencies, select **Display Dependencies** to list all the dependencies or **Validate Dependencies** to only list the missing dependencies on the current system. Quit the installer using **DONE->F1** and separately install the required dependencies, which will be listed in the `deps_list.txt` file at the **File** location. After completing this task, restart the ROCm Runfile Installer and proceed to step 2. 2. Set the ROCm options: 1. Enter the **ROCm Options** menu. 2. Set **Install ROCm** to **yes** to include ROCm components in the installation. 3. **(Optional)** Enter the **ROCm Device** submenu to select GPU architectures. By default, the installer auto-detects your GPU. 4. Enter the **ROCm Components** submenu to select component categories. 5. **(Optional)** Select **Uninstall ROCm** to uninstall a previous Runfile installation or specific architectures. 6. Leave the **ROCm Install Path** field set to the default location (`/opt`) to install ROCm to `/opt/rocm/core-x.y.z` or set the install location to a valid existing directory. 3. Set the AMD GPU Driver options: 1. Enter the **Driver Options** menu. 2. Set **Install Driver** to **yes** to include the AMD GPU Driver in the installation. 3. **(Optional)** Select **Start on install** to load the driver after installation. 4. **(Optional)** Select **Uninstall Driver** to uninstall a previous Runfile installation. 4. Set the post-install options: 1. Set the method of enabling permission for GPU access to **Add video,render group** or **Add udev rule**. 2. Set the **Post ROCm setup** to **yes** to include configuration of ROCm post-installation, which is recommended and enabled by default. Set to **no** to exclude the post-installation. ## Command line install The command line install interface can be used as an alternative to the menu-based ROCm Runfile Installer GUI to reduce user interaction during the installation and enable automation scenarios. Run the ROCm Runfile Installer from the terminal command line as follows: ```shell bash rocm-installer-10.1.0-5.run ``` The `` parameter can be set to these options: * User help/information * `help`: Displays information on how to use the ROCm Runfile Installer. * `version`: Displays the current version of the ROCm Runfile Installer. * `buildinfo`: Display ROCm build information (theRock commit, GitHub run ID, and so on). * Runfile options * `noexec`: Disable all installer execution. Extract the `.run` file content only. * `noexec-cleanup`: Disable cleanup after installer execution. Keep all `.run` extracted and runtime files. * Dependencies * `deps= `: * ``: * `list `: Lists the required dependencies for the install ``. * `validate `: Validates which required dependencies are installed or not installed for ``. * `install-only `: Installs the required dependencies only for ``. * `install `: Installs with the required dependencies for ``. * ``: Install component (`rocm`/`amdgpu`/`rocm amdgpu`). * Install * `rocm`: Enable ROCm components install. * `amdgpu`: Enable AMD GPU Driver install. * `force`: Force the ROCm and AMD GPU Driver install. * `graphics`: Enable graphics support by installing `amdgpu-lib` for Mesa/OpenGL. * `target=`: The target directory path for the ROCm components install (default: `/opt`). * `gfx=`: GPU architecture to install. * ``: Architecture specification (for example, `gfx942`, `gfx1100`, `gfx950`). Special values: * `gfx=all`: Install all available architectures. * `gfx=list`: Show available architectures in the installer. * `gfx=list-installed`: Show currently installed architectures (checks `/opt` by default; use with `target=` to check a different location). * `gfx=show`: Detect and display GPU information. * Multiple architectures: `gfx=gfx942,gfx950` (comma-separated). * If not specified, auto-detects GPU and installs matching architecture. * `compo=`: Comma-separated list of ROCm components to install. * Available components: `core`, `core-dev`, `dev-tools`, `core-sdk`, `opencl`. * Default: `core` (if not specified). * `compo=list`: Show available component categories. * Examples: `compo=core`, `compo=core,dev-tools`, `compo=core-sdk`. * Post-install * `postrocm`: Run the post-installation ROCm configuration. By default, post-install runs automatically with `rocm` installation. Use this to run post-install after installing with `nopostrocm`. * `nopostrocm`: Disable post ROCm installation configuration. Use this flag to skip post-install processing. * `amdgpu-start`: Start the AMD GPU Driver after the install. * `gpu-access=` * ``: * `user`: Adds the current user to the `render,video` group for GPU access. * `all`: Grants GPU access to all users on the system using `udev` rules. * Uninstall * `uninstall-rocm (target=)`: Uninstall ROCm. * (`target=`): Optional target directory for the ROCm uninstall (default: `/opt/rocm/core-x.y.z`). * Multi-architecture selective uninstall: * `gfx=`: Uninstall specific architecture (for example, `gfx=gfx1100`). * `gfx=all`: Uninstall all architectures. * Base components remain until last architecture is removed. * `uninstall-amdgpu`: Uninstall the AMD GPU Driver. * Information/Debug * `findrocm`: Search for a ROCm installation. * `manifest`: List the version of all ROCm components included in the installer. * `manifest=`: List components for specific GFX architecture (for example, `manifest=gfx1100`, `manifest=base`). * `prompt`: Run the installer with user prompts. * `assumeyes`: Automatically answer yes to all prompts (useful for automation/scripting). * `verbose`: Run the installer with verbose logging. #### NOTE The installer can be used with multiple `` combinations to enable specific stages of the ROCm install process (pre-installation and post-installation). The exception is any option that uses the keyword `-only` will apply that option only and no others. Some informational options are also single-option commands. ### Command line interface The command line interface for the ROCm Runfile Installer is based on the `` list provided to the installer `.run` file. #### Basic installation examples This example demonstrates how to perform a basic ROCm installation with auto-detected GPU architecture: ```shell bash rocm-installer-10.1.0-5.run rocm ``` This example demonstrates how to perform a typical ROCm installation with dependencies installed, specific GPU architecture, and post-install configuration: ```shell bash rocm-installer-10.1.0-5.run deps=install gfx=gfx942 rocm ``` This example demonstrates how to install ROCm to a custom location with GPU access configuration: ```shell bash rocm-installer-10.1.0-5.run deps=install target="$HOME/myrocm" gfx=gfx942 rocm gpu-access=all ``` #### Multi-architecture installation examples Install multiple GPU architectures: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942,gfx950,gfx1100 rocm ``` Install all available architectures: ```shell bash rocm-installer-10.1.0-5.run gfx=all rocm ``` #### Component selection examples Install core components only (default): ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm ``` Install core SDK with dependencies: ```shell bash rocm-installer-10.1.0-5.run deps=install compo=core-sdk gfx=gfx942 rocm ``` Install multiple components: ```shell bash rocm-installer-10.1.0-5.run compo=core,dev-tools gfx=gfx942 rocm ``` #### Graphics support example Install with graphics support for Mesa/OpenGL: ```shell bash rocm-installer-10.1.0-5.run deps=install gfx=gfx942 rocm graphics ``` #### AMD GPU Driver installation examples Install AMD GPU Driver only: ```shell bash rocm-installer-10.1.0-5.run amdgpu ``` Install AMD GPU Driver with dependencies: ```shell bash rocm-installer-10.1.0-5.run deps=install amdgpu ``` #### Combined installation examples Install both ROCm and AMD GPU Driver: ```shell bash rocm-installer-10.1.0-5.run deps=install gfx=gfx942 rocm amdgpu gpu-access=all ``` Install to custom location with all components: ```shell bash rocm-installer-10.1.0-5.run deps=install target="$HOME/myrocm" gfx=gfx942 rocm amdgpu gpu-access=all ``` #### Runfile options The ROCm Runfile Installer is a self-extracting `.run` file with a few options for controlling the extraction process. When the installer `.run` file starts execution, the extraction process begins with a checksum validation to verify the integrity of the `.run` file. If there are no errors, it begins extracting and decompressing the package contents. The contents are output to a new directory named `rocm-installer`, located in the current working directory. Usually, when extraction and decompression are complete, execution begins automatically by either starting up the GUI (if no arguments are provided) or executing the `rocm-installer.sh` script with all command line arguments. The `rocm-installer.sh` script is in the extracted `rocm-installer` directory. When the GUI exits or the command line completes execution, the Runfile installer will automatically clean up the `rocm-installer` directory and delete all content except for the log files and the `deps_list.txt` file. In some cases, you might want to execute multiple commands from the same extraction and save the time required to verify the checksum and extract and decompress the package contents of the `.run` file. Two command line options let you disable the `.run` cleanup process: `noexec` and `noexec-cleanup`. * `noexec` The `noexec` option is a single command line argument that lets the checksum and extraction process complete and then exits without starting the GUI or executing the `rocm-installer.sh` script. All content will be maintained after the exit. You can then use the `rocm-installer.sh` script directly from the command line without specifying the `.run` file name. For example, extract the `.run` file and then use `rocm-installer.sh` instead of `rocm-installer-10.1.0-5.run` to install ROCm and the AMD GPU Driver separately: ```shell bash rocm-installer-10.1.0-5.run noexec cd rocm-installer bash rocm-installer.sh gfx=gfx942 rocm bash rocm-installer.sh amdgpu ``` #### NOTE If the `noexec` option is used, all other `` on the command line will be ignored. * `noexec-cleanup` The `noexec-cleanup` option disables the cleanup process after the GUI or command line interface exits. Unlike the `noexec` option, all command line arguments are processed as normal, but no content is deleted upon exit or completion. At this point, you can switch to using the `rocm-installer.sh` script within the `rocm-installer` directory to avoid re-extracting the contents. #### Dependency options Like the GUI **Pre-Install Configuration** menu, the command line interface can list, validate, and install the required dependencies. At the command line, add the `deps= ` option to the list of `` for the `.run` file. The `` option can include any combination of the `rocm`, `amdgpu`, and `graphics` tags. The `graphics` option is intended for non-Instinct GPUs such as AMD Radeon or Ryzen GPUs/APUs to enable mixed graphics and compute support for Mesa/OpenGL workloads. * `deps=list ` This dependency option lists all the dependencies required for the `.run` file-based ROCm installation, AMDGPU installation, graphics support, or any combination. It lists all required (Debian or RPM) packages that require pre-installation on the system. The additional `rocm`, `amdgpu`, or `graphics` parameter is a requirement for the `deps=list` option that instructs the installer to list only the dependencies required by ROCm, the AMD GPU Driver, graphics support, or any combination. Running `deps=list` causes the installer to quit after listing the dependencies. `deps=list` can combine `rocm`, `amdgpu`, and `graphics` and output the combined list of required dependencies. Use `deps=list ` as a single `` parameter: ```shell bash rocm-installer-10.1.0-5.run deps=list rocm bash rocm-installer-10.1.0-5.run deps=list amdgpu bash rocm-installer-10.1.0-5.run deps=list graphics bash rocm-installer-10.1.0-5.run deps=list rocm amdgpu graphics ``` #### NOTE The list of required packages can be installed separately from the Runfile Installer. * `deps=validate ` This dependency option verifies whether any of the *required* ROCm, AMD GPU Driver, or graphics support packages in the dependency list are already installed on the system running the command. The output is a list of any missing dependency packages that require installation. Running `deps=validate` causes the installer to quit after listing the missing dependencies. `deps=validate` can combine `rocm`, `amdgpu`, and `graphics` and output the combined list of missing dependencies. Use `deps=validate ` as a single `` parameter: ```shell bash rocm-installer-10.1.0-5.run deps=validate rocm bash rocm-installer-10.1.0-5.run deps=validate amdgpu bash rocm-installer-10.1.0-5.run deps=validate graphics bash rocm-installer-10.1.0-5.run deps=validate rocm amdgpu graphics ``` #### NOTE The list of missing packages can be installed separately from the Runfile Installer. * `deps=install` This dependency option validates and installs any required packages in the dependency list for ROCm, the AMD GPU Driver, graphics support, or any combination that are missing on the system running the command. This dependency option is not a single `` parameter and can be added to a list of other options for the installer. The `deps=install` option expects at least one of the `rocm`, `amdgpu`, or `graphics` `` parameters to also be present in the list to enable the pre-installation of required dependencies before the Runfile Installer installs ROCm, the AMD GPU Driver, or graphics support. For example, to install the dependencies and ROCm, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run deps=install rocm ``` To install the dependencies and the AMD GPU Driver, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run deps=install amdgpu ``` To install the dependencies for graphics support, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run deps=install graphics ``` To install the dependencies for ROCm, AMD GPU Driver, and graphics support, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run deps=install rocm amdgpu graphics ``` #### NOTE The installer can be set to only install dependencies and then quit. In this case, add `-only` to the `deps=install` option: ```shell bash rocm-installer-10.1.0-5.run deps=install-only rocm bash rocm-installer-10.1.0-5.run deps=install-only amdgpu bash rocm-installer-10.1.0-5.run deps=install-only graphics bash rocm-installer-10.1.0-5.run deps=install-only rocm amdgpu graphics ``` #### Install options Like the GUI **ROCm Options** menu, the ROCm Runfile Installer can be configured to install ROCm with specific architectures, components, and installation locations. * `rocm` At the command line, add the `rocm` option to enable ROCm installation. #### NOTE This option must be in the list of `.run ` for ROCm component installation. For example, to install ROCm with auto-detected GPU architecture: ```shell bash rocm-installer-10.1.0-5.run rocm ``` * `target=` This install option is used to set the target directory where ROCm will be installed. The `target` option is only used as an option for ROCm installation and is not required for an AMD GPU Driver install. When `target=` is not specified in the `` list, the installer uses the default installation path of `/opt`. This results in a ROCm installation at `/opt/rocm/core-x.y.z`. You can change the default location and set the ROCm component installation directory using the `target=` option. The `` argument must be a valid and absolute path to a directory on the system executing the ROCm Runfile Installer. For example, to install ROCm to the default `/opt/rocm/core-x.y.z` location (explicit): ```shell bash rocm-installer-10.1.0-5.run target="/opt" gfx=gfx942 rocm ``` To install ROCm to a directory called `amd/myrocm` in the `$USER` directory: ```shell bash rocm-installer-10.1.0-5.run target="$HOME/myrocm" gfx=gfx942 rocm ``` * `gfx=` This install option specifies the GPU architecture to install. The installer includes architecture-specific components for different AMD GPU families. Single architecture installation: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm bash rocm-installer-10.1.0-5.run gfx=gfx1100 rocm bash rocm-installer-10.1.0-5.run gfx=gfx950 rocm ``` Multiple architecture installation (comma-separated): ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942,gfx950,gfx1100 rocm ``` Install all available architectures: ```shell bash rocm-installer-10.1.0-5.run gfx=all rocm ``` Auto-detect GPU (default if `gfx=` not specified): ```shell bash rocm-installer-10.1.0-5.run rocm ``` Architecture information commands: ```shell bash rocm-installer-10.1.0-5.run gfx=show # Detect and display GPU info bash rocm-installer-10.1.0-5.run gfx=list # List available architectures bash rocm-installer-10.1.0-5.run gfx=list-installed # Show installed architectures ``` * `compo=` This install option specifies which ROCm component categories to install. Components can be specified individually or as comma-separated lists. Available components: * `core`: Core ROCm components (default) * `core-dev`: Core development components * `dev-tools`: Developer tools * `core-sdk`: Core SDK components * `opencl`: OpenCL runtime Single component installation: ```shell bash rocm-installer-10.1.0-5.run compo=core gfx=gfx942 rocm bash rocm-installer-10.1.0-5.run compo=core-sdk gfx=gfx942 rocm ``` Multiple component installation (comma-separated): ```shell bash rocm-installer-10.1.0-5.run compo=core,dev-tools gfx=gfx942 rocm bash rocm-installer-10.1.0-5.run compo=core-sdk,opencl gfx=gfx942 rocm ``` List available components: ```shell bash rocm-installer-10.1.0-5.run compo=list ``` If `compo=` is not specified, the installer defaults to installing the `core` component. * `graphics` This install option enables graphics support for Mesa/OpenGL workloads. When specified, the installer includes the `amdgpu-lib` package. ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm graphics bash rocm-installer-10.1.0-5.run deps=install gfx=gfx942 rocm graphics ``` * `amdgpu` At the command line, add the `amdgpu` option to enable AMD GPU Driver installation. #### NOTE This option must be in the list of `.run ` for ROCm component installation. The AMD GPU Driver is installed for the currently running Linux kernel version. To install the AMD GPU Driver for a different kernel, reboot to the specific Linux kernel and reinstall the AMD GPU Driver using the runfile. For example, to install the AMD GPU Driver with no other options: ```shell bash rocm-installer-10.1.0-5.run amdgpu ``` #### NOTE Both `rocm` and `amdgpu` can be combined in the `` list to install both components. For this case, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm amdgpu ``` * `force` The `force` install option can be added to the `` list for the case of multiple pre-existing Runfile installs of ROCm. Add this option to disable any installer prompts that ask for confirmation to continue with the ROCm install if there are currently one or more Runfile ROCm installations already on the system. #### Post-install options Similar to the GUI **Post-Install Options** menu, the post-install options can configure the ROCm Runfile Installer to apply additional post-installation options after completing the installation. At the command line, add one or more of the post-installation options to the `` list for the `.run` file. * `postrocm` This post-install option applies any post-installation configuration settings for ROCm following installation on the target system. The post-installation configuration includes any symbolic link creation, library configuration, and script execution required to use the ROCm runtime. By default, post-install runs automatically when you use the `rocm` install option. You only need to explicitly use `postrocm` in these scenarios: * You installed with `nopostrocm` and now want to run post-install separately. * You want to run post-install on an existing installation. To run post-install separately after installing with `nopostrocm`: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm nopostrocm bash rocm-installer-10.1.0-5.run postrocm ``` The post-install takes into account the install location of ROCm, which you may specify with the addition of the `target=` option. By default, if `target=` is not provided, the default location of `/opt` will be used to apply the post-installation: ```shell bash rocm-installer-10.1.0-5.run postrocm ``` For installation locations other than `/opt`, use the `target=` option: ```shell bash rocm-installer-10.1.0-5.run target=/custom/path postrocm ``` ROCm installations using the Runfile installer can specify not only the location, but also the GPU architecture (`gfx=`) and ROCm components (`compo=`). Post-installation takes this into account and will auto-detect the architectures and components installed at a location if not provided with the `postrocm` option. However, if a user needs to specify either architecture or components, then `gfx=` and `compo=` options may be used with the `postrocm` option. Run post-install with a specific architecture: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 postrocm ``` Run post-install with a specific component: ```shell bash rocm-installer-10.1.0-5.run compo=core-sdk postrocm ``` #### NOTE Adding the `postrocm` option (or relying on the default behavior with `rocm`) is highly recommended to guarantee proper functioning of the ROCm components and applications. * `nopostrocm` This post-install option disables the automatic post-install configuration that normally runs when you use the `rocm` install option. Use this when you want to install ROCm without running the post-install scripts. ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm nopostrocm ``` You can run the post-install later using the `postrocm` option (see above). * `gpu-access=` This post-install option sets the GPU resource access permissions. ROCm runtime libraries and applications might need access to the GPU. This requires setting the access permission to the `video` and `render` groups using the ``. If the ROCm installation is for a single user, then set the `` for the `gpu-access` option to `user`. For example, to add the current user (`$USER`) to the `video,render` group for GPU access for a ROCm installation, the command line is as follows: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm gpu-access=user ``` In cases where a system administrator is installing ROCm for multiple users, they might want to enable GPU access permission for all users. For this case, set the `` for the `gpu-access` option to `all`: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm gpu-access=all ``` #### NOTE Adding the `gpu-access` option to the `` list is recommended for using ROCm. A typical ROCm installation includes one of the `gpu-access` types. #### Uninstall options These options configure the ROCm Runfile Installer to uninstall a previous ROCm or AMD GPU Driver installation. * `uninstall-rocm (target=) (gfx=)` This option configures the ROCm Runfile Installer to uninstall a previous ROCm installation. For multi-architecture installations, you can selectively uninstall specific architectures or all architectures. * Uninstall with auto-detection of architecture: To uninstall ROCm from the default location (`/opt/rocm/core-x.y.z`): ```shell bash rocm-installer-10.1.0-5.run uninstall-rocm ``` To uninstall ROCm from a custom location: ```shell bash rocm-installer-10.1.0-5.run target="$HOME/myrocm/rocm-x.y.z" uninstall-rocm ``` * Uninstall with architecture selection: Selective uninstall of one or more GPU architectures installed to a location. Using `gfx=`, you can specify the architecture or architectures to uninstall. Only gfx-specific components will be removed for multi-installs, with common components remaining until the final architecture is uninstalled. To uninstall a specific architecture: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx1100 uninstall-rocm bash rocm-installer-10.1.0-5.run target="$HOME/myrocm" gfx=gfx942 uninstall-rocm ``` To uninstall all architectures: ```shell bash rocm-installer-10.1.0-5.run gfx=all uninstall-rocm ``` #### NOTE The `uninstall-rocm` option can only remove ROCm if it was installed using the ROCm Runfile Installer. Traditional package-based ROCm installs will not be removed. * `uninstall-amdgpu` This option configures the ROCm Runfile Installer to uninstall a previous AMD GPU Driver installation. To uninstall the AMD GPU Driver from the system, use the following command line: ```shell bash rocm-installer-10.1.0-5.run uninstall-amdgpu ``` #### NOTE The `uninstall-amdgpu` option can only remove the AMD GPU Driver if it was installed using the ROCm Runfile Installer. Traditional package-based AMD GPU Driver installs will not be removed. #### Information and debug options The ROCm Runfile Installer command line interface includes options for information output or debugging. * `findrocm` This information option searches the install system for any existing installations of ROCm. Any install locations are output to the terminal and the type of installation is indicated (Runfile or Package manager). Use `findrocm` as a standalone `` parameter: ```shell bash rocm-installer-10.1.0-5.run findrocm ``` * `manifest` This information option lists the version of each ROCm component included in the installer. The `manifest` option causes the Runfile Installer to quit after listing the ROCm components. Use `manifest` as a standalone `` parameter: ```shell bash rocm-installer-10.1.0-5.run manifest ``` To list components for a specific architecture: ```shell bash rocm-installer-10.1.0-5.run manifest=gfx942 bash rocm-installer-10.1.0-5.run manifest=gfx1100 bash rocm-installer-10.1.0-5.run manifest=base ``` * `buildinfo` This information option displays theRock build information, including commit hash, GitHub run ID, build date, and other build metadata. Use `buildinfo` as a standalone `` parameter: ```shell bash rocm-installer-10.1.0-5.run buildinfo ``` * `prompt` This debug option enables user prompts in the installer. At specific, critical points of the installation process, the installer halts execution and prompts the user to either continue with the install or exit. * `assumeyes` This automation option automatically answers yes to all prompts. This is useful for automation and scripting scenarios where user interaction is not desired. ```shell bash rocm-installer-10.1.0-5.run deps=install gfx=gfx942 rocm assumeyes ``` * `verbose` This debug option enables verbose logging during ROCm Runfile Installer execution. For example, to install ROCm with user prompts and verbose logging: ```shell bash rocm-installer-10.1.0-5.run target="/opt" gfx=gfx942 rocm prompt verbose ``` ## Log files By default, the ROCm Runfile Installer GUI and command line interfaces record the output execution in log files. These log files are created in the `rocm-installer/logs` directory. The `rocm-installer` directory is created when the ROCm Runfile Installer self-extracts to the current working directory where it is being executed. ## Troubleshooting The following are common issues and solutions for the ROCm Runfile Installer. * **Issue:** Installer fails with “missing dependencies” error **Solution:** Use `deps=validate rocm` to see which dependencies are missing, then either: * Install them manually using your package manager * Use `deps=install rocm` to have the installer install them (requires internet connection) * **Issue:** GPU not detected or wrong architecture selected **Solution:** Use `gfx=show` to see detected GPUs, then manually specify the correct architecture: ```shell bash rocm-installer-10.1.0-5.run gfx=gfx942 rocm ``` * **Issue:** Post-install configuration was skipped **Solution:** Run post-install separately: ```shell bash rocm-installer-10.1.0-5.run postrocm ``` * **Issue:** Cannot access GPU after installation **Solution:** Ensure GPU access permissions are set. Either: * Add your user to the video/render groups: `bash rocm-installer-10.1.0-5.run gpu-access=user` * Grant access to all users: `bash rocm-installer-10.1.0-5.run gpu-access=all` * Log out and log back in for group membership changes to take effect * **Issue:** Multi-architecture installation conflicts **Solution:** * Check installed architectures: `bash rocm-installer-10.1.0-5.run gfx=list-installed` * Remove specific architecture if needed: `bash rocm-installer-10.1.0-5.run gfx=gfx1100 uninstall-rocm` * Reinstall with correct architecture selection --- Source: https://rocm.docs.amd.com/en/latest/install/build-from-source.html # Build the ROCm Core SDK from source You can build the ROCm Core SDK from source using the open-source unified build system [TheRock](https://github.com/ROCm/TheRock). To learn more about the motivation and architecture behind this system, see [ROCm Technology Preview: ROCm Core SDK and TheRock Build System](https://rocm.blogs.amd.com/software-tools-optimization/therock/README.html). This page consists mainly of references to [TheRock’s README](https://github.com/ROCm/TheRock?tab=readme-ov-file#building-from-source) and [supporting development manuals](https://github.com/ROCm/TheRock/blob/main/README.md#development-manuals), which provide up-to-date build instructions and guidance for supported platforms. See [TheRock Development Guide](https://github.com/ROCm/TheRock/blob/main/docs/development/development_guide.md#therock-development-guide) to learn about the overall build architecture. #### NOTE Building from source is recommended only if you need custom builds or are contributing to ROCm development. For most users, installing from official AMD releases is faster and easier. See [Install AMD ROCm 10.1.0](https://rocm.docs.amd.com/en/latest/install/rocm.html) for installation instructions. ## Prerequisites A successful build depends on a correctly configured environment. Before you begin, ensure your system meets all hardware and software requirements. Review the following resources: * [Environment setup guide](https://github.com/ROCm/TheRock/blob/main/docs/environment_setup_guide.md) * [ROCm 10.1.0 compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) ## High-level build process For an overview of the build architecture, start with TheRock’s [development guide](https://github.com/ROCm/TheRock/blob/main/docs/development/development_guide.md). While specific commands vary by platform, the general workflow for building from source involves these stages: 1. Clone the repository and install build dependencies. See [Platform-specific setup](#build-from-src-plat-setup). 2. Configure the build: Use CMake feature flags to configure the build. This step allows you to target specific platforms, build subsets of ROCm Core SDK components, and toggle component features. See [Build configuration](https://github.com/ROCm/TheRock/blob/main/README.md#build-configuration) for optional and required build flags. 3. Execute the build: Run the build command to compile the source code. This can be a time- and resource-intensive process. See [CMake build usage](https://github.com/ROCm/TheRock/blob/main/README.md#cmake-build-usage). 4. After a successful build, the outputs are available for use in downstream tasks. To learn more about build outputs, see the relevant [TheRock documentation](https://github.com/ROCm/TheRock/blob/main/docs/development/artifacts.md). Common post-build tasks include: * Using `build/dist/rocm`: When the build completes, you should have a build of ROCm in the `build/dist/rocm/` directory. See [Using installed tarballs](https://github.com/ROCm/TheRock/blob/main/RELEASES.md#using-installed-tarballs) for more information. * Building Python packages: Prepare the build artifacts for distribution as Python packages. See [Building Python packages](https://github.com/ROCm/TheRock/blob/main/docs/packaging/python_packaging.md#building-packages). * Building PyTorch: Build a compatible PyTorch version against ROCm wheels. See the [PyTorch build instructions](https://github.com/ROCm/TheRock/tree/main/external-builds/pytorch#build-instructions). ## Platform-specific setup ### ManyLinux On Linux, it’s recommended to build with ManyLinux to produce binaries that are portable across Ubuntu and other Linux distributions. To learn more about what a ROCm ManyLinux build entails, see [ManyLinux builds](https://github.com/ROCm/TheRock/blob/main/docs/design/manylinux_builds.md). Refer to [ManyLinux x86_64](https://github.com/ROCm/TheRock/blob/main/docs/environment_setup_guide.md#manylinux-x86-64) in the environment setup guide. ### Ubuntu 24.04 TheRock provides detailed instructions and scripts for preparing an Ubuntu 24.04 system, including installing necessary packages via apt. Refer to [Setup — Ubuntu 24.04](https://github.com/ROCm/TheRock?tab=readme-ov-file#setup---ubuntu-2404) in the TheRock repository for guidance. ### Windows 11 For setup instructions on Windows 11 using Visual Studio 2022, see [Setup — Windows 11](https://github.com/ROCm/TheRock?tab=readme-ov-file#setup---windows-11-vs-2022) in the TheRock repository. #### NOTE For details on supported configurations, known issues, and other Windows-specific considerations, review the [Windows support](https://github.com/ROCm/TheRock/blob/main/docs/development/windows_support.md) documentation. --- Source: https://rocm.docs.amd.com/en/latest/install/spack.html # Using Spack to install ROCm packages Spack is a package management tool designed to support multiple software versions and configurations on a wide variety of platforms and environments. It was designed for large supercomputing centers, where many users share common software installations on clusters with exotic architectures using libraries that do not have a standard ABI. Spack is non-destructive: installing a new version does not break existing installations, so many configurations can coexist on the same system. Most importantly, Spack is simple. It offers a simple `spec` syntax, so users can concisely specify versions and configuration options. Spack is also simple for package authors: package files are written in pure Python, and specs allow package authors to maintain a single file for many different builds of the same package. See the [official Spack documentation](https://spack-tutorial.readthedocs.io/en/latest/) for more information. ## Installing prerequisites for Spack #### NOTE You must install all prerequisites before installing Spack. **Ubuntu** ```shell # Install some essential utilities: apt-get -y update apt-get -y install make patch bash tar gzip unzip bzip2 file gnupg2 git gawk apt-get -y update apt-get -y install xz-utils apt-get -y install build-essential apt-get -y install vim apt-get -y install libpci-dev # Install Python: apt-get -y install python3 apt-get -y upgrade python3-pip # Install Compilers: apt-get -y install gcc apt-get -y install gfortran apt-get -y install liblzma-dev apt-get -y install libbz2-dev ``` **SLES** ```shell # Install some essential utilities: zypper update zypper install make patch bash tar gzip unzip bzip xz file gnupg2 git awk zypper in -t pattern zypper install vim # Install Python: zypper install python3 zypper install python3-pip # Install Compilers: zypper install gcc zypper install gcc-fortran zypper install gcc-c++ ``` ## Building ROCm components using Spack 1. To use the Spack package manager, clone the Spack project from [spack/spack](https://github.com/spack/spack). ```shell git clone https://github.com/spack/spack.git ``` 2. Initialize Spack. The `setup-env.sh` script initializes the Spack environment. ```shell cd spack . share/spack/setup-env.sh ``` Spack commands are available once the above steps are completed. To list the available commands, use `help`. ```shell spack help ``` After running `setup-env.sh`, the develop branch of the [Spack packages repository](https://github.com/spack/spack-packages) will be cloned and used. #### NOTE To use your own local version of spack packages execute the following command: ```shell spack repo set --destination /path/to/local/spack-packages builtin ``` ## ROCm packages in Spack #### NOTE The supported ROCm components and their versions listed below were accurate as of the time of initial ROCm release. For the most up-to-date information, see the latest version of this information at [ROCm packages in Spack](https://rocm.docs.amd.com/en/latest/install/spack.html#rocm-packages-in-spack). | Component | Spack package name | Minimum supported version | Latest supported version | |-----------------------------------|-------------------------|-----------------------------|------------------------------------| | AMD SMI | `amdsmi` | 5.6.0 | 7.14.0 | | aqlprofile | `hsa-amd-aqlprofile` | 7.0.0 | 7.14.0 | | comgr | `comgr` | 5.6.0 | 7.14.0 | | Composable Kernel | `composable-kernel` | 5.6.0 | 7.14.0 | | devicelibs | `rocm-device-libs` | 5.6.0 | 7.14.0 | | HIP (hip_in_vdi) | `hip` | 5.6.0 | 7.14.0 | | hipBLAS | `hipblas` | 5.6.0 | 7.14.0 | | hipBLAS-common | `hipblas-common` | 6.3.0 | 7.14.0 | | hipBLASLt | `hipblaslt` | 6.0.0 | 7.14.0 | | HIPCC | `hipcc` | 5.7.0 | 7.14.0 | | hipCUB | `hipcub` | 5.6.0 | 7.14.0 | | hipFFT | `hipfft` | 5.6.0 | 7.14.0 | | hipfort | `hipfort` | 5.6.0 | 7.2.3 (Not released under TheRock) | | HIPIFY | `hipify-clang` | 5.6.0 | 7.14.0 | | hipRAND | `hiprand` | 5.6.0 | 7.14.0 | | hipSOLVER | `hipsolver` | 5.6.0 | 7.14.0 | | hipSPARSE | `hipsparse` | 5.6.0 | 7.14.0 | | hipSPARSELt | `hipsparselt` | 6.0.0 | 7.14.0 | | hipTensor | `hip-tensor` | 5.7.0 | 7.14.0 | | HIP Tests | `hip-tests` | 6.1.0 | 7.14.0 | | llvm | `llvm-amdgpu` | 5.6.0 | 7.14.0 | | MIGraphX | `migraphx` | 5.6.0 | 7.14.0 | | MIOpen (HIP) | `miopen-hip` | 5.6.0 | 7.14.0 | | MIVisionX | `mivisionx` | 5.6.0 | 7.14.0 | | OpenCL | `rocm-opencl` | 5.6.0 | 7.14.0 | | openmp-extras | `rocm-openmp-extras` | 5.6.0 | 7.2.3 | | RCCL | `rccl` | 5.6.0 | 7.14.0 | | rocAL | `rocal` | 6.2.0 | 7.2.3 (Not released under TheRock) | | rocALUTION | `rocalution` | 5.6.0 | 7.14.0 | | rocBLAS | `rocblas` | 5.6.0 | 7.14.0 | | ROCdbgapi | `rocm-dbgapi` | 5.6.0 | 7.14.0 | | rocDecode | `rocdecode` | 6.1.0 | 7.14.0 | | rocFFT | `rocfft` | 5.6.0 | 7.14.0 | | rocJPEG | `rocjpeg` | 6.3.0 | 7.14.0 | | rocm-core | `rocm-core` | 5.6.0 | 7.14.0 | | rocminfo | `rocminfo` | 5.6.0 | 7.14.0 | | rocMLIR | `rocmlir` | 5.4.0 | 7.2.3 (Not released under TheRock) | | ROCm Bandwidth Test | `rocm-bandwidth-test` | 5.6.0 | 7.2.3 (Not released under TheRock) | | ROCm CMake | `rocm-cmake` | 5.6.0 | 7.14.0 | | ROCm Compute Profiler | `rocprofiler-compute` | 6.3.2 | 7.14.0 | | ROCm Data Center Tool (RDC) | `rdc` | 5.6.0 | 7.14.0 | | ROCm Debug Agent | `rocm-debug-agent` | 5.6.0 | 7.14.0 | | ROCm Debugger (ROCgdb) | `rocm-gdb` | 5.6.0 | 7.14.0 | | ROCm Examples | `rocm-examples` | 6.2.0 | 7.14.0 | | ROCm SMI Library | `rocm-smi-lib` | 5.6.0 | 7.14.0 | | ROCm Systems Profiler | `rocprofiler-systems` | 6.3.0 | 7.14.0 | | ROCm Validation Suite | `rocm-validation-suite` | 5.6.0 | 7.14.0 | | rocPRIM | `rocprim` | 5.6.0 | 7.14.0 | | ROCProfiler | `rocprofiler-dev` | 5.6.0 | 7.14.0 | | rocprofiler-register | `rocprofiler-register` | 6.1.0 | 7.14.0 | | ROCprofiler-SDK | `rocprofiler-sdk` | 6.2.4 | 7.14.0 | | rocPyDecode | `rocpydecode` | 6.2.0 | 7.2.3 (Not released under TheRock) | | rocRAND | `rocrand` | 5.6.0 | 7.14.0 | | ROCr Runtime | `hsa-rocr-dev` | 5.6.0 | 7.14.0 | | rocSHMEM | `rocshmem` | 6.4.0 | 7.14.0 | | rocSOLVER | `rocsolver` | 5.6.0 | 7.14.0 | | rocSPARSE | `rocsparse` | 5.6.0 | 7.14.0 | | rocThrust | `rocthrust` | 5.6.0 | 7.14.0 | | ROCTracer | `roctracer-dev` | 5.6.0 | 7.14.0 | | roctracer-dev-api | `roctracer-dev-api` | 5.6.0 | 7.14.0 | | rocWMMA | `rocwmma` | 5.6.0 | 7.14.0 | | ROCm Performance Primitives (RPP) | `rpp` | 5.7.0 | 7.14.0 | | TransferBench | `transferbench` | 6.3.0 | 7.2.3 (Not released under TheRock) | | aqlprofile (old) | `aqlprofile` | 5.6.0 | 6.4.3 (final) | | clang-ocl | `rocm-clang-ocl` | 5.6.0 | 6.1.2 (final) | | Omniperf | `omniperf` | 6.2.0 | 6.3.1 (final) | | Omnitrace | `omnitrace` | rocm-6.2.0 | rocm-6.3.0 (final) | | ROCT Thunk Interface | `hsakmt-roct` | 5.6.0 | 6.2.4 (final) | | Tensile | `rocm-tensile` | 5.6.0 | 7.14.0 | ## Installing ROCm components using Spack 1. `rocm-cmake` Install the default variants and the latest version of `rocm-cmake`. ```shell spack install rocm-cmake ``` To install a specific version of `rocm-cmake`, use: ```shell spack install rocm-cmake@ ``` For example, `spack install rocm-cmake@7.14.0` 2. `info` The `info` command displays basic package information. It shows the preferred, safe, and deprecated versions, in addition to the available variants. It also shows the dependencies with other packages. ```shell spack info llvm-amdgpu ``` For example: ```shell-session $ spack info llvm-amdgpu CMakePackage: llvm-amdgpu Description: Toolkit for the construction of highly optimized compilers, optimizers, and run-time environments Homepage: https://github.com/ROCm/llvm-project Preferred version: 7.14.0 https://github.com/ROCm/llvm-project/archive/refs/tags/therock-7.14.tar.gz Safe versions: 7.14.0 https://github.com/ROCm/llvm-project/archive/refs/tags/therock-7.14.tar.gz 7.13.0 https://github.com/ROCm/llvm-project/archive/refs/tags/therock-7.13.tar.gz 7.2.3 https://github.com/ROCm/llvm-project/archive/rocm-7.2.3.tar.gz 7.2.1 https://github.com/ROCm/MIVisionX/archive/rocm-7.2.1.tar.gz 7.2.0 https://github.com/ROCm/MIVisionX/archive/rocm-7.2.0.tar.gz 7.1.1 https://github.com/ROCm/MIVisionX/archive/rocm-7.1.1.tar.gz 7.1.0 https://github.com/ROCm/MIVisionX/archive/rocm-7.1.0.tar.gz 7.0.2 https://github.com/ROCm/MIVisionX/archive/rocm-7.0.2.tar.gz 7.0.0 https://github.com/ROCm/MIVisionX/archive/rocm-7.0.0.tar.gz 6.4.3 https://github.com/ROCm/MIVisionX/archive/rocm-6.4.3.tar.gz 6.4.3 https://github.com/ROCm/MIVisionX/archive/rocm-6.4.3.tar.gz 6.4.2 https://github.com/ROCm/MIVisionX/archive/rocm-6.4.2.tar.gz 6.4.1 https://github.com/ROCm/MIVisionX/archive/rocm-6.4.1.tar.gz 6.4.0 https://github.com/ROCm/MIVisionX/archive/rocm-6.4.0.tar.gz 6.3.3 https://github.com/ROCm/MIVisionX/archive/rocm-6.3.3.tar.gz 6.3.2 https://github.com/ROCm/MIVisionX/archive/rocm-6.3.2.tar.gz 6.3.1 https://github.com/ROCm/MIVisionX/archive/rocm-6.3.1.tar.gz 6.3.0 https://github.com/ROCm/MIVisionX/archive/rocm-6.3.0.tar.gz 6.2.4 https://github.com/ROCm/MIVisionX/archive/rocm-6.2.4.tar.gz 6.2.1 https://github.com/ROCm/MIVisionX/archive/rocm-6.2.1.tar.gz 6.2.0 https://github.com/ROCm/MIVisionX/archive/rocm-6.2.0.tar.gz 6.1.2 https://github.com/ROCm/MIVisionX/archive/rocm-6.1.2.tar.gz 6.1.1 https://github.com/ROCm/MIVisionX/archive/rocm-6.1.1.tar.gz 6.1.0 https://github.com/ROCm/MIVisionX/archive/rocm-6.1.0.tar.gz 6.0.2 https://github.com/ROCm/MIVisionX/archive/rocm-6.0.2.tar.gz 6.0.0 https://github.com/ROCm/MIVisionX/archive/rocm-6.0.0.tar.gz 5.7.1 https://github.com/ROCm/MIVisionX/archive/rocm-5.7.1.tar.gz 5.7.0 https://github.com/ROCm/MIVisionX/archive/rocm-5.7.0.tar.gz Deprecated versions: None Variants: build_system [cmake] cmake Build systems supported by the package build_type [Release] Debug, MinSizeRel, RelWithDebInfo, Release when build_system=cmake CMake build type generator [ninja] none when build_system=cmake the build system generator to use ipo [false] false, true when build_system=cmake %cmake@3.9: CMake interprocedural optimization link_llvm_dylib [false] false, true Link LLVM tools against the LLVM shared library llvm_dylib [false] false, true Build LLVM shared library, containing all components in a single shared library rocm-device-libs [true] false, true Build ROCm device libs as external LLVM project instead of a standalone spack package. Dependencies: c build cmake@3.13.4: build cxx build gmake build when build_system=cmake generator=make libdrm build, link when @7.1: libelf build, link when @7.1: libxml2 link ncurses+termlib link ninja build when build_system=cmake generator=ninja numactl build, link when @7.1: pkgconfig build py-pyaml build, link when @7.13: python build xxd build, link when @7.1: z3 link zlib-api link Licenses: Apache-2.0 ``` ## Installing variants for ROCm components The variants listed above indicate that the `llvm-amdgpu` package is built by default with `build_type=Release`, `rocm-device-libs=true`, `llvm_dylib=false`, and `link_llvm_dylib=false` by default. But it also supports `build_type=Debug` and `RelWithDebInfo` , with `rocm-device-libs=false`, `llvm_dylib=true` and `link_llvm_dylib=true`. For example: ```shell spack install llvm-amdgpu build_type=Debug #Debug build with variants set to default spack install llvm-amdgpu~rocm-device-libs build_type=Debug #rocm-device-libs variant is set to false so ROCm device libs won’t be built ``` * `spack spec` command To display the dependency tree, the `spack spec` command can be used with the same format. For example: ```shell-session $ spack spec mivisionx - mivisionx@7.14.0~add_tests~asan+hip~ipo amdgpu_target:=auto build_system=cmake build_type=Release commit=112b6ba9e8ab872a3e1b95afb037be0cea84fddd generator=make platform=linux os=ubuntu24.04 target=zen2 %cxx=gcc@13.3. - ^cmake@3.31.12~doc+ncurses+ownlibs~qtgui build_system=generic build_type=Release platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 - ^curl@8.20.0~gssapi~ldap~libidn2~librtmp~libssh~libssh2+nghttp2 build_system=autotools libs:=shared,static tls:=openssl platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 - ^nghttp2@1.67.1 build_system=autotools platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 - ^ncurses@6.6~symlinks+termlib abi=none build_system=autotools patches:=7a351bc platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 - ^zlib-ng@2.3.3+compat+new_strategies+opt+pic+shared build_system=autotools platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 - ^compiler-wrapper@1.1.0 build_system=generic platform=linux os=ubuntu24.04 target=zen2 - ^ffmpeg@6.1.1~X+bzlib~doc~drawtext+gpl~libaom~libmp3lame~libopenjpeg~libopus~libsnappy~libspeex~libssh~libvorbis~libvpx~libwebp~libx264~libxml2~libzmq~lzma~nonfree~openssl~sdl2+shared+version3 build_system=autotools patches:=5726e8e platform=linux os=ubuntu24.04 target=zen2 %c,cxx=gcc@13.3.0 ... ``` ## Creating an environment You can create an environment with all the required components of your version, install them collectively, and work in the environment. 1. Create a Spack environment. ```shell spack env create myenv ``` 2. Activate the created environment. ```shell spack env activate myenv ``` 3. Add the ROCm packages. ```shell spack add rocm-cmake@7.14.0 rocm-dbgapi@7.14.0 rocm-debug-agent@7.14.0 rocm-gdb@7.14.0 rocminfo@7.14.0 \ rocm-opencl@7.14.0 rocm-smi-lib@7.14.0 rocprim@7.14.0 rocprofiler-dev@7.14.0 rocrand@7.14.0 \ rocthrust@7.14.0 roctracer-dev@7.14.0 ``` 4. Generate the build plan. ```shell spack concretize ``` 5. Install the packages. ```shell spack install ``` ## Creating and applying a patch before installation Spack installs ROCm packages after pulling the source code from GitHub and building it locally. In order to build a component with any modification to the source code, you must generate a patch and apply it before the build phase. To generate a patch and build with the changes: 1. Stage the source code. For example: ```shell spack stage hip@7.14.0 # This will pull the 7.14.0 release version source code of hip and display the path to spack-src directory where entire source code is available ``` You should see something like this: ```shell-session ==> Using cached archive: /data/root/temp/rocm-7.14.0/spack/var/spack/cache/_source-cache/archive/d8/d8dba8cdf05463afb7879de2833983cafa6a006ba719815a35b96d9b92fc7fc4.tar.gz ==> Using cached archive: /data/root/temp/rocm-7.14.0/spack/var/spack/cache/_source-cache/archive/82/829e61a5c54d0c8325d02b0191c0c8254b5740e63b8bfdb05eec9e03d48f7d2c.tar.gz ==> Using cached archive: /data/root/temp/rocm-7.14.0/spack/var/spack/cache/_source-cache/archive/80/8081d4ab1a43ffa1cebd646668d83008b799ab98c14daf7b455922355a439c8a.tar.gz ==> Moving resource stage source: /tmp/root/spack-stage/resource-clr-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src/ destination: /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src/clr ==> Moving resource stage source: /tmp/root/spack-stage/resource-hip-tests-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src/ destination: /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src/hip-tests ==> Staged hip in /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46 ``` 2. Change directory to `spack-src` inside the staged directory. ```shell-session /spack$ cd /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46 /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46$ cd spack-src/ ``` 3. Create a new Git repository. ```shell /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src$ git init ``` 4. Add the entire directory to the repository. ```shell /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src$ git add . ``` 5. Make the required changes to the source code. ```shell /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src# vi hipamd/CMakeLists.txt # Make required changes in the source code ``` 6. Generate the patch using the `git diff` command. ```shell diff > /spack/var/spack/repos/builtin/packages/hip/0001-modifications.patch /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src$ git diff > /spack/var/spack/repos/builtin/packages/hip/0001-modifications.patch ``` 7. Update the recipe with the patch file name and any conditions you want to apply. ```shell /tmp/root/spack-stage/spack-stage-hip-7.14.0-zo53ondw3tevsr3gmoofbhre7asvis46/spack-src$ spack edit hip ``` 8. Provide the patch file name and the conditions for the patch to be applied in the `hip` recipe as follows. ```shell patch("0001-modifications.patch", when="@7.14.0") ``` Spack will apply `0001-modifications.patch` on the 7.14.0 release code before starting the `hip` build. 9. After each modification, you must update the recipe. If there is no change to the recipe, run ```shell touch /spack/var/spack/repos/builtin/packages/hip/package.py ``` --- Source: https://rocm.docs.amd.com/en/latest/install/asan.html # Install AMD ROCm with ASAN ASAN (AddressSanitizer) builds of ROCm are available for specific AMD Instinct GPU architectures and can be installed using the package manager or a tarball. #### IMPORTANT - ASAN builds are only available for `gfx942` and `gfx950` architectures, plus a multiarch build (`all`, both gfx942 and gfx950). - ASAN rpm and debian packages use the naming convention `amdrocm-asan10.1` or `amdrocm-asan10.1-gfxXYZ`. - ASAN rpm and debian packages install to `/opt/rocm/core-asan-10.1`, separate from regular ROCm installations at `/opt/rocm/core-10.1`. - ASAN packages are approximately 4× larger than a standard ROCm installation due to debug symbols and ASAN instrumentation. --- Use the following selector to choose your GPU architecture, operating system, and installation method. **fam=instinct** **os=ubuntu** **os=debian** **os=rhel** **os=oracle-linux** **os=rocky-linux** **os=sles** --- ## Prerequisites Before installing ROCm ASAN, make sure your system meets the ROCm hardware, software, and driver requirements. For more information, see [Install AMD ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html). For system requirements and support information, see the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). ## Install ROCm ASAN Use the following instructions to install ROCm ASAN packages on your system. **i=pkgman — Register ROCm repositories** Complete the ROCm installation prerequisites to install dependencies and configure GPU access permissions before proceeding. **os=ubuntu** **ubuntu-ver=26.04** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable-asan.sources << EOF X-Repo-Id: amdrocm-stable-asan Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages-asan/ubuntu2604/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **ubuntu-ver=24.04** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable-asan.sources << EOF X-Repo-Id: amdrocm-stable-asan Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages-asan/ubuntu2404/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **ubuntu-ver=22.04** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable-asan.sources << EOF X-Repo-Id: amdrocm-stable-asan Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages-asan/ubuntu2204/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **os=debian** **debian-ver=13** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable-asan.sources << EOF X-Repo-Id: amdrocm-stable-asan Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages-asan/debian13/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **debian-ver=12** ```bash # Download and install GPG key sudo mkdir --parents --mode=0755 /etc/apt/keyrings wget https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \ gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null sudo tee /etc/apt/sources.list.d/amdrocm-stable-asan.sources << EOF X-Repo-Id: amdrocm-stable-asan Types: deb URIs: https://stable.repo.amd.com/rocm/core/packages-asan/debian12/ Suites: stable Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/amdrocm.gpg Enabled: yes EOF sudo apt update ``` **os=rhel** **rhel-ver=10** ```bash sudo tee /etc/yum.repos.d/amdrocm-stable-asan.repo < **i=pkgman — ROCm ASAN meta packages** Meta packages group related components and dependencies together, allowing you to install only what is necessary for your use case. The following table describes available ROCm ASAN meta packages: **os=rhel os=oracle-linux os=rocky-linux os=sles** | Meta package name | Use case | Description | Contents | |------------------------------------|---------------------------|------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| | `amdrocm-asan10.1` | ROCm Base | Core runtime environment. Install this to run ROCm applications with
ASAN instrumentation. | Runtimes, libraries, system control and monitoring tools, and other
essential components with ASAN. | | `amdrocm-core-devel-asan10.1` | ROCm Developer Essentials | Development environment. Install this to build ROCm applications with
ASAN support. | `amdrocm-asan10.1` plus compilers, CMake configurations, static
library files, and headers with ASAN. | | `amdrocm-developer-tools-asan10.1` | ROCm Profiler | Install this to profile and optimize ROCm applications with ASAN. | Profilers and related tools with ASAN instrumentation. | | `amdrocm-opencl-asan10.1` | ROCm OpenCL | Install this to run OpenCL applications on ROCm with ASAN. | Components needed to run OpenCL with ASAN. | | `amdrocm-core-sdk-asan10.1` | ROCm Full Suite | Install this if you need everything with ASAN. | The complete ROCm Core SDK including runtimes, compilers, development
tools, and dependencies with ASAN. | **os=ubuntu os=debian** | Meta package name | Use case | Description | Contents | |------------------------------------|---------------------------|------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| | `amdrocm-asan10.1` | ROCm Base | Core runtime environment. Install this to run ROCm applications with
ASAN instrumentation. | Runtimes, libraries, system control and monitoring tools, and other
essential components with ASAN. | | `amdrocm-core-dev-asan10.1` | ROCm Developer Essentials | Development environment. Install this to build ROCm applications with
ASAN support. | `amdrocm-asan10.1` plus compilers, CMake configurations, static
library files, and headers with ASAN. | | `amdrocm-developer-tools-asan10.1` | ROCm Profiler | Install this to profile and optimize ROCm applications with ASAN. | Profilers and related tools with ASAN instrumentation. | | `amdrocm-opencl-asan10.1` | ROCm OpenCL | Install this to run OpenCL applications on ROCm with ASAN. | Components needed to run OpenCL with ASAN. | | `amdrocm-core-sdk-asan10.1` | ROCm Full Suite | Install this if you need everything with ASAN. | The complete ROCm Core SDK including runtimes, compilers, development
tools, and dependencies with ASAN. | #### NOTE All ASAN meta packages follow the naming convention `amdrocm--asan10.1` or `amdrocm--asan10.1-gfx` for architecture-specific builds. **i=tar — Create the installation directory** Run the following command in your desired location to create your installation directory: ```bash mkdir therock-tarball-asan && cd therock-tarball-asan ``` #### IMPORTANT Subsequent commands assume you’re working with the `therock-tarball-asan` directory. If you choose a different directory name, adjust the commands accordingly. **i=tar — Download and unpack the tarball** Use the following commands to download and untar the ROCm ASAN tarball for your target GPU architecture. **fam=all** ```bash wget https://stable.repo.amd.com/rocm/core/tarball-asan/therock-dist-linux-multiarch-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx942** ```bash wget https://stable.repo.amd.com/rocm/core/tarball-asan/therock-dist-linux-gfx94X-dcgpu-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` **gfx=gfx950** ```bash wget https://stable.repo.amd.com/rocm/core/tarball-asan/therock-dist-linux-gfx950-dcgpu-10.1.0.tar.gz mkdir install tar -xf *.tar.gz -C install ``` ## Post-installation After installing ROCm ASAN 10.1.0, complete these post-installation steps to configure your system and validate the installation. **i=pkgman i=tar — Configure your environment** Configure environment variables so that ROCm ASAN libraries and tools are available either to all users on the system or only to your user account. **System-wide setup** **i=tar** Create a profile script so that all users inherit the ROCm ASAN environment variables when they start a shell session. Make sure you’re in the `therock-tarball-asan` directory before proceeding. ```bash # Configure ROCM_ASAN_PATH to the ASan install tree (tarball extract path) ROCM_ASAN_INSTALL_PATH=$(pwd)/install sudo tee /etc/profile.d/set-rocm-asan-env.sh << EOF # ROCm ASan Configuration export ROCM_ASAN_PATH=$ROCM_ASAN_INSTALL_PATH # Add ROCm bin to PATH export PATH=\$PATH:\$ROCM_ASAN_PATH/bin # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=\$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="\$LD_LIBRARY_PATH:\${ASAN_LIB_PATH%/*}:\${ROCM_ASAN_PATH}/lib:\${ROCM_ASAN_PATH}/lib/llvm/lib:\${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="\${ASAN_LIB_PATH%/*}/\$ASAN_LIB_NAME:\${ROCM_ASAN_PATH}/lib/libamdhip64.so:\${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" EOF sudo chmod +x /etc/profile.d/set-rocm-asan-env.sh source /etc/profile.d/set-rocm-asan-env.sh ``` **i=pkgman** Create a profile script so that all users inherit the ROCm ASAN environment variables when they start a shell session. ```bash # Configure ROCM_ASAN_PATH to the ASan install tree sudo tee /etc/profile.d/set-rocm-asan-env.sh << 'EOF' # ROCm ASan Configuration export ROCM_ASAN_PATH=/opt/rocm/core-asan-10.1 # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ASAN_LIB_PATH%/*}:${ROCM_ASAN_PATH}/lib:${ROCM_ASAN_PATH}/lib/llvm/lib:${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="${ASAN_LIB_PATH%/*}/$ASAN_LIB_NAME:${ROCM_ASAN_PATH}/lib/libamdhip64.so:${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" EOF sudo chmod +x /etc/profile.d/set-rocm-asan-env.sh source /etc/profile.d/set-rocm-asan-env.sh ``` **User setup** Configure the ROCm ASAN environment for your user by updating your shell startup configuration file. **i=tar** Use the following commands to update your shell configuration file (`~/.bashrc` or `~/.profile`) and add ROCm ASAN to your PATH. Before proceeding, make sure you’re in the `therock-tarball-asan` directory so the install path resolves correctly. **i=pkgman** Use the following commands to update your shell configuration file (`~/.bashrc` or `~/.profile`) and add ROCm ASAN to your PATH. **.bashrc** **i=tar** ```bash # Configure ROCM_ASAN_PATH to the ASan install tree (tarball extract path) ROCM_ASAN_INSTALL_PATH=$(pwd)/install tee --append ~/.bashrc << EOF # BEGIN ROCm ASan Configuration export ROCM_ASAN_PATH=$ROCM_ASAN_INSTALL_PATH # Add ROCm bin to PATH export PATH=\$PATH:\$ROCM_ASAN_PATH/bin # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=\$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="\$LD_LIBRARY_PATH:\${ASAN_LIB_PATH%/*}:\${ROCM_ASAN_PATH}/lib:\${ROCM_ASAN_PATH}/lib/llvm/lib:\${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="\${ASAN_LIB_PATH%/*}/\$ASAN_LIB_NAME:\${ROCM_ASAN_PATH}/lib/libamdhip64.so:\${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" # END ROCm ASan Configuration EOF source ~/.bashrc ``` **i=pkgman** ```bash # Configure ROCM_ASAN_PATH to the ASan install tree tee --append ~/.bashrc << 'EOF' # BEGIN ROCm ASan Configuration export ROCM_ASAN_PATH=/opt/rocm/core-asan-10.1 # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ASAN_LIB_PATH%/*}:${ROCM_ASAN_PATH}/lib:${ROCM_ASAN_PATH}/lib/llvm/lib:${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="${ASAN_LIB_PATH%/*}/$ASAN_LIB_NAME:${ROCM_ASAN_PATH}/lib/libamdhip64.so:${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" # END ROCm ASan Configuration EOF source ~/.bashrc ``` **.profile** **i=tar** ```bash # Configure ROCM_ASAN_PATH to the ASan install tree (tarball extract path) ROCM_ASAN_INSTALL_PATH=$(pwd)/install tee --append ~/.profile << EOF # BEGIN ROCm ASan Configuration export ROCM_ASAN_PATH=$ROCM_ASAN_INSTALL_PATH # Add ROCm bin to PATH export PATH=\$PATH:\$ROCM_ASAN_PATH/bin # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=\$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="\$LD_LIBRARY_PATH:\${ASAN_LIB_PATH%/*}:\${ROCM_ASAN_PATH}/lib:\${ROCM_ASAN_PATH}/lib/llvm/lib:\${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="\${ASAN_LIB_PATH%/*}/\$ASAN_LIB_NAME:\${ROCM_ASAN_PATH}/lib/libamdhip64.so:\${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" # END ROCm ASan Configuration EOF source ~/.profile ``` **i=pkgman** ```bash # Configure ROCM_ASAN_PATH to the ASan install tree tee --append ~/.profile << 'EOF' # BEGIN ROCm ASan Configuration export ROCM_ASAN_PATH=/opt/rocm/core-asan-10.1 # Enable XNACK for device-side GPU instrumentation # Without this, only host-side (CPU) errors will be detected export HSA_XNACK=1 # Locate ASan runtime directory and append instrumented library directories ASAN_LIB_PATH=$(amdclang --print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "") export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ASAN_LIB_PATH%/*}:${ROCM_ASAN_PATH}/lib:${ROCM_ASAN_PATH}/lib/llvm/lib:${ROCM_ASAN_PATH}/lib/rocm_sysdeps/lib/" export ASAN_LIB_NAME=libclang_rt.asan-x86_64.so export LD_PRELOAD="${ASAN_LIB_PATH%/*}/$ASAN_LIB_NAME:${ROCM_ASAN_PATH}/lib/libamdhip64.so:${ROCM_ASAN_PATH}/lib/libhsa-runtime64.so" # END ROCm ASan Configuration EOF source ~/.profile ``` ### Verify your installation Use the following ROCm tools to verify that ROCm ASAN is correctly installed and that your AMD devices are visible to the system. Use `rocminfo` to list detected AMD GPUs and confirm that the ROCm runtimes and drivers are correctly installed and loaded: ```bash rocminfo ``` Use the AMD SMI CLI `amd-smi` to validate system information: ```bash amd-smi version ``` --- ## Uninstall ROCm ASAN **i=pkgman — Uninstall ROCm ASAN packages** 1. Disable the ROCm ASAN environment. ```bash unset ROCM_ASAN_PATH HSA_XNACK LD_PRELOAD ASAN_LIB_PATH ASAN_LIB_NAME LD_LIBRARY_PATH ``` 2. Remove the ROCm environment variables from your configuration. **System-wide setup** ```bash sudo rm -f /etc/profile.d/set-rocm-asan-env.sh ``` **User setup** Remove the ROCm environment configuration block from your shell configuration file (`~/.bashrc` or `~/.profile`). 3. Use your package manager to remove the installed packages. **os=ubuntu os=debian** **fam=all** ```bash sudo apt autoremove amdrocm-asan10.1 ``` **gfx=gfx942** ```bash sudo apt autoremove amdrocm-asan10.1-gfx942 ``` **gfx=gfx950** ```bash sudo apt autoremove amdrocm-asan10.1-gfx950 ``` **os=rhel os=oracle-linux os=rocky-linux** **fam=all** ```bash sudo dnf remove amdrocm-asan10.1 ``` **gfx=gfx942** ```bash sudo dnf remove amdrocm-asan10.1-gfx942 ``` **gfx=gfx950** ```bash sudo dnf remove amdrocm-asan10.1-gfx950 ``` **os=sles** ```bash sudo zypper remove amdrocm-*-asan10.1* ``` 4. Remove ROCm repositories. **os=ubuntu os=debian** ```bash # Remove ROCm repositories sudo rm -f /etc/apt/sources.list.d/amdrocm-stable-asan.sources # Clear the cache and clean the system sudo rm -rf /var/cache/apt/* sudo apt clean sudo apt update ``` **os=rhel os=oracle-linux os=rocky-linux** ```bash # Remove ROCm repositories sudo rm -f /etc/yum.repos.d/amdrocm-stable-asan.repo* # Clear the cache and clean the system sudo rm -rf /var/cache/dnf sudo dnf clean all ``` **os=sles** ```bash # Remove ROCm repositories sudo zypper removerepo "amdrocm-stable-asan" # Clear the cache and clean the system sudo zypper clean --all sudo zypper refresh ``` **i=tar — Uninstall the ROCm ASAN tarball** 1. Disable the ROCm ASAN environment. ```bash unset ROCM_ASAN_PATH HSA_XNACK LD_PRELOAD ASAN_LIB_PATH ASAN_LIB_NAME LD_LIBRARY_PATH ``` 2. Remove the ROCm environment variables from your configuration. **System-wide setup** ```bash sudo rm -f /etc/profile.d/set-rocm-asan-env.sh ``` **User setup** Remove the ROCm environment configuration block from your shell configuration file (`~/.bashrc` or `~/.profile`). 3. Remove the directory containing the ROCm ASAN installation: #### IMPORTANT The following command assumes you’re working with the `therock-tarball-asan` directory. If you chose a different directory name when [installing ROCm](#rocm-asan-install-rocm), adjust the command accordingly. ```bash rm -rf therock-tarball-asan ``` --- ## Next steps To run applications with ASAN instrumentation, ensure the following: - Linux kernel ≥ 5.6 with HMM enabled - `HSA_XNACK=1` - `-fsanitize=address` - Instrumented runtimes For more information, see the [GPU sanitizer guide](https://github.com/ROCm/TheRock/blob/main/docs/development/sanitizers.md#using-asan-instrumented-libraries). --- Source: https://rocm.docs.amd.com/en/latest/install/docker-containers.html # Run ROCm Docker containers Docker is a popular way to run ROCm workloads in a consistent, reproducible environment. There are two ways to expose AMD GPUs to Docker containers: * [AMD Container Runtime Toolkit](#docker-with-toolkit) — simplifies GPU access within Docker environments, enhances device discovery, and enables better integration with modern container technologies. * [Manual Docker device passthrough](#docker-manual) — passes GPU device nodes directly to the container with `--device`. No toolkit required. ## Prerequisites Regardless of which approach you use, the following are required on the host system: * On Linux, the AMD GPU driver (`amdgpu-dkms`). See [Install AMD ROCm 10.1.0](https://rocm.docs.amd.com/en/latest/install/rocm.html) for driver installation guidance for your environment. * [Docker Engine](https://docs.docker.com/engine/install/). ## With the AMD Container Runtime Toolkit The [AMD Container Runtime Toolkit](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/overview.html) provides two mechanisms for GPU injection: CDI (recommended) and the amd-container-runtime. Both require installing the toolkit first. 1. Install the toolkit by following the [Quick Start Guide (AMD Container Runtime Toolkit docs)](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/quick-start-guide.html). 2. See [Running Workloads (AMD Container Runtime Toolkit docs)](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/running-workloads.html) to get started running containerized ROCm applications on AMD GPUs. ## Without the AMD Container Runtime Toolkit If you prefer not to install the AMD Container Runtime Toolkit, or you’re using older versions of Docker Engine, you can pass GPU device nodes directly to the container using Docker’s `--device` flag. This approach requires no additional software beyond Docker. ```shell docker run -it --rm \ --device /dev/kfd \ --device /dev/dri \ --security-opt seccomp=unconfined \ ``` The purpose of each option: * `--device /dev/kfd` The main compute interface, shared by all GPUs. * `--device /dev/dri` Contains the Direct Rendering Interface (DRI) device nodes for each GPU. Passing the whole directory grants access to all GPUs. To restrict access to specific GPUs, see [Restricting GPU access](#docker-restrict-gpus). * `--security-opt seccomp=unconfined` (optional) Enables memory mapping. Recommended for HPC workloads that use `numactl` for GPU/CPU affinity mappings. See [Optional security options (Docker docs)](https://docs.docker.com/reference/cli/docker/container/run/#security-opt). ### Restricting GPU access #### NOTE [AMD Container Runtime Toolkit](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/overview.html) simplifies GPU selection, removing the need to manually map the render nodes. This is recommended if your use case needs fine-grained GPU selection. See [Running Workloads (AMD Container Toolkit Runtime docs)](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/running-workloads.html#running-workloads) for more information. By default, `--device /dev/dri` grants access to all GPUs on the system. To limit a container to specific GPUs, pass their individual render nodes instead. List available render nodes on the host: ```shell ls /dev/dri/render* ``` GPU render nodes are typically named `renderD128`, `renderD129`, and so on. Pass them individually alongside `/dev/kfd`: ```shell docker run --device /dev/kfd \ --device /dev/dri/renderD128 \ --device /dev/dri/renderD129 \ ``` #### NOTE When GPUs are partitioned (for example, an Instinct MI300X or MI350X in DPX, QPX, or CPX mode), each partition appears as a separate render node. In CPX mode, `renderD128` through `renderD136` are partitions of the first physical GPU, and `renderD137` is the second GPU. Account for this when selecting render nodes. See [GPU partitioning](https://instinct.docs.amd.com/projects/amdgpu-docs/en/latest/gpu-partitioning/mi300x/overview.html) for details. ## Docker Compose Docker Compose can simplify complex Docker invocations. See [Docker Compose usage](https://instinct.docs.amd.com/projects/container-toolkit/en/latest/container-runtime/docker-compose.html) for AMD Container Toolkit configuration examples. For manual Docker device passthrough, use the `devices` key in your Compose file: ```yaml services: myapp: image: devices: - /dev/kfd - /dev/dri ``` ## Verifying GPU access Inside any container with ROCm installed, `rocminfo` and `amd-smi list` enumerate only the GPUs passed into that container. On the host, they enumerate all ROCm-capable GPUs. [rocminfo](https://rocm.docs.amd.com/projects/rocminfo/en/latest/index.html) and [amd-smi](https://rocm.docs.amd.com/projects/amdsmi/en/latest/index.html) are provided by the ROCm Core SDK. Run either tool to confirm the expected GPUs are visible. ## Docker images The [ROCm Docker repository](https://github.com/ROCm/ROCm-docker) hosts Dockerfiles for building ROCm-capable containers. Pre-built images are available on [Docker Hub](https://hub.docker.com/u/rocm): * `rocm/rocm-terminal` — minimal image with prerequisites to build HIP applications, without any libraries. * [ROCm dev images](https://hub.docker.com/u/rocm?page=1&search=dev-) — a variety of OS and ROCm version combinations, suitable as a base for building applications. * The ROCm [AI ecosystem](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/) provides Docker images for popular inference frameworks. --- Source: https://rocm.docs.amd.com/en/latest/ai-ecosystem.html # AMD ROCm AI ecosystem The [AMD ROCm AI ecosystem documentation portal](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/index.html) includes guides covering deep framework installation and setup, large-scale model training, LLM and diffusion inference serving, and AI workload performance optimization on AMD GPUs. The ROCm AI ecosystem lives on top of the [ROCm Core SDK](https://rocm.docs.amd.com/en/latest/about/what-is-rocm.html), which provides the underlying GPU runtimes (HIP), compilers, and math libraries. Install PyTorch and JAX on AMD GPUs. Includes hardware-specific instructions for AMD Instinct and Radeon GPUs and Ryzen APUs across Linux and Windows using pip. - [Install PyTorch](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html?rocm-ver=10.1.0) - [Install JAX](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/jax/install.html?rocm-ver=10.1.0) - [Install TensorFlow](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/tensorflow/install.html?rocm-ver=10.1.0) Train and scale models on AMD GPUs. Primus provides end-to-end training infrastructure for multiple popular backend frameworks, including Megatron, TorchTitan, and MaxText. - [Primus](https://rocm.docs.amd.com/projects/primus) Serve LLMs and generative AI models using high-performance inference frameworks. Covers single-node and distributed multi-GPU deployments. - [vLLM](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/vllm.html?rocm-ver=10.1.0) - [SGLang](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/sglang.html?rocm-ver=10.1.0) - [ATOM](https://rocm.docs.amd.com/projects/atom/en/latest/) - [MIGraphX](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/migraphx.html?rocm-ver=10.1.0) - [ONNX Runtime](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/onnxruntime.html?rocm-ver=10.1.0) - [xDiT](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/xdit.html) - [ComfyUI](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/comfy.html) Multi-node prefill-decode disaggregated serving over RDMA networking using MoRI (Modular RDMA Interface) on MI355X clusters. - [vLLM with MoRI recipe](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/distributed/vllm-mori-recipe.html) - [SGLang with MoRI recipe](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/inference/distributed/sglang-mori-recipe.html) Improve throughput, latency, and memory efficiency for AI workloads on AMD Instinct GPUs. - [Workload optimization](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/workload-optimization.html) - [vLLM V1 performance](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/vllm-v1-optimization.html) - [Model quantization](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/model-quantization.html) - [Model acceleration libraries](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/model-acceleration-libs.html) - [Triton kernels](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/optimize-triton-kernels.html) - [Composable Kernel](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/optimization/optimize-with-composable-kernel.html) Hands-on guides and recipes for building AI applications on AMD hardware. - [AI Playbooks](https://developer.amd.com/playbooks) - [AI Developer Hub](https://rocm.docs.amd.com/projects/ai-developer-hub) --- Source: https://rocm.docs.amd.com/en/latest/components/core.html # ROCm Core SDK components The ROCm Core SDK is the foundation of the ROCm software stack. It provides the libraries, runtimes, compilers, and tools needed to develop and run GPU-accelerated applications on AMD hardware. ## Math and compute libraries A comprehensive set of GPU-accelerated math libraries covering dense and sparse linear algebra, FFTs, random number generation, and more. * Libraries prefixed with `roc*` are native, high-performance implementations written in HIP specifically for AMD GPUs. * Libraries prefixed with `hip*` are portable wrappers that implement NVIDIA CUDA-equivalent APIs, allowing CUDA applications to be ported to AMD GPUs with minimal code changes. Libraries include: * [Composable Kernel 1.3.0](https://rocm.docs.amd.com/projects/composable_kernel/en/docs-10.1.0/) – Provides a programming model for writing performance critical kernels for machine learning workloads across multiple architectures. * [hipBLAS 3.7.0](https://rocm.docs.amd.com/projects/hipBLAS/en/docs-10.1.0/) – BLAS-marshalling library that supports rocBLAS and cuBLAS backends. * [hipBLASLt 1.4.1](https://rocm.docs.amd.com/projects/hipBLASLt/en/docs-10.1.0/) – Provides general matrix-matrix operations with a flexible API and extends functionalities beyond traditional BLAS library. * [hipCUB 4.7.0](https://rocm.docs.amd.com/projects/hipCUB/en/docs-10.1.0/) – Thin header-only wrapper library on top of rocPRIM or CUB that allows project porting using the CUB library to the HIP layer. * [hipFFT 1.0.26](https://rocm.docs.amd.com/projects/hipFFT/en/docs-10.1.0/) – Fast Fourier Transforms (FFT)-marshalling library that supports rocFFT or cuFFT backends. * [hipRAND 3.4.0](https://rocm.docs.amd.com/projects/hipRAND/en/docs-10.1.0/) – Ports CUDA applications that use the cuRAND library into the HIP layer. * [hipSOLVER 3.7.0](https://rocm.docs.amd.com/projects/hipSOLVER/en/docs-10.1.0/) – LAPACK-marshalling library that supports rocSOLVER and cuSOLVER backends. * [hipSPARSE 4.8.0](https://rocm.docs.amd.com/projects/hipSPARSE/en/docs-10.1.0/) – SPARSE-marshalling library that supports rocSPARSE and cuSPARSE backends. * [hipSPARSELt 0.2.9](https://rocm.docs.amd.com/projects/hipSPARSELt/en/docs-10.1.0/) – Sparse matrix-matrix operations library. * [libhipcxx 3.0.2](https://rocm.docs.amd.com/projects/libhipcxx/en/docs-10.1.0/) – The C++ Standard Library for HIP, providing an opt-in, incremental, heterogeneous implementation of C++ Standard Library features that work in both host and device code. * [MIOpen 3.6.1](https://rocm.docs.amd.com/projects/MIOpen/en/docs-10.1.0/) – An open source deep-learning library. * [rocBLAS 5.7.0](https://rocm.docs.amd.com/projects/rocBLAS/en/docs-10.1.0/) – BLAS implementation (in the HIP programming language) on the ROCm runtime and toolchains. * [rocFFT 1.0.40](https://rocm.docs.amd.com/projects/rocFFT/en/docs-10.1.0/) – Software library for computing Fast Fourier Transforms (FFTs) written in HIP. * [rocPRIM 4.6.0](https://rocm.docs.amd.com/projects/rocPRIM/en/docs-10.1.0/) – Header-only library for HIP parallel primitives. * [rocRAND 5.0.0](https://rocm.docs.amd.com/projects/rocRAND/en/docs-10.1.0/) – Provides functions that generate pseudorandom and quasirandom numbers. * [rocSOLVER 3.37.0](https://rocm.docs.amd.com/projects/rocSOLVER/en/docs-10.1.0/) – An implementation of LAPACK routines on ROCm software, implemented in the HIP programming language and optimized for AMD’s latest discrete GPUs. * [rocSPARSE 5.1.0](https://rocm.docs.amd.com/projects/rocSPARSE/en/docs-10.1.0/) – Exposes a common interface that provides BLAS for sparse computation implemented on ROCm runtime and toolchains (in the HIP programming language). * [rocThrust 4.7.0](https://rocm.docs.amd.com/projects/rocThrust/en/docs-10.1.0/) – Parallel algorithm library. * [rocWMMA 2.2.1](https://rocm.docs.amd.com/projects/rocWMMA/en/docs-10.1.0/) – C++ library for accelerating mixed-precision matrix multiply-accumulate (MMA) operations. ## Communication libraries * [RCCL 2.30.7](https://rocm.docs.amd.com/projects/rccl/en/docs-10.1.0/) – Standalone library that provides multi-GPU and multi-node collective communication primitives. * [rocSHMEM 3.7.0](https://rocm.docs.amd.com/projects/rocSHMEM/en/docs-10.1.0/) – An intra-kernel networking library that provides GPU-centric networking through an OpenSHMEM-like interface. ## Profiling and debugging tools * [ROCdbgapi 0.80.0](https://rocm.docs.amd.com/projects/ROCdbgapi/en/docs-10.1.0/) – ROCm debugger API library. * [ROCgdb 16.3](https://rocm.docs.amd.com/projects/ROCgdb/en/docs-10.1.0/) – Source-level debugger for Linux, based on the GNU Debugger (GDB). * [ROCm Compute Profiler 3.9.0](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/docs-10.1.0/) – Kernel-level profiling for machine learning and high performance computing (HPC) workloads. * [ROCm Systems Profiler 1.9.0](https://rocm.docs.amd.com/projects/rocprofiler-systems/en/docs-10.1.0/) – Comprehensive profiling and tracing of applications running on the CPU or the CPU and GPU. * [ROCprofiler-SDK 1.4.1](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/docs-10.1.0/) – Toolkit for developing analysis tools for profiling and tracing GPU compute applications. * [ROCr Debug Agent 2.2.0](https://rocm.docs.amd.com/projects/rocr_debug_agent/en/docs-10.1.0/) – Prints the state of all AMD GPU wavefronts that caused a queue error by sending a SIGQUIT signal to the process while the program is running. ## Control and monitoring tools * [AMD SMI 27.1.0](https://rocm.docs.amd.com/projects/amdsmi/en/docs-10.1.0/) – System management interface to control AMD GPU settings, monitor performance, and retrieve device and process information. * [ROCm Data Center Tool 1.3.1](https://rocm.docs.amd.com/projects/rdc/en/docs-10.1.0/) – Simplifies administration and addresses key infrastructure challenges in AMD GPUs in cluster and data-center environments. * [rocminfo 1.0.0](https://rocm.docs.amd.com/projects/rocminfo/en/docs-10.1.0/) – Reports system information. ## Media and vision libraries * [rocDecode 1.10.0](https://rocm.docs.amd.com/projects/rocDecode/en/docs-10.1.0/) – High-performance SDK for access to video decoding features on AMD GPUs. * [rocJPEG 1.10.0](https://rocm.docs.amd.com/projects/rocJPEG/en/docs-10.1.0/) – Library for decoding JPEG images on AMD GPUs. * [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) – Computer vision library for AMD processors with HIP or CPU backends. ## Storage libraries * [hipFile 0.5.0](https://rocm.docs.amd.com/projects/hipFile/en/docs-10.1.0/) – AMD’s Infinity Storage library that provides direct-to-GPU I/O for the ROCm platform. ## Threading libraries * [hipThreads 1.0.0](https://rocm.docs.amd.com/projects/hipThreads/en/docs-10.1.0/) – Concurrency library that implements C++ threading and synchronization primitives for AMD GPU kernels. ## Runtimes and compilers * [HIP 7.16.0](https://rocm.docs.amd.com/projects/HIP/en/docs-10.1.0/) – A C++ runtime API and kernel programming language designed for AMD GPUs. By providing an interface closely aligned with NVIDIA CUDA, HIP allows developers to write portable applications and efficiently migrate existing CUDA code to AMD platforms. * [HIPIFY 10.1.0](https://rocm.docs.amd.com/projects/HIPIFY/en/docs-10.1.0/) – Translates CUDA source code into portable HIP C++. * [LLVM 24.0.0](https://rocm.docs.amd.com/projects/llvm-project/en/docs-10.1.0/) – AMD’s LLVM-based compiler infrastructure, including the ROCm device compiler (amdclang), which compiles HIP and OpenCL code for AMD GPUs. * [ROCr Runtime 1.21.0](https://rocm.docs.amd.com/projects/ROCR-Runtime/en/docs-10.1.0/) – AMD’s implementation of the HSA (Heterogeneous System Architecture) runtime, providing the foundation for GPU execution and management in the ROCm software stack. * [SPIRV-LLVM-Translator 24.0.0](https://github.com/ROCm/SPIRV-LLVM-Translator/tree/therock-10.1) – Library and tool for bidirectional translation between SPIR-V and LLVM. --- Source: https://rocm.docs.amd.com/en/latest/components/math-and-compute-libs.html # ROCm math and compute libraries ROCm math and compute libraries provide GPU-accelerated implementations of common numerical operations including dense and sparse linear algebra, FFTs, random number generation, and deep learning primitives. Libraries prefixed with `roc*` are native, high-performance implementations written in HIP specifically for AMD GPUs. Libraries prefixed with `hip*` are portable wrappers that implement NVIDIA CUDA-equivalent APIs, allowing CUDA applications to be ported to AMD GPUs with minimal code changes. * [Composable Kernel 1.3.0](https://rocm.docs.amd.com/projects/composable_kernel/en/docs-10.1.0/) – Provides a programming model for writing performance critical kernels for machine learning workloads across multiple architectures. * [hipBLAS 3.7.0](https://rocm.docs.amd.com/projects/hipBLAS/en/docs-10.1.0/) – BLAS-marshalling library that supports rocBLAS and cuBLAS backends. * [hipBLASLt 1.4.1](https://rocm.docs.amd.com/projects/hipBLASLt/en/docs-10.1.0/) – Provides general matrix-matrix operations with a flexible API and extends functionalities beyond traditional BLAS library. * [hipCUB 4.7.0](https://rocm.docs.amd.com/projects/hipCUB/en/docs-10.1.0/) – Thin header-only wrapper library on top of rocPRIM or CUB that allows project porting using the CUB library to the HIP layer. * [hipFFT 1.0.26](https://rocm.docs.amd.com/projects/hipFFT/en/docs-10.1.0/) – Fast Fourier Transforms (FFT)-marshalling library that supports rocFFT or cuFFT backends. * [hipRAND 3.4.0](https://rocm.docs.amd.com/projects/hipRAND/en/docs-10.1.0/) – Ports CUDA applications that use the cuRAND library into the HIP layer. * [hipSOLVER 3.7.0](https://rocm.docs.amd.com/projects/hipSOLVER/en/docs-10.1.0/) – LAPACK-marshalling library that supports rocSOLVER and cuSOLVER backends. * [hipSPARSE 4.8.0](https://rocm.docs.amd.com/projects/hipSPARSE/en/docs-10.1.0/) – SPARSE-marshalling library that supports rocSPARSE and cuSPARSE backends. * [hipSPARSELt 0.2.9](https://rocm.docs.amd.com/projects/hipSPARSELt/en/docs-10.1.0/) – Sparse matrix-matrix operations library. * [libhipcxx 3.0.2](https://rocm.docs.amd.com/projects/libhipcxx/en/docs-10.1.0/) – The C++ Standard Library for HIP, providing an opt-in, incremental, heterogeneous implementation of C++ Standard Library features that work in both host and device code. * [MIOpen 3.6.1](https://rocm.docs.amd.com/projects/MIOpen/en/docs-10.1.0/) – An open source deep-learning library. * [rocBLAS 5.7.0](https://rocm.docs.amd.com/projects/rocBLAS/en/docs-10.1.0/) – BLAS implementation (in the HIP programming language) on the ROCm runtime and toolchains. * [rocFFT 1.0.40](https://rocm.docs.amd.com/projects/rocFFT/en/docs-10.1.0/) – Software library for computing Fast Fourier Transforms (FFTs) written in HIP. * [rocPRIM 4.6.0](https://rocm.docs.amd.com/projects/rocPRIM/en/docs-10.1.0/) – Header-only library for HIP parallel primitives. * [rocRAND 5.0.0](https://rocm.docs.amd.com/projects/rocRAND/en/docs-10.1.0/) – Provides functions that generate pseudorandom and quasirandom numbers. * [rocSOLVER 3.37.0](https://rocm.docs.amd.com/projects/rocSOLVER/en/docs-10.1.0/) – An implementation of LAPACK routines on ROCm software, implemented in the HIP programming language and optimized for AMD’s latest discrete GPUs. * [rocSPARSE 5.1.0](https://rocm.docs.amd.com/projects/rocSPARSE/en/docs-10.1.0/) – Exposes a common interface that provides BLAS for sparse computation implemented on ROCm runtime and toolchains (in the HIP programming language). * [rocThrust 4.7.0](https://rocm.docs.amd.com/projects/rocThrust/en/docs-10.1.0/) – Parallel algorithm library. * [rocWMMA 2.2.1](https://rocm.docs.amd.com/projects/rocWMMA/en/docs-10.1.0/) – C++ library for accelerating mixed-precision matrix multiply-accumulate (MMA) operations. --- Source: https://rocm.docs.amd.com/en/latest/components/communication-libs.html # ROCm communication libraries ROCm communication libraries provide high-performance multi-GPU and multi-node communication primitives for deep learning and HPC workloads. * [RCCL 2.30.7](https://rocm.docs.amd.com/projects/rccl/en/docs-10.1.0/) – Standalone library that provides multi-GPU and multi-node collective communication primitives. * [rocSHMEM 3.7.0](https://rocm.docs.amd.com/projects/rocSHMEM/en/docs-10.1.0/) – An intra-kernel networking library that provides GPU-centric networking through an OpenSHMEM-like interface. --- Source: https://rocm.docs.amd.com/en/latest/components/media-libs.html # ROCm media and vision libraries ROCm media and vision libraries provide GPU-accelerated video and image decoding, image processing, and computer vision primitives for AMD GPUs. * [rocDecode 1.10.0](https://rocm.docs.amd.com/projects/rocDecode/en/docs-10.1.0/) – High-performance SDK for access to video decoding features on AMD GPUs. * [rocJPEG 1.10.0](https://rocm.docs.amd.com/projects/rocJPEG/en/docs-10.1.0/) – Library for decoding JPEG images on AMD GPUs. * [RPP 3.2.0](https://rocm.docs.amd.com/projects/rpp/en/docs-10.1.0/) – Computer vision library for AMD processors with HIP or CPU backends. --- Source: https://rocm.docs.amd.com/en/latest/components/storage-libs.html # ROCm storage libraries AMD Infinity Storage (AIS) Libraries provide optimized communication and data transfer between storage and AMD GPUs for AI/ML and HPC workloads. * [hipFile 0.5.0](https://rocm.docs.amd.com/projects/hipFile/en/docs-10.1.0/) – AMD’s Infinity Storage library that provides direct-to-GPU I/O for the ROCm platform. --- Source: https://rocm.docs.amd.com/en/latest/components/threading-libs.html # ROCm threading libraries ROCm threading libraries provide GPU threading support for applications running on AMD GPUs. * [hipThreads 1.0.0](https://rocm.docs.amd.com/projects/hipThreads/en/docs-10.1.0/) – Concurrency library that implements C++ threading and synchronization primitives for AMD GPU kernels. --- Source: https://rocm.docs.amd.com/en/latest/components/runtimes-and-compilers.html # ROCm runtimes and compilers ROCm runtimes and compilers provide the core execution environment and programming tools for GPU application development on AMD hardware. * [HIP 7.16.0](https://rocm.docs.amd.com/projects/HIP/en/docs-10.1.0/) – A C++ runtime API and kernel programming language designed for AMD GPUs. By providing an interface closely aligned with NVIDIA CUDA, HIP allows developers to write portable applications and efficiently migrate existing CUDA code to AMD platforms. * [HIPIFY 10.1.0](https://rocm.docs.amd.com/projects/HIPIFY/en/docs-10.1.0/) – Translates CUDA source code into portable HIP C++. * [LLVM 24.0.0](https://rocm.docs.amd.com/projects/llvm-project/en/docs-10.1.0/) – AMD’s LLVM-based compiler infrastructure, including the ROCm device compiler (amdclang), which compiles HIP and OpenCL code for AMD GPUs. * [ROCr Runtime 1.21.0](https://rocm.docs.amd.com/projects/ROCR-Runtime/en/docs-10.1.0/) – AMD’s implementation of the HSA (Heterogeneous System Architecture) runtime, providing the foundation for GPU execution and management in the ROCm software stack. * [SPIRV-LLVM-Translator 24.0.0](https://github.com/ROCm/SPIRV-LLVM-Translator/tree/therock-10.1) – Library and tool for bidirectional translation between SPIR-V and LLVM. --- Source: https://rocm.docs.amd.com/en/latest/components/profilers-and-debuggers.html # ROCm profiling and debugging tools ROCm profiling and debugging tools help you measure GPU application performance, identify bottlenecks, and diagnose execution faults. For an overview of the profiling tools, their relationships, and how to use them together, see [ROCm profiling tools overview](https://rocm.docs.amd.com/en/latest/components/profiling-tools-overview.html). For guidance on choosing the right tool for your performance investigation, see [Choosing the right ROCm profiling tool](https://rocm.docs.amd.com/en/latest/components/profiling-tools-selection.html). * [ROCdbgapi 0.80.0](https://rocm.docs.amd.com/projects/ROCdbgapi/en/docs-10.1.0/) – ROCm debugger API library. * [ROCgdb 16.3](https://rocm.docs.amd.com/projects/ROCgdb/en/docs-10.1.0/) – Source-level debugger for Linux, based on the GNU Debugger (GDB). * [ROCm Compute Profiler 3.9.0](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/docs-10.1.0/) – Kernel-level profiling for machine learning and high performance computing (HPC) workloads. * [ROCm Systems Profiler 1.9.0](https://rocm.docs.amd.com/projects/rocprofiler-systems/en/docs-10.1.0/) – Comprehensive profiling and tracing of applications running on the CPU or the CPU and GPU. * [ROCprofiler-SDK 1.4.1](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/docs-10.1.0/) – Toolkit for developing analysis tools for profiling and tracing GPU compute applications. * [ROCr Debug Agent 2.2.0](https://rocm.docs.amd.com/projects/rocr_debug_agent/en/docs-10.1.0/) – Prints the state of all AMD GPU wavefronts that caused a queue error by sending a SIGQUIT signal to the process while the program is running. #### NOTE In addition to the profiling tools included in the ROCm Core SDK, AMD provides standalone visualization and analysis tools that help developers explore, interpret, and gain deeper insights from collected performance data. These tools are distributed separately and complement the ROCm profiling workflow. * [ROCm Optiq](https://rocm.docs.amd.com/projects/roc-optiq/en/latest/index.html) is a unified tool for visualizing and analyzing performance data collected by ROCm Systems Profiler and ROCm Compute Profiler, providing insight into both system-level behavior and kernel-level performance for applications running on the ROCm stack. It is distributed separately as part of [ROCm Extras](https://rocm.docs.amd.com/en/latest/components/extras.html). * [ROCprof Compute Viewer](https://rocm.docs.amd.com/projects/rocprof-compute-viewer/en/latest/index.html) visualizes and analyzes GPU thread trace data collected using `rocprofv3`, helping developers understand low-level GPU execution behavior, identify performance bottlenecks, and optimize kernel efficiency. --- Source: https://rocm.docs.amd.com/en/latest/components/control-and-monitoring-tools.html # ROCm system control and monitoring tools ROCm control and monitoring tools provide interfaces for inspecting and managing AMD GPU hardware state in workstation and data center environments. * [AMD SMI 27.1.0](https://rocm.docs.amd.com/projects/amdsmi/en/docs-10.1.0/) – System management interface to control AMD GPU settings, monitor performance, and retrieve device and process information. * [ROCm Data Center Tool 1.3.1](https://rocm.docs.amd.com/projects/rdc/en/docs-10.1.0/) – Simplifies administration and addresses key infrastructure challenges in AMD GPUs in cluster and data-center environments. * [rocminfo 1.0.0](https://rocm.docs.amd.com/projects/rocminfo/en/docs-10.1.0/) – Reports system information. --- Source: https://rocm.docs.amd.com/en/latest/components/hpc-sdk/index.html # AMD ROCm HPC SDK The AMD ROCm™ open-source software stack is optimized to extract high-performance computing (HPC) workload performance from AMD Instinct™ GPUs while maintaining compatibility with industry software frameworks. ROCm enhances support and access for developers by providing streamlined and improved tools that significantly increase productivity. Being open-source, ROCm fosters innovation, differentiation, and collaboration within the developer community, making it a powerful and accessible solution for leveraging the full potential of AMD GPUs’ capabilities in diverse computational applications. Some of the most popular HPC frameworks are part of the ROCm HPC SDK, including those that help parallelize operations across multiple GPUs and servers, handle memory hierarchies, and solve linear systems. The HPC application catalog provides a vast set of platform-compatible HPC applications, including those for astrophysics, climate and weather, computational chemistry, computational fluid dynamics, earth science, genomics, geophysics, molecular dynamics, and physics computing. HPC SDK includes [hipTensor](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hiptensor) and [rocALUTION](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocalution) packaged as part of the installation. --- Source: https://rocm.docs.amd.com/en/latest/components/hpc-sdk/install.html # Install ROCm HPC SDK AMD ROCm HPC SDK provides high-performance computing libraries and tools for AMD Instinct GPUs. This guide walks you through installing the HPC SDK alongside ROCm installation on a supported Linux distribution. The ROCm for HPC applications and containers run on a standard ROCm installation. See the [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html#compat-matrix) for details on supported hardware and operating systems. The HPC application containers are published through [AMD InfinityHub-CI](https://github.com/amd/InfinityHub-CI). Each container provides parameters to specify source code branches and release versions of ROCm, OpenMPI, UCX, and Ubuntu. **fam=instinct fam=radeon fam=ryzen** **fam=instinct** **fam=radeon** **fam=ryzen** **fam=all** --- Before installing the HPC SDK, make sure your system meets the ROCm hardware, software, and driver requirements. For instructions, see [Install AMD ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-install-selector). Use the selector panel on that page to view instructions appropriate for your system environment. HPC SDK includes [hipTensor](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hiptensor) and [rocALUTION](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocalution) packaged as part of the installation. ## Install HPC SDK **rocm-ver=10.1.0** **i=tar** The standard ROCm tarball installation includes the HPC SDK. No additional steps are required. For details on ROCm tarball installation, refer to [Install AMD ROCm 10.1.0](https://rocm.docs.amd.com/en/docs-10.1.0/install/rocm.html) and select **Tarball** installation method from installation environment selector. **i=pkgman** 1. [Install ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html). Remember to complete the [ROCm installation prerequisites](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-prerequisites) to install dependencies and configure GPU access permissions. **fam=all** 1. Use the following command to install HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **gfx=gfx950** 1. Use the following command to install HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **gfx=gfx942** 1. Use the following command to install HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **gfx=gfx90a** 1. Use the following command to install HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **gfx=gfx908** 1. Use the following command to install HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **gfx=gfx1200** 1. Use the following command to install HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **gfx=gfx1201** 1. Use the following command to install HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **gfx=gfx1100** 1. Use the following command to install HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **gfx=gfx1101** 1. Use the following command to install HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **gfx=gfx1102** 1. Use the following command to install HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **gfx=gfx1103** 1. Use the following command to install HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **gfx=gfx1151** 1. Use the following command to install HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **gfx=gfx1150** 1. Use the following command to install HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **gfx=gfx1152** 1. Use the following command to install HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **gfx=gfx1153** 1. Use the following command to install HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **rocm-ver=10.0.0** **i=tar** The standard ROCm tarball installation includes the HPC SDK. No additional steps are required. For details on ROCm tarball installation, refer to [Install AMD ROCm 10.0.0](https://rocm.docs.amd.com/en/docs-10.0.0/install/rocm.html) and select **Tarball** installation method from installation environment selector. **i=pkgman** 1. [Install ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html). Remember to complete the [ROCm installation prerequisites](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-prerequisites) to install dependencies and configure GPU access permissions. **fam=all** 1. Use the following command to install HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **gfx=gfx950** 1. Use the following command to install HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **gfx=gfx942** 1. Use the following command to install HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **gfx=gfx90a** 1. Use the following command to install HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **gfx=gfx908** 1. Use the following command to install HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **gfx=gfx1200** 1. Use the following command to install HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **gfx=gfx1201** 1. Use the following command to install HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **gfx=gfx1100** 1. Use the following command to install HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **gfx=gfx1101** 1. Use the following command to install HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **gfx=gfx1102** 1. Use the following command to install HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **gfx=gfx1103** 1. Use the following command to install HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **gfx=gfx1151** 1. Use the following command to install HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **gfx=gfx1150** 1. Use the following command to install HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **gfx=gfx1152** 1. Use the following command to install HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **gfx=gfx1153** 1. Use the following command to install HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **rocm-ver=7.14.0** **i=tar** The standard ROCm tarball installation includes the HPC SDK. No additional steps are required. For details on ROCm tarball installation, refer to [Install AMD ROCm 7.14.0](https://rocm.docs.amd.com/en/docs-7.14.0/install/rocm.html) and select **Tarball** installation method from installation environment selector. **i=pkgman** 1. [Install ROCm](https://rocm.docs.amd.com/en/latest/install/rocm.html). Remember to complete the [ROCm installation prerequisites](https://rocm.docs.amd.com/en/latest/install/rocm.html#rocm-prerequisites) to install dependencies and configure GPU access permissions. **fam=all** 1. Use the following command to install HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **gfx=gfx950** 1. Use the following command to install HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **gfx=gfx942** 1. Use the following command to install HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **gfx=gfx90a** 1. Use the following command to install HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **gfx=gfx908** 1. Use the following command to install HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **gfx=gfx1200** 1. Use the following command to install HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **gfx=gfx1201** 1. Use the following command to install HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **gfx=gfx1100** 1. Use the following command to install HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **gfx=gfx1101** 1. Use the following command to install HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **gfx=gfx1102** 1. Use the following command to install HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **gfx=gfx1103** 1. Use the following command to install HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **gfx=gfx1151** 1. Use the following command to install HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **gfx=gfx1150** 1. Use the following command to install HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **gfx=gfx1152** 1. Use the following command to install HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **gfx=gfx1153** 1. Use the following command to install HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt install amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf install amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` **os=sles** ```bash sudo zypper install amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` ## Uninstall HPC SDK **rocm-ver=10.1.0** **i=tar** The standard ROCm uninstallation process can be followed to uninstall HPC SDK. No additional steps are required to remove the HPC SDK separately. Refer to [Uninstalling ROCm 10.1.0](https://rocm.docs.amd.com/en/docs-10.1.0/install/rocm.html#uninstalling) section and select **Tarball** from the installation environment selector. **i=pkgman** **fam=all** Use the following command to uninstall HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1 amdrocm-hpc-sdk10.1 ``` **gfx=gfx950** Use the following command to uninstall HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx950 amdrocm-hpc-sdk10.1-gfx950 ``` **gfx=gfx942** Use the following command to uninstall HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx942 amdrocm-hpc-sdk10.1-gfx942 ``` **gfx=gfx90a** Use the following command to uninstall HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx90a amdrocm-hpc-sdk10.1-gfx90a ``` **gfx=gfx908** Use the following command to uninstall HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx908 amdrocm-hpc-sdk10.1-gfx908 ``` **gfx=gfx1200** Use the following command to uninstall HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1200 amdrocm-hpc-sdk10.1-gfx1200 ``` **gfx=gfx1201** Use the following command to uninstall HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1201 amdrocm-hpc-sdk10.1-gfx1201 ``` **gfx=gfx1100** Use the following command to uninstall HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1100 amdrocm-hpc-sdk10.1-gfx1100 ``` **gfx=gfx1101** Use the following command to uninstall HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1101 amdrocm-hpc-sdk10.1-gfx1101 ``` **gfx=gfx1102** Use the following command to uninstall HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1102 amdrocm-hpc-sdk10.1-gfx1102 ``` **gfx=gfx1103** Use the following command to uninstall HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1103 amdrocm-hpc-sdk10.1-gfx1103 ``` **gfx=gfx1151** Use the following command to uninstall HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1151 amdrocm-hpc-sdk10.1-gfx1151 ``` **gfx=gfx1150** Use the following command to uninstall HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1150 amdrocm-hpc-sdk10.1-gfx1150 ``` **gfx=gfx1152** Use the following command to uninstall HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1152 amdrocm-hpc-sdk10.1-gfx1152 ``` **gfx=gfx1153** Use the following command to uninstall HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.1-gfx1153 amdrocm-hpc-sdk10.1-gfx1153 ``` **rocm-ver=10.0.0** **i=tar** The standard ROCm uninstallation process can be followed to uninstall HPC SDK. No additional steps are required to remove the HPC SDK separately. Refer to [Uninstalling ROCm 10.0.0](https://rocm.docs.amd.com/en/docs-10.0.0/install/rocm.html#uninstalling) section and select **Tarball** from the installation environment selector. **i=pkgman** **fam=all** Use the following command to uninstall HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0 amdrocm-hpc-sdk10.0 ``` **gfx=gfx950** Use the following command to uninstall HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx950 amdrocm-hpc-sdk10.0-gfx950 ``` **gfx=gfx942** Use the following command to uninstall HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx942 amdrocm-hpc-sdk10.0-gfx942 ``` **gfx=gfx90a** Use the following command to uninstall HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx90a amdrocm-hpc-sdk10.0-gfx90a ``` **gfx=gfx908** Use the following command to uninstall HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx908 amdrocm-hpc-sdk10.0-gfx908 ``` **gfx=gfx1200** Use the following command to uninstall HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1200 amdrocm-hpc-sdk10.0-gfx1200 ``` **gfx=gfx1201** Use the following command to uninstall HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1201 amdrocm-hpc-sdk10.0-gfx1201 ``` **gfx=gfx1100** Use the following command to uninstall HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1100 amdrocm-hpc-sdk10.0-gfx1100 ``` **gfx=gfx1101** Use the following command to uninstall HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1101 amdrocm-hpc-sdk10.0-gfx1101 ``` **gfx=gfx1102** Use the following command to uninstall HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1102 amdrocm-hpc-sdk10.0-gfx1102 ``` **gfx=gfx1103** Use the following command to uninstall HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1103 amdrocm-hpc-sdk10.0-gfx1103 ``` **gfx=gfx1151** Use the following command to uninstall HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1151 amdrocm-hpc-sdk10.0-gfx1151 ``` **gfx=gfx1150** Use the following command to uninstall HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1150 amdrocm-hpc-sdk10.0-gfx1150 ``` **gfx=gfx1152** Use the following command to uninstall HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1152 amdrocm-hpc-sdk10.0-gfx1152 ``` **gfx=gfx1153** Use the following command to uninstall HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc10.0-gfx1153 amdrocm-hpc-sdk10.0-gfx1153 ``` **rocm-ver=7.14.0** **i=tar** The standard ROCm uninstallation process can be followed to uninstall HPC SDK. No additional steps are required to remove the HPC SDK separately. Refer to [Uninstalling ROCm 7.14.0](https://rocm.docs.amd.com/en/docs-7.14.0/install/rocm.html#uninstalling) section and select **Tarball** from the installation environment selector. **i=pkgman** **fam=all** Use the following command to uninstall HPC SDK for all GPU architectures: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14 amdrocm-hpc-sdk7.14 ``` **gfx=gfx950** Use the following command to uninstall HPC SDK for your `gfx950` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx950 amdrocm-hpc-sdk7.14-gfx950 ``` **gfx=gfx942** Use the following command to uninstall HPC SDK for your `gfx942` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx942 amdrocm-hpc-sdk7.14-gfx942 ``` **gfx=gfx90a** Use the following command to uninstall HPC SDK for your `gfx90a` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx90a amdrocm-hpc-sdk7.14-gfx90a ``` **gfx=gfx908** Use the following command to uninstall HPC SDK for your `gfx908` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx908 amdrocm-hpc-sdk7.14-gfx908 ``` **gfx=gfx1200** Use the following command to uninstall HPC SDK for your `gfx1200` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1200 amdrocm-hpc-sdk7.14-gfx1200 ``` **gfx=gfx1201** Use the following command to uninstall HPC SDK for your `gfx1201` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1201 amdrocm-hpc-sdk7.14-gfx1201 ``` **gfx=gfx1100** Use the following command to uninstall HPC SDK for your `gfx1100` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1100 amdrocm-hpc-sdk7.14-gfx1100 ``` **gfx=gfx1101** Use the following command to uninstall HPC SDK for your `gfx1101` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1101 amdrocm-hpc-sdk7.14-gfx1101 ``` **gfx=gfx1102** Use the following command to uninstall HPC SDK for your `gfx1102` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1102 amdrocm-hpc-sdk7.14-gfx1102 ``` **gfx=gfx1103** Use the following command to uninstall HPC SDK for your `gfx1103` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1103 amdrocm-hpc-sdk7.14-gfx1103 ``` **gfx=gfx1151** Use the following command to uninstall HPC SDK for your `gfx1151` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1151 amdrocm-hpc-sdk7.14-gfx1151 ``` **gfx=gfx1150** Use the following command to uninstall HPC SDK for your `gfx1150` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1150 amdrocm-hpc-sdk7.14-gfx1150 ``` **gfx=gfx1152** Use the following command to uninstall HPC SDK for your `gfx1152` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1152 amdrocm-hpc-sdk7.14-gfx1152 ``` **gfx=gfx1153** Use the following command to uninstall HPC SDK for your `gfx1153` GPU: **os=ubuntu os=debian** ```bash sudo apt autoremove amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` **os=rhel os=rocky-linux os=oracle-linux** ```bash sudo dnf remove amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` **os=sles** ```bash sudo zypper remove amdrocm-hpc7.14-gfx1153 amdrocm-hpc-sdk7.14-gfx1153 ``` --- Source: https://rocm.docs.amd.com/en/latest/components/extras.html # ROCm Extra components ROCm Extra components are supplementary tools for benchmarking, validating, and managing ROCm deployments. These tools are not required for GPU application development but are useful for verifying hardware health, measuring system performance, and managing GPU fleets. * [ROCm Validation Suite](https://rocm.docs.amd.com/projects/ROCmValidationSuite/en/latest/index.html) (RVS) – A suite of tests for validating ROCm installations and AMD GPU hardware. Includes tests for GPU functionality, memory, power behavior, and peer-to-peer communication, helping diagnose installation issues and hardware faults. * [TransferBench](https://rocm.docs.amd.com/projects/TransferBench/en/latest/index.html) – A utility for benchmarking simultaneous memory transfers between user-specified devices (CPUs, GPUs, and NICs). This component is part of the ROCmValidationSuite (RVS) and is installed with it. * [ROCm Optiq](https://rocm.docs.amd.com/projects/roc-optiq/en/latest/index.html) – A unified visualization and analysis tool for performance data collected by ROCm profiling tools, specifically [ROCm Systems Profiler](https://rocm.docs.amd.com/projects/rocprofiler-systems/en/latest/index.html) and [ROCm Compute Profiler](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/index.html). It provides deep insights into both system-level behavior and kernel-level performance for applications running on the ROCm stack. * More coming soon. --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-specs.html # AMD GPU specifications The following tables provide an overview of the hardware specifications for AMD Instinct™ GPUs, AMD Radeon™ PRO and Radeon GPUs, and AMD Ryzen™ APUs. For more information about ROCm hardware compatibility, see the ROCm [Compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html). #### NOTE * [AMD GPU architectures](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/index.html) – microarchitecture details, ISA references, and white papers for each GPU generation. * [AMD GPU system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/index.html) – system setup and tuning guides for AMD Instinct, Radeon, and Ryzen hardware. * [Data types and precision support](https://rocm.docs.amd.com/en/latest/reference/precision-support.html) – supported floating-point and integer data types across GPU architectures. * [AMD GPU atomics operation support](https://rocm.docs.amd.com/en/latest/reference/gpu-atomics-operation.html) – atomics operation support by GPU architecture and memory scope. **AMD Instinct GPUs** | Name | Architecture | LLVM target name | VRAM (GiB) | Compute Units | Wavefront Size | LDS (KiB) | L3 Cache (MiB) | L2 Cache (MiB) | L1 Vector Cache (KiB) | L1 Scalar Cache (KiB) | L1 Instruction Cache (KiB) | VGPR File (KiB) | SGPR File (KiB) | GFXIP Major version | GFXIP Minor version | |-------------|----------------|--------------------|--------------|-------------------|------------------|-------------|------------------|------------------|-------------------------|-------------------------|------------------------------|--------------------------|-------------------|-----------------------|-----------------------| | MI355X | CDNA4 | gfx950 | 288 | 256 (32 per XCD) | 64 | 160 | 256 | 32 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 5 | | MI350X | CDNA4 | gfx950 | 288 | 256 (32 per XCD) | 64 | 160 | 256 | 32 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 5 | | MI350P | CDNA4 | gfx950 | 144 | 128 (32 per XCD) | 64 | 160 | 128 | 16 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 5 | | MI325X | CDNA3 | gfx942 | 256 | 304 (38 per XCD) | 64 | 64 | 256 | 32 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 4 | | MI300X | CDNA3 | gfx942 | 192 | 304 (38 per XCD) | 64 | 64 | 256 | 32 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 4 | | MI300A | CDNA3 | gfx942 | 128 | 228 (38 per XCD) | 64 | 64 | 256 | 24 (4 per XCD) | 32 | 16 per 2 CUs | 64 per 2 CUs | 512 | 12.5 | 9 | 4 | | MI250X | CDNA2 | gfx90a | 128 | 220 (110 per GCD) | 64 | 64 | | 16 (8 per GCD) | 16 | 16 per 2 CUs | 32 per 2 CUs | 512 | 12.5 | 9 | 0 | | MI250 | CDNA2 | gfx90a | 128 | 208 (104 per GCD) | 64 | 64 | | 16 (8 per GCD) | 16 | 16 per 2 CUs | 32 per 2 CUs | 512 | 12.5 | 9 | 0 | | MI210 | CDNA2 | gfx90a | 64 | 104 | 64 | 64 | | 8 | 16 | 16 per 2 CUs | 32 per 2 CUs | 512 | 12.5 | 9 | 0 | | MI100 | CDNA | gfx908 | 32 | 120 | 64 | 64 | | 8 | 16 | 16 per 3 CUs | 32 per 3 CUs | 256 VGPR and 256 AccVGPR | 12.5 | 9 | 0 | | MI60 | GCN5.1 | gfx906 | 32 | 64 | 64 | 64 | | 4 | 16 | 16 per 3 CUs | 32 per 3 CUs | 256 | 12.5 | 9 | 0 | | MI50 (32GB) | GCN5.1 | gfx906 | 32 | 60 | 64 | 64 | | 4 | 16 | 16 per 3 CUs | 32 per 3 CUs | 256 | 12.5 | 9 | 0 | | MI50 (16GB) | GCN5.1 | gfx906 | 16 | 60 | 64 | 64 | | 4 | 16 | 16 per 3 CUs | 32 per 3 CUs | 256 | 12.5 | 9 | 0 | | MI25 | GCN5.0 | gfx900 | 16 | 64 | 64 | 64 | | 4 | 16 | 16 per 3 CUs | 32 per 3 CUs | 256 | 12.5 | 9 | 0 | | MI8 | GCN3.0 | gfx803 | 4 | 64 | 64 | 64 | | 2 | 16 | 16 per 4 CUs | 32 per 4 CUs | 256 | 12.5 | 8 | 0 | | MI6 | GCN4.0 | gfx803 | 16 | 36 | 64 | 64 | | 2 | 16 | 16 per 4 CUs | 32 per 4 CUs | 256 | 12.5 | 8 | 0 | **AMD Radeon PRO GPUs** | Name | Architecture | LLVM target name | VRAM (GiB) | Compute Units | Wavefront Size | LDS (KiB) | Infinity Cache (MiB) | L2 Cache (MiB) | Graphics L1 Cache (KiB) | L0 Vector Cache (KiB) | L0 Scalar Cache (KiB) | L0 Instruction Cache (KiB) | VGPR File (KiB) | SGPR File (KiB) | GFXIP Major version | GFXIP Minor version | |----------------------------|----------------|--------------------|--------------|-----------------|------------------|-------------|------------------------|------------------|---------------------------|-------------------------|-------------------------|------------------------------|-------------------|-------------------|-----------------------|-----------------------| | Radeon AI PRO R9700S | RDNA4 | gfx1201 | 32 | 64 | 32 or 64 | 128 | 64 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon AI PRO R9700 | RDNA4 | gfx1201 | 32 | 64 | 32 or 64 | 128 | 64 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon AI PRO R9600D | RDNA4 | gfx1201 | 32 | 48 | 32 or 64 | 128 | 48 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon AI PRO R9600 | RDNA4 | gfx1201 | 32 | 48 | 32 or 64 | 128 | 48 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon PRO V710 | RDNA3 | gfx1101 | 28 | 54 | 32 or 64 | 128 | 56 | 4 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon PRO W7900 Dual Slot | RDNA3 | gfx1100 | 48 | 96 | 32 or 64 | 128 | 96 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon PRO W7900 | RDNA3 | gfx1100 | 48 | 96 | 32 or 64 | 128 | 96 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon PRO W7800 48GB | RDNA3 | gfx1100 | 48 | 70 | 32 or 64 | 128 | 96 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon PRO W7800 | RDNA3 | gfx1100 | 32 | 70 | 32 or 64 | 128 | 64 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon PRO W7700 | RDNA3 | gfx1101 | 16 | 48 | 32 or 64 | 128 | 64 | 4 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | **AMD Radeon GPUs** | Name | Architecture | LLVM target name | VRAM (GiB) | Compute Units | Wavefront Size | LDS (KiB) | Infinity Cache (MiB) | L2 Cache (MiB) | Graphics L1 Cache (KiB) | L0 Vector Cache (KiB) | L0 Scalar Cache (KiB) | L0 Instruction Cache (KiB) | VGPR File (KiB) | SGPR File (KiB) | GFXIP Major version | GFXIP Minor version | |----------------------|----------------|--------------------|--------------|-----------------|------------------|-------------|------------------------|------------------|---------------------------|-------------------------|-------------------------|------------------------------|-------------------|-------------------|-----------------------|-----------------------| | Radeon RX 9070 XT | RDNA4 | gfx1201 | 16 | 64 | 32 or 64 | 128 | 64 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9070 GRE | RDNA4 | gfx1201 | 16 | 48 | 32 or 64 | 128 | 48 | 6 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9070 | RDNA4 | gfx1201 | 16 | 56 | 32 or 64 | 128 | 64 | 8 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9060 XT LP | RDNA4 | gfx1200 | 16 | 32 | 32 or 64 | 128 | 32 | 4 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9060 XT | RDNA4 | gfx1200 | 16 | 32 | 32 or 64 | 128 | 32 | 4 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9060 | RDNA4 | gfx1200 | 8 | 28 | 32 or 64 | 128 | 32 | 4 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9050 | RDNA4 | gfx1200 | 8 | 16 | 32 or 64 | 128 | 32 | 2 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 9050 (4GB) | RDNA4 | gfx1200 | 4 | 16 | 32 or 64 | 128 | 16 | 2 | N/A | 32 | 16 | 32 | 768 | 32 | 12 | 0 | | Radeon RX 7900 XTX | RDNA3 | gfx1100 | 24 | 96 | 32 or 64 | 128 | 96 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7900 XT | RDNA3 | gfx1100 | 20 | 84 | 32 or 64 | 128 | 80 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7900 GRE | RDNA3 | gfx1100 | 16 | 80 | 32 or 64 | 128 | 64 | 6 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7800 XT | RDNA3 | gfx1101 | 16 | 60 | 32 or 64 | 128 | 64 | 4 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7700 | RDNA3 | gfx1101 | 16 | 40 | 32 or 64 | 128 | 64 | 4 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7700 XT | RDNA3 | gfx1101 | 12 | 54 | 32 or 64 | 128 | 48 | 4 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 0 | | Radeon RX 7600 | RDNA3 | gfx1102 | 8 | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | **AMD Ryzen APUs** | Name | Graphics model | Architecture | LLVM target name | VRAM (GiB) | Compute Units | Wavefront Size | LDS (KiB) | Infinity Cache (MiB) | L2 Cache (MiB) | Graphics L1 Cache (KiB) | L0 Vector Cache (KiB) | L0 Scalar Cache (KiB) | L0 Instruction Cache (KiB) | VGPR File (KiB) | SGPR File (KiB) | GFXIP Major version | GFXIP Minor version | |-----------------------|------------------|----------------|--------------------|--------------------|-----------------|------------------|-------------|------------------------|------------------|---------------------------|-------------------------|-------------------------|------------------------------|-------------------|-------------------|-----------------------|-----------------------| | Ryzen AI Max+ PRO 495 | Radeon 8065S | RDNA3.5 | gfx1151 | Dynamic + carveout | 40 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max PRO 490 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max PRO 485 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max PRO 390 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max PRO 385 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max PRO 380 | Radeon 8040S | RDNA3.5 | gfx1151 | Dynamic + carveout | 16 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max+ PRO 395 | Radeon 8060S | RDNA3.5 | gfx1151 | Dynamic + carveout | 40 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max+ 395 | Radeon 8060S | RDNA3.5 | gfx1151 | Dynamic + carveout | 40 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max+ 392 | Radeon 8060S | RDNA3.5 | gfx1151 | Dynamic + carveout | 40 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max+ 388 | Radeon 8060S | RDNA3.5 | gfx1151 | Dynamic + carveout | 40 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max 390 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI Max 385 | Radeon 8050S | RDNA3.5 | gfx1151 | Dynamic + carveout | 32 | 32 or 64 | 128 | 32 | 2 | 256 | 32 | 16 | 32 | 768 | 32 | 11 | 5 | | Ryzen AI 9 HX PRO 475 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX PRO 470 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 PRO 465 | Radeon 880M | RDNA3.5 | gfx1150 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 PRO 450 | Radeon 860M | RDNA3.5 | gfx1152 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 PRO 440 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 PRO 435 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | 0 | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 435 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | 0 | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 430 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | 0 | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX 475 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX 470 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 465 | Radeon 880M | RDNA3.5 | gfx1150 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 445 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | 0 | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 450 | Radeon 860M | RDNA3.5 | gfx1152 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX PRO 375 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX PRO 370 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX 375 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 HX 370 | Radeon 890M | RDNA3.5 | gfx1150 | Dynamic + carveout | 16 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 9 365 | Radeon 880M | RDNA3.5 | gfx1150 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 PRO 350 | Radeon 860M | RDNA3.5 | gfx1152 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 350 | Radeon 860M | RDNA3.5 | gfx1152 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 7 345 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 PRO 340 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 340 | Radeon 840M | RDNA3.5 | gfx1152 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen AI 5 330 | Radeon 820M | RDNA3.5 | gfx1152 | Dynamic + carveout | 2 | 32 or 64 | 128 | N/A | 1 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 5 | | Ryzen 7 7840U | Radeon 780M | RDNA3 | gfx1103 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 9 270 | Radeon 780M | RDNA3 | gfx1103 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 7 PRO 250 | Radeon 780M | RDNA3 | gfx1103 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 7 260 | Radeon 780M | RDNA3 | gfx1103 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 7 250 | Radeon 780M | RDNA3 | gfx1103 | Dynamic + carveout | 12 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 PRO 230 | Radeon 760M | RDNA3 | gfx1103 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 PRO 220 | Radeon 740M | RDNA3 | gfx1103 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 PRO 215 | Radeon 740M | RDNA3 | gfx1103 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 240 | Radeon 760M | RDNA3 | gfx1103 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 230 | Radeon 760M | RDNA3 | gfx1103 | Dynamic + carveout | 8 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 5 220 | Radeon 740M | RDNA3 | gfx1103 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 3 PRO 210 | Radeon 740M | RDNA3 | gfx1103 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | | Ryzen 3 210 | Radeon 740M | RDNA3 | gfx1103 | Dynamic + carveout | 4 | 32 or 64 | 128 | N/A | 2 | 256 | 32 | 16 | 32 | 512 | 32 | 11 | 0 | --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/index.html # AMD GPU architecture documentation This page collects AMD GPU architecture documentation in one place, including instruction set architecture (ISA) references, white papers, microarchitecture overviews, and performance counter documentation for AMD Instinct™ and Radeon™ GPU families. These documents can be useful when studying hardware capabilities, tuning kernel performance, interpreting profiling data, or understanding low-level architectural behavior. **CDNA™ 4** (AMD Instinct MI350 Series) * [AMD CDNA 4 (Instinct MI350 Series) ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/amd-instinct-cdna4-instruction-set-architecture.pdf) * [White paper](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/white-papers/amd-cdna-4-architecture-whitepaper.pdf) * [AMD Instinct MI350 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350.html) * [Performance counters](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350-performance-counters.html) **CDNA 3** (AMD Instinct MI300 Series) * [AMD CDNA 3 (Instinct MI300 Series) ISA reference](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/instruction-set-architectures/amd-instinct-mi300-cdna3-instruction-set-architecture.pdf) * [White paper](https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/white-papers/amd-cdna-3-white-paper.pdf) * [AMD Instinct MI300 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300.html) * [Performance counters](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300-mi200-performance-counters.html) **CDNA 2** (AMD Instinct MI200 Series) * [AMD CDNA 2 (Instinct MI200 Series) ISA reference](https://www.amd.com/system/files/TechDocs/instinct-mi200-cdna2-instruction-set-architecture.pdf) * [White paper](https://www.amd.com/content/dam/amd/en/documents/instinct-business-docs/white-papers/amd-cdna2-white-paper.pdf) * [AMD Instinct MI250 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi250.html) * [Performance counters](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300-mi200-performance-counters.html) **CDNA** (Instinct MI100) * [AMD CDNA (AMD Instinct MI100) ISA reference](https://www.amd.com/system/files/TechDocs/instinct-mi100-cdna1-shader-instruction-set-architecture%C2%A0.pdf) * [AMD Instinct MI100 microarchitecture](https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi100.html) * [White paper](https://www.amd.com/content/dam/amd/en/documents/instinct-business-docs/white-papers/amd-cdna-white-paper.pdf) **RDNA™** (Radeon and Ryzen) * [AMD RDNA 4 ISA reference](https://gpuopen.com/download/rdna4-instruction-set-architecture.pdf) * [AMD RDNA 3.5 ISA reference](https://gpuopen.com/download/rdna35_instruction_set_architecture.pdf) * [AMD RDNA 3 ISA reference](https://gpuopen.com/download/rdna3-shader-instruction-set-architecture-feb-2023.pdf) * [AMD RDNA 2 ISA reference](https://gpuopen.com/download/rdna2-shader-instruction-set-architecture.pdf) * [AMD RDNA ISA reference](https://gpuopen.com/download/RDNA_Shader_ISA_25September2020.pdf) **GCN™ and Vega** * [AMD Vega 7nm (Instinct MI50) ISA reference](https://www.amd.com/system/files/TechDocs/vega-7nm-shader-instruction-set-architecture.pdf) * [AMD Vega (Instinct MI25) ISA reference](https://www.amd.com/system/files/TechDocs/vega-shader-instruction-set-architecture.pdf) * [AMD GCN 3 ISA reference](https://www.amd.com/system/files/TechDocs/gcn3-instruction-set-architecture.pdf) --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350.html # AMD Instinct MI350 Series microarchitecture The AMD Instinct™ MI350 Series GPUs are based on the AMD CDNA4 architecture, and are designed for AI, HPC, and machine learning workloads. The series includes the MI350X (1000W, air-cooled) and the MI355X (1400W, direct liquid-cooled), both in the OAM form factor, and the MI350P, a PCIe card (600W, configurable to 450W) for deployment in mainstream servers. Each MI350X and MI355X GPU integrates eight vertically stacked accelerator complex dies (XCDs) and two I/O dies (IODs) tied together with AMD Infinity Fabric™ technology on-package, connecting to eight stacks of 12-Hi HBM3E memory. The MI350P is a smaller configuration, integrating four XCDs and a single IOD connected to four HBM3E stacks. ## Chiplet architecture The CDNA4 architecture uses a chiplet-based, heterogeneous design in which each chiplet uses a manufacturing process suited to its function. The accelerator complex dies (XCDs) house the computational portion of the processor and the lowest levels of the cache hierarchy. They are built on TSMC’s N3P process to take advantage of improved logic density and performance. The I/O dies (IODs) contain the AMD Infinity Cache™, memory controllers, and interconnects. These functions do not benefit from the latest process technology and are implemented on TSMC’s N6 process. The CDNA4 architecture consolidates the IOD functions into two larger dies rather than the four smaller IODs of the prior generation. The direct connection between the two IODs reduces latency and power consumption compared to the previous generation. ## Compute units Each XCD comprises 36 AMD CDNA4 compute units (CUs) organized as four arrays of nine CUs, of which 32 are active. On the MI350X and MI355X, the processor spans eight XCDs for up to 256 CUs total. The MI350P spans four XCDs for up to 128 CUs total. ![image](reference/gpu-arch/images/cdna4_die_diagram.png) Each CU instantiates a full processor pipeline with highly threaded and parallel execution of scalar, vector, and matrix instructions, along with a memory pipeline with an L1 data cache and a Local Data Share (LDS). The 64 KB, 8-way set-associative instruction cache is shared between two adjacent CUs. The LDS in each CDNA4 CU is 160 KB with doubled read bandwidth compared to the prior generation, which improves the utilization of the vector and matrix execution resources for matrix multiply routines. ### Matrix cores and precision support The CDNA4 Matrix Cores add hardware support for industry-standard micro-scaling (OCP MX) formats including MXFP8, MXFP6, and MXFP4, alongside existing formats such as FP16, BF16, FP8, and INT8. Execution resources for 16-bit and smaller data types are twice as many as in the prior generation. ## Memory hierarchy The L1 vector data cache in each CU is 32KB with 128B cache lines and 64-way associativity. Each XCD shares a 4MB, 16-way set-associative L2 cache with 16 parallel channels. On the MI350X and MI355X, the AMD Infinity Cache™ is a shared 256MB memory-side cache in the IODs. The HBM3E memory interfaces operate at 8 Gbps, providing up to 8 TB/s of peak theoretical memory bandwidth and 288GB of total capacity (36GB per stack). The MI350P provides a 128MB Infinity Cache in its single IOD, up to 4 TB/s of peak theoretical memory bandwidth, and 144GB of total capacity across four HBM3E stacks. ![image](reference/gpu-arch/images/mi350_conceptual_diagram.png) ## Performance The following table lists the peak theoretical performance of the MI350 Series GPUs for different data types. The MI350P figures reflect its four-XCD configuration. #### Peak theoretical performance of the AMD Instinct MI350 Series GPUs. | Computation and data type | MI350X peak theoretical | MI355X peak theoretical | MI350P peak theoretical | |-----------------------------------|---------------------------|---------------------------|---------------------------| | Matrix FP64 | 72.1 TF | 78.6 TF | 36 TF | | Vector FP64 | 72.1 TF | 78.6 TF | 36 TF | | Matrix FP32 | 144.2 TF | 157.3 TF | 72 TF | | Vector FP32 | 144.2 TF | 157.3 TF | 72 TF | | Matrix FP16 | FP16 Sparsity | 2.3 PF | 4.6 PF | 2.5 PF | 5.0 PF | 1.15 PF | 2.3 PF | | Vector FP16 | 144.2 TF | 157.3 TF | 72 TF | | Matrix BF16 | BF16 Sparsity | 2.3 PF | 4.6 PF | 2.5 PF | 5.0 PF | 1.15 PF | 2.3 PF | | Matrix OCP-FP8 | OCP-FP8 Sparsity | 4.6 PF | 9.2 PF | 5.0 PF | 10 PF | 2.3 PF | 4.6 PF | | Matrix MXFP8 | 4.6 PF | 5.0 PF | 2.3 PF | | Matrix MXFP6 / MXFP4 | 9.2 PF | 10 PF | 4.6 PF | | Matrix INT8 | INT8 Sparsity | 4.6 POPs | 9.2 POPs | 5.0 POPs | 10 POPs | 2.3 POPs | 4.6 POPs | ## Node-level architecture The MI350X and MI355X use a fully connected 8-GPU node topology, identical to the prior generation. Each GPU connects to the host via one PCIe Gen 5 x16 link and communicates with other GPUs through 7 AMD Infinity Fabric links operating at 38.4 Gbps, providing over 1 TB/s of aggregate communication bandwidth per GPU. The MI350X uses the OAM form factor on a UBB8 baseboard compatible with prior generation AMD Instinct MI325X platform designs. The MI355X uses the same form factor but targets direct liquid-cooled infrastructure. The MI350P is a full-height, full-length, dual-slot PCIe card that connects to the host via one PCIe Gen 5 x16 link. It is designed for air-cooled servers, with up to eight cards per server. ![image](reference/gpu-arch/images/mi350_platform.png) ## Compute and memory partitioning The MI350 Series supports spatial partitioning along XCD boundaries. On the MI350X and MI355X, the GPU can be divided into 1, 2, 4, or 8 compute partitions with full isolation between partitions. Memory can be configured in NPS1 mode, interleaving across all 8 HBM stacks, or NPS2 mode, which partitions the 288GB into two 144GB pools, one per IOD, to reduce cross-IOD Infinity Fabric traffic and improve latency and efficiency. Because the MI350P has a single IOD, it supports up to four compute partitions and a single (NPS1) memory partition across its 144GB. ![image](reference/gpu-arch/images/mi350_partition.png) --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi350-performance-counters.html # MI350 Series performance counters This topic lists and describes the hardware performance counters and derived metrics available on the AMD Instinct MI350 and MI355 GPUs. These counters are available for profiling using [ROCprofiler-SDK](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/latest/index.html) and [ROCm Compute Profiler](https://rocm.docs.amd.com/projects/rocprofiler-compute/en/latest/). The following sections list the performance counters based on the IP blocks. ## Command processor packet processor counters (CPC) | Hardware counter | Definition | |-------------------------------|----------------------------------------------------------------------------------------------| | CPC_ALWAYS_COUNT | Always count. | | CPC_ADC_VALID_CHUNK_NOT_AVAIL | ADC valid chunk is not available when dispatch walking is in progress in the multi-xcc mode. | | CPC_ADC_DISPATCH_ALLOC_DONE | ADC dispatch allocation is done. | | CPC_ADC_VALID_CHUNK_END | ADC crawler’s valid chunk end in the multi-xcc mode. | | CPC_SYNC_FIFO_FULL_LEVEL | SYNC FIFO full last cycles. | | CPC_SYNC_FIFO_FULL | SYNC FIFO full times. | | CPC_GD_BUSY | ADC busy. | | CPC_TG_SEND | ADC thread group send. | | CPC_WALK_NEXT_CHUNK | ADC walking next valid chunk in the multi-xcc mode. | | CPC_STALLED_BY_SE0_SPI | ADC CSDATA stalled by SE0SPI. | | CPC_STALLED_BY_SE1_SPI | ADC CSDATA stalled by SE1SPI. | | CPC_STALLED_BY_SE2_SPI | ADC CSDATA stalled by SE2SPI. | | CPC_STALLED_BY_SE3_SPI | ADC CSDATA stalled by SE3SPI. | | CPC_LTE_ALL | CPC sync counter LteAll. Only Master XCD manages LteAll. | | CPC_SYNC_WRREQ_FIFO_BUSY | CPC sync counter request FIFO is not empty. | | CPC_CANE_BUSY | CPC CANE bus is busy, which indicates the presence of inflight sync counter requests. | | CPC_CANE_STALL | CPC sync counter sending is stalled by CANE. | ## Shader pipe interpolators (SPI) counters | Hardware counter | Definition | |--------------------------|----------------------------------------------------------------| | SPI_CS0_WINDOW_VALID | Clock count enabled by PIPE0 perfcounter_start event. | | SPI_CS0_BUSY | Number of clocks with outstanding waves for PIPE0 (SPI or SH). | | SPI_CS0_NUM_THREADGROUPS | Number of thread groups launched for PIPE0. | | SPI_CS0_CRAWLER_STALL | Number of clocks when PIPE0 event or wave order FIFO is full. | | SPI_CS0_EVENT_WAVE | Number of PIPE0 events and waves. | | SPI_CS0_WAVE | Number of PIPE0 waves. | | SPI_CS1_WINDOW_VALID | Clock count enabled by PIPE1 perfcounter_start event. | | SPI_CS1_BUSY | Number of clocks with outstanding waves for PIPE1 (SPI or SH). | | SPI_CS1_NUM_THREADGROUPS | Number of thread groups launched for PIPE1. | | SPI_CS1_CRAWLER_STALL | Number of clocks when PIPE1 event or wave order FIFO is full. | | SPI_CS1_EVENT_WAVE | Number of PIPE1 events and waves. | | SPI_CS1_WAVE | Number of PIPE1 waves. | | SPI_CS2_WINDOW_VALID | Clock count enabled by PIPE2 perfcounter_start event. | | SPI_CS2_BUSY | Number of clocks with outstanding waves for PIPE2 (SPI or SH). | | SPI_CS2_NUM_THREADGROUPS | Number of thread groups launched for PIPE2. | | SPI_CS2_CRAWLER_STALL | Number of clocks when PIPE2 event or wave order FIFO is full. | | SPI_CS2_EVENT_WAVE | Number of PIPE2 events and waves. | | SPI_CS2_WAVE | Number of PIPE2 waves. | | SPI_CS3_WINDOW_VALID | Clock count enabled by PIPE3 perfcounter_start event. | | SPI_CS3_BUSY | Number of clocks with outstanding waves for PIPE3 (SPI or SH). | | SPI_CS3_NUM_THREADGROUPS | Number of thread groups launched for PIPE3. | | SPI_CS3_CRAWLER_STALL | Number of clocks when PIPE3 event or wave order FIFO is full. | | SPI_CS3_EVENT_WAVE | Number of PIPE3 events and waves. | | SPI_CS3_WAVE | Number of PIPE3 waves. | | SPI_CSQ_P0_Q0_OCCUPANCY | Sum of occupancy info for PIPE0 Queue0. | | SPI_CSQ_P0_Q1_OCCUPANCY | Sum of occupancy info for PIPE0 Queue1. | | SPI_CSQ_P0_Q2_OCCUPANCY | Sum of occupancy info for PIPE0 Queue2. | | SPI_CSQ_P0_Q3_OCCUPANCY | Sum of occupancy info for PIPE0 Queue3. | | SPI_CSQ_P0_Q4_OCCUPANCY | Sum of occupancy info for PIPE0 Queue4. | | SPI_CSQ_P0_Q5_OCCUPANCY | Sum of occupancy info for PIPE0 Queue5. | | SPI_CSQ_P0_Q6_OCCUPANCY | Sum of occupancy info for PIPE0 Queue6. | | SPI_CSQ_P0_Q7_OCCUPANCY | Sum of occupancy info for PIPE0 Queue7. | | SPI_CSQ_P1_Q0_OCCUPANCY | Sum of occupancy info for PIPE1 Queue0. | | SPI_CSQ_P1_Q1_OCCUPANCY | Sum of occupancy info for PIPE1 Queue1. | | SPI_CSQ_P1_Q2_OCCUPANCY | Sum of occupancy info for PIPE1 Queue2. | | SPI_CSQ_P1_Q3_OCCUPANCY | Sum of occupancy info for PIPE1 Queue3. | | SPI_CSQ_P1_Q4_OCCUPANCY | Sum of occupancy info for PIPE1 Queue4. | | SPI_CSQ_P1_Q5_OCCUPANCY | Sum of occupancy info for PIPE1 Queue5. | | SPI_CSQ_P1_Q6_OCCUPANCY | Sum of occupancy info for PIPE1 Queue6. | | SPI_CSQ_P1_Q7_OCCUPANCY | Sum of occupancy info for PIPE1 Queue7. | | SPI_CSQ_P2_Q0_OCCUPANCY | Sum of occupancy info for PIPE2 Queue0. | | SPI_CSQ_P2_Q1_OCCUPANCY | Sum of occupancy info for PIPE2 Queue1. | | SPI_CSQ_P2_Q2_OCCUPANCY | Sum of occupancy info for PIPE2 Queue2. | | SPI_CSQ_P2_Q3_OCCUPANCY | Sum of occupancy info for PIPE2 Queue3. | | SPI_CSQ_P2_Q4_OCCUPANCY | Sum of occupancy info for PIPE2 Queue4. | | SPI_CSQ_P2_Q5_OCCUPANCY | Sum of occupancy info for PIPE2 Queue5. | | SPI_CSQ_P2_Q6_OCCUPANCY | Sum of occupancy info for PIPE2 Queue6. | | SPI_CSQ_P2_Q7_OCCUPANCY | Sum of occupancy info for PIPE2 Queue7. | | SPI_CSQ_P3_Q0_OCCUPANCY | Sum of occupancy info for PIPE3 Queue0. | | SPI_CSQ_P3_Q1_OCCUPANCY | Sum of occupancy info for PIPE3 Queue1. | | SPI_CSQ_P3_Q2_OCCUPANCY | Sum of occupancy info for PIPE3 Queue2. | | SPI_CSQ_P3_Q3_OCCUPANCY | Sum of occupancy info for PIPE3 Queue3. | | SPI_CSQ_P3_Q4_OCCUPANCY | Sum of occupancy info for PIPE3 Queue4. | | SPI_CSQ_P3_Q5_OCCUPANCY | Sum of occupancy info for PIPE3 Queue5. | | SPI_CSQ_P3_Q6_OCCUPANCY | Sum of occupancy info for PIPE3 Queue6. | | SPI_CSQ_P3_Q7_OCCUPANCY | Sum of occupancy info for PIPE3 Queue7. | | SPI_CSQ_P0_OCCUPANCY | Sum of occupancy info for all PIPE0 queues. | | SPI_CSQ_P1_OCCUPANCY | Sum of occupancy info for all PIPE1 queues. | | SPI_CSQ_P2_OCCUPANCY | Sum of occupancy info for all PIPE2 queues. | | SPI_CSQ_P3_OCCUPANCY | Sum of occupancy info for all PIPE3 queues. | | SPI_VWC0_VDATA_VALID_WR | Number of clocks VGPR bus_0 writes VGPRs. | | SPI_VWC1_VDATA_VALID_WR | Number of clocks VGPR bus_1 writes VGPRs. | | SPI_CSC_WAVE_CNT_BUSY | Number of cycles when there is any wave in the pipe. | ## Compute unit (SQ) counters | Hardware counter | Definition | |--------------------------------|----------------------------------------------------------------------------------------------------------------------------------------| | SQ_INSTS_VALU_MFMA_F6F4 | Number of VALU V_MFMA_\*_F6F4 instructions. | | SQ_INSTS_VALU_MFMA_MOPS_F6F4 | Number of VALU matrix with the performed math operations (add or mul) divided by 512, assuming a full EXEC mask of F6 or F4 data type. | | SQ_ACTIVE_INST_VALU2 | Number of quad-cycles when two VALU instructions are issued (per-simd, nondeterministic). | | SQ_INSTS_LDS_LOAD | Number of LDS load instructions issued (per-simd, emulated). | | SQ_INSTS_LDS_STORE | Number of LDS store instructions issued (per-simd, emulated). | | SQ_INSTS_LDS_ATOMIC | Number of LDS atomic instructions issued (per-simd, emulated). | | SQ_INSTS_LDS_LOAD_BANDWIDTH | Total number of 64-bytes loaded (instrSize \* CountOnes(EXEC))/64 (per-simd, emulated). | | SQ_INSTS_LDS_STORE_BANDWIDTH | Total number of 64-bytes written (instrSize \* CountOnes(EXEC))/64 (per-simd, emulated). | | SQ_INSTS_LDS_ATOMIC_BANDWIDTH | Total number of 64-bytes atomic (instrSize \* CountOnes(EXEC))/64 (per-simd, emulated). | | SQ_INSTS_VALU_FLOPS_FP16 | Counts FLOPS per instruction on float 16 excluding MFMA/SMFMA. | | SQ_INSTS_VALU_FLOPS_FP32 | Counts FLOPS per instruction on float 32 excluding MFMA/SMFMA. | | SQ_INSTS_VALU_FLOPS_FP64 | Counts FLOPS per instruction on float 64 excluding MFMA/SMFMA. | | SQ_INSTS_VALU_FLOPS_FP16_TRANS | Counts FLOPS per instruction on float 16 trans excluding MFMA/SMFMA. | | SQ_INSTS_VALU_FLOPS_FP32_TRANS | Counts FLOPS per instruction on float 32 trans excluding MFMA/SMFMA. | | SQ_INSTS_VALU_FLOPS_FP64_TRANS | Counts FLOPS per instruction on float 64 trans excluding MFMA/SMFMA. | | SQ_INSTS_VALU_IOPS | Counts OPS per instruction on integer or unsigned or bit data (per-simd, emulated). | | SQ_LDS_DATA_FIFO_FULL | Number of cycles LDS data FIFO is full (nondeterministic, unwindowed). | | SQ_LDS_CMD_FIFO_FULL | Number of cycles LDS command FIFO is full (nondeterministic, unwindowed). | | SQ_VMEM_TA_ADDR_FIFO_FULL | Number of cycles texture requests are stalled due to full address FIFO in TA (nondeterministic, unwindowed). | | SQ_VMEM_TA_CMD_FIFO_FULL | Number of cycles texture requests are stalled due to full cmd FIFO in TA (nondeterministic, unwindowed). | | SQ_VMEM_WR_TA_DATA_FIFO_FULL | Number of cycles texture writes are stalled due to full data FIFO in TA (nondeterministic, unwindowed). | | SQC_ICACHE_MISSES_DUPLICATE | Number of duplicate misses (access to a non-resident, miss pending CL) (per-SQ, per-Bank, nondeterministic). | | SQC_DCACHE_MISSES_DUPLICATE | Number of duplicate misses (access to a non-resident, miss pending CL) (per-SQ, per-Bank, nondeterministic). | ## Texture addressing (TA) unit counters | Hardware counter | Definition | |-------------------------------|----------------------------------------------------------------------| | TA_BUFFER_READ_LDS_WAVEFRONTS | Number of buffer read wavefronts for LDS return processed by the TA. | | TA_FLAT_READ_LDS_WAVEFRONTS | Number of flat opcode reads for LDS return processed by the TA. | ## Texture data (TD) unit counters | Hardware counter | Definition | |-------------------------|------------------------------------------------------------| | TD_WRITE_ACKT_WAVEFRONT | Number of write acknowledgments, sent to SQ and not to SP. | | TD_TD_SP_TRAFFIC | Number of times this TD sends data to the SP. | ## Texture cache per pipe (TCP) counters | Hardware counter | Definition | |------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | TCP_TCP_TA_ADDR_STALL_CYCLES | TCP stalls TA addr interface. | | TCP_TCP_TA_DATA_STALL_CYCLES | TCP stalls TA data interface. Now windowed. | | TCP_LFIFO_STALL_CYCLES | Memory latency FIFOs full stall. | | TCP_RFIFO_STALL_CYCLES | Memory Request FIFOs full stall. | | TCP_TCR_RDRET_STALL | Write into cache stalled by read return from TCR. | | TCP_PENDING_STALL_CYCLES | Stall due to data pending from L2. | | TCP_UTCL1_SERIALIZATION_STALL | Total number of stalls caused due to serializing translation requests through the UTCL1. | | TCP_UTCL1_THRASHING_STALL | Stall caused by thrashing feature in any probe. Lacks accuracy when the stall signal overlaps between probe0 and probe1, which is worse with MECO of thrashing deadlock. Some probe0 events could miss being counted in with MECO on. This perf count provides a rough thrashing estimate. | | TCP_UTCL1_TRANSLATION_MISS_UNDER_MISS | Translation miss_under_miss. | | TCP_UTCL1_STALL_INFLIGHT_MAX | Total UTCL1 stalls due to inflight counter saturation. | | TCP_UTCL1_STALL_LRU_INFLIGHT | Total UTCL1 stalls due to LRU cache line with inflight traffic. | | TCP_UTCL1_STALL_MULTI_MISS | Total UTCL1 stalls due to arbitrated multiple misses. | | TCP_UTCL1_LFIFO_FULL | Total UTCL1 and UTCL2 latency, which hides FIFO full cycles. | | TCP_UTCL1_STALL_LFIFO_NOT_RES | Total UTCL1 stalls due to UTCL2 latency, which hides FIFO output (not resident). | | TCP_UTCL1_STALL_UTCL2_REQ_OUT_OF_CREDITS | Total UTCL1 stalls due to UTCL2_req being out of credits. | | TCP_CLIENT_UTCL1_INFLIGHT | The sum of inflight client to UTCL1 requests per cycle. | | TCP_TAGRAM0_REQ | Total L2 requests mapping to TagRAM 0 from this TCP to all TCCs. | | TCP_TAGRAM1_REQ | Total L2 requests mapping to TagRAM 1 from this TCP to all TCCs. | | TCP_TAGRAM2_REQ | Total L2 requests mapping to TagRAM 2 from this TCP to all TCCs. | | TCP_TAGRAM3_REQ | Total L2 requests mapping to TagRAM 3 from this TCP to all TCCs. | | TCP_TCP_LATENCY | Total TCP wave latency (from the first clock of wave entering to the first clock of wave leaving). Divide by TA_TCP_STATE_READ to find average wave latency. | | TCP_TCC_READ_REQ_LATENCY | Total TCP to TCC request latency for reads and atomics with return. Not Windowed. | | TCP_TCC_WRITE_REQ_LATENCY | Total TCP to TCC request latency for writes and atomics without return. Not Windowed. | | TCP_TCC_WRITE_REQ_HOLE_LATENCY | Total TCP req to TCC hole latency for writes and atomics. Not Windowed. | ## Texture cache per channel (TCC) counters | Hardware counter | Definition | |-------------------------------|-----------------------------------------------------------------------------------------------------------------------------| | TCC_READ_SECTORS | Total number of 32B data sectors in read requests. | | TCC_WRITE_SECTORS | Total number of 32B data sectors in write requests. | | TCC_ATOMIC_SECTORS | Total number of 32B data sectors in atomic requests. | | TCC_BYPASS_REQ | Number of bypass requests. This is measured at the tag block. | | TCC_LATENCY_FIFO_FULL | Number of cycles when the latency FIFO is full. | | TCC_SRC_FIFO_FULL | Number of cycles when the SRC FIFO is assumed to be full as measured at the IB block. | | TCC_EA0_RDREQ_64B | Number of 64-byte TCC/EA read requests. | | TCC_EA0_RDREQ_128B | Number of 128-byte TCC/EA read requests. | | TCC_IB_REQ | Number of requests through the IB. This measures the number of raw requests from graphics clients to this TCC. | | TCC_IB_STALL | Number of cycles when the IB output is stalled. | | TCC_EA0_WRREQ_WRITE_DRAM | Number of TCC/EA write requests (32-byte or 64-byte) destined for DRAM (MC). | | TCC_EA0_WRREQ_ATOMIC_DRAM | Number of TCC/EA atomic requests (32-byte or 64-byte) destined for DRAM (MC). | | TCC_EA0_RDREQ_DRAM_32B | Number of 32-byte TCC/EA read requests due to DRAM traffic. One 64-byte request is counted as two and one 128-byte as four. | | TCC_EA0_RDREQ_GMI_32B | Number of 32-byte TCC/EA read requests due to GMI traffic. One 64-byte request is counted as two and one 128-byte as four. | | TCC_EA0_RDREQ_IO_32B | Number of 32-byte TCC/EA read requests due to IO traffic. One 64-byte request is counted as two and one 128-byte as four. | | TCC_EA0_WRREQ_WRITE_DRAM_32B | Number of 32-byte TCC/EA write requests due to DRAM traffic. One 64-byte request is counted as two. | | TCC_EA0_WRREQ_ATOMIC_DRAM_32B | Number of 32-byte TCC/EA atomic requests due to DRAM traffic. One 64-byte request is counted as two. | | TCC_EA0_WRREQ_WRITE_GMI_32B | Number of 32-byte TCC/EA write requests due to GMI traffic. One 64-byte request is counted as two. | | TCC_EA0_WRREQ_ATOMIC_GMI_32B | Number of 32-byte TCC/EA atomic requests due to GMI traffic. One 64-byte request is counted as two. | | TCC_EA0_WRREQ_WRITE_IO_32B | Number of 32-byte TCC/EA write requests due to IO traffic. One 64-byte request is counted as two. | | TCC_EA0_WRREQ_ATOMIC_IO_32B | Number of 32-byte TCC/EA atomic requests due to IO traffic. One 64-byte request is counted as two. | --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300.html # AMD Instinct™ MI300 Series microarchitecture The AMD Instinct MI300 Series GPUs are based on the AMD CDNA 3 architecture which was designed to deliver leadership performance for HPC, artificial intelligence (AI), and machine learning (ML) workloads. The AMD Instinct MI300 Series GPUs are well-suited for extreme scalability and compute performance, running on everything from individual servers to the world’s largest exascale supercomputers. With the MI300 Series, AMD is introducing the Accelerator Complex Die (XCD), which contains the GPU computational elements of the processor along with the lower levels of the cache hierarchy. The following image depicts the structure of a single XCD in the AMD Instinct MI300 GPU Series. ![image](images/shared/xcd-sys-arch.png) On the XCD, four Asynchronous Compute Engines (ACEs) send compute shader workgroups to the Compute Units (CUs). The XCD has 40 CUs: 38 active CUs at the aggregate level and 2 disabled CUs for yield management. The CUs all share a 4 MB L2 cache that serves to coalesce all memory traffic for the die. With less than half of the CUs of the AMD Instinct MI200 Series compute die, the AMD CDNA™ 3 XCD die is a smaller building block. However, it uses more advanced packaging and the processor can include 6 or 8 XCDs for up to 304 CUs, roughly 40% more than MI250X. The MI300 Series integrate up to 8 vertically stacked XCDs, 8 stacks of High-Bandwidth Memory 3 (HBM3) and 4 I/O dies (containing system infrastructure) using the AMD Infinity Fabric™ technology as interconnect. The Matrix Cores inside the CDNA 3 CUs have significant improvements, emphasizing AI and machine learning, enhancing throughput of existing data types while adding support for new data types. CDNA 2 Matrix Cores support FP16 and BF16, while offering INT8 for inference. Compared to MI250X GPUs, CDNA 3 Matrix Cores triple the performance for FP16 and BF16, while providing a performance gain of 6.8 times for INT8. FP8 has a performance gain of 16 times compared to FP32, while TF32 has a gain of 4 times compared to FP32. #### Peak-performance capabilities of the MI300X for different data types. | Computation and Data Type | FLOPS/CLOCK/CU | Peak TFLOPS | |-----------------------------|------------------|---------------| | Matrix FP64 | 256 | 163.4 | | Vector FP64 | 128 | 81.7 | | Matrix FP32 | 256 | 163.4 | | Vector FP32 | 256 | 163.4 | | Vector TF32 | 1024 | 653.7 | | Matrix FP16 | 2048 | 1307.4 | | Matrix BF16 | 2048 | 1307.4 | | Matrix FP8 | 4096 | 2614.9 | | Matrix INT8 | 4096 | 2614.9 | The above table summarizes the aggregated peak performance of the AMD Instinct MI300X Open Compute Platform (OCP) Open Accelerator Modules (OAMs) for different data types and command processors. The middle column lists the peak performance (number of data elements processed in a single instruction) of a single compute unit if a SIMD (or matrix) instruction is submitted in each clock cycle. The third column lists the theoretical peak performance of the OAM. The theoretical aggregated peak memory bandwidth of the GPU is 5.3 TB per second. The following image shows the block diagram of the APU (left) and the OAM package (right) both connected via AMD Infinity Fabric™ network on-chip. ![](reference/gpu-arch/images/image008.png) ## Node-level architecture ![image](images/shared/mi300-node-level-arch.png) The image above shows the node-level architecture of a system with AMD EPYC processors in a dual-socket configuration and eight AMD Instinct MI300X GPUs. The MI300X OAMs attach to the host system via PCIe Gen 5 x16 links (yellow lines). The GPUs are using seven high-bandwidth, low-latency AMD Infinity Fabric™ links (red lines) to form a fully connected 8-GPU system. --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi300-mi200-performance-counters.html # MI300 and MI200 Series performance counters and metrics This document lists and describes the hardware performance counters and derived metrics available for the AMD Instinct™ MI300 and MI200 GPU. You can also access this information using the [ROCprofiler-SDK](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/latest/how-to/using-rocprofv3.html). ## MI300 and MI200 Series performance counters Series performance counters include the following categories: * [Command processor counters](#command-processor-counters) * [Graphics register bus manager counters](#graphics-register-bus-manager-counters) * [Shader processor input counters](#spi-counters) * [Compute unit counters](#compute-unit-counters) * [L1 instruction cache (L1i) and scalar L1 data cache (L1d) counters](#l1i-and-sl1d-cache-counters) * [Vector L1 cache subsystem counters](#vector-l1-cache-subsystem-counters) * [L2 cache access counters](#l2-cache-access-counters) The following sections provide additional details for each category. #### NOTE Preliminary validation of all MI300 and MI200 Series performance counters is in progress. Those with an asterisk (\*) require further evaluation. ### Command processor counters Command processor counters are further classified into command processor-fetcher and command processor-compute. #### Command processor-fetcher counters | Hardware counter | Unit | Definition | |--------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------| | `CPF_CMP_UTCL1_STALL_ON_TRANSLATION` | Cycles | Number of cycles one of the compute unified translation caches (L1) is stalled waiting on translation | | `CPF_CPF_STAT_BUSY` | Cycles | Number of cycles command processor-fetcher is busy | | `CPF_CPF_STAT_IDLE` | Cycles | Number of cycles command processor-fetcher is idle | | `CPF_CPF_STAT_STALL` | Cycles | Number of cycles command processor-fetcher is stalled | | `CPF_CPF_TCIU_BUSY` | Cycles | Number of cycles command processor-fetcher texture cache interface unit interface is busy | | `CPF_CPF_TCIU_IDLE` | Cycles | Number of cycles command processor-fetcher texture cache interface unit interface is idle | | `CPF_CPF_TCIU_STALL` | Cycles | Number of cycles command processor-fetcher texture cache interface unit interface is stalled waiting on free tags | The texture cache interface unit is the interface between the command processor and the memory system. #### Command processor-compute counters | Hardware counter | Unit | Definition | |----------------------------------|--------|------------------------------------------------------------------------------------------------| | `CPC_ME1_BUSY_FOR_PACKET_DECODE` | Cycles | Number of cycles command processor-compute micro engine is busy decoding packets | | `CPC_UTCL1_STALL_ON_TRANSLATION` | Cycles | Number of cycles one of the unified translation caches (L1) is stalled waiting on translation | | `CPC_CPC_STAT_BUSY` | Cycles | Number of cycles command processor-compute is busy | | `CPC_CPC_STAT_IDLE` | Cycles | Number of cycles command processor-compute is idle | | `CPC_CPC_STAT_STALL` | Cycles | Number of cycles command processor-compute is stalled | | `CPC_CPC_TCIU_BUSY` | Cycles | Number of cycles command processor-compute texture cache interface unit interface is busy | | `CPC_CPC_TCIU_IDLE` | Cycles | Number of cycles command processor-compute texture cache interface unit interface is idle | | `CPC_CPC_UTCL2IU_BUSY` | Cycles | Number of cycles command processor-compute unified translation cache (L2) interface is busy | | `CPC_CPC_UTCL2IU_IDLE` | Cycles | Number of cycles command processor-compute unified translation cache (L2) interface is idle | | `CPC_CPC_UTCL2IU_STALL` | Cycles | Number of cycles command processor-compute unified translation cache (L2) interface is stalled | | `CPC_ME1_DC0_SPI_BUSY` | Cycles | Number of cycles command processor-compute micro engine processor is busy | The micro engine runs packet-processing firmware on the command processor-compute counter. ### Graphics register bus manager counters | Hardware counter | Unit | Definition | |--------------------|--------|-----------------------------------------------------------------------------------| | `GRBM_COUNT` | Cycles | Number of free-running GPU cycles | | `GRBM_GUI_ACTIVE` | Cycles | Number of GPU active cycles | | `GRBM_CP_BUSY` | Cycles | Number of cycles any of the command processor blocks are busy | | `GRBM_SPI_BUSY` | Cycles | Number of cycles any of the shader processor input is busy in the shader engines | | `GRBM_TA_BUSY` | Cycles | Number of cycles any of the texture addressing unit is busy in the shader engines | | `GRBM_TC_BUSY` | Cycles | Number of cycles any of the texture cache blocks are busy | | `GRBM_CPC_BUSY` | Cycles | Number of cycles the command processor-compute is busy | | `GRBM_CPF_BUSY` | Cycles | Number of cycles the command processor-fetcher is busy | | `GRBM_UTCL2_BUSY` | Cycles | Number of cycles the unified translation cache (Level 2 [L2]) block is busy | | `GRBM_EA_BUSY` | Cycles | Number of cycles the efficiency arbiter block is busy | Texture cache blocks include: * Texture cache arbiter * Texture cache per pipe, also known as vector Level 1 (L1) cache * Texture cache per channel, also known as known as L2 cache * Texture cache interface ### Shader processor input counters | Hardware counter | Unit | Definition | |-----------------------------|-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `SPI_CSN_BUSY` | Cycles | Number of cycles with outstanding waves | | `SPI_CSN_WINDOW_VALID` | Cycles | Number of cycles enabled by `perfcounter_start` event | | `SPI_CSN_NUM_THREADGROUPS` | Workgroups | Number of dispatched workgroups | | `SPI_CSN_WAVE` | Wavefronts | Number of dispatched wavefronts | | `SPI_RA_REQ_NO_ALLOC` | Cycles | Number of arbiter cycles with requests but no allocation | | `SPI_RA_REQ_NO_ALLOC_CSN` | Cycles | Number of arbiter cycles with compute shader (nth pipe) requests but no compute shader (nth pipe) allocation | | `SPI_RA_RES_STALL_CSN` | Cycles | Number of arbiter stall cycles due to shortage of compute shader (nth pipe) pipeline slots | | `SPI_RA_TMP_STALL_CSN` | Cycles | Number of stall cycles due to shortage of temp space | | `SPI_RA_WAVE_SIMD_FULL_CSN` | SIMD-cycles | Accumulated number of single instruction, multiple data (SIMD) per cycle affected by shortage of wave slots for compute shader (nth pipe) wave dispatch | | `SPI_RA_VGPR_SIMD_FULL_CSN` | SIMD-cycles | Accumulated number of SIMDs per cycle affected by shortage of vector general-purpose register (VGPR) slots for compute shader (nth pipe) wave dispatch | | `SPI_RA_SGPR_SIMD_FULL_CSN` | SIMD-cycles | Accumulated number of SIMDs per cycle affected by shortage of scalar general-purpose register (SGPR) slots for compute shader (nth pipe) wave dispatch | | `SPI_RA_LDS_CU_FULL_CSN` | CU | Number of compute units affected by shortage of local data share (LDS) space for compute shader (nth pipe) wave dispatch | | `SPI_RA_BAR_CU_FULL_CSN` | CU | Number of compute units with compute shader (nth pipe) waves waiting at a BARRIER | | `SPI_RA_BULKY_CU_FULL_CSN` | CU | Number of compute units with compute shader (nth pipe) waves waiting for BULKY resource | | `SPI_RA_TGLIM_CU_FULL_CSN` | Cycles | Number of compute shader (nth pipe) wave stall cycles due to restriction of `tg_limit` for thread group size | | `SPI_RA_WVLIM_STALL_CSN` | Cycles | Number of cycles compute shader (nth pipe) is stalled due to `WAVE_LIMIT` | | `SPI_VWC_CSC_WR` | Qcycles | Number of quad-cycles taken to initialize VGPRs when launching waves | | `SPI_SWC_CSC_WR` | Qcycles | Number of quad-cycles taken to initialize SGPRs when launching waves | ### Compute unit counters The compute unit counters are further classified into instruction mix, matrix fused multiply-add (FMA) operation counters, level counters, wavefront counters, wavefront cycle counters, and LDS counters. #### Instruction mix | Hardware counter | Unit | Definition | |---------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------| | `SQ_INSTS` | Instr | Number of instructions issued | | `SQ_INSTS_VALU` | Instr | Number of vector arithmetic logic unit (VALU) instructions including matrix FMA issued | | `SQ_INSTS_VALU_ADD_F16` | Instr | Number of VALU half-precision floating-point (F16) `ADD` or `SUB` instructions issued | | `SQ_INSTS_VALU_MUL_F16` | Instr | Number of VALU F16 Multiply instructions issued | | `SQ_INSTS_VALU_FMA_F16` | Instr | Number of VALU F16 FMA or multiply-add instructions issued | | `SQ_INSTS_VALU_TRANS_F16` | Instr | Number of VALU F16 Transcendental instructions issued | | `SQ_INSTS_VALU_ADD_F32` | Instr | Number of VALU full-precision floating-point (F32) `ADD` or `SUB` instructions issued | | `SQ_INSTS_VALU_MUL_F32` | Instr | Number of VALU F32 Multiply instructions issued | | `SQ_INSTS_VALU_FMA_F32` | Instr | Number of VALU F32 FMAor multiply-add instructions issued | | `SQ_INSTS_VALU_TRANS_F32` | Instr | Number of VALU F32 Transcendental instructions issued | | `SQ_INSTS_VALU_ADD_F64` | Instr | Number of VALU F64 `ADD` or `SUB` instructions issued | | `SQ_INSTS_VALU_MUL_F64` | Instr | Number of VALU F64 Multiply instructions issued | | `SQ_INSTS_VALU_FMA_F64` | Instr | Number of VALU F64 FMA or multiply-add instructions issued | | `SQ_INSTS_VALU_TRANS_F64` | Instr | Number of VALU F64 Transcendental instructions issued | | `SQ_INSTS_VALU_INT32` | Instr | Number of VALU 32-bit integer instructions (signed or unsigned) issued | | `SQ_INSTS_VALU_INT64` | Instr | Number of VALU 64-bit integer instructions (signed or unsigned) issued | | `SQ_INSTS_VALU_CVT` | Instr | Number of VALU Conversion instructions issued | | `SQ_INSTS_VALU_MFMA_I8` | Instr | Number of 8-bit Integer matrix FMA instructions issued | | `SQ_INSTS_VALU_MFMA_F16` | Instr | Number of F16 matrix FMA instructions issued | | `SQ_INSTS_VALU_MFMA_F32` | Instr | Number of F32 matrix FMA instructions issued | | `SQ_INSTS_VALU_MFMA_F64` | Instr | Number of F64 matrix FMA instructions issued | | `SQ_INSTS_MFMA` | Instr | Number of matrix FMA instructions issued | | `SQ_INSTS_VMEM_WR` | Instr | Number of vector memory write instructions (including flat) issued | | `SQ_INSTS_VMEM_RD` | Instr | Number of vector memory read instructions (including flat) issued | | `SQ_INSTS_VMEM` | Instr | Number of vector memory instructions issued, including both flat and buffer instructions | | `SQ_INSTS_SALU` | Instr | Number of scalar arithmetic logic unit (SALU) instructions issued | | `SQ_INSTS_SMEM` | Instr | Number of scalar memory instructions issued | | `SQ_INSTS_SMEM_NORM` | Instr | Number of scalar memory instructions normalized to match `smem_level` issued | | `SQ_INSTS_FLAT` | Instr | Number of flat instructions issued | | `SQ_INSTS_FLAT_LDS_ONLY` | Instr | **MI200 Series only** Number of FLAT instructions that read/write only from/to LDS issued. Works only if `EARLY_TA_DONE` is enabled. | | `SQ_INSTS_LDS` | Instr | Number of LDS instructions issued **(MI200: includes flat; MI300: does not include flat)** | | `SQ_INSTS_GDS` | Instr | Number of global data share instructions issued | | `SQ_INSTS_EXP_GDS` | Instr | Number of EXP and global data share instructions excluding skipped export instructions issued | | `SQ_INSTS_BRANCH` | Instr | Number of branch instructions issued | | `SQ_INSTS_SENDMSG` | Instr | Number of `SENDMSG` instructions including `s_endpgm` issued | | `SQ_INSTS_VSKIPPED` | Instr | Number of vector instructions skipped | Flat instructions allow read, write, and atomic access to a generic memory address pointer that can resolve to any of the following physical memories: * Global Memory * Scratch (“private”) * LDS (“shared”) * Invalid - `MEM_VIOL` TrapStatus #### Matrix fused multiply-add operation counters | Hardware counter | Unit | Definition | |--------------------------------|--------|-----------------------------------------------------------| | `SQ_INSTS_VALU_MFMA_MOPS_I8` | IOP | Number of 8-bit integer matrix FMA ops in the unit of 512 | | `SQ_INSTS_VALU_MFMA_MOPS_F16` | FLOP | Number of F16 floating matrix FMA ops in the unit of 512 | | `SQ_INSTS_VALU_MFMA_MOPS_BF16` | FLOP | Number of BF16 floating matrix FMA ops in the unit of 512 | | `SQ_INSTS_VALU_MFMA_MOPS_F32` | FLOP | Number of F32 floating matrix FMA ops in the unit of 512 | | `SQ_INSTS_VALU_MFMA_MOPS_F64` | FLOP | Number of F64 floating matrix FMA ops in the unit of 512 | #### Level counters #### NOTE All level counters must be followed by `SQ_ACCUM_PREV_HIRES` counter to measure average latency. | Hardware counter | Unit | Definition | |-----------------------|--------|----------------------------------------------------------------------------------------| | `SQ_ACCUM_PREV` | Count | Accumulated counter sample value where accumulation takes place once every four cycles | | `SQ_ACCUM_PREV_HIRES` | Count | Accumulated counter sample value where accumulation takes place once every cycle | | `SQ_LEVEL_WAVES` | Waves | Number of inflight waves | | `SQ_INST_LEVEL_VMEM` | Instr | Number of inflight vector memory (including flat) instructions | | `SQ_INST_LEVEL_SMEM` | Instr | Number of inflight scalar memory instructions | | `SQ_INST_LEVEL_LDS` | Instr | Number of inflight LDS (including flat) instructions | | `SQ_IFETCH_LEVEL` | Instr | Number of inflight instruction fetch requests from the cache | Use the following formulae to calculate latencies: * Vector memory latency = `SQ_ACCUM_PREV_HIRES` divided by `SQ_INSTS_VMEM` * Wave latency = `SQ_ACCUM_PREV_HIRES` divided by `SQ_WAVE` * LDS latency = `SQ_ACCUM_PREV_HIRES` divided by `SQ_INSTS_LDS` * Scalar memory latency = `SQ_ACCUM_PREV_HIRES` divided by `SQ_INSTS_SMEM_NORM` * Instruction fetch latency = `SQ_ACCUM_PREV_HIRES` divided by `SQ_IFETCH` #### Wavefront counters | Hardware counter | Unit | Definition | |---------------------|--------|-------------------------------------------------------------------------------------------| | `SQ_WAVES` | Waves | Number of wavefronts dispatched to sequencers, including both new and restored wavefronts | | `SQ_WAVES_SAVED` | Waves | Number of context-saved waves | | `SQ_WAVES_RESTORED` | Waves | Number of context-restored waves sent to sequencers | | `SQ_WAVES_EQ_64` | Waves | Number of wavefronts with exactly 64 active threads sent to sequencers | | `SQ_WAVES_LT_64` | Waves | Number of wavefronts with less than 64 active threads sent to sequencers | | `SQ_WAVES_LT_48` | Waves | Number of wavefronts with less than 48 active threads sent to sequencers | | `SQ_WAVES_LT_32` | Waves | Number of wavefronts with less than 32 active threads sent to sequencers | | `SQ_WAVES_LT_16` | Waves | Number of wavefronts with less than 16 active threads sent to sequencers | #### Wavefront cycle counters | Hardware counter | Unit | Definition | |----------------------------|---------|-----------------------------------------------------------------------------------------------------------------| | `SQ_CYCLES` | Cycles | Clock cycles | | `SQ_BUSY_CYCLES` | Cycles | Number of cycles while sequencers reports it to be busy | | `SQ_BUSY_CU_CYCLES` | Qcycles | Number of quad-cycles each compute unit is busy | | `SQ_VALU_MFMA_BUSY_CYCLES` | Cycles | Number of cycles the matrix FMA arithmetic logic unit (ALU) is busy | | `SQ_WAVE_CYCLES` | Qcycles | Number of quad-cycles spent by waves in the compute units | | `SQ_WAIT_ANY` | Qcycles | Number of quad-cycles spent waiting for anything | | `SQ_WAIT_INST_ANY` | Qcycles | Number of quad-cycles spent waiting for any instruction to be issued | | `SQ_ACTIVE_INST_ANY` | Qcycles | Number of quad-cycles spent by each wave to work on an instruction | | `SQ_ACTIVE_INST_VMEM` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on a vector memory instruction | | `SQ_ACTIVE_INST_LDS` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on an LDS instruction | | `SQ_ACTIVE_INST_VALU` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on a VALU instruction | | `SQ_ACTIVE_INST_SCA` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on a SALU or scalar memory instruction | | `SQ_ACTIVE_INST_EXP_GDS` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on an `EXPORT` or `GDS` instruction | | `SQ_ACTIVE_INST_MISC` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on a `BRANCH` or `SENDMSG` instruction | | `SQ_ACTIVE_INST_FLAT` | Qcycles | Number of quad-cycles spent by the sequencer instruction arbiter to work on a flat instruction | | `SQ_INST_CYCLES_VMEM_WR` | Qcycles | Number of quad-cycles spent to send addr and cmd data for vector memory write instructions | | `SQ_INST_CYCLES_VMEM_RD` | Qcycles | Number of quad-cycles spent to send addr and cmd data for vector memory read instructions | | `SQ_INST_CYCLES_SMEM` | Qcycles | Number of quad-cycles spent to execute scalar memory reads | | `SQ_INST_CYCLES_SALU` | Qcycles | Number of quad-cycles spent to execute non-memory read scalar operations | | `SQ_THREAD_CYCLES_VALU` | Qcycles | Number of quad-cycles spent to execute VALU operations on active threads | | `SQ_WAIT_INST_LDS` | Qcycles | Number of quad-cycles spent waiting for LDS instruction to be issued | `SQ_THREAD_CYCLES_VALU` is similar to `INST_CYCLES_VALU`, but it’s multiplied by the number of active threads. #### LDS counters | Hardware counter | Unit | Definition | |--------------------------|--------|------------------------------------------------------------------------------------| | `SQ_LDS_ATOMIC_RETURN` | Cycles | Number of atomic return cycles in LDS | | `SQ_LDS_BANK_CONFLICT` | Cycles | Number of cycles LDS is stalled by bank conflicts | | `SQ_LDS_ADDR_CONFLICT` | Cycles | Number of cycles LDS is stalled by address conflicts | | `SQ_LDS_UNALIGNED_STALL` | Cycles | Number of cycles LDS is stalled processing flat unaligned load or store operations | | `SQ_LDS_MEM_VIOLATIONS` | Count | Number of threads that have a memory violation in the LDS | | `SQ_LDS_IDX_ACTIVE` | Cycles | Number of cycles LDS is used for indexed operations | #### Miscellaneous counters | Hardware counter | Unit | Definition | |--------------------|---------|-----------------------------------------------------------------| | `SQ_IFETCH` | Count | Number of instruction fetch requests from L1i, in 32-byte width | | `SQ_ITEMS` | Threads | Number of valid items per wave | ### L1 instruction cache (L1i) and scalar L1 data cache (L1d) counters | Hardware counter | Unit | Definition | |---------------------------------|--------|-------------------------------------------------------------------------------------------------------------| | `SQC_ICACHE_REQ` | Req | Number of L1 instruction (L1i) cache requests | | `SQC_ICACHE_HITS` | Count | Number of L1i cache hits | | `SQC_ICACHE_MISSES` | Count | Number of non-duplicate L1i cache misses including uncached requests | | `SQC_ICACHE_MISSES_DUPLICATE` | Count | Number of duplicate L1i cache misses whose previous lookup miss on the same cache line is not fulfilled yet | | `SQC_DCACHE_REQ` | Req | Number of scalar L1d requests | | `SQC_DCACHE_INPUT_VALID_READYB` | Cycles | Number of cycles while sequencer input is valid but scalar L1d is not ready | | `SQC_DCACHE_HITS` | Count | Number of scalar L1d hits | | `SQC_DCACHE_MISSES` | Count | Number of non-duplicate scalar L1d misses including uncached requests | | `SQC_DCACHE_MISSES_DUPLICATE` | Count | Number of duplicate scalar L1d misses | | `SQC_DCACHE_REQ_READ_1` | Req | Number of constant cache read requests in a single 32-bit data word | | `SQC_DCACHE_REQ_READ_2` | Req | Number of constant cache read requests in two 32-bit data words | | `SQC_DCACHE_REQ_READ_4` | Req | Number of constant cache read requests in four 32-bit data words | | `SQC_DCACHE_REQ_READ_8` | Req | Number of constant cache read requests in eight 32-bit data words | | `SQC_DCACHE_REQ_READ_16` | Req | Number of constant cache read requests in 16 32-bit data words | | `SQC_DCACHE_ATOMIC` | Req | Number of atomic requests | | `SQC_TC_REQ` | Req | Number of texture cache requests that were issued by instruction and constant caches | | `SQC_TC_INST_REQ` | Req | Number of instruction requests to the L2 cache | | `SQC_TC_DATA_READ_REQ` | Req | Number of data Read requests to the L2 cache | | `SQC_TC_DATA_WRITE_REQ` | Req | Number of data write requests to the L2 cache | | `SQC_TC_DATA_ATOMIC_REQ` | Req | Number of data atomic requests to the L2 cache | | `SQC_TC_STALL` | Cycles | Number of cycles while the valid requests to the L2 cache are stalled | ### Vector L1 cache subsystem counters The vector L1 cache subsystem counters are further classified into texture addressing unit, texture data unit, vector L1d or texture cache per pipe, and texture cache arbiter counters. #### Texture addressing unit counters | Hardware counter | Unit | Definition | Value range for `n` | |---------------------------------------|--------|---------------------------------------------------------------------------------------|-----------------------| | `TA_TA_BUSY[n]` | Cycles | Texture addressing unit busy cycles | 0-15 | | `TA_TOTAL_WAVEFRONTS[n]` | Instr | Number of wavefronts processed by texture addressing unit | 0-15 | | `TA_BUFFER_WAVEFRONTS[n]` | Instr | Number of buffer wavefronts processed by texture addressing unit | 0-15 | | `TA_BUFFER_READ_WAVEFRONTS[n]` | Instr | Number of buffer read wavefronts processed by texture addressing unit | 0-15 | | `TA_BUFFER_WRITE_WAVEFRONTS[n]` | Instr | Number of buffer write wavefronts processed by texture addressing unit | 0-15 | | `TA_BUFFER_ATOMIC_WAVEFRONTS[n]` | Instr | Number of buffer atomic wavefronts processed by texture addressing unit | 0-15 | | `TA_BUFFER_TOTAL_CYCLES[n]` | Cycles | Number of buffer cycles (including read and write) issued to texture cache | 0-15 | | `TA_BUFFER_COALESCED_READ_CYCLES[n]` | Cycles | Number of coalesced buffer read cycles issued to texture cache | 0-15 | | `TA_BUFFER_COALESCED_WRITE_CYCLES[n]` | Cycles | Number of coalesced buffer write cycles issued to texture cache | 0-15 | | `TA_ADDR_STALLED_BY_TC_CYCLES[n]` | Cycles | Number of cycles texture addressing unit address path is stalled by texture cache | 0-15 | | `TA_DATA_STALLED_BY_TC_CYCLES[n]` | Cycles | Number of cycles texture addressing unit data path is stalled by texture cache | 0-15 | | `TA_ADDR_STALLED_BY_TD_CYCLES[n]` | Cycles | Number of cycles texture addressing unit address path is stalled by texture data unit | 0-15 | | `TA_FLAT_WAVEFRONTS[n]` | Instr | Number of flat opcode wavefronts processed by texture addressing unit | 0-15 | | `TA_FLAT_READ_WAVEFRONTS[n]` | Instr | Number of flat opcode read wavefronts processed by texture addressing unit | 0-15 | | `TA_FLAT_WRITE_WAVEFRONTS[n]` | Instr | Number of flat opcode write wavefronts processed by texture addressing unit | 0-15 | | `TA_FLAT_ATOMIC_WAVEFRONTS[n]` | Instr | Number of flat opcode atomic wavefronts processed by texture addressing unit | 0-15 | #### Texture data unit counters | Hardware counter | Unit | Definition | Value range for `n` | |-------------------------------|--------|------------------------------------------------------------------------------|-----------------------| | `TD_TD_BUSY[n]` | Cycle | Texture data unit busy cycles while it is processing or waiting for data | 0-15 | | `TD_TC_STALL[n]` | Cycle | Number of cycles texture data unit is stalled waiting for texture cache data | 0-15 | | `TD_SPI_STALL[n]` | Cycle | Number of cycles texture data unit is stalled by shader processor input | 0-15 | | `TD_LOAD_WAVEFRONT[n]` | Instr | Number of wavefront instructions (read, write, atomic) | 0-15 | | `TD_STORE_WAVEFRONT[n]` | Instr | Number of write wavefront instructions | 0-15 | | `TD_ATOMIC_WAVEFRONT[n]` | Instr | Number of atomic wavefront instructions | 0-15 | | `TD_COALESCABLE_WAVEFRONT[n]` | Instr | Number of coalescable wavefronts according to texture addressing unit | 0-15 | #### Texture cache per pipe counters | Hardware counter | Unit | Definition | Value range for `n` | |------------------------------------------|--------|------------------------------------------------------------------------------------------------------------------|-----------------------| | `TCP_GATE_EN1[n]` | Cycles | Number of cycles vector L1d interface clocks are turned on | 0-15 | | `TCP_GATE_EN2[n]` | Cycles | Number of cycles vector L1d core clocks are turned on | 0-15 | | `TCP_TD_TCP_STALL_CYCLES[n]` | Cycles | Number of cycles texture data unit stalls vector L1d | 0-15 | | `TCP_TCR_TCP_STALL_CYCLES[n]` | Cycles | Number of cycles texture cache router stalls vector L1d | 0-15 | | `TCP_READ_TAGCONFLICT_STALL_CYCLES[n]` | Cycles | Number of cycles tag RAM conflict stalls on a read | 0-15 | | `TCP_WRITE_TAGCONFLICT_STALL_CYCLES[n]` | Cycles | Number of cycles tag RAM conflict stalls on a write | 0-15 | | `TCP_ATOMIC_TAGCONFLICT_STALL_CYCLES[n]` | Cycles | Number of cycles tag RAM conflict stalls on an atomic | 0-15 | | `TCP_PENDING_STALL_CYCLES[n]` | Cycles | Number of cycles vector L1d is stalled due to data pending from L2 Cache | 0-15 | | `TCP_TCP_TA_DATA_STALL_CYCLES` | Cycles | Number of cycles texture cache per pipe stalls texture addressing unit data interface | NA | | `TCP_TA_TCP_STATE_READ[n]` | Req | Number of state reads | 0-15 | | `TCP_VOLATILE[n]` | Req | Number of L1 volatile pixels or buffers from texture addressing unit | 0-15 | | `TCP_TOTAL_ACCESSES[n]` | Req | Number of vector L1d accesses. Equals `TCP_PERF_SEL_TOTAL_READ`+`TCP_PERF_SEL_TOTAL_NONREAD` | 0-15 | | `TCP_TOTAL_READ[n]` | Req | Number of vector L1d read accesses | 0-15 | | `TCP_TOTAL_WRITE[n]` | Req | Number of vector L1d write accesses | 0-15 | | `TCP_TOTAL_ATOMIC_WITH_RET[n]` | Req | Number of vector L1d atomic requests with return | 0-15 | | `TCP_TOTAL_ATOMIC_WITHOUT_RET[n]` | Req | Number of vector L1d atomic without return | 0-15 | | `TCP_TOTAL_WRITEBACK_INVALIDATES[n]` | Count | Total number of vector L1d writebacks and invalidates | 0-15 | | `TCP_UTCL1_REQUEST[n]` | Req | Number of address translation requests to unified translation cache (L1) | 0-15 | | `TCP_UTCL1_TRANSLATION_HIT[n]` | Req | Number of unified translation cache (L1) translation hits | 0-15 | | `TCP_UTCL1_TRANSLATION_MISS[n]` | Req | Number of unified translation cache (L1) translation misses | 0-15 | | `TCP_UTCL1_PERMISSION_MISS[n]` | Req | Number of unified translation cache (L1) permission misses | 0-15 | | `TCP_TOTAL_CACHE_ACCESSES[n]` | Req | Number of vector L1d cache accesses including hits and misses | 0-15 | | `TCP_TCP_LATENCY[n]` | Cycles | **MI200 Series only** Accumulated wave access latency to vL1D over all wavefronts | 0-15 | | `TCP_TCC_READ_REQ_LATENCY[n]` | Cycles | **MI200 Series only** Total vL1D to L2 request latency over all wavefronts for reads and atomics with return | 0-15 | | `TCP_TCC_WRITE_REQ_LATENCY[n]` | Cycles | **MI200 Series only** Total vL1D to L2 request latency over all wavefronts for writes and atomics without return | 0-15 | | `TCP_TCC_READ_REQ[n]` | Req | Number of read requests to L2 cache | 0-15 | | `TCP_TCC_WRITE_REQ[n]` | Req | Number of write requests to L2 cache | 0-15 | | `TCP_TCC_ATOMIC_WITH_RET_REQ[n]` | Req | Number of atomic requests to L2 cache with return | 0-15 | | `TCP_TCC_ATOMIC_WITHOUT_RET_REQ[n]` | Req | Number of atomic requests to L2 cache without return | 0-15 | | `TCP_TCC_NC_READ_REQ[n]` | Req | Number of non-coherently cached read requests to L2 cache | 0-15 | | `TCP_TCC_UC_READ_REQ[n]` | Req | Number of uncached read requests to L2 cache | 0-15 | | `TCP_TCC_CC_READ_REQ[n]` | Req | Number of coherently cached read requests to L2 cache | 0-15 | | `TCP_TCC_RW_READ_REQ[n]` | Req | Number of coherently cached with write read requests to L2 cache | 0-15 | | `TCP_TCC_NC_WRITE_REQ[n]` | Req | Number of non-coherently cached write requests to L2 cache | 0-15 | | `TCP_TCC_UC_WRITE_REQ[n]` | Req | Number of uncached write requests to L2 cache | 0-15 | | `TCP_TCC_CC_WRITE_REQ[n]` | Req | Number of coherently cached write requests to L2 cache | 0-15 | | `TCP_TCC_RW_WRITE_REQ[n]` | Req | Number of coherently cached with write write requests to L2 cache | 0-15 | | `TCP_TCC_NC_ATOMIC_REQ[n]` | Req | Number of non-coherently cached atomic requests to L2 cache | 0-15 | | `TCP_TCC_UC_ATOMIC_REQ[n]` | Req | Number of uncached atomic requests to L2 cache | 0-15 | | `TCP_TCC_CC_ATOMIC_REQ[n]` | Req | Number of coherently cached atomic requests to L2 cache | 0-15 | | `TCP_TCC_RW_ATOMIC_REQ[n]` | Req | Number of coherently cached with write atomic requests to L2 cache | 0-15 | Note that: * `TCP_TOTAL_READ[n]` = `TCP_PERF_SEL_TOTAL_HIT_LRU_READ` + `TCP_PERF_SEL_TOTAL_MISS_LRU_READ` + `TCP_PERF_SEL_TOTAL_MISS_EVICT_READ` * `TCP_TOTAL_WRITE[n]` = `TCP_PERF_SEL_TOTAL_MISS_LRU_WRITE``+ ``TCP_PERF_SEL_TOTAL_MISS_EVICT_WRITE` * `TCP_TOTAL_WRITEBACK_INVALIDATES[n]` = `TCP_PERF_SEL_TOTAL_WBINVL1``+ ``TCP_PERF_SEL_TOTAL_WBINVL1_VOL``+ ``TCP_PERF_SEL_CP_TCP_INVALIDATE``+ ``TCP_PERF_SEL_SQ_TCP_INVALIDATE_VOL` #### Texture cache arbiter counters | Hardware counter | Unit | Definition | Value range for `n` | |--------------------|--------|--------------------------------------------------------------|-----------------------| | `TCA_CYCLE[n]` | Cycles | Number of texture cache arbiter cycles | 0-31 | | `TCA_BUSY[n]` | Cycles | Number of cycles texture cache arbiter has a pending request | 0-31 | ### L2 cache access counters L2 cache is also known as texture cache per channel. **MI300 hardware counter** | Hardware counter | Unit | Definition | Value range for `n` | |--------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------| | `TCC_CYCLE[n]` | Cycles | Number of L2 cache free-running clocks | 0-31 | | `TCC_BUSY[n]` | Cycles | Number of L2 cache busy cycles | 0-31 | | `TCC_REQ[n]` | Req | Number of L2 cache requests of all types (measured at the tag block) | 0-31 | | `TCC_STREAMING_REQ[n]` | Req | Number of L2 cache streaming requests (measured at the tag block) | 0-31 | | `TCC_NC_REQ[n]` | Req | Number of non-coherently cached requests (measured at the tag block) | 0-31 | | `TCC_UC_REQ[n]` | Req | Number of uncached requests. This is measured at the tag block | 0-31 | | `TCC_CC_REQ[n]` | Req | Number of coherently cached requests. This is measured at the tag block | 0-31 | | `TCC_RW_REQ[n]` | Req | Number of coherently cached with write requests. This is measured at the tag block | 0-31 | | `TCC_PROBE[n]` | Req | Number of probe requests | 0-31 | | `TCC_PROBE_ALL[n]` | Req | Number of external probe requests with `EA_TCC_preq_all == 1` | 0-31 | | `TCC_READ[n]` | Req | Number of L2 cache read requests (includes compressed reads but not metadata reads) | 0-31 | | `TCC_WRITE[n]` | Req | Number of L2 cache write requests | 0-31 | | `TCC_ATOMIC[n]` | Req | Number of L2 cache atomic requests of all types | 0-31 | | `TCC_HIT[n]` | Req | Number of L2 cache hits | 0-31 | | `TCC_MISS[n]` | Req | Number of L2 cache misses | 0-31 | | `TCC_WRITEBACK[n]` | Req | Number of lines written back to the main memory, including writebacks of dirty lines and uncached write or atomic requests | 0-31 | | `TCC_EA0_WRREQ[n]` | Req | Number of 32-byte and 64-byte transactions going over the `TC_EA_wrreq` interface (doesn’t include probe commands) | 0-31 | | `TCC_EA0_WRREQ_64B[n]` | Req | Total number of 64-byte transactions (write or `CMPSWAP`) going over the `TC_EA_wrreq` interface | 0-31 | | `TCC_EA0_WR_UNCACHED_32B[n]` | Req | Number of 32 or 64-byte write or atomic going over the `TC_EA_wrreq` interface due to uncached traffic | 0-31 | | `TCC_EA0_WRREQ_STALL[n]` | Cycles | Number of cycles a write request is stalled | 0-31 | | `TCC_EA0_WRREQ_IO_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of input-output (IO) credits | 0-31 | | `TCC_EA0_WRREQ_GMI_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of GMI credits | 0-31 | | `TCC_EA0_WRREQ_DRAM_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of DRAM credits | 0-31 | | `TCC_TOO_MANY_EA_WRREQS_STALL[n]` | Cycles | Number of cycles the L2 cache is unable to send an efficiency arbiter write request due to it reaching its maximum capacity of pending efficiency arbiter write requests | 0-31 | | `TCC_EA0_WRREQ_LEVEL[n]` | Req | The accumulated number of efficiency arbiter write requests in flight | 0-31 | | `TCC_EA0_ATOMIC[n]` | Req | Number of 32-byte or 64-byte atomic requests going over the `TC_EA_wrreq` interface | 0-31 | | `TCC_EA0_ATOMIC_LEVEL[n]` | Req | The accumulated number of efficiency arbiter atomic requests in flight | 0-31 | | `TCC_EA0_RDREQ[n]` | Req | Number of 32-byte or 64-byte read requests to efficiency arbiter | 0-31 | | `TCC_EA0_RDREQ_32B[n]` | Req | Number of 32-byte read requests to efficiency arbiter | 0-31 | | `TCC_EA0_RD_UNCACHED_32B[n]` | Req | Number of 32-byte efficiency arbiter reads due to uncached traffic. A 64-byte request is counted as 2 | 0-31 | | `TCC_EA0_RDREQ_IO_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of IO credits | 0-31 | | `TCC_EA0_RDREQ_GMI_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of GMI credits | 0-31 | | `TCC_EA0_RDREQ_DRAM_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of DRAM credits | 0-31 | | `TCC_EA0_RDREQ_LEVEL[n]` | Req | The accumulated number of efficiency arbiter read requests in flight | 0-31 | | `TCC_EA0_RDREQ_DRAM[n]` | Req | Number of 32-byte or 64-byte efficiency arbiter read requests to High Bandwidth Memory (HBM) | 0-31 | | `TCC_EA0_WRREQ_DRAM[n]` | Req | Number of 32-byte or 64-byte efficiency arbiter write requests to HBM | 0-31 | | `TCC_TAG_STALL[n]` | Cycles | Number of cycles the normal request pipeline in the tag is stalled for any reason | 0-31 | | `TCC_NORMAL_WRITEBACK[n]` | Req | Number of writebacks due to requests that are not writeback requests | 0-31 | | `TCC_ALL_TC_OP_WB_WRITEBACK[n]` | Req | Number of writebacks due to all `TC_OP` writeback requests | 0-31 | | `TCC_NORMAL_EVICT[n]` | Req | Number of evictions due to requests that are not invalidate or probe requests | 0-31 | | `TCC_ALL_TC_OP_INV_EVICT[n]` | Req | Number of evictions due to all `TC_OP` invalidate requests | 0-31 | **MI200 hardware counter** | Hardware counter | Unit | Definition | Value range for `n` | |-------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------| | `TCC_CYCLE[n]` | Cycles | Number of L2 cache free-running clocks | 0-31 | | `TCC_BUSY[n]` | Cycles | Number of L2 cache busy cycles | 0-31 | | `TCC_REQ[n]` | Req | Number of L2 cache requests of all types (measured at the tag block) | 0-31 | | `TCC_STREAMING_REQ[n]` | Req | Number of L2 cache streaming requests (measured at the tag block) | 0-31 | | `TCC_NC_REQ[n]` | Req | Number of non-coherently cached requests (measured at the tag block) | 0-31 | | `TCC_UC_REQ[n]` | Req | Number of uncached requests. This is measured at the tag block | 0-31 | | `TCC_CC_REQ[n]` | Req | Number of coherently cached requests. This is measured at the tag block | 0-31 | | `TCC_RW_REQ[n]` | Req | Number of coherently cached with write requests. This is measured at the tag block | 0-31 | | `TCC_PROBE[n]` | Req | Number of probe requests | 0-31 | | `TCC_PROBE_ALL[n]` | Req | Number of external probe requests with `EA_TCC_preq_all == 1` | 0-31 | | `TCC_READ[n]` | Req | Number of L2 cache read requests (includes compressed reads but not metadata reads) | 0-31 | | `TCC_WRITE[n]` | Req | Number of L2 cache write requests | 0-31 | | `TCC_ATOMIC[n]` | Req | Number of L2 cache atomic requests of all types | 0-31 | | `TCC_HIT[n]` | Req | Number of L2 cache hits | 0-31 | | `TCC_MISS[n]` | Req | Number of L2 cache misses | 0-31 | | `TCC_WRITEBACK[n]` | Req | Number of lines written back to the main memory, including writebacks of dirty lines and uncached write or atomic requests | 0-31 | | `TCC_EA_WRREQ[n]` | Req | Number of 32-byte and 64-byte transactions going over the `TC_EA_wrreq` interface (doesn’t include probe commands) | 0-31 | | `TCC_EA_WRREQ_64B[n]` | Req | Total number of 64-byte transactions (write or `CMPSWAP`) going over the `TC_EA_wrreq` interface | 0-31 | | `TCC_EA_WR_UNCACHED_32B[n]` | Req | Number of 32 write or atomic going over the `TC_EA_wrreq` interface due to uncached traffic. A 64-byte request will be counted as 2 | 0-31 | | `TCC_EA_WRREQ_STALL[n]` | Cycles | Number of cycles a write request is stalled | 0-31 | | `TCC_EA_WRREQ_IO_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of input-output (IO) credits | 0-31 | | `TCC_EA_WRREQ_GMI_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of GMI credits | 0-31 | | `TCC_EA_WRREQ_DRAM_CREDIT_STALL[n]` | Cycles | Number of cycles an efficiency arbiter write request is stalled due to the interface running out of DRAM credits | 0-31 | | `TCC_TOO_MANY_EA_WRREQS_STALL[n]` | Cycles | Number of cycles the L2 cache is unable to send an efficiency arbiter write request due to it reaching its maximum capacity of pending efficiency arbiter write requests | 0-31 | | `TCC_EA_WRREQ_LEVEL[n]` | Req | The accumulated number of efficiency arbiter write requests in flight | 0-31 | | `TCC_EA_ATOMIC[n]` | Req | Number of 32-byte or 64-byte atomic requests going over the `TC_EA_wrreq` interface | 0-31 | | `TCC_EA_ATOMIC_LEVEL[n]` | Req | The accumulated number of efficiency arbiter atomic requests in flight | 0-31 | | `TCC_EA_RDREQ[n]` | Req | Number of 32-byte or 64-byte read requests to efficiency arbiter | 0-31 | | `TCC_EA_RDREQ_32B[n]` | Req | Number of 32-byte read requests to efficiency arbiter | 0-31 | | `TCC_EA_RD_UNCACHED_32B[n]` | Req | Number of 32-byte efficiency arbiter reads due to uncached traffic. A 64-byte request is counted as 2 | 0-31 | | `TCC_EA_RDREQ_IO_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of IO credits | 0-31 | | `TCC_EA_RDREQ_GMI_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of GMI credits | 0-31 | | `TCC_EA_RDREQ_DRAM_CREDIT_STALL[n]` | Cycles | Number of cycles there is a stall due to the read request interface running out of DRAM credits | 0-31 | | `TCC_EA_RDREQ_LEVEL[n]` | Req | The accumulated number of efficiency arbiter read requests in flight | 0-31 | | `TCC_EA_RDREQ_DRAM[n]` | Req | Number of 32-byte or 64-byte efficiency arbiter read requests to High Bandwidth Memory (HBM) | 0-31 | | `TCC_EA_WRREQ_DRAM[n]` | Req | Number of 32-byte or 64-byte efficiency arbiter write requests to HBM | 0-31 | | `TCC_TAG_STALL[n]` | Cycles | Number of cycles the normal request pipeline in the tag is stalled for any reason | 0-31 | | `TCC_NORMAL_WRITEBACK[n]` | Req | Number of writebacks due to requests that are not writeback requests | 0-31 | | `TCC_ALL_TC_OP_WB_WRITEBACK[n]` | Req | Number of writebacks due to all `TC_OP` writeback requests | 0-31 | | `TCC_NORMAL_EVICT[n]` | Req | Number of evictions due to requests that are not invalidate or probe requests | 0-31 | | `TCC_ALL_TC_OP_INV_EVICT[n]` | Req | Number of evictions due to all `TC_OP` invalidate requests | 0-31 | Note the following: * `TCC_REQ[n]` may be more than the number of requests arriving at the texture cache per channel, but it’s a good indication of the total amount of work that needs to be performed. * For `TCC_EA0_WRREQ[n]`, atomics may travel over the same interface and are generally classified as write requests. * CC mtypes can produce uncached requests, and those are included in `TCC_EA0_WR_UNCACHED_32B[n]` * `TCC_EA0_WRREQ_LEVEL[n]` is primarily intended to measure average efficiency arbiter write latency. * Average write latency = `TCC_PERF_SEL_EA0_WRREQ_LEVEL` divided by `TCC_PERF_SEL_EA0_WRREQ` * `TCC_EA0_ATOMIC_LEVEL[n]` is primarily intended to measure average efficiency arbiter atomic latency * Average atomic latency = `TCC_PERF_SEL_EA0_WRREQ_ATOMIC_LEVEL` divided by `TCC_PERF_SEL_EA0_WRREQ_ATOMIC` * `TCC_EA0_RDREQ_LEVEL[n]` is primarily intended to measure average efficiency arbiter read latency. * Average read latency = `TCC_PERF_SEL_EA0_RDREQ_LEVEL` divided by `TCC_PERF_SEL_EA0_RDREQ` * Stalls can occur regardless of the need for a read to be performed * Normally, stalls are measured exactly at one point in the pipeline however in the case of `TCC_TAG_STALL[n]`, probes can stall the pipeline at a variety of places. There is no single point that can accurately measure the total stalls ## MI300 and MI200 Series derived metrics list | Hardware counter | Definition | |--------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `ALUStalledByLDS` | Percentage of GPU time ALU units are stalled due to the LDS input queue being full or the output queue not being ready (value range: 0% (optimal) to 100%) | | `FetchSize` | Total kilobytes fetched from the video memory; measured with all extra fetches and any cache or memory effects taken into account | | `FlatLDSInsts` | Average number of flat instructions that read from or write to LDS, run per work item (affected by flow control) | | `FlatVMemInsts` | Average number of flat instructions that read from or write to the video memory, run per work item (affected by flow control). Includes flat instructions that read from or write to scratch | | `GDSInsts` | Average number of global data share read or write instructions run per work item (affected by flow control) | | `GPUBusy` | Percentage of time GPU is busy | | `L2CacheHit` | Percentage of fetch, write, atomic, and other instructions that hit the data in L2 cache (value range: 0% (no hit) to 100% (optimal)) | | `LDSBankConflict` | Percentage of GPU time LDS is stalled by bank conflicts (value range: 0% (optimal) to 100%) | | `LDSInsts` | Average number of LDS read or write instructions run per work item (affected by flow control). Excludes flat instructions that read from or write to LDS. | | `MemUnitBusy` | Percentage of GPU time the memory unit is active, which is measured with all extra fetches and writes and any cache or memory effects taken into account (value range: 0% to 100% (fetch-bound)) | | `MemUnitStalled` | Percentage of GPU time the memory unit is stalled (value range: 0% (optimal) to 100%) | | `MemWrites32B` | Total number of effective 32B write transactions to the memory | | `TCA_BUSY_sum` | Total number of cycles texture cache arbiter has a pending request, over all texture cache arbiter instances | | `TCA_CYCLE_sum` | Total number of cycles over all texture cache arbiter instances | | `SALUBusy` | Percentage of GPU time scalar ALU instructions are processed (value range: 0% to 100% (optimal)) | | `SALUInsts` | Average number of scalar ALU instructions run per work item (affected by flow control) | | `SFetchInsts` | Average number of scalar fetch instructions from the video memory run per work item (affected by flow control) | | `VALUBusy` | Percentage of GPU time vector ALU instructions are processed (value range: 0% to 100% (optimal)) | | `VALUInsts` | Average number of vector ALU instructions run per work item (affected by flow control) | | `VALUUtilization` | Percentage of active vector ALU threads in a wave, where a lower number can mean either more thread divergence in a wave or that the work-group size is not a multiple of 64 (value range: 0%, 100% (optimal - no thread divergence)) | | `VFetchInsts` | Average number of vector fetch instructions from the video memory run per work-item (affected by flow control); excludes flat instructions that fetch from video memory | | `VWriteInsts` | Average number of vector write instructions to the video memory run per work-item (affected by flow control); excludes flat instructions that write to video memory | | `Wavefronts` | Total wavefronts | | `WRITE_REQ_32B` | Total number of 32-byte effective memory writes | | `WriteSize` | Total kilobytes written to the video memory; measured with all extra fetches and any cache or memory effects taken into account | | `WriteUnitStalled` | Percentage of GPU time the write unit is stalled (value range: 0% (optimal) to 100%) | You can lower `ALUStalledByLDS` by reducing LDS bank conflicts or number of LDS accesses. You can lower `MemUnitStalled` by reducing the number or size of fetches and writes. `MemUnitBusy` includes the stall time (`MemUnitStalled`). ### Hardware counters by and over all texture addressing unit instances The following table shows the hardware counters *by* all texture addressing unit instances. | Hardware counter | Definition | |----------------------------------------|----------------------------------------------------------------------------------| | `TA_BUFFER_WAVEFRONTS_sum` | Total number of buffer wavefronts processed | | `TA_BUFFER_READ_WAVEFRONTS_sum` | Total number of buffer read wavefronts processed | | `TA_BUFFER_WRITE_WAVEFRONTS_sum` | Total number of buffer write wavefronts processed | | `TA_BUFFER_ATOMIC_WAVEFRONTS_sum` | Total number of buffer atomic wavefronts processed | | `TA_BUFFER_TOTAL_CYCLES_sum` | Total number of buffer cycles (including read and write) issued to texture cache | | `TA_BUFFER_COALESCED_READ_CYCLES_sum` | Total number of coalesced buffer read cycles issued to texture cache | | `TA_BUFFER_COALESCED_WRITE_CYCLES_sum` | Total number of coalesced buffer write cycles issued to texture cache | | `TA_FLAT_READ_WAVEFRONTS_sum` | Sum of flat opcode reads processed | | `TA_FLAT_WRITE_WAVEFRONTS_sum` | Sum of flat opcode writes processed | | `TA_FLAT_WAVEFRONTS_sum` | Total number of flat opcode wavefronts processed | | `TA_FLAT_ATOMIC_WAVEFRONTS_sum` | Total number of flat opcode atomic wavefronts processed | | `TA_TOTAL_WAVEFRONTS_sum` | Total number of wavefronts processed | The following table shows the hardware counters *over* all texture addressing unit instances. | Hardware counter | Definition | |------------------------------------|---------------------------------------------------------------------------------------------| | `TA_ADDR_STALLED_BY_TC_CYCLES_sum` | Total number of cycles texture addressing unit address path is stalled by texture cache | | `TA_ADDR_STALLED_BY_TD_CYCLES_sum` | Total number of cycles texture addressing unit address path is stalled by texture data unit | | `TA_BUSY_avr` | Average number of busy cycles | | `TA_BUSY_max` | Maximum number of texture addressing unit busy cycles | | `TA_BUSY_min` | Minimum number of texture addressing unit busy cycles | | `TA_DATA_STALLED_BY_TC_CYCLES_sum` | Total number of cycles texture addressing unit data path is stalled by texture cache | | `TA_TA_BUSY_sum` | Total number of texture addressing unit busy cycles | ### Hardware counters over all texture cache per channel instances | Hardware counter | Definition | |---------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `TCC_ALL_TC_OP_WB_WRITEBACK_sum` | Total number of writebacks due to all `TC_OP` writeback requests. | | `TCC_ALL_TC_OP_INV_EVICT_sum` | Total number of evictions due to all `TC_OP` invalidate requests. | | `TCC_ATOMIC_sum` | Total number of L2 cache atomic requests of all types. | | `TCC_BUSY_avr` | Average number of L2 cache busy cycles. | | `TCC_BUSY_sum` | Total number of L2 cache busy cycles. | | `TCC_CC_REQ_sum` | Total number of coherently cached requests. | | `TCC_CYCLE_sum` | Total number of L2 cache free running clocks. | | `TCC_EA0_WRREQ_sum` | Total number of 32-byte and 64-byte transactions going over the `TC_EA0_wrreq` interface. Atomics may travel over the same interface and are generally classified as write requests. This does not include probe commands. | | `TCC_EA0_WRREQ_64B_sum` | Total number of 64-byte transactions (write or CMPSWAP) going over the `TC_EA0_wrreq` interface. | | `TCC_EA0_WR_UNCACHED_32B_sum` | Total Number of 32-byte write or atomic going over the `TC_EA0_wrreq` interface due to uncached traffic. Note that coherently cached mtypes can produce uncached requests, and those are included in this. A 64-byte request is counted as 2. | | `TCC_EA0_WRREQ_STALL_sum` | Total Number of cycles a write request is stalled, over all instances. | | `TCC_EA0_WRREQ_IO_CREDIT_STALL_sum` | Total number of cycles an efficiency arbiter write request is stalled due to the interface running out of IO credits, over all instances. | | `TCC_EA0_WRREQ_GMI_CREDIT_STALL_sum` | Total number of cycles an efficiency arbiter write request is stalled due to the interface running out of GMI credits, over all instances. | | `TCC_EA0_WRREQ_DRAM_CREDIT_STALL_sum` | Total number of cycles an efficiency arbiter write request is stalled due to the interface running out of DRAM credits, over all instances. | | `TCC_EA0_WRREQ_LEVEL_sum` | Total number of efficiency arbiter write requests in flight. | | `TCC_EA0_RDREQ_LEVEL_sum` | Total number of efficiency arbiter read requests in flight. | | `TCC_EA0_ATOMIC_sum` | Total Number of 32-byte or 64-byte atomic requests going over the `TC_EA0_wrreq` interface. | | `TCC_EA0_ATOMIC_LEVEL_sum` | Total number of efficiency arbiter atomic requests in flight. | | `TCC_EA0_RDREQ_sum` | Total number of 32-byte or 64-byte read requests to efficiency arbiter. | | `TCC_EA0_RDREQ_32B_sum` | Total number of 32-byte read requests to efficiency arbiter. | | `TCC_EA0_RD_UNCACHED_32B_sum` | Total number of 32-byte efficiency arbiter reads due to uncached traffic. | | `TCC_EA0_RDREQ_IO_CREDIT_STALL_sum` | Total number of cycles there is a stall due to the read request interface running out of IO credits. | | `TCC_EA0_RDREQ_GMI_CREDIT_STALL_sum` | Total number of cycles there is a stall due to the read request interface running out of GMI credits. | | `TCC_EA0_RDREQ_DRAM_CREDIT_STALL_sum` | Total number of cycles there is a stall due to the read request interface running out of DRAM credits. | | `TCC_EA0_RDREQ_DRAM_sum` | Total number of 32-byte or 64-byte efficiency arbiter read requests to HBM. | | `TCC_EA0_WRREQ_DRAM_sum` | Total number of 32-byte or 64-byte efficiency arbiter write requests to HBM. | | `TCC_HIT_sum` | Total number of L2 cache hits. | | `TCC_MISS_sum` | Total number of L2 cache misses. | | `TCC_NC_REQ_sum` | Total number of non-coherently cached requests. | | `TCC_NORMAL_WRITEBACK_sum` | Total number of writebacks due to requests that are not writeback requests. | | `TCC_NORMAL_EVICT_sum` | Total number of evictions due to requests that are not invalidate or probe requests. | | `TCC_PROBE_sum` | Total number of probe requests. | | `TCC_PROBE_ALL_sum` | Total number of external probe requests with `EA0_TCC_preq_all == 1`. | | `TCC_READ_sum` | Total number of L2 cache read requests (including compressed reads but not metadata reads). | | `TCC_REQ_sum` | Total number of all types of L2 cache requests. | | `TCC_RW_REQ_sum` | Total number of coherently cached with write requests. | | `TCC_STREAMING_REQ_sum` | Total number of L2 cache streaming requests. | | `TCC_TAG_STALL_sum` | Total number of cycles the normal request pipeline in the tag is stalled for any reason. | | `TCC_TOO_MANY_EA0_WRREQS_STALL_sum` | Total number of cycles L2 cache is unable to send an efficiency arbiter write request due to it reaching its maximum capacity of pending efficiency arbiter write requests. | | `TCC_UC_REQ_sum` | Total number of uncached requests. | | `TCC_WRITE_sum` | Total number of L2 cache write requests. | | `TCC_WRITEBACK_sum` | Total number of lines written back to the main memory including writebacks of dirty lines and uncached write or atomic requests. | | `TCC_WRREQ_STALL_max` | Maximum number of cycles a write request is stalled. | ### Hardware counters by, for, or over all texture cache per pipe instances The following table shows the hardware counters *by* all texture cache per pipe instances. | Hardware counter | Definition | |----------------------------------|--------------------------------------------------------------------------------| | `TCP_TA_TCP_STATE_READ_sum` | Total number of state reads by ATCPPI | | `TCP_TOTAL_CACHE_ACCESSES_sum` | Total number of vector L1d accesses (including hits and misses) | | `TCP_UTCL1_PERMISSION_MISS_sum` | Total number of unified translation cache (L1) permission misses | | `TCP_UTCL1_REQUEST_sum` | Total number of address translation requests to unified translation cache (L1) | | `TCP_UTCL1_TRANSLATION_MISS_sum` | Total number of unified translation cache (L1) translation misses | | `TCP_UTCL1_TRANSLATION_HIT_sum` | Total number of unified translation cache (L1) translation hits | The following table shows the hardware counters *for* all texture cache per pipe instances. | Hardware counter | Definition | |---------------------------------|--------------------------------------------------------------------------------------------------| | `TCP_TCC_READ_REQ_LATENCY_sum` | Total vector L1d to L2 request latency over all wavefronts for reads and atomics with return | | `TCP_TCC_WRITE_REQ_LATENCY_sum` | Total vector L1d to L2 request latency over all wavefronts for writes and atomics without return | | `TCP_TCP_LATENCY_sum` | Total wave access latency to vector L1d over all wavefronts | The following table shows the hardware counters *over* all texture cache per pipe instances. | Hardware counter | Definition | |-------------------------------------------|--------------------------------------------------------------------------------------| | `TCP_ATOMIC_TAGCONFLICT_STALL_CYCLES_sum` | Total number of cycles tag RAM conflict stalls on an atomic | | `TCP_GATE_EN1_sum` | Total number of cycles vector L1d interface clocks are turned on | | `TCP_GATE_EN2_sum` | Total number of cycles vector L1d core clocks are turned on | | `TCP_PENDING_STALL_CYCLES_sum` | Total number of cycles vector L1d cache is stalled due to data pending from L2 Cache | | `TCP_READ_TAGCONFLICT_STALL_CYCLES_sum` | Total number of cycles tag RAM conflict stalls on a read | | `TCP_TCC_ATOMIC_WITH_RET_REQ_sum` | Total number of atomic requests to L2 cache with return | | `TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum` | Total number of atomic requests to L2 cache without return | | `TCP_TCC_CC_READ_REQ_sum` | Total number of coherently cached read requests to L2 cache | | `TCP_TCC_CC_WRITE_REQ_sum` | Total number of coherently cached write requests to L2 cache | | `TCP_TCC_CC_ATOMIC_REQ_sum` | Total number of coherently cached atomic requests to L2 cache | | `TCP_TCC_NC_READ_REQ_sum` | Total number of non-coherently cached read requests to L2 cache | | `TCP_TCC_NC_WRITE_REQ_sum` | Total number of non-coherently cached write requests to L2 cache | | `TCP_TCC_NC_ATOMIC_REQ_sum` | Total number of non-coherently cached atomic requests to L2 cache | | `TCP_TCC_READ_REQ_sum` | Total number of read requests to L2 cache | | `TCP_TCC_RW_READ_REQ_sum` | Total number of coherently cached with write read requests to L2 cache | | `TCP_TCC_RW_WRITE_REQ_sum` | Total number of coherently cached with write write requests to L2 cache | | `TCP_TCC_RW_ATOMIC_REQ_sum` | Total number of coherently cached with write atomic requests to L2 cache | | `TCP_TCC_UC_READ_REQ_sum` | Total number of uncached read requests to L2 cache | | `TCP_TCC_UC_WRITE_REQ_sum` | Total number of uncached write requests to L2 cache | | `TCP_TCC_UC_ATOMIC_REQ_sum` | Total number of uncached atomic requests to L2 cache | | `TCP_TCC_WRITE_REQ_sum` | Total number of write requests to L2 cache | | `TCP_TCR_TCP_STALL_CYCLES_sum` | Total number of cycles texture cache router stalls vector L1d | | `TCP_TD_TCP_STALL_CYCLES_sum` | Total number of cycles texture data unit stalls vector L1d | | `TCP_TOTAL_ACCESSES_sum` | Total number of vector L1d accesses | | `TCP_TOTAL_READ_sum` | Total number of vector L1d read accesses | | `TCP_TOTAL_WRITE_sum` | Total number of vector L1d write accesses | | `TCP_TOTAL_ATOMIC_WITH_RET_sum` | Total number of vector L1d atomic requests with return | | `TCP_TOTAL_ATOMIC_WITHOUT_RET_sum` | Total number of vector L1d atomic requests without return | | `TCP_TOTAL_WRITEBACK_INVALIDATES_sum` | Total number of vector L1d writebacks and invalidates | | `TCP_VOLATILE_sum` | Total number of L1 volatile pixels or buffers from texture addressing unit | | `TCP_WRITE_TAGCONFLICT_STALL_CYCLES_sum` | Total number of cycles tag RAM conflict stalls on a write | ### Hardware counter over all texture data unit instances | Hardware counter | Definition | |--------------------------------|------------------------------------------------------------------------------------------| | `TD_ATOMIC_WAVEFRONT_sum` | Total number of atomic wavefront instructions | | `TD_COALESCABLE_WAVEFRONT_sum` | Total number of coalescable wavefronts according to texture addressing unit | | `TD_LOAD_WAVEFRONT_sum` | Total number of wavefront instructions (read, write, atomic) | | `TD_SPI_STALL_sum` | Total number of cycles texture data unit is stalled by shader processor input | | `TD_STORE_WAVEFRONT_sum` | Total number of write wavefront instructions | | `TD_TC_STALL_sum` | Total number of cycles texture data unit is stalled waiting for texture cache data | | `TD_TD_BUSY_sum` | Total number of texture data unit busy cycles while it is processing or waiting for data | --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi250.html # AMD Instinct™ MI250 microarchitecture The microarchitecture of the AMD Instinct MI250 GPU is based on the AMD CDNA 2 architecture that targets compute applications such as HPC, artificial intelligence (AI), and machine learning (ML) and that run on everything from individual servers to the world’s largest exascale supercomputers. The overall system architecture is designed for extreme scalability and compute performance. The following image shows the components of a single Graphics Compute Die (GCD) of the CDNA 2 architecture. On the top and the bottom are AMD Infinity Fabric™ interfaces and their physical links that are used to connect the GPU die to the other system-level components of the node (see also Section 2.2). Both interfaces can drive four AMD Infinity Fabric links. One of the AMD Infinity Fabric links of the controller at the bottom can be configured as a PCIe link. Each of the AMD Infinity Fabric links between GPUs can run at up to 25 GT/sec, which correlates to a peak transfer bandwidth of 50 GB/sec for a 16-wide link ( two bytes per transaction). Section 2.2 has more details on the number of AMD Infinity Fabric links and the resulting transfer rates between the system-level components. To the left and the right are memory controllers that attach the High Bandwidth Memory (HBM) modules to the GCD. AMD Instinct MI250 GPUs use HBM2e, which offers a peak memory bandwidth of 1.6 TB/sec per GCD. The execution units of the GPU are depicted in the following image as Compute Units (CU). The MI250 GCD has 104 active CUs. Each compute unit is further subdivided into four SIMD units that process SIMD instructions of 16 data elements per instruction (for the FP64 data type). This enables the CU to process 64 work items (a so-called “wavefront”) at a peak clock frequency of 1.7 GHz. Therefore, the theoretical maximum FP64 peak performance per GCD is 22.6 TFLOPS for vector instructions. This equates to 45.3 TFLOPS for vector instructions for both GCDs together. The MI250 compute units also provide specialized execution units (also called matrix cores), which are geared toward executing matrix operations like matrix-matrix multiplications. For FP64, the peak performance of these units amounts to 90.5 TFLOPS. ![Structure of a single GCD in the AMD Instinct MI250 GPU.](reference/gpu-arch/images/image001.png) #### Peak-performance capabilities of the MI250 OAM for different data types. | Computation and Data Type | FLOPS/CLOCK/CU | Peak TFLOPS | |-----------------------------|------------------|---------------| | Matrix FP64 | 256 | 90.5 | | Vector FP64 | 128 | 45.3 | | Matrix FP32 | 256 | 90.5 | | Packed FP32 | 256 | 90.5 | | Vector FP32 | 128 | 45.3 | | Matrix FP16 | 1024 | 362.1 | | Matrix BF16 | 1024 | 362.1 | | Matrix INT8 | 1024 | 362.1 | The above table summarizes the aggregated peak performance of the AMD Instinct MI250 Open Compute Platform (OCP) Open Accelerator Modules (OAMs) and its two GCDs for different data types and execution units. The middle column lists the peak performance (number of data elements processed in a single instruction) of a single compute unit if a SIMD (or matrix) instruction is being retired in each clock cycle. The third column lists the theoretical peak performance of the OAM module. The theoretical aggregated peak memory bandwidth of the GPU is 3.2 TB/sec (1.6 TB/sec per GCD). ![Dual-GCD architecture of the AMD Instinct MI250 GPUs](reference/gpu-arch/images/image002.png) The following image shows the block diagram of an OAM package that consists of two GCDs, each of which constitutes one GPU device in the system. The two GCDs in the package are connected via four AMD Infinity Fabric links running at a theoretical peak rate of 25 GT/sec, giving 200 GB/sec peak transfer bandwidth between the two GCDs of an OAM, or a bidirectional peak transfer bandwidth of 400 GB/sec for the same. ## Node-level architecture The following image shows the node-level architecture of a system that is based on the AMD Instinct MI250 GPU. The MI250 OAMs attach to the host system via PCIe Gen 4 x16 links (yellow lines). Each GCD maintains its own PCIe x16 link to the host part of the system. Depending on the server platform, the GCD can attach to the AMD EPYC processor directly or via an optional PCIe switch . Note that some platforms may offer an x8 interface to the GCDs, which reduces the available host-to-GPU bandwidth. ![Block diagram of AMD Instinct MI250 GPUs with 3rd Generation AMD EPYC processor](reference/gpu-arch/images/image003.png) The preceding image shows the node-level architecture of a system with AMD EPYC processors in a dual-socket configuration and four AMD Instinct MI250 GPUs. The MI250 OAMs attach to the host processors system via PCIe Gen 4 x16 links (yellow lines). Depending on the system design, a PCIe switch may exist to make more PCIe lanes available for additional components like network interfaces and/or storage devices. Each GCD maintains its own PCIe x16 link to the host part of the system or to the PCIe switch. Please note, some platforms may offer an x8 interface to the GCDs, which will reduce the available host-to-GPU bandwidth. Between the OAMs and their respective GCDs, a peer-to-peer (P2P) network allows for direct data exchange between the GPU dies via AMD Infinity Fabric links ( black, green, and red lines). Each of these 16-wide links connects to one of the two GPU dies in the MI250 OAM and operates at 25 GT/sec, which corresponds to a theoretical peak transfer rate of 50 GB/sec per link (or 100 GB/sec bidirectional peak transfer bandwidth). The GCD pairs 2 and 6 as well as GCDs 0 and 4 connect via two XGMI links, which is indicated by the thicker red line in the preceding image. --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/mi100.html # AMD Instinct™ MI100 microarchitecture The following image shows the node-level architecture of a system that comprises two AMD EPYC™ processors and (up to) eight AMD Instinct™ GPUs. The two EPYC processors are connected to each other with the AMD Infinity™ fabric which provides a high-bandwidth (up to 18 GT/sec) and coherent links such that each processor can access the available node memory as a single shared-memory domain in a non-uniform memory architecture (NUMA) fashion. In a 2P, or dual-socket, configuration, three AMD Infinity™ fabric links are available to connect the processors plus one PCIe Gen 4 x16 link per processor can attach additional I/O devices such as the host adapters for the network fabric. ![Structure of a single GCD in the AMD Instinct MI100 GPU](reference/gpu-arch/images/image004.png) In a typical node configuration, each processor can host up to four AMD Instinct™ GPUs that are attached using PCIe Gen 4 links at 16 GT/sec, which corresponds to a peak bidirectional link bandwidth of 32 GB/sec. Each hive of four GPUs can participate in a fully connected, coherent AMD Instinct™ fabric that connects the four GPUs using 23 GT/sec AMD Infinity fabric links that run at a higher frequency than the inter-processor links. This inter-GPU link can be established in certified server systems if the GPUs are mounted in neighboring PCIe slots by installing the AMD Infinity Fabric™ bridge for the AMD Instinct™ GPUs. ## Microarchitecture The microarchitecture of the AMD Instinct GPUs is based on the AMD CDNA architecture, which targets compute applications such as high-performance computing (HPC) and AI & machine learning (ML) that run on everything from individual servers to the world’s largest exascale supercomputers. The overall system architecture is designed for extreme scalability and compute performance. ![Structure of the AMD Instinct GPU (MI100 generation)](reference/gpu-arch/images/image005.png) The above image shows the AMD Instinct GPU with its PCIe Gen 4 x16 link (16 GT/sec, at the bottom) that connects the GPU to (one of) the host processor(s). It also shows the three AMD Infinity Fabric ports that provide high-speed links (23 GT/sec, also at the bottom) to the other GPUs of the local hive. On the left and right of the floor plan, the High Bandwidth Memory (HBM) attaches via the GPU memory controller. The MI100 generation of the AMD Instinct GPU offers four stacks of HBM generation 2 (HBM2) for a total of 32GB with a 4,096bit-wide memory interface. The peak memory bandwidth of the attached HBM2 is 1.228 TB/sec at a memory clock frequency of 1.2 GHz. The execution units of the GPU are depicted in the above image as Compute Units (CU). There are a total 120 compute units that are physically organized into eight Shader Engines (SE) with fifteen compute units per shader engine. Each compute unit is further sub-divided into four SIMD units that process SIMD instructions of 16 data elements per instruction. This enables the CU to process 64 data elements (a so-called ‘wavefront’) at a peak clock frequency of 1.5 GHz. Therefore, the theoretical maximum FP64 peak performance is 11.5 TFLOPS (`4 [SIMD units] x 16 [elements per instruction] x 120 [CU] x 1.5 [GHz]`). ![Block diagram of an MI100 compute unit with detailed SIMD view of the AMD CDNA architecture](reference/gpu-arch/images/image006.png) The preceding image shows the block diagram of a single CU of an AMD Instinct™ MI100 GPU and summarizes how instructions flow through the execution engines. The CU fetches the instructions via a 32KB instruction cache and moves them forward to execution via a dispatcher. The CU can handle up to ten wavefronts at a time and feed their instructions into the execution unit. The execution unit contains 256 vector general-purpose registers (VGPR) and 800 scalar general-purpose registers (SGPR). The VGPR and SGPR are dynamically allocated to the executing wavefronts. A wavefront can access a maximum of 102 scalar registers. Excess scalar-register usage will cause register spilling and thus may affect execution performance. A wavefront can occupy any number of VGPRs from 0 to 256, directly affecting occupancy; that is, the number of concurrently active wavefronts in the CU. For instance, with 119 VGPRs used, only two wavefronts can be active in the CU at the same time. With the instruction latency of four cycles per SIMD instruction, the occupancy should be as high as possible such that the compute unit can improve execution efficiency by scheduling instructions from multiple wavefronts. #### Peak-performance capabilities of MI100 for different data types. | Computation and Data Type | FLOPS/CLOCK/CU | Peak TFLOPS | |-----------------------------|------------------|---------------| | Vector FP64 | 64 | 11.5 | | Matrix FP32 | 256 | 46.1 | | Vector FP32 | 128 | 23.1 | | Matrix FP16 | 1024 | 184.6 | | Matrix BF16 | 512 | 92.3 | --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/rdna.html # AMD RDNA architecture The AMD RDNA™ architecture powers AMD Radeon™ and Ryzen™ GPUs. Detailed microarchitecture documentation for RDNA is coming soon. In the meantime, refer to the instruction set architecture (ISA) references for each RDNA generation. ## ISA references * [AMD RDNA 4 ISA reference](https://gpuopen.com/download/rdna4-instruction-set-architecture.pdf) * [AMD RDNA 3.5 ISA reference](https://gpuopen.com/download/rdna35_instruction_set_architecture.pdf) * [AMD RDNA 3 ISA reference](https://gpuopen.com/download/rdna3-shader-instruction-set-architecture-feb-2023.pdf) * [AMD RDNA 2 ISA reference](https://gpuopen.com/download/rdna2-shader-instruction-set-architecture.pdf) * [AMD RDNA ISA reference](https://gpuopen.com/download/RDNA_Shader_ISA_25September2020.pdf) --- Source: https://rocm.docs.amd.com/en/latest/reference/gpu-arch/gcn-vega.html # AMD GCN and Vega architectures This page collects instruction set architecture (ISA) references for the AMD GCN and Vega GPU architectures. Detailed microarchitecture documentation for these architectures is coming soon. ## ISA references * [AMD Vega 7nm (Instinct MI50) ISA reference](https://www.amd.com/system/files/TechDocs/vega-7nm-shader-instruction-set-architecture.pdf) * [AMD Vega (Instinct MI25) ISA reference](https://www.amd.com/system/files/TechDocs/vega-shader-instruction-set-architecture.pdf) * [AMD GCN 3 ISA reference](https://www.amd.com/system/files/TechDocs/gcn3-instruction-set-architecture.pdf) --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/index.html # AMD GPU system optimization This guide outlines system setup and tuning suggestions for AMD hardware to optimize performance for specific types of workloads or use cases. The contents are structured according to the hardware: * [AMD Instinct MI355X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi355x.html) * [AMD Instinct MI350X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi350x.html) * [AMD Instinct MI325X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi325x.html) * [AMD Instinct MI300X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi300x.html) * [AMD Instinct MI300A](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi300a.html) * [AMD Instinct MI250 / MI250X](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi250.html) * [AMD Instinct MI210](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi210.html) * [AMD Instinct MI100](https://instinct.docs.amd.com/projects/system-acceptance/en/latest/gpus/mi100.html) * [AMD RDNA3.5 system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna3-5.html) * [AMD RDNA2 system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna2.html) * [GPU isolation techniques](https://rocm.docs.amd.com/en/latest/reference/system-optimization/gpu-isolation.html) * [BAR access limits](https://rocm.docs.amd.com/en/latest/reference/system-optimization/bar-access-limits.html) --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/cdna.html # AMD Instinct system optimization --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna.html # AMD Radeon and Ryzen system optimization This topic outlines system setup and tuning suggestions for AMD Radeon and Ryzen hardware to optimize performance for specific workloads or use cases. * [AMD RDNA3.5 system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna3-5.html) * [AMD RDNA2 system optimization](https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna2.html) --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna3-5.html # AMD RDNA3.5 system optimization This topic describes how to optimize systems powered by AMD Ryzen APUs with RDNA3.5 architecture. These APUs combine high-performance CPU cores with integrated RDNA3.5 graphics, and support LPDDR5X-8000 or DDR5 memory, making them particularly well-suited for: * LLM development and inference systems * High-performance workstations * Virtualization hosts running multiple VMs * GPU compute and parallel processing * Gaming systems * Home servers and AI development platforms ## Memory settings AMD Ryzen APUs with RDNA3.5 architecture (gfx1150, gfx1151, and gfx1152 LLVM targets) handle memory access through GPU Virtual Memory (GPUVM), which provides per-process GPU virtual address spaces (VMIDs) rather than a separate, discrete VRAM pool. As a result, memory on RDNA3.5 APUs is mapped rather than physically partitioned. The terms Graphics Address Remapping Table (GART) and Graphics Translation Table (GTT) describe limits on how much system memory can be mapped into GPU address spaces and who can use it, rather than distinct types of physical memory. * **GART** Defines the amount of platform address space (system RAM or Memory-Mapped I/O) that can be mapped into the GPU virtual address space used by the kernel driver. On systems with physically shared CPU and GPU memory, such as RDNA3.5-based systems, this mapped system memory effectively serves as VRAM for the GPU. GART is typically kept relatively small to limit GPU page-table size and is primarily used for driver-internal operations. * **GTT** Defines the amount of system RAM that can be mapped into GPU virtual address spaces for user processes. This is the memory pool used by applications such as PyTorch and other AI/compute workloads. GTT allocations are dynamic and not permanently reserved, allowing the operating system to reclaim memory when the GPU isn’t actively using it. By default, the GTT limit is set to approximately 50 percent of total system RAM. #### NOTE On systems with physically shared CPU and GPU memory, such as RDNA3.5-based systems, several terms are often used interchangeably in firmware menus, documentation, and community discussions: * VRAM * Carve-out * GART * Dedicated GPU memory * Firmware-reserved GPU memory In this topic, VRAM will be used going forward. You can adjust the amount of memory available to the GPU by: * Increasing the VRAM in BIOS, or * Reducing the configured GTT size to be smaller than the reserved amount. If the GTT size is larger than the VRAM, the AMD GPU driver performs VRAM allocations using GTT (GTT-backed allocations), as described in the [torvalds/linux@759e764](https://github.com/torvalds/linux/commit/759e764f7d587283b4e0b01ff930faca64370e59) GitHub commit. Because memory is physically shared, there’s no performance distinction like that of discrete GPUs, where dedicated VRAM is significantly faster than system memory. Firmware may optionally reserve some memory exclusively for GPU use, but this provides little benefit for most workloads while permanently reducing available system memory. For this reason, AI frameworks work more efficiently with GTT-backed allocations. GTT allows large, flexible mappings without permanently reserving memory, resulting in better overall system utilization on unified memory systems. ### Configuring shared memory limits on Linux The maximum amount of shared GPU-accessible memory can be increased by changing the kernel **Translation Table Manager (TTM)** page limit. This setting controls how many system memory pages can be mapped for GPU use and is exposed at: ```default /sys/module/ttm/parameters/pages_limit ``` The value is expressed in pages, and not bytes or gigabytes (GB). #### NOTE It’s recommended to keep the dedicated VRAM reservation in BIOS small (for example, 0.5 GB) and increase the shared (TTM/GTT) limit instead. A helper utility is available to simplify configuration. 1. Install `pipx`: ```default sudo apt install pipx pipx ensurepath ``` 2. Install the AMD debug tools: ```default pipx install amd-debug-tools ``` 3. Query the current shared memory configuration: ```default amd-ttm ``` 4. Set the usable shared memory (in GB): ```default amd-ttm --set ``` 5. Reboot for changes to take effect. #### NOTE The amd-ttm command converts the pages to GB to help the users. #### Example with output Check the current settings: ```default amd-ttm 💻 Current TTM pages limit: 16469033 pages (62.82 GB) 💻 Total system memory: 125.65 GB ``` Change the usable shared memory: ```default ❯ amd-ttm --set 100 🐧 Successfully set TTM pages limit to 26214400 pages (100.00 GB) 🐧 Configuration written to /etc/modprobe.d/ttm.conf ○ NOTE: You need to reboot for changes to take effect. Would you like to reboot the system now? (y/n): y ``` Revert to kernel defaults: ```default ❯ amd-ttm --clear 🐧 Configuration /etc/modprobe.d/ttm.conf removed Would you like to reboot the system now? (y/n): y ``` ## Operating system support The ROCm operating system requirements are available in [Operating system support](https://rocm.docs.amd.com/en/latest/about/release-notes.html#release-supported-os). AMD Ryzen AI Max series APUs (gfx1151) have additional kernel version requirements, as described in the following section. ### Required Linux kernel version Support for AMD Ryzen AI Max series APUs requires specific Linux kernel fixes that update internal limits in the AMD KFD driver to ensure correct queue creation and memory availability checks. Without these updates, GPU compute workloads might fail to initialize or exhibit unpredictable behavior. The following commits are required for AMD Ryzen AI Max series support: - [gregkh/linux@7f26af7](https://github.com/gregkh/linux/commit/7f26af7bf9b76c2c2a1a761aab5803e52be21eea) - [gregkh/linux@7445db6](https://github.com/gregkh/linux/commit/7445db6a7d5a0242d8214582b480600b266cba9e) These patches are available in the following minimum kernel versions: - Ubuntu 24.04 Hardware Enablement (HWE): `6.17.0-19.19~24.04.2` or later - Ubuntu 24.04 Original Equipment Manufacturer (OEM): `6.14.0-1018` or later - All other distributions: Linux kernel `6.18.4` or later The table below reflects compatibility for AMD-released pre-built ROCm binaries only. Distributions that ship native ROCm packaging might provide different support levels. | ❌ | Unsupported combination | |------|-----------------------------------| | ⚠️ | Unstable/experimental combination | | ✅ | Stable and supported combination | | ROCm Release | Ubuntu 24.04 HWE (>= 6.17.0-19.19~24.04.2),


Ubuntu 24.04 OEM (>= 6.14.0-1018) or


Ubuntu 26.04 Generic

| Other distributions >= 6.18.4 | Other distributions < 6.18.4 | |------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------|--------------------------------| | 10.0.0 or 10.1.0 | ✅ | ✅ | ⚠️ | | 7.14.0 or 7.14.1 | ✅ | ✅ | ⚠️ | | 7.2.1, 7.2.2, 7.2.3 or 7.2.4 | ✅ | ✅ | ⚠️ | | 7.2.0 | ✅ | ✅ | ❌ | | 7.1.x | ❌ | ❌ | ⚠️ | | 6.4.x | ❌ | ❌ | ⚠️ | #### NOTE Ubuntu 24.04 HWE kernels earlier than `6.17.0-19.19~24.04.2` and Ubuntu 24.04 OEM kernels earlier than `6.14.0-1018` are not supported for RDNA3.5 APUs. The following distributions include the required fixes in their native packaging, independent of AMD pre-built binaries: - Fedora 43 - Ubuntu 26.04 - Arch Linux 2026.02.01 --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/rdna2.html # AMD RDNA2 system optimization The topic covers specific software requirements and processes needed to use these GPUs for Single Root I/O Virtualization (SR-IOV) and machine learning tasks. The main purpose of this document is to help users utilize the RDNA™ 2 GPUs to their full potential. ## Workstation workloads Workstation workloads, much like those for HPC, have a unique set of requirements: a blend of both graphics and compute, certification, stability, and more. For more information about RDNA2, see the [RDNA 2 Instruction Set Architecture: Reference Guide](https://docs.amd.com/v/u/en-US/rdna2-shader-instruction-set-architecture). ## System settings This section discusses system settings used to configure the system for ROCm virtualization on RDNA2-based AMD Radeon™ PRO GPUs. Installing ROCm on Bare Metal follows the routine [ROCm installation procedure](https://rocm.docs.amd.com/en/latest/install/rocm.html). To enable ROCm virtualization on V620, set up Single Root I/O Virtualization (SR-IOV) in the BIOS via settings found in [System BIOS settings](#bios-settings). A tested configuration can be followed in [Operating system settings](#os-settings). #### ATTENTION SR-IOV is supported on V620 and unsupported on W6800. ### System BIOS settings | Advanced / North Bridge Configuration | IOMMU | Enabled | Input-output Memory Management Unit | |-----------------------------------------|-----------------|-----------|---------------------------------------| | Advanced / North Bridge Configuration | ACS Enable | Enabled | Access Control Service | | Advanced / PCIe/PCI/PnP Configuration | SR-IOV Support | Enabled | Single Root I/O Virtualization | | Advanced / ACPI settings | PCI AER Support | Enabled | Advanced Error Reporting | To set up the host, update SBIOS to version 1.2a. ### Operating system settings | Server | [SMC 4124](https://www.supermicro.com/en/Aplus/system/4U/4124/AS-4124GS-TNR.cfm) [AS -4124GS-TNR] | |--------------|-----------------------------------------------------------------------------------------------------| | Host OS | Ubuntu 20.04.3 LTS | | Host Kernel | 5.4.0-97-generic | | CPU | AMD EPYC 7552 48-Core Processor | | GPU | RDNA2 V620 (D603GLXE) | | SBIOS | Version SMC_r_1.2a | | VBIOS | 113-D603GLXE-077 | | Guest OS 1 | Ubuntu 20.04.5 LTS | | Guest OS 2 | RHEL 9.0 | | GIM Driver | gim-dkms_1.0.0.1234577_all | | VM CPU Cores | 32 | | VM RAM | 64 GB | Install the following Kernel-based Virtual Machine (KVM) Hypervisor packages: ```shell sudo apt-get -y install qemu-kvm qemu-utils bridge-utils virt-manager gir1.2-spiceclientgtk* gir1.2-spice-client-gtk* libvirt-daemon-system dnsmasq-base sudo virsh net-start default /*to enable Virtual network by default ``` Enable input-output memory management unit (IOMMU) in GRUB settings by adding the following line to `/etc/default/grub`: ```none GRUB_CMDLINE_LINUX_DEFAULT="quiet splash" for AMD CPU ``` Update grub and reboot ```shell sudo update=grub sudo reboot ``` Install the GPU-IOV Module (GIM, where IOV is I/O Virtualization) driver and follow the steps below.z ```shell sudo dpkg -i sudo reboot # Load Host Driver to Create 1VF sudo modprobe gim vf_num=1 # Note: If GIM driver loaded successfully, we could see "gim info:(gim_init:213) *****Running GIM*****" in dmesg lspci -d 1002: ``` Which should output something like: ```none 01:00.0 PCI bridge: Advanced Micro Devices, Inc. [AMD/ATI] Device 1478 02:00.0 PCI bridge: Advanced Micro Devices, Inc. [AMD/ATI] Device 1479 03:00.0 Display controller: Advanced Micro Devices, Inc. [AMD/ATI] Device 73a1 03:02.0 Display controller: Advanced Micro Devices, Inc. [AMD/ATI] Device 73ae → VF ``` ### Guest OS installation First, assign GPU virtual function (VF) to VM using the following steps. 1. Stop the VM. 2. Run `virt-manager` 3. In the **Virtual Machine Manager** GUI, select the **VM** and click **Open**. ![Virtual Machine Manager](reference/system-optimization/images/tuning014.png) 4. In the VM GUI, go to **Show Virtual Hardware Details > Add Hardware** to configure hardware. ![Show virtual hardware details](reference/system-optimization/images/tuning015.png) 5. Go to **Add Hardware > PCI Host Device > VF** and click **Finish**. ![VF Selection](reference/system-optimization/images/tuning016.png) Then start the VM. Lastly, install ROCm on the virtual machine (VM). For detailed instructions, refer to the [Linux install guide](https://rocm.docs.amd.com/en/latest/install/rocm.html). --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/common.html # Common system settings These topics discuss system-level GPU configuration that applies across AMD hardware and workload types. * [GPU isolation techniques](https://rocm.docs.amd.com/en/latest/reference/system-optimization/gpu-isolation.html) – Restrict application access to a subset of GPUs using environment variables, cgroups, or virtual machines. * [BAR access limits](https://rocm.docs.amd.com/en/latest/reference/system-optimization/bar-access-limits.html) – Understand Base Address Register (BAR) physical addressing limits and how to handle peer-to-peer DMA access restrictions. --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/gpu-isolation.html # GPU isolation techniques Restricting the access of applications to a subset of GPUs, aka isolating GPUs allows users to hide GPU resources from programs. The programs by default will only use the “exposed” GPUs ignoring other (hidden) GPUs in the system. There are multiple ways to achieve isolation of GPUs in the ROCm software stack, differing in which applications they apply to and the security they provide. This page serves as an overview of the techniques. ## Environment variables The runtimes in the ROCm software stack read these environment variables to select the exposed or default device to present to applications using them. See [ROCm environment variables](https://rocm.docs.amd.com/en/latest/reference/environment-variables/index.html#env-variables-reference) for more information. Environment variables shouldn’t be used for isolating untrusted applications, as an application can reset them before initializing the runtime. ### `ROCR_VISIBLE_DEVICES` A list of device indices or s that will be exposed to applications. Runtime : ROCm Software Runtime. Applies to all applications using the user mode ROCm software stack. ```shell export ROCR_VISIBLE_DEVICES="0,GPU-4b2c1a9f-8d3e-6f7a-b5c9-2e4d8a1f6c3b" ``` ### `GPU_DEVICE_ORDINAL` Devices indices exposed to OpenCL and HIP applications. Runtime : ROCm Compute Language Runtime (`ROCclr`). Applies to applications and runtimes using the `ROCclr` abstraction layer including HIP and OpenCL applications. ```shell export GPU_DEVICE_ORDINAL="0,2" ``` ### `HIP_VISIBLE_DEVICES` Device indices exposed to HIP applications. Runtime: HIP runtime. Applies only to applications using HIP on the AMD platform. ```shell export HIP_VISIBLE_DEVICES="0,2" ``` ### `CUDA_VISIBLE_DEVICES` Provided for CUDA compatibility, has the same effect as `HIP_VISIBLE_DEVICES` on the AMD platform. Runtime : HIP or CUDA Runtime. Applies to HIP applications on the AMD or NVIDIA platform and CUDA applications. ### `OMP_DEFAULT_DEVICE` Default device used for OpenMP target offloading. Runtime : OpenMP Runtime. Applies only to applications using OpenMP offloading. ```shell export OMP_DEFAULT_DEVICE="2" ``` ## Docker Docker uses Linux kernel namespaces to provide isolated environments for applications. This isolation applies to most devices by default, including GPUs. To access them in containers explicit access must be granted, please see docker-access-gpus-in-container for details. Specifically refer to [Restricting GPU access](https://rocm.docs.amd.com/en/latest/install/docker-containers.html#docker-restrict-gpus) on exposing just a subset of all GPUs. Docker isolation is more secure than environment variables, and applies to all programs that use the `amdgpu` kernel module interfaces. Even programs that don’t use the ROCm runtime, like graphics applications using OpenGL or Vulkan, can only access the GPUs exposed to the container. ## GPU passthrough to virtual machines Virtual machines achieve the highest level of isolation, because even the kernel of the virtual machine is isolated from the host. Devices physically installed in the host system can be passed to the virtual machine using PCIe passthrough. This allows for using the GPU with a different operating systems like a Windows guest from a Linux host. Setting up PCIe passthrough is specific to the hypervisor used. ROCm supports [VMware ESXi](https://www.vmware.com/products/esxi-and-esx.html) for select GPUs. --- Source: https://rocm.docs.amd.com/en/latest/reference/system-optimization/bar-access-limits.html # BAR access limits and physical addressing for AMD GPUs Direct Memory Access (DMA) to PCIe devices using Base Address Registers (BARs) can be restricted due to physical addressing limits. These restrictions can result in data access failures between the system components. Peer-to-peer (P2P) DMA is used to access resources such as registers and memory between devices. PCIe devices need memory-mapped input/output (MMIO) space for DMA, and these MMIO spaces are defined in the PCIe BARs. These BARs are a set of 32-bit or 64-bit registers that are used to define the resources that PCIe devices provide. The CPU and other system devices also use these to access the resources of the PCIe devices. P2P DMA only works when one device can directly access the local BAR memory of another. If the memory address of a BAR memory exceeds the physical addressing limit of a device, the device will not be able to access that BAR. This could be the device’s own BAR or the BAR of another device in the system. If the BAR memory exceeds than the physical addressing limit of the device, the device will not be able to access the remote BAR. To handle any BAR access issues that might occur, you need to be aware of the physical address limitations of the devices and understand the [BAR configuration of AMD GPUs](#bar-configuration). This information is important when setting up additional MMIO apertures for PCIe devices in the system’s physical address space. ## Handling physical address limitation When a system boots, the system BIOS allocates the physical address space for the components in the system, including system memory and MMIO apertures. On modern 64-bit platforms, there are generally two or more MMIO apertures: one located below 4 GB of physical address space for 32-bit compatibility, and one or more above 4 GB for devices needing more space. You can control the memory address of the high MMIO aperture from the system BIOS configuration options. This lets you configure the additional MMIO space to align with the physical addressing limit and allows P2P DMA between the devices. For example, if a PCIe device is limited to 44-bit of physical addressing, you should ensure that the MMIO aperture is set below 44-bit in the system physical address space. There are two ways to handle this: * Ensure that the high MMIO aperture is within the physical addressing limits of the devices in the system. For example, if the devices have a 44-bit physical addressing limit, set the `MMIO High Base` and `MMIO High size` options in the BIOS such that the aperture is within the 44-bit address range, and ensure that the `Above 4G Decoding` option is Enabled. * Enable the Input-Output Memory Management Unit (IOMMU). When the IOMMU is enabled in non-passthrough mode, it will create a virtual I/O address space for each device on the system. It also ensures that all virtual addresses created in that space are within the physical addressing limits of the device. For more information on IOMMU, see [Input-Output Memory Management Unit (IOMMU)](https://instinct.docs.amd.com/projects/amdgpu-docs/en/latest/conceptual/iommu.html). ## BAR configuration for AMD GPUs The following table shows how the BARs are configured for AMD GPUs. | BAR Type | Value | Description | |------------------|----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | BAR0-1 registers | 64-bit, Prefetchable, GPU memory | 8 GB or 16 GB depending on GPU. Set to less than 2^44 to support P2P access from other GPUs with a 44-bit physical address limit. Prefetchable memory enables faster read operation for high-performance computing (HPC) by fetching the contiguous data from the same data source even before requested as an anticipation of a future request. | | BAR2-3 registers | 64-bit, Prefetchable, Doorbell | Set to less than 2^44 to support P2P access from other GPUs with a 44-bit physical address limit. As a Doorbell BAR, it indicates to the GPU that a new operation is in its queue to be processed. | | BAR4 register | Optional | Not a boot device | | BAR5 register | 32-bit, Non-prefetchable, MMIO | Is set to less than 4 GB. | ### Example of BAR usage on AMD GPUs Following is an example configuration of BARs set by the system BIOS on GFX8 GPUs with the 40-bit physical addressing limit: ```shell 11:00.0 Display controller: Advanced Micro Devices, Inc. [AMD/ATI] Fiji [Radeon R9 FURY / NANO Series] (rev c1) Subsystem: Advanced Micro Devices, Inc. [AMD/ATI] Device 0b35 Flags: bus master, fast devsel, latency 0, IRQ 119 Memory at bf40000000 (64-bit, prefetchable) [size=256M] Memory at bf50000000 (64-bit, prefetchable) [size=2M] I/O ports at 3000 [size=256] Memory at c7400000 (32-bit, non-prefetchable) [size=256K] Expansion ROM at c7440000 [disabled] [size=128K] ``` Details of the BARs configured in the example are: **GPU Frame Buffer BAR:** `Memory at bf40000000 (64-bit, prefetchable) [size=256M]` The size of the BAR in the example is 256 MB. Generally, it will be the size of the GPU memory (typically 4 GB+). Depending upon the physical address limit and generation of AMD GPUs, the BAR can be set below 2^40, 2^44, or 2^48. **Doorbell BAR:** `Memory at bf50000000 (64-bit, prefetchable) [size=2M]` The size of the BAR should typically be less than 10 MB for this generation of GPUs and has been set to 2 MB in the example. This BAR is placed less than 2^40 to allow peer-to-peer access from other generations of AMD GPUs. **I/O BAR:** `I/O ports at 3000 [size=256]` This is for legacy VGA and boot device support. Because the GPUs used are not connected to a display (VGA devices), this is not a concern, even if it isn’t set up in the system BIOS. **MMIO BAR:** `Memory at c7400000 (32-bit, non-prefetchable) [size=256K]` The AMD Driver requires this to access the configuration registers. Since the reminder of the BAR available is only 1 DWORD (32-bit), this is set less than 4 GB. In the example, it is fixed at 256 KB. **Expansion ROM:** `Expansion ROM at c7440000 [disabled] [size=128K]` This is required by the AMD Driver to access the GPU video-BIOS. In the example, it is fixed at 128 KB. --- Source: https://rocm.docs.amd.com/en/latest/reference/precision-support.html # Data types and precision support This topic summarizes the data types supported on AMD GPUs and ROCm libraries, along with corresponding [HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/index.html) data types. ## Integral types The signed and unsigned integral types supported by ROCm are listed in the following table. | Type name | HIP type | Description | |-------------|-----------------------|-------------------------------------| | int8 | `int8_t`, `uint8_t` | A signed or unsigned 8-bit integer | | int16 | `int16_t`, `uint16_t` | A signed or unsigned 16-bit integer | | int32 | `int32_t`, `uint32_t` | A signed or unsigned 32-bit integer | | int64 | `int64_t`, `uint64_t` | A signed or unsigned 64-bit integer | ## Floating-point types The floating-point types supported by ROCm are listed in the following table. ![Supported floating-point types](reference/images/floating-point-data-types.png) | Type name | HIP type | Description | |---------------|-----------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | float4 (E2M1) | `__hip_fp4_e2m1`

| A 4-bit floating-point number with **E2M1** bit layout, as described
in [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html). | | float6 (E3M2) | `__hip_fp6_e3m2`

| A 6-bit floating-point number with **E3M2** bit layout, as described
in [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html). | | float6 (E2M3) | `__hip_fp6_e2m3`

| A 6-bit floating-point number with **E2M3** bit layout, as described
in [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html). | | float8 (E4M3) | `__hip_fp8_e4m3_fnuz`,


`__hip_fp8_e4m3`

| An 8-bit floating-point number with **E4M3** bit layout, as described in [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html).
The FNUZ variant has expanded range with no infinity or signed zero (NaN represented as negative zero),
while the OCP variant follows the Open Compute Project specification. | | float8 (E5M2) | `__hip_fp8_e5m2_fnuz`,


`__hip_fp8_e5m2`

| An 8-bit floating-point number with **E5M2** bit layout, as described in [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html).
The FNUZ variant has expanded range with no infinity or signed zero (NaN represented as negative zero),
while the OCP variant follows the Open Compute Project specification. | | float16 | `half` | A 16-bit floating-point number that conforms to the IEEE 754-2008
half-precision storage format. | | bfloat16 | `bfloat16` | A shortened 16-bit version of the IEEE 754 single-precision storage
format. | | tensorfloat32 | Not available | A floating-point number that occupies 32 bits or less of storage,
providing improved range compared to half (16-bit) format, at
(potentially) greater throughput than single-precision (32-bit) formats. | | float32 | `float` | A 32-bit floating-point number that conforms to the IEEE 754
single-precision storage format. | | float64 | `double` | A 64-bit floating-point number that conforms to the IEEE 754
double-precision storage format. | #### NOTE * The float8 and tensorfloat32 types are internal types used in calculations in Matrix Cores and can be stored in any type of the same size. * CDNA3 natively supports FP8 FNUZ (E4M3 and E5M2), which differs from the customized FP8 format used with NVIDIA H100 ([FP8 Formats for Deep Learning](https://arxiv.org/abs/2209.05433)). * In some AMD documents and articles, float8 (E5M2) is referred to as bfloat8. * The [low precision floating point types page](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/low_fp_types.html) describes how to use these types in HIP with examples. ## Level of support definitions In the following sections, icons represent the level of support. These icons, described in the following table, are also used in the library data type support pages. | Icon | Definition | |--------|-----------------| | NA | Not applicable | | ❌ | Not supported | | ⚠️ | Partial support | | ✅ | Full support | #### NOTE * Full support means that the type is supported natively or with hardware emulation. * Native support means that the operations for that type are implemented in hardware. Types that are not natively supported are emulated with the available hardware. The performance of non-natively supported types can differ from the full instruction throughput rate. For example, 16-bit integer operations can be performed on the 32-bit integer ALUs at full rate; however, 64-bit integer operations might need several instructions on the 32-bit integer ALUs. * Any type can be emulated by software, but this page does not cover such cases. ## Data type support by hardware architecture AMD’s GPU lineup spans multiple architecture generations: * CDNA1 such as MI100 * CDNA2 such as MI210, MI250, and MI250X * CDNA3 such as MI300A, MI300X, and MI325X * CDNA4 such as MI350X and MI355X * RDNA2 such as PRO W6800 and PRO V620 * RDNA3 such as RX 7900XT and RX 7900XTX * RDNA4 such as RX 9070 and RX 9070XT ### HIP C++ type implementation support The HIP C++ types available on different hardware platforms are listed in the following table. | HIP C++ Type | CDNA1 | CDNA2 | CDNA3 | CDNA4 | RDNA2 | RDNA3 | RDNA4 | |-----------------------|---------|---------|---------|---------|---------|---------|---------| | `int8_t`, `uint8_t` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `int16_t`, `uint16_t` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `int32_t`, `uint32_t` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `int64_t`, `uint64_t` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `__hip_fp4_e2m1` | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | | `__hip_fp6_e2m3` | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | | `__hip_fp6_e3m2` | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | | `__hip_fp8_e4m3_fnuz` | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | ❌ | | `__hip_fp8_e5m2_fnuz` | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | ❌ | | `__hip_fp8_e4m3` | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ | | `__hip_fp8_e5m2` | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ | | `half` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `bfloat16` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `float` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | `double` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | #### NOTE Library support for specific data types is contingent upon hardware support. Even if a ROCm library indicates support for a particular data type, that type will only be fully functional if the underlying hardware architecture (as shown in the table above) also supports it. For example, fp8 types are only available on architectures shown with a checkmark in the relevant rows. ### Compute units support The following table lists data type support for compute units. **Integral types** | Type name | int8 | int16 | int32 | int64 | |-------------|--------|---------|---------|---------| | CDNA1 | ✅ | ✅ | ✅ | ✅ | | CDNA2 | ✅ | ✅ | ✅ | ✅ | | CDNA3 | ✅ | ✅ | ✅ | ✅ | | CDNA4 | ✅ | ✅ | ✅ | ✅ | | RDNA2 | ✅ | ✅ | ✅ | ✅ | | RDNA3 | ✅ | ✅ | ✅ | ✅ | | RDNA4 | ✅ | ✅ | ✅ | ✅ | **Low precision floating-point types** | Type name | float4 | float6 (E2M3) | float6 (E3M2) | float8 (E4M3) | float8 (E5M2) | |-------------|----------|-----------------|-----------------|-----------------|-----------------| | CDNA1 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA2 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA3 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA4 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA2 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA3 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA4 | ❌ | ❌ | ❌ | ❌ | ❌ | **High precision floating-point types** | Type name | float16 | bfloat16 | tensorfloat32 | float32 | float64 | |-------------|-----------|------------|-----------------|-----------|-----------| | CDNA1 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA2 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA3 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA4 | ✅ | ✅ | ❌ | ✅ | ✅ | | RDNA2 | ✅ | ✅ | ❌ | ✅ | ✅ | | RDNA3 | ✅ | ✅ | ❌ | ✅ | ✅ | | RDNA4 | ✅ | ✅ | ❌ | ✅ | ✅ | ### Matrix core support The following table lists data type support for AMD GPU matrix cores. **Integral types** | Type name | int8 | int16 | int32 | int64 | |-------------|--------|---------|---------|---------| | CDNA1 | ✅ | ❌ | ❌ | ❌ | | CDNA2 | ✅ | ❌ | ❌ | ❌ | | CDNA3 | ✅ | ❌ | ❌ | ❌ | | CDNA4 | ✅ | ❌ | ❌ | ❌ | | RDNA2 | ✅ | ❌ | ❌ | ❌ | | RDNA3 | ✅ | ❌ | ❌ | ❌ | | RDNA4 | ✅ | ❌ | ❌ | ❌ | **Low precision floating-point types** | Type name | float4 | float6 (E2M3) | float6 (E3M2) | float8 (E4M3) | float8 (E5M2) | |-------------|----------|-----------------|-----------------|-----------------|-----------------| | CDNA1 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA2 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA3 | ❌ | ❌ | ❌ | ✅ | ✅ | | CDNA4 | ✅ | ✅ | ✅ | ✅ | ✅ | | RDNA2 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA3 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA4 | ❌ | ❌ | ❌ | ✅ | ✅ | **High precision floating-point types** | Type name | float16 | bfloat16 | tensorfloat32 | float32 | float64 | |-------------|-----------|------------|-----------------|-----------|-----------| | CDNA1 | ✅ | ✅ | ❌ | ✅ | ❌ | | CDNA2 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA3 | ✅ | ✅ | ✅ | ✅ | ✅ | | CDNA4 | ✅ | ✅ | ✅ | ✅ | ✅ | | RDNA2 | ✅ | ✅ | ❌ | ❌ | ❌ | | RDNA3 | ✅ | ✅ | ❌ | ❌ | ❌ | | RDNA4 | ✅ | ✅ | ❌ | ❌ | ❌ | ### Atomic operations support The following table lists which data types are supported for atomic operations on AMD GPUs. The atomics operation type behavior is affected by the memory locations, memory granularity, or scope of operations. For detailed various support of atomic read-modify-write (atomicRMW) operations collected on the [Hardware atomics operation support](https://rocm.docs.amd.com/en/latest/reference/gpu-atomics-operation.html#hw-atomics-operation-support) page. **Integral types** | Type name | int8 | int16 | int32 | int64 | |-------------|--------|---------|---------|---------| | CDNA 1 | ❌ | ❌ | ✅ | ✅ | | CDNA 2 | ❌ | ❌ | ✅ | ✅ | | CDNA 3 | ❌ | ❌ | ✅ | ✅ | | RDNA 3 | ❌ | ❌ | ✅ | ✅ | | RDNA 4 | ❌ | ❌ | ✅ | ✅ | **Low precision floating-point types** | Type name | float4 | float6 (E2M3) | float6 (E3M2) | float8 (E4M3) | float8 (E5M2) | |-------------|----------|-----------------|-----------------|-----------------|-----------------| | CDNA 1 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA 2 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA 3 | ❌ | ❌ | ❌ | ❌ | ❌ | | CDNA 4 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA 2 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA 3 | ❌ | ❌ | ❌ | ❌ | ❌ | | RDNA 4 | ❌ | ❌ | ❌ | ❌ | ❌ | **High precision floating-point types** | Type name | 2 x float16 | 2 x bfloat16 | tensorfloat32 | float32 | float64 | |-------------|---------------|----------------|-----------------|-----------|-----------| | CDNA 1 | ✅ | ✅ | ❌ | ✅ | ❌ | | CDNA 2 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA 3 | ✅ | ✅ | ❌ | ✅ | ✅ | | CDNA 4 | ✅ | ✅ | ❌ | ✅ | ✅ | | RDNA 2 | ❌ | ❌ | ❌ | ✅ | ❌ | | RDNA 3 | ❌ | ❌ | ❌ | ✅ | ❌ | | RDNA 4 | ✅ | ✅ | ❌ | ✅ | ❌ | #### NOTE You can emulate atomic operations using software for cases that are not natively supported. Software-emulated atomic operations have a high negative performance impact when they frequently access the same memory address. ## Data type support in ROCm libraries ROCm library support for int8, float8 (E4M3), float8 (E5M2), int16, float16, bfloat16, int32, tensorfloat32, float32, int64, and float64 is listed in the following tables. ### Libraries input/output type support The following tables list ROCm library support for specific input and output data types. Select a library from the below table to view the supported data types. For more information, please visit [Composable Kernel](https://rocm.docs.amd.com/projects/composable_kernel/en/latest/reference/Composable_Kernel_data_type_support.html). | Data Type | Support | |---------------|-----------| | int8 | ✅ | | int32 | ✅ | | float4 (E2M1) | ✅ | | float6 (E2M3) | ✅ | | float6 (E3M2) | ✅ | | float8 (E4M3) | ✅ | | float8 (E5M2) | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit MIGraphX. | Data Type | Support | |---------------|-----------| | int8 | ✅ | | int16 | ✅ | | int32 | ✅ | | int64 | ✅ | | float8 (E4M3) | ✅ | | float8 (E5M2) | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit [MIOpen](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/data_type_support.html). | Data Type | Support | |---------------|-----------| | int8 | ⚠️ | | int32 | ⚠️ | | float8 (E4M3) | ⚠️ | | float8 (E5M2) | ⚠️ | | float16 | ✅ | | bfloat16 | ⚠️ | | float32 | ✅ | | float64 | ⚠️ | For more information, please visit [RCCL](https://rocm.docs.amd.com/projects/rccl/en/latest/api-reference/data-type-support.html). | Data Type | Support | |---------------|-----------| | int8 | ✅ | | int32 | ✅ | | int64 | ✅ | | float8 (E4M3) | ✅ | | float8 (E5M2) | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit [hipBLAS](https://rocm.docs.amd.com/projects/hipBLAS/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | float16 | ⚠️ | | bfloat16 | ⚠️ | | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [hipBLASLt](https://rocm.docs.amd.com/projects/hipBLASLt/en/latest/reference/data-type-support.html). | Data Type | Support | |---------------|------------| | int8 | ✅ | | float4 (E2M1) | Input only | | float8 (E4M3) | ✅ | | float8 (E5M2) | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | For more information, please visit [hipFFT](https://rocm.docs.amd.com/projects/hipFFT/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | float16 | ⚠️ | | float32 | ✅ | | float64 | ✅ | | cfloat16 | ⚠️ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [hipRAND](https://rocm.docs.amd.com/projects/hipRAND/en/latest/api-reference/data-type-support.html). | Data Type | Support | |-------------|-------------| | int8 | Output only | | int16 | Output only | | int32 | Output only | | int64 | Output only | | float16 | Output only | | float32 | Output only | | float64 | Output only | For more information, please visit [hipSOLVER](https://rocm.docs.amd.com/projects/hipSOLVER/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [hipSPARSE](https://rocm.docs.amd.com/projects/hipSPARSE/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [hipSPARSELt](https://rocm.docs.amd.com/projects/hipSPARSELt/en/latest/reference/data-type-support.html). | Data Type | Support | |---------------|-------------| | int8 | ✅ | | int32 | Output only | | float8 (E4M3) | Input only | | float8 (E5M2) | Input only | | float16 | ✅ | | bfloat16 | ✅ | | float32 | Output only | For more information, please visit [rocBLAS](https://rocm.docs.amd.com/projects/rocBLAS/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | int8 | ⚠️ | | int32 | ⚠️ | | float16 | ⚠️ | | bfloat16 | ⚠️ | | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [rocFFT](https://rocm.docs.amd.com/projects/rocFFT/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | float16 | ✅ | | float32 | ✅ | | float64 | ✅ | | cfloat16 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [rocRAND](https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/data-type-support.html). | Data Type | Support | |-------------|-------------| | int8 | Output only | | int16 | Output only | | int32 | Output only | | int64 | Output only | | float16 | Output only | | float32 | Output only | | float64 | Output only | For more information, please visit [rocSOLVER](https://rocm.docs.amd.com/projects/rocSOLVER/en/latest/reference/data_type_support.html). | Data Type | Support | |-------------|-----------| | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [rocSPARSE](https://rocm.docs.amd.com/projects/rocSPARSE/en/latest/reference/data_type_support.html). | Data Type | Support | |-------------|-----------| | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit rocWMMA. | Data Type | Support | |---------------|-------------| | int8 | ✅ | | int32 | Output only | | float8 (E4M3) | Input only | | float8 (E5M2) | Input only | | float16 | ✅ | | bfloat16 | ✅ | | tensorfloat32 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit [Tensile](https://rocm.docs.amd.com/projects/Tensile/en/latest/src/reference/precision-support.html). | Data Type | Support | |---------------|-----------| | int8 | ✅ | | int32 | ✅ | | float8 (E4M3) | ✅ | | float8 (E5M2) | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | tensorfloat32 | ✅ | | float32 | ✅ | | float64 | ✅ | | cfloat32 | ✅ | | cfloat64 | ✅ | For more information, please visit [hipCUB](https://rocm.docs.amd.com/projects/hipCUB/en/latest/api-reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | int8 | ✅ | | int16 | ✅ | | int32 | ✅ | | int64 | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit hipTensor. | Data Type | Support | |-------------|-----------| | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ⚠️ | | cfloat32 | ⚠️ | | cfloat64 | ⚠️ | For more information, please visit [rocPRIM](https://rocm.docs.amd.com/projects/rocPRIM/en/latest/reference/data-type-support.html). | Data Type | Support | |-------------|-----------| | int8 | ✅ | | int16 | ✅ | | int32 | ✅ | | int64 | ✅ | | float16 | ✅ | | bfloat16 | ✅ | | float32 | ✅ | | float64 | ✅ | For more information, please visit [rocThrust](https://rocm.docs.amd.com/projects/rocThrust/en/latest/reference/rocThrust-data-type-support.html). | Data Type | Support | |-------------|-----------| | int8 | ✅ | | int16 | ✅ | | int32 | ✅ | | int64 | ✅ | | float16 | ⚠️ | | bfloat16 | ⚠️ | | float32 | ✅ | | float64 | ✅ | #### NOTE The meaning of partial support depends on the library. Please refer to the individual libraries’ documentation for more information. #### NOTE As random number generation libraries, rocRAND and hipRAND only specify output data types for the random values they generate, with no need for input data types. #### NOTE hipBLASLt supports additional data types as internal compute types, which may differ from the supported input/output types shown in the tables above. While TensorFloat32 is not supported as an input or output type in this library, it is available as an internal compute type. For complete details on supported compute types, refer to the [hipBLASLt](https://rocm.docs.amd.com/projects/hipBLASLt/en/latest/reference/data-type-support.html) documentation. ### hipDataType enumeration The `hipDataType` enumeration defines data precision types and is primarily used when the data reference itself does not include type information, such as in `void*` pointers. This enumeration is mainly utilized in BLAS libraries. The HIP type equivalents of the `hipDataType` enumeration are listed in the following table with descriptions and values. | hipDataType | HIP type | Value | Description | |----------------------|-----------------------|---------|-------------------------------------------------------------| | `HIP_R_8I` | `int8_t` | 3 | 8-bit real signed integer. | | `HIP_R_8U` | `uint8_t` | 8 | 8-bit real unsigned integer. | | `HIP_R_16I` | `int16_t` | 20 | 16-bit real signed integer. | | `HIP_R_16U` | `uint16_t` | 22 | 16-bit real unsigned integer. | | `HIP_R_32I` | `int32_t` | 10 | 32-bit real signed integer. | | `HIP_R_32U` | `uint32_t` | 12 | 32-bit real unsigned integer. | | `HIP_R_32F` | `float` | 0 | 32-bit real single precision floating-point. | | `HIP_R_64F` | `double` | 1 | 64-bit real double precision floating-point. | | `HIP_R_16F` | `half` | 2 | 16-bit real half precision floating-point. | | `HIP_R_16BF` | `bfloat16` | 14 | 16-bit real bfloat16 precision floating-point. | | `HIP_R_8F_E4M3` | `__hip_fp8_e4m3` | 28 | 8-bit real float8 precision floating-point (OCP version). | | `HIP_R_8F_E5M2` | `__hip_fp8_e5m2` | 29 | 8-bit real bfloat8 precision floating-point (OCP version). | | `HIP_R_6F_E2M3` | `__hip_fp6_e2m3` | 31 | 6-bit real float6 precision floating-point. | | `HIP_R_6F_E3M2` | `__hip_fp6_e3m2` | 32 | 6-bit real bfloat6 precision floating-point. | | `HIP_R_4F_E2M1` | `__hip_fp4_e2m1` | 33 | 4-bit real float4 precision floating-point. | | `HIP_R_8F_E4M3_FNUZ` | `__hip_fp8_e4m3_fnuz` | 1000 | 8-bit real float8 precision floating-point (FNUZ version). | | `HIP_R_8F_E5M2_FNUZ` | `__hip_fp8_e5m2_fnuz` | 1001 | 8-bit real bfloat8 precision floating-point (FNUZ version). | The full list of the `hipDataType` enumeration listed in [library_types.h](https://github.com/ROCm/hip/blob/amd-staging/include/hip/library_types.h). --- Source: https://rocm.docs.amd.com/en/latest/reference/graph-safe-support.html # Graph-safe support for ROCm libraries HIP graph-safe libraries operate safely in HIP execution graphs. [HIP graphs](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_runtime_api/hipgraph.html#how-to-hip-graph) are an alternative way of executing tasks on a GPU that can provide performance benefits over launching kernels using the standard method via streams. Functions and routines from graph-safe libraries shouldn’t result in issues like race conditions, deadlocks, or unintended dependencies. The following table shows whether a ROCm library is graph-safe. | ROCm library | Graph safe support | |----------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------| | [Composable Kernel](https://github.com/ROCm/composable_kernel) | ❌ | | [hipBLAS](https://github.com/ROCm/hipBLAS) | ✅ | | [hipBLASLt](https://github.com/ROCm/hipBLASLt) | ⚠️ | | [hipCUB](https://github.com/ROCm/hipCUB) | ✅ | | [hipFFT](https://github.com/ROCm/hipFFT) | ✅ (see [details](https://rocm.docs.amd.com/projects/hipFFT/en/latest/reference/hipfft-api-usage.html#hip-graph-support-for-hipfft)) | | [hipRAND](https://github.com/ROCm/hipRAND) | ✅ | | [hipSOLVER](https://github.com/ROCm/hipSOLVER) | ⚠️ (experimental) | | [hipSPARSE](https://github.com/ROCm/hipSPARSE) | ✅ | | [hipSPARSELt](https://github.com/ROCm/hipSPARSELt) | ⚠️ (experimental) | | [hipTensor](https://github.com/ROCm/hipTensor) | ❌ | | [MIOpen](https://github.com/ROCm/MIOpen) | ❌ | | [RCCL](https://github.com/ROCm/rccl) | ✅ | | [rocAL](https://github.com/ROCm/rocAL) | ❌ | | [rocALUTION](https://github.com/ROCm/rocALUTION) | ❌ | | [rocBLAS](https://github.com/ROCm/rocBLAS) | ✅ (see [details](https://rocm.docs.amd.com/projects/rocBLAS/en/latest/reference/beta-features.html)) | | [rocDecode](https://github.com/ROCm/rocDecode) | ❌ | | [rocFFT](https://github.com/ROCm/rocFFT) | ✅ (see [details](https://rocm.docs.amd.com/projects/rocFFT/en/latest/reference/api.html#hip-graph-support-for-rocfft)) | | [rocHPCG](https://github.com/ROCm/rocHPCG) | ❌ | | [rocJPEG](https://github.com/ROCm/rocJPEG) | ❌ | | [rocPRIM](https://github.com/ROCm/rocPRIM) | ✅ | | [rocRAND](https://github.com/ROCm/rocRAND) | ✅ | | [rocSOLVER](https://github.com/ROCm/rocSOLVER) | ⚠️ (experimental) | | [rocSPARSE](https://github.com/ROCm/rocSPARSE) | ⚠️ (experimental) | | [rocThrust](https://github.com/ROCm/rocThrust) | ❌ | | [rocWMMA](https://github.com/ROCm/rocWMMA) | ❌ | | [RPP](https://github.com/ROCm/rpp) | ⚠️ | | [Tensile](https://github.com/ROCm/Tensile) | ✅ | ✅: full support ⚠️: partial support ❌: not supported --- Source: https://rocm.docs.amd.com/en/latest/reference/environment-variables/index.html # ROCm environment variables ROCm provides a set of environment variables that allow users to configure and optimize their development and runtime experience. These variables define key settings such as installation paths, platform selection, and runtime behavior for applications running on AMD accelerators and GPUs. This page outlines commonly used environment variables across different components of the ROCm software stack, including HIP and ROCR-Runtime. Understanding these variables can help streamline software development and execution in ROCm-based environments. ## HIP environment variables The following tables list the HIP environment variables. ### GPU isolation variables Restricting the access of applications to a subset of GPUs, also known as GPU isolation, allows users to hide GPU resources from programs. The GPU isolation environment variables in HIP are collected in the following table. | **Environment variable** | **Links** | **Value** | |------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------| | `ROCR_VISIBLE_DEVICES`


A list of device indices or UUIDs that will be exposed to applications.

| GPU isolation, Setting the number of compute units | Example: `0,GPU-4b2c1a9f-8d3e-6f7a-b5c9-2e4d8a1f6c3b` | | `GPU_DEVICE_ORDINAL`


Devices indices exposed to OpenCL and HIP applications.

| GPU isolation | Example: `0,2` | | `HIP_VISIBLE_DEVICES`


Device indices exposed to HIP applications.

| GPU isolation, [HIP debugging](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/debugging.html) | Example: `0,2` | #### NOTE ### Recommendation * On Linux, use `ROCR_VISIBLE_DEVICES`. * On Windows, use `HIP_VISIBLE_DEVICES`. ### Profiling variables The profiling environment variables in HIP are collected in the following table. For more information, check setting the number of CUs page. | **Environment variable** | **Value** | |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------| | `HSA_CU_MASK`


Sets the mask on a lower level of queue creation in the driver, this mask will also be set for queues being profiled.

| Example: `1:0-8` | | `ROC_GLOBAL_CU_MASK`


Sets the mask on queues created by the HIP or the OpenCL runtimes, this mask will also be set for queues being profiled.

| Example: `0xf`, enables only 4 CUs | | `HIP_FORCE_QUEUE_PROFILING`


Used to run the app as if it were run in rocprof. Forces command queue profiling on by default.

| 0: Disable


1: Enable

| ### Debug variables The debugging environment variables in HIP are collected in the following table. For more information, check [Logging HIP activity](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/logging.html), [Debugging with HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/debugging.html) and GPU isolation. | **Environment variable** | **Default value** | **Value** | |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `AMD_LOG_LEVEL`


Enables HIP log on various level.

| `0` | 0: Disable log.


1: Enables error logs.


2: Enables warning logs next to lower-level logs.


3: Enables information logs next to lower-level logs.


4: Enables debug logs next to lower-level logs.


5: Enables debug extra logs next to lower-level logs.

| | `AMD_LOG_LEVEL_FILE`


Sets output file for `AMD_LOG_LEVEL`.

| stderr output | | | `AMD_LOG_MASK`


Specifies HIP log filters. Here is the [complete list of log masks](https://github.com/ROCm/rocm-systems/blob/develop/projects/clr/rocclr/utils/debug.hpp#L48).

| `0x7FFFFFFF` | 0x1: Log API calls.


0x2: Kernel and copy commands and barriers.


0x4: Synchronization and waiting for commands to finish.


0x8: Decode and display AQL packets.


0x10: Queue commands and queue contents.


0x20: Signal creation, allocation, pool.


0x40: Locks and thread-safety code.


0x80: Kernel creations and arguments, etc.


0x100: Copy debug.


0x200: Detailed copy debug.


0x400: Resource allocation, performance-impacting events.


0x800: Initialization and shutdown.


0x1000: Misc debug, not yet classified.


0x2000: Show raw bytes of AQL packet.


0x4000: Show code creation debug.


0x8000: More detailed command info, including barrier commands.


0x10000: Log message location.


0x20000: Memory allocation.


0x40000: Memory pool allocation, including memory in graphs.


0x80000: Timestamp details.


0x100000: Comgr path information print.


0xFFFFFFFF: Log always even mask flag is zero.

| | `HIP_FORCE_DEV_KERNARG`


Forces kernel arguments to be stored in device memory to reduce latency.


Can improve performance by 2-3 µs for some kernels.

| `1` | 0: Disable


1: Enable

| | `HIP_LAUNCH_BLOCKING`


Used for serialization on kernel execution.

| `0` | 0: Disable. Kernel executes normally.


1: Enable. Serializes kernel enqueue, behaves the same as `AMD_SERIALIZE_KERNEL`.

| | `HIP_VISIBLE_DEVICES`


Only devices whose index is present in the sequence are visible to HIP

| Unset by default. | 0,1,2: Depending on the number of devices on the system. | | `GPU_DUMP_CODE_OBJECT`


Dump code object.

| `0` | 0: Disable


1: Enable

| | `AMD_SERIALIZE_KERNEL`


Serialize kernel enqueue.

| `0` | 0: Disable


1: Wait for completion before enqueue.


2: Wait for completion after enqueue.


3: Both

| | `AMD_SERIALIZE_COPY`


Serialize copies

| `0` | 0: Disable


1: Wait for completion before enqueue.


2: Wait for completion after enqueue.


3: Both

| | `GPU_MAX_HW_QUEUES`


The maximum number of hardware queues allocated per device.

| `4` | The recommended maximum value for this setting is 4.


The variable controls how many independent hardware queues HIP runtime can create per process,


per device. If an application allocates more HIP streams than this number, then HIP runtime reuses


the same hardware queues for the new streams in a round-robin manner. Note that this maximum


number does not apply to hardware queues that are created for CU-masked HIP streams, or


cooperative queues for HIP Cooperative Groups (single queue per device).

| ### Memory management related variables The memory management related environment variables in HIP are collected in the following table. The `HIP_HOST_COHERENT` variable linked at the following pages: - [Coherence control](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_runtime_api/memory_management/coherence_control.html#coherence-control) - [Memory allocation flags](https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_runtime_api/memory_management/host_memory.html#memory-allocation-flags) | **Environment variable** | **Default value** | **Value** | |-----------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `HIP_HIDDEN_FREE_MEM`


Amount of memory to hide from the free memory reported by hipMemGetInfo.

| `0` | 0: Disable


Unit: megabyte (MB)

| | `HIP_HOST_COHERENT`


Specifies if the memory is coherent between the host and GPU in `hipHostMalloc`.

| `0` | 0: Memory is not coherent.


1: Memory is coherent.


Environment variable has effect, if the following conditions are statisfied:


- One of the `hipHostMallocDefault`, `hipHostMallocPortable`, `hipHostMallocWriteCombined` or `hipHostMallocNumaUser` flag set to 1.


- `hipHostMallocCoherent`, `hipHostMallocNonCoherent` and `hipHostMallocMapped` flags set to 0.

| | `HIP_INITIAL_DM_SIZE`


Set initial heap size for device malloc.

| `8388608` | Unit: Byte


The default value corresponds to 8 MB.

| | `HIP_MEM_POOL_SUPPORT`


Enables memory pool support in HIP.

| `0` | 0: Disable


1: Enable

| | `HIP_MEM_POOL_USE_VM`


Enables memory pool support in HIP.

| `0`: other OS


`1`: Windows

| 0: Disable


1: Enable

| | `HIP_VMEM_MANAGE_SUPPORT`


Virtual Memory Management Support.

| `1` | 0: Disable


1: Enable

| | `GPU_SINGLE_ALLOC_PERCENT`


Limits the maximum size of a single memory allocation as a percentage of GPU memory.

| `100` | Unit: Percentage


Prevents single allocations from consuming all available GPU memory.

| | `GPU_MAX_HEAP_SIZE`


Set maximum size of the GPU heap to % of board memory.

| `100` | Unit: Percentage

| | `GPU_MAX_REMOTE_MEM_SIZE`


Maximum size that allows device memory substitution with system.

| `2` | Unit: kilobyte (KB)

| | `GPU_NUM_MEM_DEPENDENCY`


Number of memory objects for dependency tracking.

| `256` | | | `GPU_STREAMOPS_CP_WAIT`


Force the stream memory operation to wait on CP.

| `0` | 0: Disable


1: Enable

| | `HSA_LOCAL_MEMORY_ENABLE`


Enable HSA device local memory usage.

| `1` | 0: Disable


1: Enable

| | `PAL_ALWAYS_RESIDENT`


Force memory resources to become resident at allocation time.

| `0` | 0: Disable


1: Enable

| | `PAL_PREPINNED_MEMORY_SIZE`


Size of prepinned memory.

| `64` | Unit: kilobyte (KB)

| | `REMOTE_ALLOC`


Use remote memory for the global heap allocation.

| `0` | 0: Disable


1: Enable

| ### Other useful variables The following table lists environment variables that are useful but relate to different features in HIP. | **Environment variable** | **Default value** | **Value** | |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|--------------------------------------------------------------------------------------------------------------------------------| | `HIPRTC_COMPILE_OPTIONS_APPEND`


Sets compile options needed for `hiprtc` compilation.

| Unset by default. | `--gpu-architecture=gfx906:sramecc+:xnack`, `-fgpu-rdc` | | `AMD_COMGR_SAVE_TEMPS`


Controls the deletion of temporary files generated during the compilation of Comgr. These files do not appear in the current working directory, but are instead left in a platform-specific temporary directory.

| Unset by default. | 0: Temporary files are deleted automatically.


Non zero integer: Turn off the temporary files deletion.

| | `AMD_COMGR_EMIT_VERBOSE_LOGS`


Sets logging of Comgr to include additional Comgr-specific informational messages.

| Unset by default. | 0: Verbose log disabled.


Non zero integer: Verbose log enabled.

| | `AMD_COMGR_REDIRECT_LOGS`


Controls redirect logs of Comgr.

| Unset by default. | stdout / -: Redirected to the standard output.


stderr: Redirected to the error stream.

| ## ROCR-Runtime environment variables The following table lists the [ROCR-Runtime](https://rocm.docs.amd.com/projects/ROCR-Runtime/en/latest/index.html) environment variables: | Environment variable | Default value | Value | |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `ROCR_VISIBLE_DEVICES`


Specifies a list of device indices or UUIDs to be exposed to the applications.

| None | `0,GPU-DEADBEEFDEADBEEF` | | `HSA_NO_SCRATCH_RECLAIM`


Controls whether scratch memory allocations are permanently assigned to queues or can be reclaimed based on usage thresholds.

| `0` | 0: Disable.


When dispatches need scratch memory that are lower than the threshold, the memory will be permanently assigned to the queue. For dispatches that exceed the threshold, a scratch-use-once mechanism will be used, resulting in the memory to be unassigned after the dispatch.


1: Enable.


If a kernel dispatch needs scratch memory, runtime will allocate and permanently assign device memory to the queue handling the dispatch, even if the amount of scratch memory exceeds the default threshold. This memory will not be available to other queues or processes until this process exits.

| | `HSA_SCRATCH_SINGLE_LIMIT`


Specifies the threshold for the amount of scratch memory allocated and reclaimed in kernel dispatches.


Enabling `HSA_NO_SCRATCH_RECLAIM` circumvents `HSA_SCRATCH_SINGLE_LIMIT`, and treats `HSA_SCRATCH_SINGLE_LIMIT` as the maximum value.




**NOTE:** In the 7.0 release the developer can use the HIP enumerator `hipExtLimitScratchCurrent` to programmatically change the default scratch memory allocation size. For more information, see [Global enums and defines](https://rocm.docs.amd.com/projects/HIP/en/latest/reference/hip_runtime_api/global_defines_enums_structs_files.html).

| `146800640` | 0 to 4GB per XCC | | `HSA_SCRATCH_SINGLE_LIMIT_ASYNC`


On GPUs that support asynchronous scratch reclaim, this variable is used instead of `HSA_SCRATCH_SINGLE_LIMIT` to specify the threshold for scratch memory allocation.

| `3221225472` (3GB) | 0 to 4GB per XCC | | `HSA_ENABLE_SCRATCH_ASYNC_RECLAIM`


Controls asynchronous scratch memory reclamation on supported GPUs.


When enabled, if a device memory allocation fails, ROCr will attempt to reclaim scratch memory assigned to all queues and retry the allocation.

| `1` | 0: Disable asynchronous scratch reclaim.


1: Enable asynchronous scratch reclaim on supported GPUs.

| | `HSA_XNACK`


Enables XNACK.

| None | 1: Enable | | `HSA_CU_MASK`


Sets the mask on a lower level of queue creation in the driver.


This mask is also applied to the queues being profiled.

| None | `1:0-8` | | `HSA_ENABLE_SDMA`


Enables the use of direct memory access (DMA) engines in all copy directions (Host-to-Device, Device-to-Host, Device-to-Device), when using any of the following APIs:


`hsa_memory_copy`,


`hsa_amd_memory_fill`,


`hsa_amd_memory_async_copy`,


`hsa_amd_memory_async_copy_on_engine`.

| `1` | 0: Disable


1: Enable

| | `HSA_ENABLE_PEER_SDMA`


**Note**: This environment variable is ignored if `HSA_ENABLE_SDMA` is set to 0.


Enables the use of DMA engines for Device-to-Device copies, when using any of the following APIs:


`hsa_memory_copy`,


`hsa_amd_memory_async_copy`,


`hsa_amd_memory_async_copy_on_engine`.

| `1` | 0: Disable


1: Enable

| | `HSA_ENABLE_SDMA_GPU_POLL`


Windows only, and only meaningful on a native SDMA user queue, which the device capability decides. Selects who executes the dependency `POLL_REGMEM` packets the copy writes into the ring: the SDMA engine, or a host thread in the thunk that waits the signals out, strips the packets, and only then submits the span.


Defaults to host-thread emulation. Set to 1 once the driver supports GPU-side polling.

| `0` | 0: Emulate the polls on a host thread.


1: Let the SDMA engine execute the polls.

| | `HSA_ENABLE_MWAITX`


When mwaitx is enabled, on AMD CPUs, runtime will hint to the CPU to go into lower power-states when doing busy loops by using the mwaitx instruction.

| `1` | 0: Disable


1: Enable

| | `HSA_OVERRIDE_CPU_AFFINITY_DEBUG`


Controls whether ROCm helper threads inherit the parent process’s CPU affinity mask.

| `1` | 0: Enable inheritance. Helper threads use the parent process’s core affinity mask, which should be set with enough cores for all threads.


1: Disable inheritance. Helper threads spawn on all available cores, ignoring the parent’s affinity settings, which may affect performance in certain environments.

| | `HSA_ENABLE_DEBUG`


Enables additional debug information and validation in the runtime.

| `0` | 0: Disable debug mode.


1: Enable debug mode with additional validation and logging.

| | `HSA_HOTSWAP_ENABLE`


Enables automatic loading of the HotSwap tool, which retargets code objects for `gfx1250` A0 agents. Automatic loading is disabled by default and only occurs when explicitly enabled and a supported agent is present. This variable does not prevent explicit loading through `HSA_TOOLS_LIB`.

| `0` | Unset, empty, 0, `false`, `off`, `no`, `n`, or `f`: Skip automatic loading of the HotSwap tool.


Any other value: Automatically load the HotSwap tool when a supported agent is present.

| | `HSA_DISABLE_GFX12_STRICT`


Controls reporting of the “strict” ISA variant on A0 silicon. Disabled by default, so the agent keeps the base target. Set to 0 to opt in and have the agent report the strict variant instead.

| `1` | 0: Report the strict ISA variant on A0 agents.


1, unset, empty, or any other value: Keep the base target on A0 agents.

| | `HSA_HOTSWAP_VERBOSE`


Enables HotSwap diagnostic logging to stderr. Read by the HotSwap tool itself, not by the runtime, so it has no effect unless the tool is loaded. Errors are always reported regardless of this setting.

| `0` | Unset, empty, or 0: Disable HotSwap diagnostic logging.


Any other value: Enable HotSwap diagnostic logging.

| | `HSA_HOTSWAP_DUMP_SOURCE`


Writes the source code object to disk when the HotSwap tool refuses to translate it. Off by default because these objects are large and a failed translation is not memoized, so the same bytes fail again on every load. At most one artifact is written per source, for at most 32 distinct sources per process; an out-of-resources failure is never captured.

| `0` | Unset, empty, or 0: Do not write refused code objects.


Any other value: Write each refused code object once.

| | `HSA_HOTSWAP_DUMP_DIR`


Directory that receives the artifacts written by `HSA_HOTSWAP_DUMP_SOURCE`. Naming a destination does not by itself enable capture.

| `TMPDIR`, else `/tmp` | Any non-empty path: Write artifacts there.


Unset or empty: Fall back to `TMPDIR`, then `/tmp`.

| | `HSA_ENABLE_DXG_DETECTION`


Controls detection of the DXG driver (/dev/dxg) on WSL2.

| `1` | 0: Disable DXG detection.


1: Enable DXG detection, allowing ROCr to detect that it is running in WSL2.

| ### Hardware Debugging Environment Variables The following environment variables are intended for experienced users who are debugging hardware-specific issues. These settings may impact performance and stability and should only be used when troubleshooting specific hardware problems. | Environment variable | Default value | Value | |--------------------------------------------------------------------------------------------------------------------------------------------|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `HSA_DISABLE_FRAGMENT_ALLOCATOR`


Disables internal memory fragment caching to help debug memory faults.

| `0` | 0: Fragment allocator enabled (normal operation).


1: Fragment allocator disabled. Helps debug tools identify memory faults at their origin by preventing cached memory blocks from masking out-of-bounds writes.

| | `HSAKMT_DEBUG_LEVEL`


Controls the verbosity level of debug messages from the `libhsakmt.so` driver layer.

| `3` | 3: Only error messages (`pr_err`) are printed.


4: Error and warning messages (`pr_err`, `pr_warn`) are printed.


5: Same as level 4 (notice level not implemented).


6: Error, warning, and info messages (`pr_err`, `pr_warn`, `pr_info`) are printed.


7: All debug messages including `pr_debug` are printed.

| | `HSA_ENABLE_INTERRUPT`


Controls how completion signals are detected, useful for diagnosing interrupt storm issues.

| `1` | 0: Disable hardware interrupts. Uses memory-based polling for completion signals instead of interrupts.


1: Enable hardware interrupts (normal operation).

| | `HSA_SVM_GUARD_PAGES`


Controls the use of guard pages in Shared Virtual Memory (SVM) allocations.

| `1` | 0: Disable SVM guard pages (for debugging memory access patterns).


1: Enable SVM guard pages (normal operation).

| | `HSA_DISABLE_CACHE`


Controls GPU L2 cache utilization for all memory regions.

| `0` | 0: Normal caching behavior (L2 cache enabled).


1: Disables L2 cache entirely. Sets all memory regions as uncacheable (MTYPE=UC) in the GPU, bypassing the L2 cache. Useful for diagnosing cache-related performance or correctness issues.

| ## HIPCC environment variables This topic provides descriptions of the HIPCC environment variables. | Environment variable | Value | |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `HIP_PLATFORM`


The platform targeted by HIP. If `HIP_PLATFORM` isn’t set, then [HIPCC](https://rocm.docs.amd.com/projects/HIPCC/en/latest/index.html) attempts to auto-detect the platform based on whether the `nvcc` tool is found.

| `amd`, `nvidia` | | `HIP_PATH`


The path of the HIP SDK on Microsoft Windows for AMD platforms.

| Default: `C:/hip` | | `ROCM_PATH`


The path of the installed ROCm software stack on Linux for AMD platforms.

| Default: `/opt/rocm` | | `CUDA_PATH`


Path to the CUDA SDK, which is only used for NVIDIA platforms.

| Default: `/usr/local/cuda` | | `HIP_CLANG_PATH`


Path to the clang, which is only used for AMD platforms.

| Default: `ROCM_PATH/llvm/bin` or `HIP_PATH/../llvm/bin"` | | `HIP_LIB_PATH`


The HIP device library installation path.

| Default: `HIP_PATH/lib` | | `HIP_DEVICE_LIB_PATH`


The HIP device library installation path.

| | | `HIPCC_COMPILE_FLAGS_APPEND`


Append extra flags as compilation options to `hipcc`.

| | | `HIPCC_LINK_FLAGS_APPEND`


Append extra flags as compilation options to `hipcc`.

| | | `HIPCC_VERBOSE`


Outputs detailed information on subcommands executed during compilation.


**Note:** The `--hipcc-verbose=` command-line option provides


equivalent functionality and takes precedence over this variable when both are set.

| 1: Displays the command to `clang++` or `nvcc` with all options (`hipcc-cmd`).


2: Displays all relevant environment variables and their values.


4: Displays only the arguments passed to the `hipcc` command (`hipcc_args`).


5: Displays both the command to `clang++` or `nvcc` and `hipcc` arguments (`hipcc-cmd` and `hipcc-args`).


6: Displays all relevant environment variables and their values, along with the arguments to the `hipcc` command.


7: Displays all of the above: `hipcc-cmd`, `hipcc-args`, and environment variables.

| ## Environment variables in ROCm libraries Many ROCm libraries define environment variables for specific tuning, debugging, or behavioral control. The table below provides an overview and links to further documentation. | Library | Purpose of Environment Variables | |--------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [hipBLASLt](https://rocm.docs.amd.com/projects/hipBLASLt/en/latest/reference/env-variables.html) | Manage logging, debugging, offline tuning, and stream-K configuration
for hipBLASLt. | | [hipFile](https://rocm.docs.amd.com/projects/hipFile/en/latest/reference/hipFile-environment-variables.html) | Control compatibility modes, supported file systems, and statistics collection. | | [hipSPARSELt](https://rocm.docs.amd.com/projects/hipSPARSELt/en/latest/reference/env-variables.html) | Control logging, debugging and performance monitoring of hipSPARSELt. | | [rocBLAS](https://rocm.docs.amd.com/projects/rocBLAS/en/latest/reference/env-variables.html) | Performance tuning, kernel selection, logging, and debugging for BLAS
operations. | | [rocSHMEM](https://rocm.docs.amd.com/projects/rocSHMEM/en/latest/env_variables.html) | Control the behavior of rocSHMEM. | | [rocSOLVER](https://rocm.docs.amd.com/projects/rocSOLVER/en/latest/reference/env_variables.html) | Control logging of rocSOLVER. | | [rocSPARSE](https://rocm.docs.amd.com/projects/rocSPARSE/en/latest/reference/env_variables.html) | Control logging of rocSPARSE. | | [MIGraphX](https://rocm.docs.amd.com/projects/AMDMIGraphX/en/latest/reference/MIGraphX-dev-env-vars.html) | Control debugging, testing, and model performance tuning options for
MIGraphX. | | [MIOpen](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/env_variables.html) | Control MIOpen logging and debugging, find mode and algorithm behavior
and others. | | [MIVisionX](https://rocm.docs.amd.com/projects/MIVisionX/en/latest/reference/MIVisionX-env-variables.html) | Control core OpenVX, GPU/device and debugging/profiling, stitching and
chroma key configurations, file I/O operations, model deployment, and
neural network parameters of MIVisionX. | | [RCCL](https://rocm.docs.amd.com/projects/rccl/en/latest/api-reference/env-variables.html) | Control the logging, debugging, compiler and assembly behavior, and
cache of RPP. | | [RPP](https://rocm.docs.amd.com/projects/rpp/en/latest/reference/rpp-env-variables.html) | Logging, debugging, compiler and assembly management, and cache control in RPP | | [Tensile](https://rocm.docs.amd.com/projects/Tensile/en/latest/src/reference/environment-variables.html) | Enable testing, debugging, and experimental features for Tensile clients and applications | ## Key single-variable details This section provides detailed descriptions, in the standard format, for ROCm libraries that feature a single, key environment variable (or a very minimal set) which is documented directly on this page for convenience. ### rocALUTION | Environment variable | Value | |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------| | `ROCALUTION_LAYER`


If set to `1`, enable file logging. Logs each rocALUTION function call including object constructor/destructor, address of the object, memory allocation, data transfers, all function calls for matrices, vectors, solvers, and preconditioners. The log file is placed in the working directory.

| `1` (Enable trace file logging)


Default: Not set.

| --- Source: https://rocm.docs.amd.com/en/latest/reference/environment-variables/setting-cus.html # Set the number of compute units ![image](images/shared/compute-unit.png) The GPU driver provides two environment variables to set the number of compute units (CUs) used: - `HSA_CU_MASK` - `ROC_GLOBAL_CU_MASK` The `ROC_GLOBAL_CU_MASK` variable sets the CU mask on queues created by HIP or OpenCL runtimes. The `HSA_CU_MASK` variable sets the mask on a lower level of queue creation in the driver. It also sets the mask on the queues being profiled. #### NOTE When using GPUs to accelerate compute workloads, it sometimes becomes necessary to configure the hardware’s usage of compute units (CU). This is a more advanced option, so please read this page before experimentation. The environment variables have the following syntax: ```default ID = [0-9][0-9]* ex. base 10 numbers ID_list = (ID | ID-ID)[, (ID | ID-ID)]* ex. 0,2-4,7 GPU_list = ID_list ex. 0,2-4,7 CU_list = 0x[0-F]* | ID_list ex. 0x337F OR 0,2-4,7 CU_Set = GPU_list : CU_list ex. 0,2-4,7:0-15,32-47 OR 0,2-4,7:0x337F HSA_CU_MASK = CU_Set [; CU_Set]* ex. 0,2-4,7:0-15,32-47; 3-9:0x337F ``` The GPU indices are taken post `ROCR_VISIBLE_DEVICES` reordering. The listed or masked CUs are enabled for listed GPUs, and the others are disabled. Unlisted GPUs are not be affected, and their CUs are enabled. The variable parsing stops when a syntax error occurs. The erroneous set and the following are ignored. Repeating GPU or CU IDs results in a syntax error. Specifying a mask with no usable CUs (CU_list is 0x0) results in a syntax error. To exclude GPU devices, use `ROCR_VISIBLE_DEVICES`. #### NOTE These environment variables only affect ROCm software, not graphics applications. Not all CU configurations are valid on all devices. For example, on devices where two CUs can be combined into a WGP (for kernels running in WGP mode), it’s not valid to disable only a single CU in a WGP. --- Source: https://rocm.docs.amd.com/en/latest/reference/hip-programming.html # AMD GPU programming on ROCm ROCm provides a robust environment for heterogeneous programs running on CPUs and AMD GPUs. ROCm supports various programming languages and frameworks to help developers access the power of AMD GPUs. The natively supported programming languages are HIP and OpenCL, but HIP bindings are available for Python and Fortran. #### NOTE For a complete description of the HIP programming language, see the [HIP documentation](https://rocm.docs.amd.com/projects/HIP/en/latest/index.html). #### NOTE Developers who require a unified, book-style reference for ROCm and HIP can consult the [ROCm handbook](https://rocm-handbook.amd.com/en/latest/index.html). It aggregates documentation from the ROCm portal and organizes it into a structured format optimized for in-depth study and offline access in both PDF and HTML formats. The handbook includes the following volumes: * [AMD ROCm Programming Guide](https://rocm-handbook.amd.com/projects/amd-rocm-programming-guide/en/latest/) * [AMD ROCm Optimization Guide](https://rocm-handbook.amd.com/projects/amd-rocm-optimization-guide/en/latest/) HIP is an API based on C++ that provides a runtime and kernel language for GPU programming and is the essential ROCm programming language. HIP enables single-source C++ programming with support for templates, C++11 lambdas, classes, and namespaces, letting developers create applications that run on heterogeneous systems using both CPUs and AMD GPUs from a single code base. HIP provides two components: code that runs on the host (CPU) and code that runs on the device (GPU). Host code manages device buffers, moves data between host and device, launches kernels, and handles streams, events, and synchronization. The kernel language provides access to GPU-specific hardware capabilities for massively parallel execution. ROCm includes a complete toolchain: compilers ([clang](https://rocm.docs.amd.com/projects/llvm-project/en/latest/index.html), [hipcc](https://rocm.docs.amd.com/projects/HIPCC/en/latest/index.html)), a code profiler ([rocprofv3](https://rocm.docs.amd.com/projects/rocprofiler-sdk/en/latest/how-to/using-rocprofv3.html)), and a debugger ([rocgdb](https://rocm.docs.amd.com/projects/ROCgdb/en/latest/index.html)). ROCm also provides libraries such as [hipFFT](https://rocm.docs.amd.com/projects/hipFFT/en/latest/index.html) and [hipBLAS](https://rocm.docs.amd.com/projects/hipBLAS/en/latest/index.html) that offer API compatibility with equivalent NVIDIA CUDA libraries, making it easier to integrate into existing workflows. Developers with CUDA experience will find the HIP API familiar. HIP allows code written for CUDA to be ported to AMD GPUs. [HIPIFY](https://rocm.docs.amd.com/projects/HIPIFY/en/latest/index.html), based on the Clang front-end and Perl, can convert CUDA API calls into the corresponding HIP API calls. However, HIP is not a drop-in replacement for CUDA, and some manual coding and performance tuning may be required when porting existing projects to AMD GPUs. Python bindings can be found at [ROCm/hip-python](https://github.com/ROCm/hip-python). Python is popular in AI and machine learning applications due to the availability of frameworks such as PyTorch and TensorFlow. Fortran bindings can be found at [ROCm/hipfort](https://github.com/ROCm/hipfort). It enables scientific, academic, and legacy applications, particularly those in high-performance computing, to run on AMD GPUs via HIP. OpenCL (Open Computing Language) is an open standard for cross-platform, parallel programming of diverse processors. ROCm supports OpenCL for developers who want to use standard frameworks across different hardware platforms, including CPUs, GPUs, and APUs. For more information, see [OpenCL](https://www.khronos.org/opencl/). --- Source: https://rocm.docs.amd.com/en/latest/contribute/contributing.html # Contributing to ROCm documentation ROCm documentation is open source and available on GitHub. You can contribute to ROCm documentation by cloning the appropriate repository, making your changes, and opening a pull request. #### NOTE To provide feedback on the ROCm documentation without contributing to it, see [Providing feedback about the ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/feedback.html). The documentation for ROCm and for all ROCm components is under their respective `docs` folders. The `docs` folders for all components across ROCm have the same structure: | Sub-folder name | Documentation type | |-------------------|------------------------------------------------------------------| | `install` | Installation instructions, build instructions, and prerequisites | | `conceptual` | Important concepts | | `how-to` | How to implement specific use cases | | `tutorials` | Tutorials | | `reference` | API references and other reference resources | | `sphinx` | `_toc.yaml.in` file | ROCm stack documentation differs from this structure. Most documentation topics are written in [reStructuredText (rst)](https://www.sphinx-doc.org/en/master/usage/restructuredtext/index.html), with some topics written in Markdown. Only use reStructuredText when adding new topics. Only use Markdown if the topic you are editing is already in Markdown. To edit or add to the documentation, first clone the appropriate repository, ensuring that you follow the repository recommendations as outlined in their respective README files: | Module | Repository | |-----------------------|---------------------------------------------------------------| | ROCm stack | [ROCm/rocm-docs](https://github.com/ROCm/rocm-docs) | | ROCm libraries | [ROCm/rocm-libraries](https://github.com/ROCm/rocm-libraries) | | ROCm systems projects | [ROCm/rocm-systems](https://github.com/ROCm/rocm-systems) | #### NOTE Individual components in the ROCm libraries and the ROCm systems projects repositories are located under the `projects` folder. Some components have their own individual repositories. Each component has a link to its GitHub location from its documentation. Cut a local branch from the `develop` branch of the repository and make your changes. Your changes must adhere to the [Google developer documentation style guide](https://developers.google.com/style/highlights). If you’re adding a topic, provide a link to it from the `index.rst` and `_toc.yaml.in` files. Build the documentation locally to verify your changes. #### NOTE If you’re making changes to the Doxygen comments within the source code, delete the `docs/doxygen/xml` and `docs/doxygen/html` folders between each build. From within the `docs` directory, run: ```bash python3 -m sphinx -T -E -b html -d _build/doctrees -D language=en . _build/html ``` The output will be saved to the `docs/_build` folder. Open `docs/_build/html/index.html` to view the documentation. #### NOTE If your build returns an error due to missing packages, run `pip3 install -r sphinx/requirements.txt` This command only needs to be run once. Once you’ve verified your changes, push your branch and create a pull request. Your pull request will be reviewed by a member of the ROCm documentation team. For information about how to clone a repository, or how to create and push a local branch, see the [GitHub documentation](https://docs.github.com/en). For information about ROCm build tools, see [Documentation toolchain](https://rocm.docs.amd.com/en/latest/contribute/toolchain.html). #### IMPORTANT By creating a pull request (PR), you agree to allow your contribution to be licensed under the terms of the LICENSE.txt file in the corresponding repository. Different repositories can use different licenses. --- Source: https://rocm.docs.amd.com/en/latest/contribute/toolchain.html # ROCm documentation toolchain The ROCm documentation relies on several open source toolchains and sites. ## rocm-docs-core [rocm-docs-core](https://github.com/ROCm/rocm-docs-core) is an AMD-maintained project that applies customizations for the ROCm documentation. This project is the tool most ROCm repositories use as part of their documentation build pipeline. It is available as a [pip package on PyPI](https://pypi.org/project/rocm-docs-core/). See the user and developer guides for rocm-docs-core at [rocm-docs-core documentation](https://rocm.docs.amd.com/projects/rocm-docs-core/en/latest/index.html). ## Sphinx [Sphinx](https://www.sphinx-doc.org/en/master/) is a documentation generator originally used for Python. It is now widely used in the open source community. ### Sphinx External ToC [Sphinx External ToC](https://sphinx-external-toc.readthedocs.io/en/latest/intro.html) is a Sphinx extension used for ROCm documentation navigation. This tool generates a navigation menu on the left based on a YAML file (`_toc.yml.in`) that contains the table of contents. ### Sphinx-book-theme [Sphinx-book-theme](https://sphinx-book-theme.readthedocs.io/en/latest/) is a Sphinx theme that defines the base appearance for ROCm documentation. ROCm documentation applies some customization, such as a custom header and footer, on top of the Sphinx Book Theme. ### Sphinx Design [Sphinx design](https://sphinx-design.readthedocs.io/en/latest/index.html) is a Sphinx extension that adds design functionality. ROCm documentation uses Sphinx Design for grids, cards, and synchronized tabs. ## Doxygen [Doxygen](https://www.doxygen.nl/) is a documentation generator that extracts information from in-code comments. It is used for API documentation. ## Breathe [Breathe](https://www.breathe-doc.org/) is a Sphinx plugin for integrating Doxygen content. ## Read the Docs [Read the Docs](https://docs.readthedocs.io/en/stable/) is the service that builds and hosts the HTML version of the ROCm documentation. --- Source: https://rocm.docs.amd.com/en/latest/contribute/building.html # Building documentation ## GitHub If you open a pull request and scroll down to the summary panel, there is a commit status section. Next to the line `docs/readthedocs.com:advanced-micro-devices-demo`, there is a `Details` link. If you click this, it takes you to the Read the Docs build for your pull request. ![GitHub PR commit status](data/contribute/commit-status.png) If you don’t see this line, click `Show all checks` to get an itemized view. ## Command line You can build our documentation via the command line using Python. See the `build.tools.python` setting in the [Read the Docs configuration file](https://github.com/ROCm/ROCm/blob/develop/.readthedocs.yaml) for the Python version used by Read the Docs to build documentation. See the [Python requirements file](https://github.com/ROCm/ROCm/blob/develop/docs/sphinx/requirements.txt) for Python packages needed to build the documentation. Use the Python Virtual Environment (`venv`) and run the following commands from the project root: **Linux and WSL** ```sh python3 -mvenv .venv .venv/bin/python -m pip install -r docs/sphinx/requirements.txt .venv/bin/python -m sphinx -T -E -b html -d _build/doctrees -D language=en docs _build/html ``` **Windows** ```powershell python -mvenv .venv .venv\Scripts\python.exe -m pip install -r docs/sphinx/requirements.txt .venv\Scripts\python.exe -m sphinx -T -E -b html -d _build/doctrees -D language=en docs _build/html ``` Navigate to `_build/html/index.html` and open this file in a web browser. ## Visual Studio Code With the help of a few extensions, you can create a productive environment to author and test documentation locally using Visual Studio (VS) Code. Follow these steps to configure VS Code: 1. Install the required extensions: * Python: `(ms-python.python)` * Live Server: `(ritwickdey.LiveServer)` 2. Add the following entries to `.vscode/settings.json`. ```json { "liveServer.settings.root": "/.vscode/build/html", "liveServer.settings.wait": 1000, "python.terminal.activateEnvInCurrentTerminal": true } ``` * `liveServer.settings.root`: Sets the root of the output website for live previews. Must be changed alongside the `tasks.json` command. * `liveServer.settings.wait`: Tells the live server to wait with the update in order to give Sphinx time to regenerate the site contents and not refresh before the build is complete. * `python.terminal.activateEnvInCurrentTerminal`: Activates the automatic virtual environment, so you can build the site from the integrated terminal. 3. Add the following tasks to `.vscode/tasks.json`. ```json { "version": "2.0.0", "tasks": [ { "label": "Build Docs", "type": "process", "windows": { "command": "${workspaceFolder}/.venv/Scripts/python.exe" }, "command": "${workspaceFolder}/.venv/bin/python3", "args": [ "-m", "sphinx", "-j", "auto", "-T", "-b", "html", "-d", "${workspaceFolder}/.vscode/build/doctrees", "-D", "language=en", "${workspaceFolder}/docs", "${workspaceFolder}/.vscode/build/html" ], "problemMatcher": [ { "owner": "sphinx", "fileLocation": "absolute", "pattern": { "regexp": "^(?:.*\\.{3}\\s+)?(\\/[^:]*|[a-zA-Z]:\\\\[^:]*):(\\d+):\\s+(WARNING|ERROR):\\s+(.*)$", "file": 1, "line": 2, "severity": 3, "message": 4 } }, { "owner": "sphinx", "fileLocation": "absolute", "pattern": { "regexp": "^(?:.*\\.{3}\\s+)?(\\/[^:]*|[a-zA-Z]:\\\\[^:]*):{1,2}\\s+(WARNING|ERROR):\\s+(.*)$", "file": 1, "severity": 2, "message": 3 } } ], "group": { "kind": "build", "isDefault": true } } ] } ``` > Implementation detail: two problem matchers were needed to be defined, > because VS Code doesn’t tolerate some problem information being potentially > absent. While a single regex could match all types of errors, if a capture > group remains empty (the line number doesn’t show up in all warning/error > messages) but the `pattern` references said empty capture group, VS Code > discards the message completely. 4. Configure the Python virtual environment (`venv`). From the Command Palette, run `Python: Create Environment`. Select `venv` environment and `docs/sphinx/requirements.txt`. 5. Build the docs. Launch the default build task using one of the following options: * A hotkey (the default is `Ctrl+Shift+B`) * Issuing the `Tasks: Run Build Task` from the Command Palette 6. Open the live preview. Navigate to the site output within VS Code: right-click on `.vscode/build/html/index.html` and select `Open with Live Server`. The contents should update on every rebuild without having to refresh the browser. --- Source: https://rocm.docs.amd.com/en/latest/contribute/feedback.html # Providing feedback about the ROCm documentation Feedback about the ROCm documentation is welcome. You can provide feedback about the ROCm documentation either through GitHub Discussions or GitHub Issues. ## Participating in discussions through GitHub Discussions You can ask questions, view announcements, suggest new features, and communicate with other members of the community through [GitHub Discussions](https://github.com/ROCm/TheRock/discussions). ## Submitting issues through GitHub Issues You can submit issues through [GitHub Issues](https://github.com/ROCm/TheRock/issues). When creating a new issue, follow the following guidelines: 1. Always do a search to see if the same issue already exists. If the issue already exists, upvote it, and comment or post to provide any additional details you might have. 2. If you find an issue that is similar to your issue, log your issue, then add a comment that includes a link to the similar issue, as well as its issue number. 3. Always provide as much information as possible. This helps reduce the time required to reproduce the issue. After creating your issue, make sure to check it regularly for any requests for additional information. For information about contributing content to the ROCm documentation, see [Contributing to the ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html). --- Source: https://rocm.docs.amd.com/en/latest/about/license.html # ROCm licenses MIT License Copyright © 2023 - 2026 Advanced Micro Devices, Inc. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #### NOTE The preceding license applies to the [ROCm repository](https://github.com/ROCm/ROCm), which primarily contains documentation. For licenses related to other ROCm components, refer to the following section. ## ROCm component licenses ROCm is released by Advanced Micro Devices, Inc. (AMD) and is licensed per component separately. The following table is a list of ROCm components with links to their respective license terms. These components may include third party components subject to additional licenses. Please review individual repositories for more information. | Component | License | |----------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------| | [AMD Compute Language Runtime (CLR)](https://github.com/ROCm/rocm-systems/tree/develop/projects/clr) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/clr/LICENSE.md) | | [AMD SMI](https://github.com/ROCm/amdsmi) | [MIT](https://github.com/ROCm/amdsmi/blob/amd-staging/LICENSE) | | [aomp](https://github.com/ROCm/aomp/) | [Apache 2.0](https://github.com/ROCm/aomp/blob/aomp-dev/LICENSE) | | [aomp-extras](https://github.com/ROCm/aomp-extras/) | [MIT](https://github.com/ROCm/aomp-extras/blob/aomp-dev/LICENSE) | | [AQLprofile](https://github.com/ROCm/rocm-systems/tree/develop/projects/aqlprofile/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/aqlprofile/LICENSE.md) | | [Code Object Manager (Comgr)](https://github.com/ROCm/llvm-project/tree/amd-staging/amd/comgr) | [The University of Illinois/NCSA](https://github.com/ROCm/llvm-project/blob/amd-staging/amd/comgr/LICENSE.txt) | | [Composable Kernel](https://github.com/ROCm/rocm-libraries/tree/develop/projects/composablekernel) | [MIT](https://github.com/ROCm/rocm-libraries/tree/develop/projects/composablekernel/LICENSE) | | [half](https://github.com/ROCm/half/) | [MIT](https://github.com/ROCm/half/blob/rocm/LICENSE.txt) | | [HIP](https://github.com/ROCm/rocm-systems/tree/develop/projects/hip/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/hip/LICENSE.md) | | [hipamd](https://github.com/ROCm/rocm-systems/tree/develop/projects/clr/hipamd/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/clr/hipamd/LICENSE.md) | | [hipBLAS](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipblas/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipblas/LICENSE.md) | | [hipBLASLt](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipblaslt/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipblaslt/LICENSE.md) | | [HIPCC](https://github.com/ROCm/llvm-project/tree/amd-staging/amd/hipcc) | [MIT](https://github.com/ROCm/llvm-project/blob/amd-staging/amd/hipcc/LICENSE.txt) | | [hipCUB](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipcub/) | [Custom](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipcub/LICENSE.txt) | | [hipFFT](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipfft/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipfft/LICENSE.md) | | [hipFile](https://github.com/ROCm/rocm-systems/tree/develop/projects/hipfile/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/hipfile/LICENSE.md) | | [hipfort](https://github.com/ROCm/hipfort/) | [MIT](https://github.com/ROCm/hipfort/blob/develop/LICENSE) | | [HIPIFY](https://github.com/ROCm/HIPIFY/) | [MIT](https://github.com/ROCm/HIPIFY/blob/amd-staging/LICENSE.txt) | | [hipRAND](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hiprand/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hiprand/LICENSE.md) | | [hipSOLVER](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipsolver/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipsolver/LICENSE.md) | | [hipSPARSE](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipsparse/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipsparse/LICENSE.md) | | [hipSPARSELt](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipsparselt/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipsparselt/LICENSE.md) | | [hipThreads](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipthreads/) | [Apache 2.0 with LLVM Exceptions](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipthreads/LICENSE.txt) | | [hipTensor](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hiptensor/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hiptensor/LICENSE) | | [libhipcxx](https://github.com/ROCm/libhipcxx) | [Apache 2.0 with LLVM Exceptions](https://github.com/ROCm/libhipcxx/blob/amd-develop/LICENSE.TXT) | | [llvm-project](https://github.com/ROCm/llvm-project/) | [Apache](https://github.com/ROCm/llvm-project/blob/amd-staging/LICENSE.TXT) | | [llvm-project/flang](https://github.com/ROCm/llvm-project/tree/amd-staging/flang) | [Apache 2.0](https://github.com/ROCm/llvm-project/blob/amd-staging/flang/LICENSE.TXT) | | [MIGraphX](https://github.com/ROCm/AMDMIGraphX/) | [MIT](https://github.com/ROCm/AMDMIGraphX/blob/develop/LICENSE) | | [MIOpen](https://github.com/ROCm/rocm-libraries/tree/develop/projects/miopen/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/miopen/LICENSE.md) | | [MIVisionX](https://github.com/ROCm/MIVisionX/) | [MIT](https://github.com/ROCm/MIVisionX/blob/develop/LICENSE.txt) | | [rocAL](https://github.com/ROCm/rocAL) | [MIT](https://github.com/ROCm/rocAL/blob/develop/LICENSE.txt) | | [rocALUTION](https://github.com/ROCm/rocALUTION/) | [MIT](https://github.com/ROCm/rocALUTION/blob/develop/LICENSE.md) | | [rocBLAS](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocblas/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocblas/LICENSE.md) | | [ROCdbgapi](https://github.com/ROCm/ROCdbgapi/) | [MIT](https://github.com/ROCm/ROCdbgapi/blob/amd-staging/LICENSE.txt) | | [rocDecode](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocdecode) | [MIT](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocdecode/LICENSE) | | [rocFFT](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocfft/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocfft/LICENSE.md) | | [ROCgdb](https://github.com/ROCm/ROCgdb/) | [GNU General Public License v3.0](https://github.com/ROCm/ROCgdb/blob/amd-staging/COPYING3) | | [rocJPEG](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocjpeg) | [MIT](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocjpeg/LICENSE) | | [ROCK-Kernel-Driver](https://github.com/ROCm/ROCK-Kernel-Driver/) | [GPL 2.0 WITH Linux-syscall-note](https://github.com/ROCm/ROCK-Kernel-Driver/blob/master/COPYING) | | [rocminfo](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocminfo/) | [The University of Illinois/NCSA](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocminfo/License.txt) | | [ROCm Bandwidth Test](https://github.com/ROCm/rocm_bandwidth_test/) | [MIT](https://github.com/ROCm/rocm_bandwidth_test/blob/master/LICENSE.txt) | | [ROCm CMake](https://github.com/ROCm/rocm-cmake/) | [MIT](https://github.com/ROCm/rocm-cmake/blob/develop/LICENSE) | | [ROCm Communication Collectives Library (RCCL)](https://github.com/ROCm/rccl/) | [Custom](https://github.com/ROCm/rccl/blob/develop/LICENSE.txt) | | [ROCm-Core](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocm-core/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocm-core/LICENSE.md) | | [ROCm Compute Profiler](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler-compute/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocprofiler-compute/LICENSE.md) | | [ROCm Data Center (RDC)](https://github.com/ROCm/rocm-systems/tree/develop/projects/rdc/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rdc/LICENSE.md) | | [ROCm-Device-Libs](https://github.com/ROCm/llvm-project/tree/amd-staging/amd/device-libs) | [The University of Illinois/NCSA](https://github.com/ROCm/llvm-project/blob/amd-staging/amd/device-libs/LICENSE.TXT) | | [ROCm-OpenCL-Runtime](https://github.com/ROCm/rocm-systems/tree/develop/projects/clr/opencl/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/clr/opencl/LICENSE.md) | | [ROCm Performance Primitives (RPP)](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rpp) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rpp/LICENSE) | | [ROCm SMI Lib](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocm-smi-lib/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocm-smi-lib/LICENSE.md) | | [ROCm Systems Profiler](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler-systems/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocprofiler-systems/LICENSE.md) | | [ROCm Validation Suite](https://github.com/ROCm/ROCmValidationSuite/) | [MIT](https://github.com/ROCm/ROCmValidationSuite/blob/master/LICENSE) | | [rocPRIM](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocprim/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocprim/LICENSE.md) | | [ROCProfiler](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocprofiler/LICENSE.md) | | [ROCprofiler-SDK](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler-sdk/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocprofiler-sdk/LICENSE.md) | | [rocPyDecode](https://github.com/ROCm/rocPyDecode) | [MIT](https://github.com/ROCm/rocPyDecode/blob/develop/LICENSE.txt) | | [rocRAND](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocrand/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocrand/LICENSE.md) | | [ROCR Debug Agent](https://github.com/ROCm/rocr_debug_agent/) | [The University of Illinois/NCSA](https://github.com/ROCm/rocr_debug_agent/blob/amd-staging/LICENSE.txt) | | [ROCR-Runtime](https://github.com/ROCm/rocm-systems/tree/develop/projects/rocr-runtime/) | [The University of Illinois/NCSA](https://github.com/ROCm/rocm-systems/blob/develop/projects/rocr-runtime/LICENSE.txt) | | [rocSHMEM](https://github.com/ROCm/rocSHMEM/) | [MIT](https://github.com/ROCm/rocSHMEM/blob/develop/LICENSE.md) | | [rocSOLVER](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocsolver/) | [BSD-2-Clause](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocsolver/LICENSE.md) | | [rocSPARSE](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocsparse/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocsparse/LICENSE.md) | | [rocThrust](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocthrust/) | [Apache 2.0](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocthrust/LICENSE) | | [ROCTracer](https://github.com/ROCm/rocm-systems/tree/develop/projects/roctracer/) | [MIT](https://github.com/ROCm/rocm-systems/blob/develop/projects/roctracer/LICENSE.md) | | [rocWMMA](https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocwmma/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocwmma/LICENSE.md) | | [Tensile](https://github.com/ROCm/rocm-libraries/tree/develop/shared/tensile/) | [MIT](https://github.com/ROCm/rocm-libraries/blob/develop/shared/tensile/LICENSE.md) | | [TransferBench](https://github.com/ROCm/TransferBench) | [MIT](https://github.com/ROCm/TransferBench/blob/develop/LICENSE.md) | Open sourced ROCm components are released via public GitHub repositories, packages on [https://repo.radeon.com](https://repo.radeon.com) and other distribution channels. Proprietary products are only available on [https://repo.radeon.com](https://repo.radeon.com). Proprietary components are organized in a proprietary subdirectory in the package repositories to distinguish from open sourced packages. #### NOTE The following additional terms and conditions apply to your use of ROCm technical documentation. ©2023 - 2025 Advanced Micro Devices, Inc. All rights reserved. The information presented in this document is for informational purposes only and may contain technical inaccuracies, omissions, and typographical errors. The information contained herein is subject to change and may be rendered inaccurate for many reasons, including but not limited to product and roadmap changes, component and motherboard version changes, new model and/or product releases, product differences between differing manufacturers, software changes, BIOS flashes, firmware upgrades, or the like. Any computer system has risks of security vulnerabilities that cannot be completely prevented or mitigated. AMD assumes no obligation to update or otherwise correct or revise this information. However, AMD reserves the right to revise this information and to make changes from time to time to the content hereof without obligation of AMD to notify any person of such revisions or changes. THIS INFORMATION IS PROVIDED “AS IS.” AMD MAKES NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE CONTENTS HEREOF AND ASSUMES NO RESPONSIBILITY FOR ANY INACCURACIES, ERRORS, OR OMISSIONS THAT MAY APPEAR IN THIS INFORMATION. AMD SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT WILL AMD BE LIABLE TO ANY PERSON FOR ANY RELIANCE, DIRECT, INDIRECT, SPECIAL, OR OTHER CONSEQUENTIAL DAMAGES ARISING FROM THE USE OF ANY INFORMATION CONTAINED HEREIN, EVEN IF AMD IS EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. AMD, the AMD Arrow logo, ROCm, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies. ### Package licensing #### ATTENTION ROCprof Trace Decoder and AOCC CPU optimizations are provided in binary form, subject to the license agreement enclosed on [GitHub](https://github.com/ROCm/rocprof-trace-decoder/blob/amd-mainline/LICENSE) for ROCprof Trace Decoder, and [Developer Central](https://www.amd.com/en/developer/aocc.html) for AOCC. By using, installing, copying or distributing ROCprof Trace Decoder or AOCC CPU Optimizations, you agree to the terms and conditions of this license agreement. If you do not agree to the terms of this agreement, do not install, copy or use ROCprof Trace Decoder or the AOCC CPU Optimizations. For the rest of the ROCm packages, you can find the licensing information at the following location: `/opt/rocm/share/doc//` or in the locations specified in the preceding table. For example, you can fetch the licensing information of the `amd_comgr` component (Code Object Manager) from the `/opt/rocm/share/doc/amd_comgr/LICENSE.txt` file.