AMD Radeon Open Compute ROCm 3.5 released

Drivers 2920 Published by

AMD has released a new version of the Radeon Open Compute Linux stack for AMD graphics cards.





ROCm is designed to be a universal platform for gpu-accelerated computing. This modular design allows hardware vendors to build drivers that support the ROCm framework. ROCm is also designed to integrate multiple programming languages and makes it easy to add support for other languages.

Note: You can also clone the source code for individual ROCm components from the GitHub repositories.

ROCm Components

The following components for the ROCm platform are released and available for the v2.10 release:
• Drivers
• Tools
• Libraries
• Source Code

You can access the latest supported version of drivers, tools, libraries, and source code for the ROCm platform at the following location: https://github.com/RadeonOpenCompute/ROCm

Supported Operating Systems

The AMD ROCm v3.5.x platform is designed to support the following operating systems:
  • Ubuntu 16.04.6(Kernel 4.15) and 18.04.4(Kernel 5.3)
  • CentOS 7.7 (Kernel 3.10-1062) and RHEL 7.8(Kernel 3.10.0-1127)(Using devtoolset-7 runtime support)
  • SLES 15 SP1
  • CentOS and RHEL 8.1(Kernel 4.18.0-147)

Whats New in This Release

Upgrading to This Release

You must perform a fresh and a clean AMD ROCm install to successfully upgrade from v3.3 to v3.5. The following changes apply in this release:

  • HCC is deprecated and replaced with the HIP-Clang compiler
  • HIP-HCC runtime is changed to Radeon Open Compute Common Language Runtime (HIP-ROCClr)
  • In the v3.5 release, the firmware is separated from the kernel package. The difference is as follows:
    • v3.5 release has two separate rock-dkms and rock-dkms-firmware packages
    • v3.3 release had the firmware as part of the rock-dkms package

rocProf Command Line Tool Python Requirement

SQLite3 is a required Python module for the rocprof command-line tool. You can install the SQLite3 Python module using the pip utility and set env var ROCP_PYTHON_VERSION to the Python version, which includes the SQLite3 module.

Heterogeneous-Compute Interface for Portability

In this release, the Heterogeneous Compute Compiler (HCC) compiler is deprecated and the HIP-Clang compiler is introduced for compiling Heterogeneous-Compute Interface for Portability (HIP) programs.

NOTE: The HCC environment variables will be gradually deprecated in subsequent releases.

The majority of the codebase for the HIP-Clang compiler has been upstreamed to the Clang trunk. The HIP-Clang implementation has undergone a strict code review by the LLVM/Clang community and comprehensive tests consisting of LLVM/Clang build bots. These reviews and tests resulted in higher productivity, code quality, and lower cost of maintenance.

For most HIP applications, the transition from HCC to HIP-Clang is transparent and efficient as the HIPCC and HIP cmake files automatically choose compilation options for HIP-Clang and hide the difference between the HCC and HIP-Clang code. However, minor changes may be required as HIP-Clang has a stricter syntax and semantic checks compared to HCC.

NOTE: Native HCC language features are no longer supported.

Radeon Open Compute Common Language Runtime

In this release, the HIP runtime API is implemented on top of Radeon Open Compute Common Language Runtime (ROCclr). ROCclr is an abstraction layer that provides the ability to interact with different runtime backends such as ROCr.

OpenCL Runtime

The following OpenCL runtime changes are made in this release:

  • AMD ROCm OpenCL Runtime extends support to OpenCL2.2
  • The developer branch is changed from master to master-next

AMD ROCm GNU Debugger (ROCgdb)

The AMD ROCm Debugger (ROCgdb) is the AMD ROCm source-level debugger for Linux based on the GNU Debugger (GDB). It enables heterogeneous debugging on the AMD ROCm platform of an x86-based host architecture along with AMD GPU architectures and supported by the AMD Debugger API Library (ROCdbgapi).

The AMD ROCm Debugger is installed by the rocm-gdb package. The rocm-gdb package is part of the rocm-dev meta-package, which is in the rocm-dkms package.

The current AMD ROCm Debugger (ROCgdb) is an initial prototype that focuses on source line debugging. Note, symbolic variable debugging capabilities are not currently supported.

You can use the standard GDB commands for both CPU and GPU code debugging. For more information about ROCgdb, refer to the ROCgdb User Guide, which is installed at:

  • /opt/rocm/share/info/gdb.info as a texinfo file
  • /opt/rocm/share/doc/gdb/gdb.pdf as a PDF file

The AMD ROCm Debugger User Guide is available as a PDF at:

