Glossary

This guide was created for versions: v0.1.0 - Latest

Accessor

An accessor is an interface which allows a kernel function to access data managed by a buffer or image class. Accessors are used to express the dependencies among the different command groups. [sycl-spec]

Buffer

The buffer class manages data for the SYCL C++ host application and the SYCL device kernels. The buffer class acquires ownership of any host pointers, that are passed to its constructors. The buffer and accessor classes are responsible for tracking memory transfers and guaranteeing data consistency among the different kernels. The SYCL Runtime manages the memory allocations on both the host and the device within the lifetime of the buffer object.

Barrier

Command Queue Barrier

The SYCL API provides two variants for functions that force synchronisation on a SYCL command queue. The cl::sycl::queue::wait() and cl::sycl::queue::wait_and_throw() functions force the SYCL command queue to wait for the execution of the Command Group Functor before it is able to continue executing.

Kernel Execution Work Group Barrier

The Work-Group barrier, cl::sycl::group::barrier, is a memory synchronization point on a work-group. All the Work-Items of a work-group have to execute any work-item continues execution after the barrier. Additionally, any access on the corresponding memory address space before the barrier, must complete before continuing to process any data from that memory space after the barrier. Note: In OpenCL 1.2 there is no synchronization between different work-groups.[opencl-1.2-spec],[opencl-2.1-spec]

Command Group

SYCL groups OpenCL commands into a functor given a unique command group handler object to perform all the necessary work required to correctly process host data on a device using a kernel. In this way, they group the commands of transferring and processing these data in order to enqueue them on a device for execution. Command groups are submitted to a SYCL queue.[sycl-spec]

Command Group Functor

All of the OpenCL commands, memory object creation, copying, mapping and synchronization operations to correctly execute a kernel on a device are defined in a functor and called a command group functor. Command group functors executed in different threads are added to queues atomically, so it is safe to submit command group functors operating on shared queues, buffers and images.[sycl-spec]

Command Group Scope

The command group scope is the function scope defined by the command group functor. Command Group Handler object lifetime is restricted to the Command Group Scope.[sycl-spec]

Command Queue

A SYCL Command Queue is an object that holds Command Groups that will be executed on a SYCL device. SYCL provides a heterogeneous platform integration using device queue, which is the minimum requirement for a SYCL application to run on a SYCL device.

Constant Memory

A region of global memory that remains constant during the execution of a kernel [opencl-1.2-spec]. The SYCL Runtime allocates and initializes memory objects placed into constant memory.

Device

A SYCL device encapsulates OpenCL devices and the SYCL host device, which can execute SYCL kernels on host.

Device Compiler

A SYCL device compiler is a compiler that produces OpenCL device binaries from a valid SYCL program.

Functor

Functors are a concept from C++. An alternative name for function in C++ is function object. A functor is a C++ class with an operator() method that enables the object to be executed in a way that looks like a function call, but where the object itself is also passed in as a parameter.

Global ID

As in OpenCL, a global ID is used to uniquely identify a work-item and is derived from the number of global work-items specified when executing a kernel. A global ID is a one, two or three-dimensional value that starts at 0 per dimension. [sycl-spec],[opencl-1.2-spec]

Global Memory

Global memory is a memory region accessible to all work-items executing on a device. [sycl-spec],[opencl-1.2-spec]

Group Id

As in OpenCL, SYCL kernels execute in work groups. The group ID is the ID of the work group that a work item is executing within. A group ID is an one, two or three dimensional value that starts at 0 per dimension. [sycl-spec],[opencl-1.2-spec]

Group Range

A group range is the size of the Work-Group for every dimension.

Command Group Handler

The Command Group Handler class provides the interface for the commands that can be executed inside the command group scope and it is provided as a scoped object to all of the data access requests within the command group scope. [sycl-spec]

ID

It is a unique identifier of an item in an index space. It can be one, two or three dimensional index space, since the SYCL Kernel execution model is an nd-range. It is one of the Index Space Classes.

Image

Images in SYCL, like buffers, are abstractions of the OpenCL equivalent. As in OpenCL, an image stores a two- or three-dimensional structured array. The SYCL runtime will make available images in OpenCL contexts in order to execute semantically correct kernels in different OpenCL contexts. [sycl-spec]

Implementation Defined

Behavior that is explicitly allowed to vary between conforming implementations of SYCL. A SYCL implementer is required to document the implementation defined behavior.[sycl-spec]

Index Space Classes

OpenCL Kernel Execution Model defines an nd-range index space. The SYCL runtime class that defines an nd_range is the cl::sycl::nd_range, which takes as input the sizes of global and local work-items, represented using the cl::sycl::range class. The kernel library classes for indexing in the defined nd_range are the following classes: * cl::sycl::id : The basic index class representing a work-item ID. * cl::sycl::item : The index class that contains the global and local work-item ID. * cl::sycl::nd_item : The index class that contains the global, local work-item ID and the Group ID. * cl::sycl::group : The group class that contains the global and local Group ID and the methods on a Work-Group.

