Our Intel® C++ Compiler Is the First to Earn Khronos SYCL* 2020 Conformance

Get the Latest on All Things CODE



It is no secret that GPU accelerators have become an important solution for parallel workloads ranging from AI to HPC to image processing. Until recently, the programming model for these platforms has been dominated by proprietary languages that lock application developers to a single vendor’s hardware. The Khronos Group has been solving this problem, though, by defining SYCL*, a new multi-vendor open standard for programming GPUs and other offload accelerators. SYCL is based on modern C++ programming features, and it provides an API that can target any vendor’s GPU devices or even other accelerator devices, like field-programmable gate arrays (FPGAs).

The Khronos Group ratified the SYCL 2020 specification early in 2021, and vendors have been working hard to achieve full conformance to the specification since then. Intel Corporation recently became the first vendor to do this with the 2024.1 release of the Intel® oneAPI DPC++/C++ Compiler.

The Khronos Group does not just take a vendor’s word when they claim conformance. In addition to publishing a specification for SYCL, the Khronos Group also provides a comprehensive SYCL conformance test suite. To claim conformance, a vendor must first demonstrate that its compiler passes this test suite. This level of rigor is good for the industry because it helps ensure that application code is portable from one vendor’s compiler to another.

Applications written in C++ with SYCL are also portable across different vendors’ hardware, but the responsibility is shared between the compiler and the application developer. A fundamental challenge is that GPU features differ from one vendor to another, and even more so from one type of accelerator (e.g., GPU) to another (e.g., FPGA). History has shown that hiding these differences often leads to code that performs poorly or code that runs with vastly different performance on different vendors’ hardware.

SYCL takes a different approach and exposes these differences to the programmer. Application developers can then decide whether portability across vendor hardware is important. If a developer only cares to run an application on a single vendor’s hardware, they can simply use the features that are supported on that hardware. However, if a developer wants to write a portable application, they can use the rich query mechanisms in the SYCL language to conditionally make use of features that each device provides, eking out the last bit of performance on each hardware device. The power of SYCL is that it provides a common programming language that can be used across diverse types of accelerators while still exposing the features that are unique to each of those accelerators.

With Intel’s announcement of the first conformant SYCL compiler, this portability is now available to developers. Application developers can make use of the full set of features in the SYCL 2020 specification, with the assurance that their code will be portable to any other compiler that is conformant to that specification.

In this world of accelerators, we do need to ask what SYCL compiler means in this context. First, it is a C++ compiler with SYCL support. C++ compilers might also support other parallelization or offloading with another standard such as OpenMP*. It is important to know we are programming in C++ with some added support to give us control over offloading data and computations to accelerators. Secondly, conformance is proven with a combination of a compiler and runtime(s). Therefore, the Khronos website lists the conformant products (link is given at the end of this article) in a precise enough fashion to see what has passed the rigors of submission, review, and acceptance.

I will conclude with a list of some of the most valuable resources to learn more about SYCL and this first conformant SYCL compiler: