CLKernel (JavaCL Core / BridJ 1.0.0-RC4 API)

java.lang.Object
- com.nativelibs4java.opencl.CLKernel

```
public class CLKernel
extends Object
```
OpenCL kernel.
A kernel is a function declared in a program.
A kernel is identified by the __kernel qualifier applied to any function in a program.
A kernel object encapsulates the specific __kernel function declared in a program and the argument values to be used when executing this __kernel function.

Kernels can be queued for execution in a CLQueue (see enqueueTask and enqueueNDRange) See CLProgram.createKernel(java.lang.String, java.lang.Object[]) and CLProgram.createKernels()

Author:

Olivier Chafik

Field Summary

Fields
Modifier and Type Field and Description

static Object NULL_POINTER_KERNEL_ARGUMENT

Fields
Modifier and Type	Field and Description
`static Object`	`NULL_POINTER_KERNEL_ARGUMENT`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`CLEvent`	`enqueueNDRange(CLQueue queue, int[] globalWorkSizes, CLEvent... eventsToWaitFor)` Calls clEnqueueNDRangeKernel.
`CLEvent`	`enqueueNDRange(CLQueue queue, int[] globalWorkSizes, int[] localWorkSizes, CLEvent... eventsToWaitFor)` Calls clEnqueueNDRangeKernel.
`CLEvent`	`enqueueNDRange(CLQueue queue, int[] globalOffsets, int[] globalWorkSizes, int[] localWorkSizes, CLEvent... eventsToWaitFor)` Deprecated. Use `enqueueNDRange(CLQueue, long[], long[], long[], CLEvent[])` instead.
`CLEvent`	`enqueueNDRange(CLQueue queue, long[] globalOffsets, long[] globalWorkSizes, long[] localWorkSizes, CLEvent... eventsToWaitFor)` Calls clEnqueueNDRangeKernel.
`CLEvent`	`enqueueTask(CLQueue queue, CLEvent... eventsToWaitFor)` Calls clEnqueueTask.
`boolean`	`equals(Object obj)` Underyling implementation pointer-based equality test
`Map<CLDevice,long[]>`	`getCompileWorkGroupSize()` Returns the work-group size specified by the __attribute__((reqd_work_gr oup_size(X, Y, Z))) qualifier.
`static <E extends TypedPointer,A extends com.nativelibs4java.opencl.CLAbstractEntity> Pointer<E>`	`getEntities(A[] objects, Pointer<E> out)`
`String`	`getFunctionName()` Return the kernel function name.
`Map<CLDevice,Long>`	`getLocalMemSize()` Returns the amount of local memory in bytes being used by a kernel.
`int`	`getNumArgs()` Return the number of arguments to kernel.
`Map<CLDevice,Long>`	`getPreferredWorkGroupSizeMultiple()` Returns the preferred multiple of work- group size for launch.
`CLProgram`	`getProgram()`
`Map<CLDevice,Long>`	`getWorkGroupSize()` This provides a mechanism for the application to query the maximum work-group size that can be used to execute a kernel on a specific device given by device.
`int`	`hashCode()` Underyling implementation pointer-based hashCode computation
`void`	`release()` Manual release of the OpenCL resources represented by this object.
`void`	`setArg(int i, boolean arg)` Calls clSetKernelArg.
`void`	`setArg(int i, boolean[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, byte arg)` Calls clSetKernelArg.
`void`	`setArg(int i, byte[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, char[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, com.nativelibs4java.opencl.CLAbstractEntity arg)` Calls clSetKernelArg.
`void`	`setArg(int i, double arg)` Calls clSetKernelArg.
`void`	`setArg(int i, double[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, float arg)` Calls clSetKernelArg.
`void`	`setArg(int i, float[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, int arg)` Calls clSetKernelArg.
`void`	`setArg(int i, int[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, LocalSize arg)` Calls clSetKernelArg.
`void`	`setArg(int i, long arg)` Calls clSetKernelArg.
`void`	`setArg(int i, long[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, Pointer<?> ptr)` Calls clSetKernelArg.
`void`	`setArg(int i, short arg)` Calls clSetKernelArg.
`void`	`setArg(int i, short[] arg)` Calls clSetKernelArg.
`void`	`setArg(int i, SizeT arg)` Calls clSetKernelArg.
`void`	`setArgs(Object... args)`
`void`	`setLocalArg(int argIndex, long localArgByteLength)`
`void`	`setObjectArg(int iArg, Object arg)`
`String`	`toString()`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - NULL_POINTER_KERNEL_ARGUMENT
```
public static final Object NULL_POINTER_KERNEL_ARGUMENT
```
- Method Detail
  - getProgram
