diff options
Diffstat (limited to 'src/com/jogamp/opencl/CLCommandQueue.java')
| -rw-r--r-- | src/com/jogamp/opencl/CLCommandQueue.java | 1585 |
1 files changed, 1585 insertions, 0 deletions
diff --git a/src/com/jogamp/opencl/CLCommandQueue.java b/src/com/jogamp/opencl/CLCommandQueue.java new file mode 100644 index 00000000..1781a8ae --- /dev/null +++ b/src/com/jogamp/opencl/CLCommandQueue.java @@ -0,0 +1,1585 @@ +package com.jogamp.opencl; + +import com.jogamp.common.nio.Int64Buffer; +import com.jogamp.opencl.gl.CLGLI; +import com.jogamp.common.nio.PointerBuffer; +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.List; + +import static com.jogamp.opencl.CLException.*; +import static com.jogamp.opencl.CL.*; +import static com.jogamp.opencl.util.CLUtil.*; + +/** + * The command queue is used to queue a set of operations for a specific {@link CLDevice}. + * 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.<br/> + * Sharing of objects across multiple queues or using a CLCommandQueue + * form multiple Threads will require the application to perform appropriate synchronization. + * @see CLDevice#createCommandQueue(com.jogamp.opencl.CLCommandQueue.Mode...) + * @author Michael Bien + */ +public class CLCommandQueue extends CLObject implements CLResource { + + private final CLDevice device; + private long properties; + + /* + * Those direct memory buffers are used to move data between the JVM and OpenCL. + */ + private final PointerBuffer pbA; + private final Int64Buffer ibA; + private final Int64Buffer ibB; + private final Int64Buffer ibC; + + private CLCommandQueue(CLContext context, long id, CLDevice device, long properties) { + super(context, id); + + this.device = device; + this.properties = properties; + + this.ibA = Int64Buffer.allocateDirect(3); + this.ibB = Int64Buffer.allocateDirect(3); + this.ibC = Int64Buffer.allocateDirect(3); + + this.pbA = PointerBuffer.allocateDirect(1); + + } + + static CLCommandQueue create(CLContext context, CLDevice device, long properties) { + int[] status = new int[1]; + long id = context.cl.clCreateCommandQueue(context.ID, device.ID, properties, status, 0); + + if(status[0] != CL_SUCCESS) { + throw newException(status[0], "can not create command queue on " + device +" with properties: " + Mode.valuesOf(properties)); + } + + return new CLCommandQueue(context, id, device, properties); + } + + /** + * Calls {@native clEnqueueWriteBuffer}. + */ + public CLCommandQueue putWriteBuffer(CLBuffer<?> writeBuffer, boolean blockingRead) { + return putWriteBuffer(writeBuffer, blockingRead, null, null); + } + + /** + * Calls {@native clEnqueueWriteBuffer}. + */ + public CLCommandQueue putWriteBuffer(CLBuffer<?> writeBuffer, boolean blockingRead, CLEventList events) { + return putWriteBuffer(writeBuffer, blockingRead, null, events); + } + + /** + * Calls {@native clEnqueueWriteBuffer}. + */ + public CLCommandQueue putWriteBuffer(CLBuffer<?> writeBuffer, boolean blockingWrite, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueWriteBuffer( + ID, writeBuffer.ID, clBoolean(blockingWrite), + 0, writeBuffer.getSize(), writeBuffer.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue WriteBuffer: " + writeBuffer + "with " + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + /** + * Calls {@native clEnqueueReadBuffer}. + */ + public CLCommandQueue putReadBuffer(CLBuffer<?> readBuffer, boolean blockingRead) { + putReadBuffer(readBuffer, blockingRead, null, null); + return this; + } + + /** + * Calls {@native clEnqueueReadBuffer}. + */ + public CLCommandQueue putReadBuffer(CLBuffer<?> readBuffer, boolean blockingRead, CLEventList events) { + putReadBuffer(readBuffer, blockingRead, null, events); + return this; + } + + /** + * Calls {@native clEnqueueReadBuffer}. + */ + public CLCommandQueue putReadBuffer(CLBuffer<?> readBuffer, boolean blockingRead, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueReadBuffer( + ID, readBuffer.ID, clBoolean(blockingRead), + 0, readBuffer.getSize(), readBuffer.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue ReadBuffer: " + readBuffer + "with " + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + /** + * Calls {@native clEnqueueCopyBuffer}. + */ + public CLCommandQueue putCopyBuffer(CLBuffer<?> src, CLBuffer<?> dest) { + return putCopyBuffer(src, dest, 0, 0, src.getCLSize(), null, null); + } + + /** + * Calls {@native clEnqueueCopyBuffer}. + */ + public CLCommandQueue putCopyBuffer(CLBuffer<?> src, CLBuffer<?> dest, long bytesToCopy) { + return putCopyBuffer(src, dest, 0, 0, bytesToCopy, null, null); + } + + /** + * Calls {@native clEnqueueCopyBuffer}. + */ + public CLCommandQueue putCopyBuffer(CLBuffer<?> src, CLBuffer<?> dest, int srcOffset, int destOffset, long bytesToCopy, CLEventList events) { + return putCopyBuffer(src, dest, 0, 0, bytesToCopy, null, events); + } + + /** + * Calls {@native clEnqueueCopyBuffer}. + */ + public CLCommandQueue putCopyBuffer(CLBuffer<?> src, CLBuffer<?> dest, int srcOffset, int destOffset, long bytesToCopy, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueCopyBuffer( + ID, src.ID, dest.ID, srcOffset, destOffset, bytesToCopy, + conditions, conditionIDs, events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not copy Buffer from " + src + " to " + dest + " with srcOffset: "+ srcOffset + + " dstOffset: " + destOffset + " bytesToCopy: " + bytesToCopy + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + //2D + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage2d<?> writeImage, boolean blockingWrite) { + return putWriteImage(writeImage, 0, 0, 0, writeImage.width, writeImage.height, blockingWrite, null, null); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage2d<?> writeImage, boolean blockingWrite, CLEventList events) { + return putWriteImage(writeImage, 0, 0, 0, writeImage.width, writeImage.height, blockingWrite, null, events); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage2d<?> writeImage, boolean blockingWrite, CLEventList condition, CLEventList events) { + return putWriteImage(writeImage, 0, 0, 0, writeImage.width, writeImage.height, blockingWrite, condition, events); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage2d<?> writeImage, int inputRowPitch, + int originX, int originY, int rangeX, int rangeY, boolean blockingWrite) { + return putWriteImage(writeImage, inputRowPitch, originX, originY, rangeX, rangeY, blockingWrite, null, null); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage2d<?> writeImage, int inputRowPitch, + int originX, int originY, int rangeX, int rangeY, boolean blockingWrite, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + // spec: CL_INVALID_VALUE if image is a 2D image object and origin[2] is not equal to 0 + // or region[2] is not equal to 1 or slice_pitch is not equal to 0. + copy2NIO(ibA, originX, originY, 0); + copy2NIO(ibB, rangeX, rangeY, 1); + + int ret = cl.clEnqueueWriteImage(ID, writeImage.ID, clBoolean(blockingWrite), + ibA, ibB, inputRowPitch, 0, writeImage.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue WriteImage " + writeImage + " with inputRowPitch: " + inputRowPitch + + " origin: " + toStr(originX, originY)+ " range: " + toStr(rangeX, rangeY) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //3D + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage3d<?> writeImage, boolean blockingWrite) { + return putWriteImage(writeImage, 0, 0, 0, 0, 0, writeImage.width, writeImage.height, writeImage.depth, blockingWrite, null, null); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage3d<?> writeImage, boolean blockingWrite, CLEventList events) { + return putWriteImage(writeImage, 0, 0, 0, 0, 0, writeImage.width, writeImage.height, writeImage.depth, blockingWrite, null, events); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage3d<?> writeImage, boolean blockingWrite, CLEventList condition, CLEventList events) { + return putWriteImage(writeImage, 0, 0, 0, 0, 0, writeImage.width, writeImage.height, writeImage.depth, blockingWrite, condition, events); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage3d<?> writeImage, int inputRowPitch, int inputSlicePitch, + int originX, int originY, int originZ, int rangeX, int rangeY, int rangeZ, boolean blockingWrite) { + return putWriteImage(writeImage, inputRowPitch, inputSlicePitch, originX, originY, originZ, rangeX, rangeY, rangeZ, blockingWrite, null, null); + } + + /** + * Calls {@native clEnqueueWriteImage}. + */ + public CLCommandQueue putWriteImage(CLImage3d<?> writeImage, int inputRowPitch, int inputSlicePitch, + int originX, int originY, int originZ, int rangeX, int rangeY, int rangeZ, boolean blockingWrite, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + copy2NIO(ibA, originX, originY, originZ); + copy2NIO(ibB, rangeX, rangeY, rangeZ); + + int ret = cl.clEnqueueWriteImage(ID, writeImage.ID, clBoolean(blockingWrite), + ibA, ibB, inputRowPitch, inputSlicePitch, writeImage.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue WriteImage " + writeImage + " with inputRowPitch: " + inputRowPitch + " inputSlicePitch: " + inputSlicePitch + + " origin: " + toStr(originX, originY, originZ)+ " range: " + toStr(rangeX, rangeY, rangeZ) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //2D + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage2d<?> readImage, boolean blockingRead) { + return putReadImage(readImage, 0, 0, 0, readImage.width, readImage.height, blockingRead, null, null); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage2d<?> readImage, boolean blockingRead, CLEventList events) { + return putReadImage(readImage, 0, 0, 0, readImage.width, readImage.height, blockingRead, null, events); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage2d<?> readImage, boolean blockingRead, CLEventList condition, CLEventList events) { + return putReadImage(readImage, 0, 0, 0, readImage.width, readImage.height, blockingRead, condition, events); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage2d<?> readImage, int inputRowPitch, + int originX, int originY, int rangeX, int rangeY, boolean blockingRead) { + return putReadImage(readImage, inputRowPitch, originX, originY, rangeX, rangeY, blockingRead, null, null); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage2d<?> readImage, int inputRowPitch, + int originX, int originY, int rangeX, int rangeY, boolean blockingRead, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + // spec: CL_INVALID_VALUE if image is a 2D image object and origin[2] is not equal to 0 + // or region[2] is not equal to 1 or slice_pitch is not equal to 0. + copy2NIO(ibA, originX, originY, 0); + copy2NIO(ibB, rangeX, rangeY, 1); + + int ret = cl.clEnqueueReadImage(ID, readImage.ID, clBoolean(blockingRead), + ibA, ibB, inputRowPitch, 0, readImage.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue ReadImage " + readImage + " with inputRowPitch: " + inputRowPitch + + " origin: " + toStr(originX, originY)+ " range: " + toStr(rangeX, rangeY) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //3D + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage3d<?> readImage, boolean blockingRead) { + return putReadImage(readImage, 0, 0, 0, 0, 0, readImage.width, readImage.height, readImage.depth, blockingRead, null, null); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage3d<?> readImage, boolean blockingRead, CLEventList events) { + return putReadImage(readImage, 0, 0, 0, 0, 0, readImage.width, readImage.height, readImage.depth, blockingRead, null, events); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage3d<?> readImage, boolean blockingRead, CLEventList condition, CLEventList events) { + return putReadImage(readImage, 0, 0, 0, 0, 0, readImage.width, readImage.height, readImage.depth, blockingRead, condition, events); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage3d<?> readImage, int inputRowPitch, int inputSlicePitch, + int originX, int originY, int originZ, int rangeX, int rangeY, int rangeZ, boolean blockingRead) { + return putReadImage(readImage, inputRowPitch, inputSlicePitch, originX, originY, originZ, rangeX, rangeY, rangeZ, blockingRead, null, null); + } + + /** + * Calls {@native clEnqueueReadImage}. + */ + public CLCommandQueue putReadImage(CLImage3d<?> readImage, int inputRowPitch, int inputSlicePitch, + int originX, int originY, int originZ, int rangeX, int rangeY, int rangeZ, boolean blockingRead, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + copy2NIO(ibA, originX, originY, originZ); + copy2NIO(ibB, rangeX, rangeY, rangeZ); + + int ret = cl.clEnqueueReadImage(ID, readImage.ID, clBoolean(blockingRead), + ibA, ibB, inputRowPitch, inputSlicePitch, readImage.buffer, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue ReadImage " + readImage + " with inputRowPitch: " + inputRowPitch + " inputSlicePitch: " + inputSlicePitch + + " origin: " + toStr(originX, originY, originZ)+ " range: " + toStr(rangeX, rangeY, rangeZ) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //2D + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage2d<?> srcImage, CLImage2d<?> dstImage) { + return putCopyImage(srcImage, dstImage, null); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage2d<?> srcImage, CLImage2d<?> dstImage, CLEventList events) { + return putCopyImage(srcImage, dstImage, 0, 0, 0, 0, srcImage.width, srcImage.height, null, events); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage2d<?> srcImage, CLImage2d<?> dstImage, CLEventList condition, CLEventList events) { + return putCopyImage(srcImage, dstImage, 0, 0, 0, 0, srcImage.width, srcImage.height, condition, events); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage2d<?> srcImage, CLImage2d<?> dstImage, + int srcOriginX, int srcOriginY, + int dstOriginX, int dstOriginY, + int rangeX, int rangeY) { + return putCopyImage(srcImage, dstImage, srcOriginX, srcOriginY, dstOriginX, dstOriginY, rangeX, rangeY, null, null); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage2d<?> srcImage, CLImage2d<?> dstImage, + int srcOriginX, int srcOriginY, + int dstOriginX, int dstOriginY, + int rangeX, int rangeY, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + //spec: CL_INVALID_VALUE if src_image is a 2D image object and origin[2] or dst_origin[2] is not equal to 0 + // or region[2] is not equal to 1. + copy2NIO(ibA, srcOriginX, srcOriginY, 0); + copy2NIO(ibB, dstOriginX, dstOriginY, 0); + copy2NIO(ibC, rangeX, rangeY, 1); + + int ret = cl.clEnqueueCopyImage(ID, srcImage.ID, dstImage.ID, ibA, ibB, ibC, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not CopyImage " + srcImage +" to "+ dstImage + + " with srcOrigin: " + toStr(srcOriginX, srcOriginY) + " dstOrigin: " + toStr(dstOriginX, dstOriginY) + + " range: " + toStr(rangeX, rangeY) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //3D + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage3d<?> srcImage, CLImage3d<?> dstImage) { + return putCopyImage(srcImage, dstImage, null); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage3d<?> srcImage, CLImage3d<?> dstImage, CLEventList events) { + return putCopyImage(srcImage, dstImage, 0, 0, 0, 0, 0, 0, srcImage.width, srcImage.height, srcImage.depth, null, events); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage3d<?> srcImage, CLImage3d<?> dstImage, CLEventList condition, CLEventList events) { + return putCopyImage(srcImage, dstImage, 0, 0, 0, 0, 0, 0, srcImage.width, srcImage.height, srcImage.depth, condition, events); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage3d<?> srcImage, CLImage3d<?> dstImage, + int srcOriginX, int srcOriginY, int srcOriginZ, + int dstOriginX, int dstOriginY, int dstOriginZ, + int rangeX, int rangeY, int rangeZ) { + return putCopyImage(srcImage, dstImage, srcOriginX, srcOriginY, srcOriginZ, + dstOriginX, dstOriginY, dstOriginZ, + rangeX, rangeY, rangeZ, null, null); + } + + /** + * Calls {@native clEnqueueCopyImage}. + */ + public CLCommandQueue putCopyImage(CLImage3d<?> srcImage, CLImage3d<?> dstImage, + int srcOriginX, int srcOriginY, int srcOriginZ, + int dstOriginX, int dstOriginY, int dstOriginZ, + int rangeX, int rangeY, int rangeZ, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + copy2NIO(ibA, srcOriginX, srcOriginY, srcOriginZ); + copy2NIO(ibB, dstOriginX, dstOriginY, dstOriginZ); + copy2NIO(ibC, rangeX, rangeY, rangeZ); + + int ret = cl.clEnqueueCopyImage(ID, srcImage.ID, dstImage.ID, ibA, ibB, ibC, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not CopyImage " + srcImage +" to "+ dstImage + + " with srcOrigin: " + toStr(srcOriginX, srcOriginY, srcOriginZ) + " dstOrigin: " + toStr(dstOriginX, dstOriginY, dstOriginZ) + + " range: " + toStr(rangeX, rangeY, rangeZ) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //2D + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage2d<?> dstImage) { + return putCopyBufferToImage(srcBuffer, dstImage, null); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage2d<?> dstImage, CLEventList events) { + return putCopyBufferToImage(srcBuffer, dstImage, 0, 0, 0, dstImage.width, dstImage.height, null, events); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage2d<?> dstImage, CLEventList condition, CLEventList events) { + return putCopyBufferToImage(srcBuffer, dstImage, 0, 0, 0, dstImage.width, dstImage.height, condition, events); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage2d<?> dstImage, + long srcOffset, int dstOriginX, int dstOriginY, + int rangeX, int rangeY) { + return putCopyBufferToImage(srcBuffer, dstImage, + srcOffset, dstOriginX, dstOriginY, rangeX, rangeY, null, null); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage2d<?> dstImage, + long srcOffset, int dstOriginX, int dstOriginY, + int rangeX, int rangeY, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + // spec: CL_INVALID_VALUE if dst_image is a 2D image object and dst_origin[2] is not equal to 0 + // or region[2] is not equal to 1. + copy2NIO(ibA, dstOriginX, dstOriginY, 0); + copy2NIO(ibB, rangeX, rangeY, 1); + + int ret = cl.clEnqueueCopyBufferToImage(ID, srcBuffer.ID, dstImage.ID, + srcOffset, ibA, ibB, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not copy " + srcBuffer +" to "+ dstImage + + " with srcOffset: " + srcOffset + " dstOrigin: " + toStr(dstOriginX, dstOriginY) + + " range: " + toStr(rangeX, rangeY) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //3D + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage3d<?> dstImage) { + return putCopyBufferToImage(srcBuffer, dstImage, null); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage3d<?> dstImage, CLEventList events) { + return putCopyBufferToImage(srcBuffer, dstImage, 0, 0, 0, 0, dstImage.width, dstImage.height, dstImage.depth, null, events); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage3d<?> dstImage, CLEventList condition, CLEventList events) { + return putCopyBufferToImage(srcBuffer, dstImage, 0, 0, 0, 0, dstImage.width, dstImage.height, dstImage.depth, condition, events); + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage3d<?> dstImage, + long srcOffset, int dstOriginX, int dstOriginY, int dstOriginZ, + int rangeX, int rangeY, int rangeZ) { + return putCopyBufferToImage(srcBuffer, dstImage, + srcOffset, dstOriginX, dstOriginY, dstOriginZ, rangeX, rangeY, rangeZ, null, null); + + } + + /** + * Calls {@native clEnqueueCopyBufferToImage}. + */ + public CLCommandQueue putCopyBufferToImage(CLBuffer<?> srcBuffer, CLImage3d<?> dstImage, + long srcOffset, int dstOriginX, int dstOriginY, int dstOriginZ, + int rangeX, int rangeY, int rangeZ, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + copy2NIO(ibA, dstOriginX, dstOriginY, dstOriginZ); + copy2NIO(ibB, rangeX, rangeY, rangeZ); + + int ret = cl.clEnqueueCopyBufferToImage(ID, srcBuffer.ID, dstImage.ID, + srcOffset, ibA, ibB, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not copy " + srcBuffer +" to "+ dstImage + + " with srcOffset: " + srcOffset + " dstOrigin: " + toStr(dstOriginX, dstOriginY, dstOriginZ) + + " range: " + toStr(rangeX, rangeY, dstOriginZ) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //2D + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage2d<?> srcImage, CLBuffer<?> dstBuffer) { + return putCopyImageToBuffer(srcImage, dstBuffer, null); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage2d<?> srcImage, CLBuffer<?> dstBuffer, CLEventList events) { + return putCopyImageToBuffer(srcImage, dstBuffer, 0, 0, srcImage.width, srcImage.height, 0, null, events); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage2d<?> srcImage, CLBuffer<?> dstBuffer, CLEventList condition, CLEventList events) { + return putCopyImageToBuffer(srcImage, dstBuffer, 0, 0, srcImage.width, srcImage.height, 0, condition, events); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage2d<?> srcImage, CLBuffer<?> dstBuffer, + int srcOriginX, int srcOriginY, + int rangeX, int rangeY, long dstOffset) { + return putCopyImageToBuffer(srcImage, dstBuffer, + srcOriginX, srcOriginY, rangeX, rangeY, dstOffset, null, null); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage2d<?> srcImage, CLBuffer<?> dstBuffer, + int srcOriginX, int srcOriginY, + int rangeX, int rangeY, long dstOffset, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + // spec: CL_INVALID_VALUE if src_image is a 2D image object and src_origin[2] is not equal to 0 + // or region[2] is not equal to 1. + copy2NIO(ibA, srcOriginX, srcOriginY, 0); + copy2NIO(ibB, rangeX, rangeY, 1); + + int ret = cl.clEnqueueCopyImageToBuffer(ID, dstBuffer.ID, srcImage.ID, + ibA, ibB, dstOffset, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not copy " + srcImage +" to "+ dstBuffer + + " with srcOrigin: " + toStr(srcOriginX, srcOriginY) + " range: " + toStr(rangeX, rangeY) + + " dstOffset: " + dstOffset + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + //3D + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage3d<?> srcImage, CLBuffer<?> dstBuffer) { + return putCopyImageToBuffer(srcImage, dstBuffer, 0, 0, 0, srcImage.width, srcImage.height, srcImage.depth, 0, null, null); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage3d<?> srcImage, CLBuffer<?> dstBuffer, CLEventList events) { + return putCopyImageToBuffer(srcImage, dstBuffer, 0, 0, 0, srcImage.width, srcImage.height, srcImage.depth, 0, null, events); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage3d<?> srcImage, CLBuffer<?> dstBuffer, CLEventList condition, CLEventList events) { + return putCopyImageToBuffer(srcImage, dstBuffer, 0, 0, 0, srcImage.width, srcImage.height, srcImage.depth, 0, condition, events); + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage3d<?> srcImage, CLBuffer<?> dstBuffer, + int srcOriginX, int srcOriginY, int srcOriginZ, + int rangeX, int rangeY, int rangeZ, long dstOffset) { + return putCopyImageToBuffer(srcImage, dstBuffer, + srcOriginX, srcOriginY, srcOriginZ, rangeX, rangeY, rangeZ, dstOffset, null, null); + + } + + /** + * Calls {@native clEnqueueCopyImageToBuffer}. + */ + public CLCommandQueue putCopyImageToBuffer(CLImage3d<?> srcImage, CLBuffer<?> dstBuffer, + int srcOriginX, int srcOriginY, int srcOriginZ, + int rangeX, int rangeY, int rangeZ, long dstOffset, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + copy2NIO(ibA, srcOriginX, srcOriginY, srcOriginZ); + copy2NIO(ibB, rangeX, rangeY, rangeZ); + + int ret = cl.clEnqueueCopyImageToBuffer(ID, dstBuffer.ID, srcImage.ID, + ibA, ibB, dstOffset, + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not copy " + srcImage +" to "+ dstBuffer + + " with srcOrigin: " + toStr(srcOriginX, srcOriginY, srcOriginZ) + " range: " + toStr(rangeX, rangeY, rangeZ) + + " dstOffset: " + dstOffset + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + /** + * Calls {@native clEnqueueMapBuffer}. + */ + public ByteBuffer putMapBuffer(CLBuffer<?> buffer, CLMemory.Map flag, boolean blockingMap) { + return putMapBuffer(buffer, flag, blockingMap, null); + } + + /** + * Calls {@native clEnqueueMapBuffer}. + */ + public ByteBuffer putMapBuffer(CLBuffer<?> buffer, CLMemory.Map flag, boolean blockingMap, CLEventList events) { + return putMapBuffer(buffer, flag, 0, buffer.getCLSize(), blockingMap, null, events); + } + + /** + * Calls {@native clEnqueueMapBuffer}. + */ + public ByteBuffer putMapBuffer(CLBuffer<?> buffer, CLMemory.Map flag, boolean blockingMap, CLEventList condition, CLEventList events) { + return putMapBuffer(buffer, flag, 0, buffer.getCLSize(), blockingMap, condition, events); + } + + /** + * Calls {@native clEnqueueMapBuffer}. + */ + public ByteBuffer putMapBuffer(CLBuffer<?> buffer, CLMemory.Map flag, long offset, long length, boolean blockingMap) { + return putMapBuffer(buffer, flag, offset, length, blockingMap, null, null); + } + + /** + * Calls {@native clEnqueueMapBuffer}. + */ + public ByteBuffer putMapBuffer(CLBuffer<?> buffer, CLMemory.Map flag, long offset, long length, boolean blockingMap, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + IntBuffer error = pbA.position(0).getBuffer().asIntBuffer(); + ByteBuffer mappedBuffer = cl.clEnqueueMapBuffer(ID, buffer.ID, clBoolean(blockingMap), + flag.FLAGS, offset, length, + conditions, conditionIDs, events==null ? null : events.IDs, error); + if(error.get(0) != CL_SUCCESS) { + throw newException(error.get(0), "can not map " + buffer + " with: " + flag + + " offset: " + offset + " lenght: " + length + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return mappedBuffer; + } + + // 2D + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage2d<?> image, CLMemory.Map flag, boolean blockingMap) { + return putMapImage(image, flag, blockingMap, null); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage2d<?> image, CLMemory.Map flag, boolean blockingMap, CLEventList events) { + return putMapImage(image, flag, 0, 0, image.width, image.height, blockingMap, null, events); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage2d<?> image, CLMemory.Map flag, boolean blockingMap, CLEventList condition, CLEventList events) { + return putMapImage(image, flag, 0, 0, image.width, image.height, blockingMap, condition, events); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage2d<?> buffer, CLMemory.Map flag, int offsetX, int offsetY, + int rangeX, int rangeY, boolean blockingMap) { + return putMapImage(buffer, flag, offsetX, offsetY, rangeX, rangeY, blockingMap, null, null); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage2d<?> image, CLMemory.Map flag, + int offsetX, int offsetY, + int rangeX, int rangeY, boolean blockingMap, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + IntBuffer error = pbA.position(0).getBuffer().asIntBuffer(); + + // spec: CL_INVALID_VALUE if image is a 2D image object and origin[2] is not equal to 0 or region[2] is not equal to 1 + copy2NIO(ibB, offsetX, offsetY, 0); + copy2NIO(ibC, rangeX, rangeY, 1); + + ByteBuffer mappedImage = cl.clEnqueueMapImage(ID, image.ID, clBoolean(blockingMap), + flag.FLAGS, ibB, ibC, null, null, + conditions, conditionIDs, events==null ? null : events.IDs, error); + if(error.get(0) != CL_SUCCESS) { + throw newException(error.get(0), "can not map " + image + " with: " + flag + + " offset: " + toStr(offsetX, offsetY) + " range: " + toStr(rangeX, rangeY) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return mappedImage; + } + + // 3D + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage3d<?> image, CLMemory.Map flag, boolean blockingMap) { + return putMapImage(image, flag, blockingMap, null); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage3d<?> image, CLMemory.Map flag, boolean blockingMap, CLEventList events) { + return putMapImage(image, flag, 0, 0, 0, image.width, image.height, image.depth, blockingMap, null, events); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage3d<?> image, CLMemory.Map flag, boolean blockingMap, CLEventList condition, CLEventList events) { + return putMapImage(image, flag, 0, 0, 0, image.width, image.height, image.depth, blockingMap, condition, events); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage3d<?> image, CLMemory.Map flag, + int offsetX, int offsetY, int offsetZ, + int rangeX, int rangeY, int rangeZ, boolean blockingMap) { + return putMapImage(image, flag, offsetX, offsetY, offsetZ, rangeX, rangeY, rangeZ, blockingMap, null, null); + } + + /** + * Calls {@native clEnqueueMapImage}. + */ + public ByteBuffer putMapImage(CLImage3d<?> image, CLMemory.Map flag, + int offsetX, int offsetY, int offsetZ, + int rangeX, int rangeY, int rangeZ, boolean blockingMap, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + IntBuffer error = pbA.position(0).getBuffer().asIntBuffer(); + copy2NIO(ibB, offsetX, offsetY, offsetZ); + copy2NIO(ibC, rangeX, rangeY, rangeZ); + ByteBuffer mappedImage = cl.clEnqueueMapImage(ID, image.ID, clBoolean(blockingMap), + flag.FLAGS, ibB, ibC, null, null, + conditions, conditionIDs, events==null ? null : events.IDs, error); + if(error.get(0) != CL_SUCCESS) { + throw newException(error.get(0), "can not map " + image + " with: " + flag + + " offset: " + toStr(offsetX, offsetY, offsetZ) + " range: " + toStr(rangeX, rangeY, rangeZ) + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return mappedImage; + } + + /** + * Calls {@native clEnqueueUnmapMemObject}. + */ + public CLCommandQueue putUnmapMemory(CLMemory<?> memory) { + return putUnmapMemory(memory, null, null); + } + + /** + * Calls {@native clEnqueueUnmapMemObject}. + */ + public CLCommandQueue putUnmapMemory(CLMemory<?> memory, CLEventList events) { + return putUnmapMemory(memory, null, events); + } + + /** + * Calls {@native clEnqueueUnmapMemObject}. + */ + public CLCommandQueue putUnmapMemory(CLMemory<?> memory, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueUnmapMemObject(ID, memory.ID, memory.getBuffer(), + conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not unmap " + memory + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + return this; + } + + /** + * Calls {@native clEnqueueMarker}. + */ + public CLCommandQueue putMarker(CLEventList events) { + int ret = cl.clEnqueueMarker(ID, events.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue marker " + events); + } + return this; + } + + /** + * Calls {@native clWaitForEvents} if blockingWait equals true otherwise {@native clEnqueueWaitForEvents}. + */ + public CLCommandQueue putWaitForEvent(CLEventList list, int index, boolean blockingWait) { + int marker = list.IDs.position()-1; + list.IDs.position(index); + int ret = blockingWait ? cl.clWaitForEvents(1, list.IDs) + : cl.clEnqueueWaitForEvents(ID, 1, list.IDs); + list.IDs.position(marker); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not "+ (blockingWait?"blocking": "") +" wait for event #" + index+ " in "+list); + } + return this; + } + + /** + * Calls {@native clWaitForEvents} if blockingWait equals true otherwise {@native clEnqueueWaitForEvents}. + */ + public CLCommandQueue putWaitForEvents(CLEventList list, boolean blockingWait) { + list.IDs.rewind(); + int ret = blockingWait ? cl.clWaitForEvents(list.size, list.IDs) + : cl.clEnqueueWaitForEvents(ID, list.size, list.IDs); + if(ret != CL_SUCCESS) { + throw newException(ret, "can not "+ (blockingWait?"blocking": "") +" wait for events " + list); + } + return this; + } + + /** + * Calls {@native clEnqueueBarrier}. + */ + public CLCommandQueue putBarrier() { + int ret = cl.clEnqueueBarrier(ID); + checkForError(ret, "can not enqueue Barrier"); + return this; + } + + /** + * Equivalent to calling + * {@link #put1DRangeKernel(CLKernel kernel, long globalWorkOffset, long globalWorkSize, long localWorkSize)} + * with globalWorkOffset = null, globalWorkSize set to 1, and localWorkSize set to 1. + * <p>Calls {@native clEnqueueTask}.</p> + */ + public CLCommandQueue putTask(CLKernel kernel) { + putTask(kernel, null, null); + return this; + } + + /** + * <p>Calls {@native clEnqueueTask}.</p> + * @see #putTask(com.jogamp.opencl.CLKernel) + */ + public CLCommandQueue putTask(CLKernel kernel, CLEventList events) { + putTask(kernel, null, events); + return this; + } + + /** + * Calls {@native clEnqueueTask}. + * @see #putTask(com.jogamp.opencl.CLKernel) + */ + public CLCommandQueue putTask(CLKernel kernel, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueTask(ID, kernel.ID, conditions, conditionIDs, events==null ? null : events.IDs); + if(ret != CL_SUCCESS) { + checkForError(ret, "can not enqueue Task: " + kernel + toStr(condition, events)); + } + if(events != null) { + events.createEvent(context); + } + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put1DRangeKernel(CLKernel kernel, long globalWorkOffset, long globalWorkSize, long localWorkSize) { + this.put1DRangeKernel(kernel, globalWorkOffset, globalWorkSize, localWorkSize, null, null); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put1DRangeKernel(CLKernel kernel, long globalWorkOffset, long globalWorkSize, long localWorkSize, CLEventList events) { + this.put1DRangeKernel(kernel, globalWorkOffset, globalWorkSize, localWorkSize, null, events); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put1DRangeKernel(CLKernel kernel, long globalWorkOffset, long globalWorkSize, long localWorkSize, CLEventList condition, CLEventList events) { + Int64Buffer globWO = null; + Int64Buffer globWS = null; + Int64Buffer locWS = null; + + if(globalWorkOffset != 0) { + globWO = copy2NIO(ibA, globalWorkOffset); + } + if(globalWorkSize != 0) { + globWS = copy2NIO(ibB, globalWorkSize); + } + if(localWorkSize != 0) { + locWS = copy2NIO(ibC, localWorkSize); + } + + this.putNDRangeKernel(kernel, 1, globWO, globWS, locWS, condition, events); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put2DRangeKernel(CLKernel kernel, long globalWorkOffsetX, long globalWorkOffsetY, + long globalWorkSizeX, long globalWorkSizeY, + long localWorkSizeX, long localWorkSizeY) { + this.put2DRangeKernel(kernel, + globalWorkOffsetX, globalWorkOffsetY, + globalWorkSizeX, globalWorkSizeY, + localWorkSizeX, localWorkSizeY, null, null); + + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put2DRangeKernel(CLKernel kernel, long globalWorkOffsetX, long globalWorkOffsetY, + long globalWorkSizeX, long globalWorkSizeY, + long localWorkSizeX, long localWorkSizeY, CLEventList events) { + this.put2DRangeKernel(kernel, + globalWorkOffsetX, globalWorkOffsetY, + globalWorkSizeX, globalWorkSizeY, + localWorkSizeX, localWorkSizeY, null, events); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue put2DRangeKernel(CLKernel kernel, long globalWorkOffsetX, long globalWorkOffsetY, + long globalWorkSizeX, long globalWorkSizeY, + long localWorkSizeX, long localWorkSizeY, CLEventList condition, CLEventList events) { + Int64Buffer globalWorkOffset = null; + Int64Buffer globalWorkSize = null; + Int64Buffer localWorkSize = null; + + if(globalWorkOffsetX != 0 && globalWorkOffsetY != 0) { + globalWorkOffset = copy2NIO(ibA, globalWorkOffsetX, globalWorkOffsetY); + } + if(globalWorkSizeX != 0 && globalWorkSizeY != 0) { + globalWorkSize = copy2NIO(ibB, globalWorkSizeX, globalWorkSizeY); + } + if(localWorkSizeX != 0 && localWorkSizeY !=0) { + localWorkSize = copy2NIO(ibC, localWorkSizeX, localWorkSizeY); + } + this.putNDRangeKernel(kernel, 2, globalWorkOffset, globalWorkSize, localWorkSize, condition, events); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue putNDRangeKernel(CLKernel kernel, int workDimension, Int64Buffer globalWorkOffset, Int64Buffer globalWorkSize, Int64Buffer localWorkSize) { + this.putNDRangeKernel(kernel, workDimension, globalWorkOffset, globalWorkSize, localWorkSize, null, null); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue putNDRangeKernel(CLKernel kernel, int workDimension, Int64Buffer globalWorkOffset, Int64Buffer globalWorkSize, Int64Buffer localWorkSize, CLEventList events) { + this.putNDRangeKernel(kernel, workDimension, globalWorkOffset, globalWorkSize, localWorkSize, null, events); + return this; + } + + /** + * Calls {@native clEnqueueNDRangeKernel}. + */ + public CLCommandQueue putNDRangeKernel(CLKernel kernel, int workDimension, Int64Buffer globalWorkOffset, + Int64Buffer globalWorkSize, Int64Buffer localWorkSize, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + int ret = cl.clEnqueueNDRangeKernel( + ID, kernel.ID, workDimension, + globalWorkOffset, + globalWorkSize, + localWorkSize, + conditions, conditionIDs, + events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not enqueue NDRangeKernel: " + kernel + " with gWO: "+toStr(globalWorkOffset) + + " gWS: "+toStr(globalWorkSize) + " lWS: " + toStr(localWorkSize) + toStr(condition, events)); + + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + /** + * Calls {@native clEnqueueAcquireGLObjects}. + */ + public CLCommandQueue putAcquireGLObject(long glObject) { + this.putAcquireGLObject(glObject, null, null); + return this; + } + + /** + * Calls {@native clEnqueueAcquireGLObjects}. + */ + public CLCommandQueue putAcquireGLObject(long glObject, CLEventList events) { + this.putAcquireGLObject(glObject, null, events); + return this; + } + + /** + * Calls {@native clEnqueueAcquireGLObjects}. + */ + public CLCommandQueue putAcquireGLObject(long glObject, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + CLGLI xl = (CLGLI) cl; + + PointerBuffer glObj = copy2NIO(pbA, glObject); + + int ret = xl.clEnqueueAcquireGLObjects(ID, 1, glObj, + conditions, conditionIDs, + events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not aquire GLObject: " + glObject + "with " + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + /** + * Calls {@native clEnqueueReleaseGLObjects}. + */ + public CLCommandQueue putReleaseGLObject(long glObject) { + this.putReleaseGLObject(glObject, null); + return this; + } + + /** + * Calls {@native clEnqueueReleaseGLObjects}. + */ + public CLCommandQueue putReleaseGLObject(long glObject, CLEventList events) { + this.putReleaseGLObject(glObject, null, events); + return this; + } + + /** + * Calls {@native clEnqueueReleaseGLObjects}. + */ + public CLCommandQueue putReleaseGLObject(long glObject, CLEventList condition, CLEventList events) { + + PointerBuffer conditionIDs = null; + int conditions = 0; + if(condition != null) { + conditionIDs = condition.IDs; + conditions = condition.size; + } + + CLGLI xl = (CLGLI) cl; + + PointerBuffer glObj = copy2NIO(pbA, glObject); + + int ret = xl.clEnqueueReleaseGLObjects(ID, 1, glObj, + conditions, conditionIDs, + events==null ? null : events.IDs); + + if(ret != CL_SUCCESS) { + throw newException(ret, "can not release GLObject: " + glObject + "with " + toStr(condition, events)); + } + + if(events != null) { + events.createEvent(context); + } + + return this; + } + + /** + * Calls {@native clFinish}. + */ + public CLCommandQueue finish() { + int ret = cl.clFinish(ID); + checkForError(ret, "can not finish command queue"); + return this; + } + + /** + * Calls {@native clFlush}. + */ + public CLCommandQueue flush() { + int ret = cl.clFlush(ID); + checkForError(ret, "can not flush command queue"); + return this; + } + + /** + * Returns true only when {@link Mode#PROFILING_MODE} has been enabled. + */ + public boolean isProfilingEnabled() { + return (Mode.PROFILING_MODE.QUEUE_MODE & properties) != 0; + } + + /** + * Returns true only when {@link Mode#OUT_OF_ORDER_MODE} mode has been enabled. + */ + public boolean isOutOfOrderModeEnabled() { + return (Mode.OUT_OF_ORDER_MODE.QUEUE_MODE & properties) != 0; + } + + public void release() { + int ret = cl.clReleaseCommandQueue(ID); + context.onCommandQueueReleased(device, this); + checkForError(ret, "can not release command queue"); + } + + public void close() { + release(); + } + + private static PointerBuffer copy2NIO(PointerBuffer buffer, long a) { + return (PointerBuffer) buffer.put(0, a); + } + +// private static PointerBuffer copy2NIO(PointerBuffer buffer, long a, long b) { +// return buffer.position(1).put(a).put(b).position(1); +// } +// +// private static PointerBuffer copy2NIO(PointerBuffer buffer, long a, long b, long c) { +// return buffer.rewind().put(a).put(b).put(c).rewind(); +// } + + private static Int64Buffer copy2NIO(Int64Buffer buffer, long a) { + return (Int64Buffer) buffer.put(2, a).position(2); + } + + private static Int64Buffer copy2NIO(Int64Buffer buffer, long a, long b) { + return (Int64Buffer) ((Int64Buffer)buffer.position(1)).put(a).put(b).position(1); + } + + private static Int64Buffer copy2NIO(Int64Buffer buffer, long a, long b, long c) { + return (Int64Buffer) ((Int64Buffer)buffer.rewind()).put(a).put(b).put(c).rewind(); + } + + private static String toStr(Int64Buffer buffer) { + if(buffer == null) { + return null; + } + StringBuilder sb = new StringBuilder(); + sb.append('{'); + for (int i = buffer.position(); i < buffer.capacity(); i++) { + sb.append(buffer.get(i)); + if(i != buffer.capacity()-1) { + sb.append(", "); + } + } + return sb.append('}').toString(); + } + + private static String toStr(CLEventList condition, CLEventList events) { + return " cond.: " + condition +" events: "+events; + } + + private String toStr(int... values) { + return Arrays.asList(values).toString(); + } + + /** + * Returns the device of this command queue. + */ + public CLDevice getDevice() { + return device; + } + + /** + * Returns the command queue properties as EnumSet. + */ + public EnumSet<Mode> getProperties() { + return Mode.valuesOf(properties); + } + + /** + * Setting properties after a command queue has been created can be implementation specific, + * please refer to the specification ({@native clSetCommandQueueProperty}) or vendor documentation. + */ + public void setProperty(Mode property, boolean enabled) { + int ret = cl.clSetCommandQueueProperty(ID, property.QUEUE_MODE, clBoolean(enabled), null); + if(ret != CL_SUCCESS) { + checkForError(ret, "can not set command queue property: " + property); + } + if(enabled) { + properties |= property.QUEUE_MODE; + }else{ + properties &= ~property.QUEUE_MODE; + } + } + + @Override + public boolean equals(Object obj) { + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final CLCommandQueue other = (CLCommandQueue) obj; + if (this.ID != other.ID) { + return false; + } + if (this.context != other.context && (this.context == null || !this.context.equals(other.context))) { + return false; + } + if (this.device != other.device && (this.device == null || !this.device.equals(other.device))) { + return false; + } + return true; + } + + @Override + public int hashCode() { + int hash = 3; + hash = 89 * hash + (int) (this.ID ^ (this.ID >>> 32)); + hash = 89 * hash + (this.context != null ? this.context.hashCode() : 0); + hash = 89 * hash + (this.device != null ? this.device.hashCode() : 0); + return hash; + } + + /** + * Enumeration for the command-queue settings. + */ + public enum Mode { + /** + * If set, the commands in the command-queue are + * executed out-of-order. Otherwise, commands are executed in-order. + */ + OUT_OF_ORDER_MODE(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE), + + /** + * Enables profiling of commands in the command-queue. + * If set, the profiling of commands is enabled. Otherwise profiling of + * commands is disabled. See {@link com.jogamp.opencl.CLEvent} for more information. + */ + PROFILING_MODE(CL_QUEUE_PROFILING_ENABLE); + + /** + * Value of wrapped OpenCL device type. + */ + public final int QUEUE_MODE; + + private Mode(int value) { + this.QUEUE_MODE = value; + } + + public static Mode valueOf(int queueMode) { + switch(queueMode) { + case(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE): + return OUT_OF_ORDER_MODE; + case(CL_QUEUE_PROFILING_ENABLE): + return PROFILING_MODE; + } + return null; + } + + public static EnumSet<Mode> valuesOf(long bitfield) { + List<Mode> matching = new ArrayList<Mode>(); + Mode[] values = Mode.values(); + for (Mode value : values) { + if((value.QUEUE_MODE & bitfield) != 0) + matching.add(value); + } + if(matching.isEmpty()) + return EnumSet.noneOf(Mode.class); + else + return EnumSet.copyOf(matching); + } + + } +} |