Minisymposium

The SYCL implementation ecosystem currently consists of two main implementations: The commercial and vendor-driven DPC++ project, led by Intel, and the independent, community-driven AdaptiveCpp project.AdaptiveCpp provides a flexible, portable heterogeneous computing framework with its support for GPUs from Intel, NVIDIA, and AMD as well as any LLVM-supported CPU.

In this presentation, we will discuss how AdaptiveCpp can help users to develop highly performant applications with reasonable effort. This includes its ability to provide a low barrier of entry to heterogeneous computing: Its support for offloading C++ standard parallelism constructs provides a convenient, high-level model, while frequently outperforming vendor compilers.Additionally, we will show how AdaptiveCpp's unique design can automatically synthesize highly-specialized kernels from portable code at runtime. This enables AdaptiveCpp to deliver highly competitive performance while potentially requiring less interaction with users than other SYCL compilers.

We argue that community-driven projects such as AdaptiveCpp are crucial to avoid the dangers of vendor lock-in, and will show how developers and scientists can engage with AdaptiveCpp and participate in its development, and thus help shape it into the tool they want.

Molecular dynamics simulations have quickly embraced General-Purpose computing on Graphics Processing Units. As GPU performance grew, the strong scaling problem became apparent due to the fixed size of typical biophysical systems.

GROMACS is a widely used molecular dynamics engine, designed for both high performance and portability across hardware and software. Originally, when GROMACS 2021 introduced support for SYCL—an open standard for parallel computing—it was only compatible with Intel GPUs. Since then, its compatibility has been significantly broadened to include GPUs from all three major vendors. Although GROMACS still recommends the CUDA backend for NVIDIA devices for optimal performance, SYCL is the recommended option for Intel and AMD GPUs.

This presentation will share insights from deploying GROMACS with SYCL across both multi-GPU and multi-node setups, using Intel oneAPI DPC++ and AdaptiveCpp runtimes. We will explore the challenges encountered and the performance levels, underscoring SYCL's potential as an efficient GPU framework.

In our presentation we explore the portability challenges and solutions encountered in adapting scientific applications to heterogeneous computing architectures using SYCL. To this end, we present two application porting efforts, HemeLB and DPEcho, spanning different scientific domains and requiring different porting strategies. DPEcho is a general relativistic magnetohydrodynamics (GR-MHD) code for compact, magnetized astrophysical objects, such as black hole accretion and stellar winds, or MHD waves. DPEcho is a SYCL + MPI rewriting of a legacy CPU-only Fortran application, written with the goals of source readability and cross-platform portability in mind. At the same time, we achieved a high performance on all tested hardware, and outperformed the original implementation on the same CPU architecture. HemeLB is a large-scale Lattice Boltzmann solver developed for simulating blood flow in sparse geometries such as the human vasculature system. It cleverly overlaps communication and computation to achieve good scaling on large-scale HPC systems. With a CUDA version already available, we pursued SYCL porting using the automatic Data Parallel C++ Compatibility (DPCT) tool, and then manually refactored sections of the code to account for differences between programming models. This resulted in a unified code tree which can execute on all major GPU architectures.

In this talk, we discuss the development of the SYCL implementation of CRK-HACC, an extreme-scale cosmological simulation code with physics for resolving gas hydrodynamics. We describe our CUDA-to-SYCL migration pipeline for producing function objects and detail how we achieved a high level of “performance portability” across GPUs from AMD, Intel, and NVIDIA, requiring us to develop an abstraction for multiple “shuffle” operations: the sycl::select_from_group function from SYCL 2020, a shuffle operation emulated via work-group local memory, and a highly specialized shuffle operation implemented for Intel GPUs in assembly (vISA). To facilitate code maintainability we also created abstractions for host-side code that is shared across HIP, SYCL, and CUDA. We believe our techniques will generalize well to other application domains and provide a balance of maintainability and performance portability.