command_queue
A valid command-queue. The kernel will be queued for execution on
the device associated with command_queue
.
kernel
A valid kernel object. The
OpenCL context associated with kernel
and
command_queue
must be the same.
work_dim
The number of dimensions
used to specify the global work-items and work-items in the
work-group. work_dim
must be greater than zero and less
than or equal to CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS
.
global_work_offset
global_work_offset
can be used to specify an array of work_dim
unsigned
values that describe the offset used to calculate the global ID of a
work-item. If global_work_offset
is NULL, the global
IDs start at offset (0, 0, ... 0).
global_work_size
Points to an array of
work_dim
unsigned values that describe the number
of global work-items in work_dim
dimensions
that will execute the kernel function. The total number of global
work-items is computed as global_work_size
[0] *...*
global_work_size
[work_dim
- 1].
local_work_size
Points to an array of
work_dim
unsigned values that describe the number
of work-items that make up a work-group (also referred to as the
size of the work-group) that will execute the kernel specified
by kernel
. The total number of work-items in
a work-group is computed as local_work_size
[0]
*... * local_work_size
[work_dim
-
1]. The total number of work-items in the work-group must be less than
or equal to the CL_DEVICE_MAX_WORK_GROUP_SIZE
value specified in table of OpenCL Device Queries for
clGetDeviceInfo
and the number of work-items specified
in local_work_size
[0],...
local_work_size
[work_dim
- 1]
must be less than or equal to the corresponding values specified
by CL_DEVICE_MAX_WORK_ITEM_SIZES
[0],....
CL_DEVICE_MAX_WORK_ITEM_SIZES
[work_dim
- 1]. The explicitly specified local_work_size
will be used to determine how to break the global work-items specified
by global_work_size
into appropriate work-group
instances. If local_work_size
is specified,
the values specified in global_work_size
[0],...
global_work_size
[work_dim
- 1] must be evenly divisible by the corresponding values
specified in local_work_size
[0],...
local_work_size
[work_dim
- 1].
local_work_size
can also be a NULL value in which
case the OpenCL implementation will determine how to be break the global
work-items into appropriate work-group instances.
event_wait_list
and
num_events_in_wait_list
Specify events that need
to complete before this particular command can be executed. If
event_wait_list
is NULL, then this particular command does
not wait on any event to complete. If event_wait_list
is NULL, num_events_in_wait_list
must be 0. If
event_wait_list
is not NULL, the list of events
pointed to by event_wait_list
must be valid
and num_events_in_wait_list
must be greater
than 0. The events specified in event_wait_list
act as synchronization points. The context associated with events in
event_wait_list
and command_queue
must
be the same. The memory associated with event_wait_list
can be reused or freed after the function returns.
event
Returns an event object that identifies
this particular kernel execution instance. Event objects are unique and
can be used to identify a particular kernel execution instance later on. If
event
is NULL, no event will be created for this kernel
execution instance and therefore it will not be possible for the application
to query or queue a wait for this particular kernel execution instance.
The work-group size to be used for kernel
can also
be specified in the program source using the __attribute__
((reqd_work_group_size(X, Y, Z)))
qualifier. In this case the size
of work group specified by local_work_size
must match the
value specified by the reqd_work_group_size
__attribute__ qualifier.
These work-group instances are executed in parallel across multiple compute units or concurrently on the same compute unit.
Each work-item is uniquely identified by a global identifier. The global ID,
which can be read inside the kernel, is computed using the value given by
global_work_size
and global_work_offset
.
In addition, a work-item is also identified within a work-group by a unique local ID.
The local ID, which can also be read by the kernel, is computed using the value given
by local_work_size
. The starting local ID is always (0, 0, ... 0).
Returns CL_SUCCESS if the kernel execution was successfully queued. Otherwise, it returns one of the following errors:
command_queue
.
command_queue
is not a
valid command-queue.
kernel
is
not a valid kernel object.
command_queue
and kernel
is not the same
or if the context associated with command_queue
and events in
event_wait_list
are not the same.
work_dim
is not a valid value (i.e. a value between 1 and 3).
global_work_size
is NULL, or if any of the values specified in
global_work_size
[0], ...global_work_size
[work_dim
- 1] are 0 or exceed the range given by the
sizeof(size_t)
for the device on which the kernel execution will
be enqueued.
global_work_size
+ the corresponding values in
global_work_offset
for any dimensions is greater than the
sizeof(size_t)
for the device on which the kernel execution will
be enqueued.
local_work_size
is specified and number of work-items specified by
global_work_size
is not evenly divisable by size of work-group
given by local_work_size
or does not match the work-group
size specified for kernel
using the __attribute__
((reqd_work_group_size(X, Y, Z)))
qualifier in program source.
local_work_size
is specified and the total number of
work-items in the work-group computed as local_work_size
[0] *...
local_work_size
[work_dim
- 1] is greater than
the value specified by CL_DEVICE_MAX_WORK_GROUP_SIZE
in the table of OpenCL Device Queries for
clGetDeviceInfo.
local_work_size
is NULL and
the __attribute__ ((reqd_work_group_size(X,
Y, Z)))
qualifier is used to declare the work-group size for
kernel
in the program source.
local_work_size
[0],
... local_work_size
[work_dim
- 1] is greater than the corresponding values specified by
CL_DEVICE_MAX_WORK_ITEM_SIZES
[0], ....
CL_DEVICE_MAX_WORK_ITEM_SIZES
[work_dim
- 1].
offset
specified when the sub-buffer object is created is not
aligned to CL_DEVICE_MEM_BASE_ADDR_ALIGN
value for device
associated with queue
.
queue
.
queue
.
kernel
on the command-queue because of
insufficient resources needed to execute the kernel. For example, the explicitly
specified local_work_size
causes a failure to execute the kernel
because of insufficient resources such as registers or local memory. Another example
would be the number of read-only image args used in kernel
exceed the CL_DEVICE_MAX_READ_IMAGE_ARGS
value for
device or the number of write-only image args used in kernel
exceed the CL_DEVICE_MAX_WRITE_IMAGE_ARGS
value for
device or the number of samplers used in kernel
exceed
CL_DEVICE_MAX_SAMPLERS
for device.
kernel
.
event_wait_list
is NULL and
num_events_in_wait_list
> 0,
or event_wait_list
is not NULL and
num_events_in_wait_list
is 0, or if event objects in
event_wait_list
are not valid events.
clCreateCommandQueue, clGetDeviceInfo, clEnqueueNativeKernel, clEnqueueTask, Work-Item Functions