1. SYCL: An Introduction to SYCL

Introduction to SYCL: A Guide to Simplified Heterogeneous Computing

Introduction

With the proliferation of heterogeneous computing platforms—where CPUs, GPUs, FPGAs, and other devices work together—the need for simplified and portable programming solutions has become increasingly evident. SYCL (pronounced 'sickle') addresses this need. SYCL is a high-level C++ programming model that targets heterogeneous platforms, offering abstractions to make heterogeneous programming more straightforward. This blog post aims to introduce you to the ins and outs of SYCL programming, discussing its various components, implementations, and even providing a simple example to get you started.

Table of Contents

• What is SYCL?
• Compilation Phases in SYCL
• SYCL Implementations: tricycle, hep-c Co, and cycleGTX
• Components of a SYCL Application
• Writing a Simple SYCL Program
• Conclusion

What is SYCL?

SYCL is an acronym for "Standard for Programming Heterogeneous Systems," and it is governed by the Khronos Group. It provides a single-source programming model using standard C++. This means you can write both host and device code in the same source file. It can target various heterogeneous platforms supported by its back-ends, such as OpenCL and CUDA.

Compilation Phases in SYCL

SYCL has two primary compilation phases:

1. Host Compilation: In this phase, the host code gets compiled using a standard C++ compiler.
2. Device Compilation: In this phase, the device code is compiled using a device compiler that understands SYCL-specific constructs.

These phases enable SYCL to be highly portable while making optimal use of the underlying hardware.

SYCL Implementations: tricycle, hep-c Co, and cycleGTX

Tricycle

This is a minimal SYCL implementation designed primarily for testing and teaching purposes. It may lack some performance optimizations but serves as a good starting point for understanding SYCL.

hep-c Co

A more sophisticated implementation, hep-c Co is geared toward scientific computations and is optimized for performance in such applications.

cycleGTX

This implementation targets NVIDIA GPUs and offers high performance through various CUDA-specific optimizations.

Components of a SYCL Application

1. SYCL API: The API provides all the essential functions and objects, such as buffers, queues, and kernels, to write a SYCL application.
2. SYCL Runtime: Manages the execution of SYCL code on various devices.
3. Host Device: The CPU or the primary computing device where the SYCL application runs.
4. Backend API: The underlying API, like OpenCL or CUDA, that interfaces with the hardware.
5. Device Compiler: Compiles the SYCL code targeted at the device.

Writing a Simple SYCL Program

To give you a hands-on feel, let's write a simple SYCL program that adds two arrays.

#include <CL/sycl.hpp>
using namespace sycl;

int main() {
  // Initialize data
  const int N = 1024;
  float a[N], b[N], c[N];
  for(int i=0; i<N; i++) {
    a[i] = i;
    b[i] = i;
  }

  // Create a buffer
  buffer<float> bufferA(a, range<1>(N));
  buffer<float> bufferB(b, range<1>(N));
  buffer<float> bufferC(c, range<1>(N));

  // Create a queue
  queue myQueue;

  // Submit a command group to the queue
  myQueue.submit([&](handler& h) {
    // Create accessors
    auto accessorA = bufferA.get_access<access::mode::read>(h);
    auto accessorB = bufferB.get_access<access::mode::read>(h);
    auto accessorC = bufferC.get_access<access::mode::write>(h);

    // Define the kernel
    h.parallel_for(range<1>(N), [=](id<1> i) {
      accessorC[i] = accessorA[i] + accessorB[i];
    });
  });

  // Synchronize and copy results
  myQueue.wait();

  // Print results (optional)
  for(int i=0; i<N; i++) {
    std::cout << c[i] << " ";
  }
  std::cout << std::endl;

  return 0;
}
  

In this example, we first initialize arrays a and b and prepare to store their sum in array c. We create buffers for each array and a queue for the device. The kernel function, defined within parallel_for, performs the addition operation.

Conclusion

SYCL offers a simplified and highly portable programming model for heterogeneous computing. Its dual compilation phases, versatile implementations, and high-level abstractions make it an excellent choice for modern computing needs. Whether you're venturing into scientific computing, machine learning, or any other domain requiring high-performance calculations, SYCL is worth considering.