https://github.com/RadeonOpenCompute/ROCm/blob/master/gdb.pdf

For more information about GNU Debugger (GDB), refer to the GNU Debugger (GDB) web site at:  http://www.gnu.org/software/gdb

AMD ROCm Debugger API Library

The AMD ROCm Debugger API Library (ROCdbgapi) implements an AMD GPU debugger application programming interface (API) that provides the support necessary for a client of the library to control the execution and inspect the state of AMD GPU devices.

The following AMD GPU architectures are supported:

  • Vega 10
  • Vega 7nm

The AMD ROCm Debugger API Library is installed by the rocm-dbgapi package. The rocm-gdb package is part of the rocm-dev meta-package, which is in the rocm-dkms package. The AMD ROCm Debugger API Specification is available as a PDF at:

https://github.com/RadeonOpenCompute/ROCm/blob/master/amd-dbgapi.pdf

rocProfiler Dispatch Callbacks Start Stop API

In this release, a new rocprofiler start/stop API is added to enable/disable GPU kernel HSA dispatch callbacks. The callback can be registered with the 'rocprofiler_set_hsa_callbacks' API. The API helps you eliminate some profiling performance impact by invoking the profiler only for kernel dispatches of interest. This optimization will result in significant performance gains.

The API provides the following functions:

  • hsa_status_t rocprofiler_start_queue_callbacks(); is used to start profiling
  • hsa_status_t rocprofiler_stop_queue_callbacks(); is used to stop profiling.

For more information on kernel dispatches, see the HSA Platform System Architecture Specification guide at  http://www.hsafoundation.com/standards/.

ROCm Communications Collective Library

The ROCm Communications Collective Library (RCCL) consists of the following enhancements:

  • Re-enable target 0x803
  • Build time improvements for the HIP-Clang compiler

NVIDIA Communications Collective Library Version Compatibility

AMD RCCL is now compatible with NVIDIA Communications Collective Library (NCCL) v2.6.4 and provides the following features:

  • Network interface improvements with API v3
  • Network topology detection
  • Improved CPU type detection
  • Infiniband adaptive routing support

MIOpen Optional Kernel Package Installation

MIOpen provides an optional pre-compiled kernel package to reduce startup latency.

NOTE: The installation of this package is optional. MIOpen will continue to function as expected even if you choose to not install the pre-compiled kernel package. This is because MIOpen compiles the kernels on the target machine once the kernel is run. However, the compilation step may significantly increase the startup time for different operations.

To install the kernel package for your GPU architecture, use the following command:

apt-get install miopen-kernels--

  • is the GPU architecture. For example, gfx900, gfx906
  • is the number of CUs available in the GPU. For example, 56 or 64

New SMI Event Interface and Library

A Systems Management Interface (SMI) event interface is added to the kernel and ROCm SMI lib for system administrators to get notified when specific events occur. On the kernel side, AMDKFD_IOC_SMI_EVENTS input/output control is enhanced to allow notifications propagation to user mode through the event channel.

On the ROCm SMI lib side, APIs are added to set an event mask and receive event notifications with a timeout option. Further, ROCm SMI API details can be found in the PDF generated by Doxygen from source or by referring to the rocm_smi.h header file (see the rsmi_event_notification_* functions).

For the more details about ROCm SMI API, see

https://github.com/RadeonOpenCompute/ROCm/blob/master/ROCm_SMI_Manual.pdf

API for CPU Affinity

A new API is introduced for aiding applications to select the appropriate memory node for a given accelerator(GPU).

The API for CPU affinity has the following signature:

*rsmi_status_t rsmi_topo_numa_affinity_get(uint32_t dv_ind, uint32_t numa_node);

This API takes as input, device index (dv_ind), and returns the NUMA node (CPU affinity), stored at the location pointed by numa_node pointer, associated with the device.

Non-Uniform Memory Access (NUMA) is a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to the processor.

Radeon Performance Primitives Library

The new Radeon Performance Primitives (RPP) library is a comprehensive high-performance computer vision library for AMD (CPU and GPU) with the HIP and OpenCL backend. The target operating system is Linux.

For more information about prerequisites and library functions, see

https://github.com/GPUOpen-ProfessionalCompute-Libraries/MIVisionX/tree/master/docs

Download

MODICIA O.S. Review

OneDrive lets you fetch files from remote PC

Windows

Linux

macOS

Community

  • dhamu
    Hello Phil, I have a Linux Tutorial website that curre ...
  • StephanX
    Hi friends, i am new in the Linux universe but i try to ...
  • Philipp
    I would try the XanMod kernel: https://xanmod.org  I ...