In the era of exascale computing, the landscape of high-performance hardware has become increasingly fragmented. Researchers no longer target a single CPU architecture; instead, they must navigate a sea of heterogeneous accelerators, including NVIDIA, AMD, and Intel GPUs, FPGAs, and specialized AI chips. Traditionally, achieving peak performance required writing vendor-specific code—such as CUDA for NVIDIA or ROCm for AMD—leading to "vendor lock-in" and expensive manual rewrites.
The research direction of performance portability seeks to break this cycle. The goal is to allow a single, high-level codebase to execute across diverse hardware architectures with near-native efficiency. This is achieved not through a single tool, but through a layered strategy of decoupling, abstraction, and automated specialization.
Decoupling Algorithmic Intent from Execution
The foundational principle of performance portability is the separation of concerns. By decoupling what a program should calculate (algorithmic intent) from how it should be executed (execution strategy), developers can write hardware-agnostic code.
Arvind K. Sujeeth et al. demonstrate this in OptiML: An Implicitly Parallel Domain-Specific Language for Machine Learning, where a domain-specific language (DSL) allows researchers to write high-level code that the underlying runtime automatically optimizes for either multi-core CPUs or GPUs. Similarly, in climate science, Oliver Fuhrer et al. used a DSL to separate scientific logic from hardware optimizations, enabling a near-global climate simulation to scale across thousands of GPUs in Near-global climate simulation at 1 km resolution: establishing a performance baseline on 4888 GPUs with COSMO 5.0.
This decoupling ensures that when new hardware arrives, only the backend compiler or runtime needs to be updated, rather than the entire scientific application.
Unified Interfaces and Thin Abstraction Layers
To bridge the gap between different GPU vendors, researchers often employ thin abstraction layers that map generic function calls to vendor-specific libraries.
- Macro-based mapping: Hao Lu et al. achieved exascale performance on both NVIDIA and AMD supercomputers by using a thin macro-based layer to map generic calls to CUDA and ROCm libraries, as described in Climbing the Summit and Pushing the Frontier of Mixed Precision Benchmarks at Extreme Scale.
- Unified Libraries: The Geryon library, proposed by W. Michael Brown et al., provides a unified interface for managing accelerators, allowing the same molecular dynamics code to compile for both CUDA and OpenCL.
- Standardized Runtimes: Topi Leppänen et al. argue for a centralized registry of standardized function signatures that map high-level tasks to device-specific implementations in Cross-vendor programming abstraction for diverse heterogeneous platforms.
These abstractions act as a "middleware bridge," allowing high-level frameworks like PyTorch or Julia to "free-ride" on the engineering investments of hardware vendors. For instance, Dong He et al. show in Query Processing on Tensor Computation Runtimes that database engines can inherit hardware portability by simply targeting the high-level APIs of AI frameworks.
The Micro-kernel and Macro Approach
A more granular approach to portability involves isolating hardware-specific assembly or vector instructions into the smallest possible units, known as micro-kernels.
Adrián Castelló 0001 et al. propose a system of hardware-independent macros for basic operations like vector loading and fused multiply-add. In Micro-kernels for portable and efficient matrix multiplication in deep learning, the authors demonstrate that by redefining these macros for different instruction sets (like Intel AVX or ARM Neon), high-performance kernels can be ported rapidly without rewriting the core logic.
This strategy is also effective for complex operations like convolutions. Pablo San Juan et al. show in High Performance and Portable Convolution Operators for Multicore Processors that by embedding data transformations directly into the data-packing phase of a micro-kernel, one can maintain portability while eliminating memory overhead.
Compiler-Driven Specialization
The most advanced form of performance portability leverages compilers to automatically generate architecture-specific code from high-level descriptions.
Frameworks like UNIT, described by Jian Weng et al., treat specialized hardware instructions (like NVIDIA Tensor Cores) as small programs described in a DSL. This allows the compiler to use "arithmetic isomorphism" to automatically match high-level operations to hardware capabilities. Similarly, Vicki Carrica et al. utilize Julia’s multiple dispatch to generate architecture-specific code for NVIDIA, AMD, and Apple Silicon GPUs from a single recursive implementation in Toward Portable GPU Performance: Julia Recursive Implementation of TRMM and TRSM.
By moving the burden of optimization from the human programmer to the compiler stack, as seen in the work on AutoSP by Ahan Gupta, the field is moving toward a future where "write once, run anywhere" applies even to the most demanding exascale workloads.