CLQueue (JavaCL Core / BridJ 1.0.0-RC4 API)

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

```
public class CLQueue
extends Object
```
OpenCL command queue.
OpenCL objects such as memory, program and kernel objects are created using a context.
Operations on these objects are performed using a command-queue.
The command-queue can be used to queue a set of operations (referred to as commands) in order.
Having multiple command-queues allows applications to queue multiple independent commands without requiring synchronization.
Note that this should work as long as these objects are not being shared.
Sharing of objects across multiple command-queues will require the application to perform appropriate synchronization.

A queue is bound to a single device. see CLDevice.createQueue(com.nativelibs4java.opencl.CLContext, com.nativelibs4java.opencl.CLDevice.QueueProperties[]) see CLDevice.createOutOfOrderQueue(com.nativelibs4java.opencl.CLContext) see CLDevice.createProfilingQueue(com.nativelibs4java.opencl.CLContext) see CLContext.createDefaultQueue(com.nativelibs4java.opencl.CLDevice.QueueProperties[]) see CLContext.createDefaultOutOfOrderQueue() see CLContext.createDefaultProfilingQueue()

Author:

Olivier Chafik

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface CLQueue.NativeKernel

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CLQueue.NativeKernel`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`CLEvent`	`enqueueAcquireGLObjects(CLMem[] objects, CLEvent... eventsToWaitFor)` Calls clEnqueueAcquireGLObjects.
`CLEvent`	`enqueueBarrier(CLEvent... eventsToWaitFor)` Calls clEnqueueBarrierWithWaitList.
`CLEvent`	`enqueueMarker(CLEvent... eventsToWaitFor)` Deprecated.
`CLEvent`	`enqueueMigrateMemObjects(CLMem[] memObjects, EnumSet<CLMem.Migration> flags, CLEvent... eventsToWaitFor)` Calls clEnqueueMigrateMemObjects.
`CLEvent`	`enqueueReleaseGLObjects(CLMem[] objects, CLEvent... eventsToWaitFor)` Calls clEnqueueReleaseGLObjects.
`void`	`enqueueWaitForEvents(CLEvent... eventsToWaitFor)` Calls clEnqueueWaitForEvents.
`boolean`	`equals(Object obj)` Underyling implementation pointer-based equality test
`void`	`finish()` Calls clFinish.
`void`	`flush()` Calls clFlush.
`CLContext`	`getContext()`
`CLDevice`	`getDevice()`
`static <E extends TypedPointer,A extends com.nativelibs4java.opencl.CLAbstractEntity> Pointer<E>`	`getEntities(A[] objects, Pointer<E> out)`
`EnumSet<CLDevice.QueueProperties>`	`getProperties()`
`int`	`hashCode()` Underyling implementation pointer-based hashCode computation
`boolean`	`isOutOfOrder()`
`void`	`release()` Manual release of the OpenCL resources represented by this object.
`void`	`setProperty(CLDevice.QueueProperties property, boolean enabled)`

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

- Method Detail
  - getContext
```
public CLContext getContext()
```
  - getDevice
```
public CLDevice getDevice()
```
  - isOutOfOrder
```
public boolean isOutOfOrder()
```
  - getProperties
```
public EnumSet<CLDevice.QueueProperties> getProperties()
```
  - setProperty
```
public void setProperty(CLDevice.QueueProperties property,
                        boolean enabled)
```
  - finish
```
public void finish()
```
    Calls clFinish.
    Blocks until all previously queued OpenCL commands in this queue are issued to the associated device and have completed.
    finish() does not return until all queued commands in this queue have been processed and completed.
    finish() is also a synchronization point.
  - flush
```
public void flush()
```
    Calls clFlush.
    Issues all previously queued OpenCL commands in this queue to the device associated with this queue.
    flush() only guarantees that all queued commands in this queue get issued to the appropriate device.
    There is no guarantee that they will be complete after flush() returns.
  - enqueueWaitForEvents
```
public void enqueueWaitForEvents(CLEvent... eventsToWaitFor)
```
    Calls clEnqueueWaitForEvents.
    Enqueues a wait for a specific event or a list of events to complete before any future commands queued in the this queue are executed.
  - enqueueMigrateMemObjects
```
public CLEvent enqueueMigrateMemObjects(CLMem[] memObjects,
                                        EnumSet<CLMem.Migration> flags,
                                        CLEvent... eventsToWaitFor)
```
    Calls clEnqueueMigrateMemObjects.
    Enqueues a command to indicate which device a set of memory objects should be associated with.
  - enqueueBarrier
```
public CLEvent enqueueBarrier(CLEvent... eventsToWaitFor)
```
    Calls clEnqueueBarrierWithWaitList.
    Enqueue a barrier operation.
    The enqueueBarrier() command ensures that all queued commands in command_queue have finished execution before the next batch of commands can begin execution.
    enqueueBarrier() is a synchronization point.
    
    Parameters:
    
    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.
  - enqueueMarker
```
@Deprecated
public CLEvent enqueueMarker(CLEvent... eventsToWaitFor)
```
    Deprecated.
    
    Calls clEnqueueMarkerWithWaitList.
    Enqueue a marker command to command_queue.
    The marker command returns an event which can be used by to queue a wait on this marker event i.e. wait for all commands queued before the marker command to complete.
    
    Parameters:
    
    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.
  - enqueueAcquireGLObjects
```
public CLEvent enqueueAcquireGLObjects(CLMem[] objects,
                                       CLEvent... eventsToWaitFor)
```
    Calls clEnqueueAcquireGLObjects.
    Used to acquire OpenCL memory objects that have been created from OpenGL objects.
    These objects need to be acquired before they can be used by any OpenCL commands queued to a command-queue.
    The OpenGL objects are acquired by the OpenCL context associated with this queue and can therefore be used by all command-queues associated with the OpenCL context.
    
    Parameters:
    
    objects - CL memory objects that correspond to GL objects.
    
    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.
  - enqueueReleaseGLObjects
```
public CLEvent enqueueReleaseGLObjects(CLMem[] objects,
                                       CLEvent... eventsToWaitFor)
```
    Calls clEnqueueReleaseGLObjects.
    Used to release OpenCL memory objects that have been created from OpenGL objects.
    These objects need to be released before they can be used by OpenGL.
    The OpenGL objects are released by the OpenCL context associated with this queue.
    
    Parameters:
    
    objects - CL memory objects that correpond to GL objects.
    
    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.
  - 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 CLQueue

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getContext

getDevice

isOutOfOrder

getProperties

setProperty

finish

flush

enqueueWaitForEvents

enqueueMigrateMemObjects

enqueueBarrier

enqueueMarker

enqueueAcquireGLObjects

enqueueReleaseGLObjects

release

getEntities

hashCode

equals