```
public CLProgram getProgram()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getPreferredWorkGroupSizeMultiple
```
public Map<CLDevice,Long> getPreferredWorkGroupSizeMultiple()
```
    Returns the preferred multiple of work- group size for launch.
    This is a performance hint.
    Specifying a work- group size that is not a multiple of the value returned by this query as the value of the local work size argument to clEnqueueNDRangeKernel will not fail to enqueue the kernel for execution unless the work-group size specified is larger than the device maximum.
    
    Since:
    
    OpenCL 1.1
  - getWorkGroupSize
```
public Map<CLDevice,Long> getWorkGroupSize()
```
    This provides a mechanism for the application to query the maximum work-group size that can be used to execute a kernel on a specific device given by device.
    The OpenCL implementation uses the resource requirements of the kernel (register usage etc.) to determine what this work- group size should be.
    See CL_KERNEL_WORK_GROUP_SIZE
  - getCompileWorkGroupSize
```
public Map<CLDevice,long[]> getCompileWorkGroupSize()
```
    Returns the work-group size specified by the __attribute__((reqd_work_gr oup_size(X, Y, Z))) qualifier.
    Refer to section 6.7.2.
    If the work-group size is not specified using the above attribute qualifier (0, 0, 0) is returned.
    See CL_KERNEL_COMPILE_WORK_GROUP_SIZE
    
    Returns:
    
    for each CLDevice, array of 3 longs
  - getLocalMemSize
```
public Map<CLDevice,Long> getLocalMemSize()
```
    Returns the amount of local memory in bytes being used by a kernel.
    This includes local memory that may be needed by an implementation to execute the kernel, variables declared inside the kernel with the __local address qualifier and local memory to be allocated for arguments to the kernel declared as pointers with the __local address qualifier and whose size is specified with clSetKernelArg.
    If the local memory size, for any pointer argument to the kernel declared with the __local address qualifier, is not specified, its size is assumed to be 0.
    See CL_KERNEL_LOCAL_MEM_SIZE
  - setArgs
```
public void setArgs(Object... args)
```
  - setObjectArg
```
public void setObjectArg(int iArg,
                         Object arg)
```
  - setArg
```
public void setArg(int i,
                   LocalSize arg)
```
    Calls clSetKernelArg.
  - setLocalArg
```
public void setLocalArg(int argIndex,
                        long localArgByteLength)