Integration Header

The integration header is a C++ header file generated by compute++ that includes all the information the SYCL Runtime requires to access the device kernels.

Item ID

The index class that contains the global and local Work-Item ID.

Kernel

A SYCL kernel is a C++ functor or lambda function that is compiled to execute on a device. There are several ways to define SYCL kernels defined in the SYCL specification. It is also possible in SYCL to use OpenCL kernels as specified in the OpenCL specification. Kernels can execute on either an OpenCL device or on the host.[sycl-spec]

Kernel Dispatch

Issuing a kernel to an OpenCL device.

Kernel Functor

See Kernel.

Kernel Name

A kernel name is a class type that is used to assign a name to the kernel function, used to link the host system with the kernel object output by the device compiler.[sycl-spec]

Kernel Scope

The function scope of a kernel functor or lambda function. Note that any function or method called from the kernel is also compiled in kernel scope. The kernel scope allows C++ language extensions as well as restrictions to reflect the capabilities of OpenCL devices. The extensions and restrictions are defined in the SYCL device compiler specification.[sycl-spec]

Local Memory

As in OpenCL, local memory is a memory region associated with a work-group and accessible only by work-items in that work-group.[sycl-spec]

NDRange (nd-range)

The OpenCL Execution Model is based on a three-dimensional index space, where Work-Items are grouped into Work-Groups. The size of the cl::sycl::nd_range is given by the total number of work-items per dimension and the number of work-groups per dimension. The size of an nd_range is represented using a cl::sycl::range. The minimum size of a cl::sycl::range is 1 per dimension, consequently, the minimum size of an cl::sycl::nd_range is 1 per dimension. [sycl-spec],[opencl-1.2-spec],[opencl-2.1-spec]

Platform

The host plus a collection of devices managed by the OpenCL framework that allow an application to share resources and execute kernels on devices in the platform.[opencl-2.1-spec] A SYCL application can target one or multiple OpenCL platforms provided by OpenCL device vendors.

Private Memory

A region of memory private to a work-item. Variables defined in one workitem’s private memory are not visible to another work-item. [opencl-2.1-spec]

Program Object

A program object in SYCL is an OpenCL program object encapsulated in a SYCL class. It contains OpenCL kernels and functions compiled to execute on OpenCL devices. A program object can be generated from SYCL C++ kernels by the SYCL runtime, or obtained from an OpenCL implementation.[sycl-spec]

Single Source Multiple Compiler Passes

The compilation flow technique where a single source file is parsed by multiple compilers for building native programs per compilation target. For example, a standard C++ CPU compiler for targeting host will parse the single source file to create the C++ host application which offloads parts of the computation to other devices. A SYCL device compiler will parse the same source file and target only SYCL kernels. Refer to the SYCL specification for details on the Single Source Multiple Compiler Passes (also called shared source) approach.

SYCL Host Device

The SYCL Host Device is multi-threaded native C implementation of a SYCL device. It does not have an OpenCL cl_device_id and it will only appear in the available SYCL devices, as it is not an OpenCL device. It has full SYCL capabilities and reports them through the SYCL information retrieval interface. The SYCL Host Device is mandatory for every SYCL implementation and is always available, but may not achieve the same performance as an OpenCL CPU device. Any C application debugger can be used for debugging SYCL kernels executing on a SYCL host device.

SYCL Runtime

A SYCL runtime is an implementation of the SYCL API specification. The SYCL runtime manages the different OpenCL platforms, devices, contexts as well as memory handling of data between host and OpenCL contexts to enable semantically correct execution of SYCL programs.

SYCL File

A C++ source file that contains SYCL API calls.

Work Group

The SYCL work-group (cl::sycl::group class) is a representation of an OpenCL work group. A collection of related work-items that execute on a single compute unit. The work-items in the group execute the same kernel-instance and share local memory and workgroup functions.[opencl-2.1-spec]

Work-Item

The SYCL work-item (cl::sycl::nd_item class) is a representation of an OpenCL work item. One of a collection of parallel executions of a kernel invoked on a device by a command. A work-item is executed by one or more processing elements as part of a work-group executing on a compute unit. A work-item is distinguished from other work-items by its global ID or the combination of its work-group ID and its local ID within a work-group.[opencl-2.1-spec]

Work-Item ID

Local Work-Item ID

A unique identifier of a work-item among other work-items of a Work-Group.

Global Work-Item ID

A unique identifier of a work-item among all the work-items in the nd-range.

Bibliography

[sycl-spec] Khronos OpenCL Working Group, The SYCL Specification, version 1.2, 2015. [Online]. Available: http://www.khronos.org/registry/sycl/specs/sycl-1.2.pdf

[opencl-1.2-spec] Khronos OpenCL Working Group, The OpenCL Specification, version 1.2.19, 2012. [Online]. Available: https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf

[opencl-2.1-spec] Khronos OpenCL Working Group, The OpenCL Specification, version 2.1, 2015. [Online]. Available: https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf