Filling Performance Portability and High-Productivity Gaps for Scientific Applications with Julia and JACC

The performance gap in high-productivity languages such as Python, Julia, R, and Matlab is still an open research area in which significant investments are being made. However, the challenge of writing code once that performs efficiently across disparate hardware is made even greater by architectural heterogeneity. Our work focuses on JACC [3]1, a performance portable CPU/GPU library implementation for the scientific LLVM-based Julia programming language. Similar to Kokkos and SYCL in C++, JACC provides a simple high-level metaprogramming API for Julia. JACC leverages CPU and GPU vendor-specific backends, and thus its proposition is to reuse rather than reinvent current investments in the language. In addition, JACC is complementary to existing performance-portable solutions in Julia, such as KernelAbstractions.jl [2], which targets mainly GPUs using a fine-granularity programming model, similar to CUDA and HIP. Due to its novelty, JACC must still be evaluated across multidisciplinary science domains and heterogeneous hardware architectures.Julia is no different from other programming languages in facing performance-portability challenges. Currently, Julia's programming models tend to closely follow vendor layers, which could still be too low level, thereby hindering programming productivity. JACC addresses this challenge for Julia programmers and applications, providing a high-level API for CPU and GPU hardware, which could potentially be extended to other architectures (e.g., AI custom hardware, field-programmable gate arrays) and configurations (e.g., distributed memory, multidevice use).Our poster presents a comprehensive view of JACC for productive scientific computing. First, we describe the JACC model divided into two main components: (i) portable memory and (ii) kernel launching. JACC architecture is then described showing how it leverages four backends inside JACC, so far on top of Julia's Base Threads, CUDA, AMDGPU, and OneAPI to target multi-core CPUs, and NVIDIA, AMD, and Intel GPUs, respectively.The performance of JACC is evaluated on widely used science application workloads: Hartree-Fock, XSBench, miniBUDE, BabelStream, and LULESH on recent CPUs and NVIDIA, AMD, and Intel GPUs where possible. Our results show that JACC is competitive and can achieve performance similar to that of OpenMP, Kokkos, OpenCL, SYCL, and CUDA/HIP baseline implementations on C++, C, and Fortran for several workloads, though gaps still need to be understood for specific corner cases. We also provide a roadmap for JACC's support of multiple-GPU, shared memory and future backends (e.g. Apple's Metal for GPU) support. JACC and Julia is a strong paradigm for HPC [1] for developing performance-portable codes at a fraction of the cost.