```
  - setArg
```
public void setArg(int i,
                   Pointer<?> ptr)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   float[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   int[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   double[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   long[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   short[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   byte[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   boolean[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   char[] arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   SizeT arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   int arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   long arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   short arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   byte arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   boolean arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   float arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   double arg)
```
    Calls clSetKernelArg.
  - setArg
```
public void setArg(int i,
                   com.nativelibs4java.opencl.CLAbstractEntity arg)
```
    Calls clSetKernelArg.
  - enqueueTask
```
public CLEvent enqueueTask(CLQueue queue,
                           CLEvent... eventsToWaitFor)
```
    Calls clEnqueueTask.
    Enqueues a command to execute a kernel on a device.
    The kernel is executed using a single work-item.
    
    Parameters:
    
    queue -
    
    eventsToWaitFor - Events that need to complete before this particular command can be executed. Special value CLEvent.FIRE_AND_FORGET can be used to avoid returning a CLEvent.
    
    Returns:
    
    Event object that identifies this command and can be used to query or queue a wait for the command to complete, or null if eventsToWaitFor contains CLEvent.FIRE_AND_FORGET.
  - enqueueNDRange
```
public CLEvent enqueueNDRange(CLQueue queue,
                              int[] globalWorkSizes,
                              int[] localWorkSizes,
                              CLEvent... eventsToWaitFor)
```
    Calls clEnqueueNDRangeKernel.
    Enqueues a command to execute a kernel on a device (see enqueueNDRange(CLQueue, int[], int[], int[], CLEvent[]))
    
    Parameters:
    
    globalWorkSizes - Each element describes the number of global work-items in a dimension that will execute the kernel function. The total number of global work-items is computed as globalWorkSizes[0] * ... * globalWorkSizes[globalWorkSizes.length - 1].
    
    localWorkSizes - Each element describes 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 localWorkSizes[0] * ... * localWorkSizes[localWorkSizes.length - 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 4.3 and the number of work- items specified in localWorkSizes[0], ... localWorkSizes[localWorkSizes.length - 1] must be less than or equal to the corresponding values specified by CLDevice.getMaxWorkItemSizes()[dimensionIndex]. The explicitly specified localWorkSize will be used to determine how to break the global work-items specified by global_work_size into appropriate work-group instances. If localWorkSize is specified, the values specified in globalWorkSize[dimensionIndex] must be evenly divisible by the corresponding values specified in localWorkSize[dimensionIndex]. This parameter can be left null, in which case the OpenCL implementation will choose good values.
    
    queue - This kernel will be queued for execution on the device associated with that queue.
    
    eventsToWaitFor - Events that need to complete before this particular command can be executed. Special value CLEvent.FIRE_AND_FORGET can be used to avoid returning a CLEvent.
    
    Returns:
    
    Event object that identifies this command and can be used to query or queue a wait for the command to complete, or null if eventsToWaitFor contains CLEvent.FIRE_AND_FORGET.
  - enqueueNDRange
```
public CLEvent enqueueNDRange(CLQueue queue,
                              int[] globalWorkSizes,
                              CLEvent... eventsToWaitFor)
```
    Calls clEnqueueNDRangeKernel.
    Enqueues a command to execute a kernel on a device, using local work sizes chosen by the OpenCL implementation. See enqueueNDRange(CLQueue, int[], int[], int[], CLEvent[])
    
    Parameters:
    
    globalWorkSizes - Each element describes the number of global work-items in a dimension that will execute the kernel function. The total number of global work-items is computed as globalWorkSizes[0] * ... * globalWorkSizes[globalWorkSizes.length - 1].
    
    queue - This kernel will be queued for execution on the device associated with that queue.
    
    eventsToWaitFor - Events that need to complete before this particular command can be executed. Special value CLEvent.FIRE_AND_FORGET can be used to avoid returning a CLEvent.
    
    Returns:
    
    Event object that identifies this command and can be used to query or queue a wait for the command to complete, or null if eventsToWaitFor contains CLEvent.FIRE_AND_FORGET.
  - enqueueNDRange
```
public CLEvent enqueueNDRange(CLQueue queue,
                              long[] globalOffsets,
                              long[] globalWorkSizes,
                              long[] localWorkSizes,
                              CLEvent... eventsToWaitFor)
```
    Calls clEnqueueNDRangeKernel.
    Enqueues a command to execute a kernel on a device.
    
    Parameters:
    
    globalOffsets - Must be null in OpenCL 1.0. Each element describes the offset used to calculate the global ID of a work-item. If globalOffsets is null, the global IDs start at offset (0, 0, ... 0).
    
    globalWorkSizes - Each element describes the number of global work-items in a dimension that will execute the kernel function. The total number of global work-items is computed as globalWorkSizes[0] * ... * globalWorkSizes[globalWorkSizes.length - 1].
    
    localWorkSizes - Each element describes 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 localWorkSizes[0] * ... * localWorkSizes[localWorkSizes.length - 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 4.3 and the number of work- items specified in localWorkSizes[0], ... localWorkSizes[localWorkSizes.length - 1] must be less than or equal to the corresponding values specified by CLDevice.getMaxWorkItemSizes()[dimensionIndex]. The explicitly specified localWorkSize will be used to determine how to break the global work-items specified by global_work_size into appropriate work-group instances. If localWorkSize is specified, the values specified in globalWorkSize[dimensionIndex] must be evenly divisible by the corresponding values specified in localWorkSize[dimensionIndex]. This parameter can be left null, in which case the OpenCL implementation will choose good values.
    
    queue - This kernel will be queued for execution on the device associated with that queue.
    
    eventsToWaitFor - Events that need to complete before this particular command can be executed. Special value CLEvent.FIRE_AND_FORGET can be used to avoid returning a CLEvent.
    
    Returns:
    
    Event object that identifies this command and can be used to query or queue a wait for the command to complete, or null if eventsToWaitFor contains CLEvent.FIRE_AND_FORGET.
  - enqueueNDRange
```
@Deprecated
public CLEvent enqueueNDRange(CLQueue queue,
                                          int[] globalOffsets,
                                          int[] globalWorkSizes,
                                          int[] localWorkSizes,
                                          CLEvent... eventsToWaitFor)
```
    Deprecated. Use enqueueNDRange(CLQueue, long[], long[], long[], CLEvent[]) instead.
  - getNumArgs
```
public int getNumArgs()
```
    Return the number of arguments to kernel.
  - getFunctionName
```
public String getFunctionName()
```
    Return the kernel function name.
  - release
```
public void release()
```
    Manual release of the OpenCL resources represented by this object.
    Note that resources are automatically released by the garbage collector, so in general there's no need to call this method.
    In an environment with fast allocation/deallocation of large objects, it might be safer to call release() manually, though.
    Note that release() does not necessarily free the object immediately : OpenCL maintains a reference count for all its objects, and an object released on the Java side might still be pointed to by running kernels or queued operations.
  - getEntities
```
public static <E extends TypedPointer,A extends com.nativelibs4java.opencl.CLAbstractEntity> Pointer<E> getEntities(A[] objects,
                                                                                                                    Pointer<E> out)
```
  - hashCode
```
public int hashCode()
```
    Underyling implementation pointer-based hashCode computation
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Underyling implementation pointer-based equality test
    
    Overrides:
    
    equals in class Object

Class CLKernel

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NULL_POINTER_KERNEL_ARGUMENT

Method Detail

getProgram

toString

getPreferredWorkGroupSizeMultiple

getWorkGroupSize

getCompileWorkGroupSize

getLocalMemSize

setArgs

setObjectArg

setArg

setLocalArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

setArg

enqueueTask

enqueueNDRange

enqueueNDRange

enqueueNDRange

enqueueNDRange

getNumArgs

getFunctionName

release

getEntities

hashCode

equals