aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--resources/cl-common.cfg1
-rw-r--r--src/com/mbien/opencl/CLCommandQueue.java59
-rw-r--r--src/com/mbien/opencl/CLContext.java54
-rw-r--r--src/com/mbien/opencl/CLDevice.java10
-rw-r--r--src/com/mbien/opencl/CLException.java727
-rw-r--r--src/com/mbien/opencl/CLGLContext.java26
-rw-r--r--src/com/mbien/opencl/CLKernel.java14
-rw-r--r--src/com/mbien/opencl/CLMemory.java3
-rw-r--r--src/com/mbien/opencl/CLPlatform.java12
-rw-r--r--src/com/mbien/opencl/CLProgram.java32
-rw-r--r--test/com/mbien/opencl/CLBufferTest.java12
-rw-r--r--test/com/mbien/opencl/CLCommandQueueTest.java8
-rw-r--r--test/com/mbien/opencl/HighLevelBindingTest.java51
13 files changed, 814 insertions, 195 deletions
diff --git a/resources/cl-common.cfg b/resources/cl-common.cfg
index 79c2845c..c6b7b07f 100644
--- a/resources/cl-common.cfg
+++ b/resources/cl-common.cfg
@@ -78,6 +78,7 @@ NioDirectOnly clSetCommandQueueProperty
NioDirectOnly clWaitForEvents
#NioDirectOnly clCreateContext
#NioDirectOnly clBuildProgram
+NioDirectOnly clIcdGetPlatformIDsKHR
#extensions
NioDirectOnly clGetGLContextInfoKHR
diff --git a/src/com/mbien/opencl/CLCommandQueue.java b/src/com/mbien/opencl/CLCommandQueue.java
index c8b862be..1a70605a 100644
--- a/src/com/mbien/opencl/CLCommandQueue.java
+++ b/src/com/mbien/opencl/CLCommandQueue.java
@@ -11,12 +11,13 @@ import static com.mbien.opencl.CLException.*;
import static com.mbien.opencl.CL.*;
/**
- * The command-queue can be used to queue a set of operations in order. Having multiple
- * command-queues allows applications to queue multiple independent commands without
+ * 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 command-queues or using a CLCommandQueue
+ * 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.mbien.opencl.CLCommandQueue.Mode[])
* @author Michael Bien
*/
public class CLCommandQueue implements CLResource {
@@ -49,7 +50,7 @@ public class CLCommandQueue implements CLResource {
this.ID = cl.clCreateCommandQueue(context.ID, device.ID, properties, status, 0);
if(status[0] != CL_SUCCESS)
- throw new CLException(status[0], "can not create command queue on "+device);
+ throw newException(status[0], "can not create command queue on "+device);
}
public CLCommandQueue putWriteBuffer(CLBuffer<?> writeBuffer, boolean blockingRead) {
@@ -64,7 +65,7 @@ public class CLCommandQueue implements CLResource {
0, null, events==null ? null : events.IDs);
if(ret != CL_SUCCESS)
- throw new CLException(ret, "can not enqueue WriteBuffer: " + writeBuffer);
+ throw newException(ret, "can not enqueue WriteBuffer: " + writeBuffer);
if(events != null) {
events.createEvent(context);
@@ -86,7 +87,7 @@ public class CLCommandQueue implements CLResource {
0, null, events==null ? null : events.IDs);
if(ret != CL_SUCCESS)
- throw new CLException(ret, "can not enqueue ReadBuffer: " + readBuffer);
+ throw newException(ret, "can not enqueue ReadBuffer: " + readBuffer);
if(events != null) {
events.createEvent(context);
@@ -710,7 +711,7 @@ public class CLCommandQueue implements CLResource {
events==null ? null : events.IDs);
if(ret != CL_SUCCESS)
- throw new CLException(ret, "can not enqueue NDRangeKernel: " + kernel);
+ throw newException(ret, "can not enqueue NDRangeKernel: " + kernel);
if(events != null) {
events.createEvent(context);
@@ -733,7 +734,7 @@ public class CLCommandQueue implements CLResource {
events==null ? null : events.IDs);
if(ret != CL_SUCCESS)
- throw new CLException(ret, "can not aquire GLObject: " + glObject);
+ throw newException(ret, "can not aquire GLObject: " + glObject);
if(events != null) {
events.createEvent(context);
@@ -756,7 +757,7 @@ public class CLCommandQueue implements CLResource {
events==null ? null : events.IDs);
if(ret != CL_SUCCESS)
- throw new CLException(ret, "can not release GLObject: " + glObject);
+ throw newException(ret, "can not release GLObject: " + glObject);
if(events != null) {
events.createEvent(context);
@@ -779,10 +780,10 @@ public class CLCommandQueue implements CLResource {
}
/**
- * Returns true only when {@link Mode#OUT_OF_ORDER_EXEC_MODE} mode has been enabled.
+ * Returns true only when {@link Mode#OUT_OF_ORDER_MODE} mode has been enabled.
*/
public boolean isOutOfOrderModeEnabled() {
- return (Mode.OUT_OF_ORDER_EXEC_MODE.QUEUE_MODE & properties) != 0;
+ return (Mode.OUT_OF_ORDER_MODE.QUEUE_MODE & properties) != 0;
}
public void release() {
@@ -803,6 +804,36 @@ public class CLCommandQueue implements CLResource {
return buffer.rewind().put(a).put(b).put(c).rewind();
}
+ /**
+ * 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 refere to the specification ({@native clSetCommandQueueProperty}) or vendor documentation.
+ */
+ public void setProperty(Mode property, boolean enabled) {
+ int ret = cl.clSetCommandQueueProperty(ID, property.QUEUE_MODE, enabled ? CL_TRUE : CL_FALSE, 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) {
@@ -841,7 +872,7 @@ public class CLCommandQueue implements CLResource {
* If set, the commands in the command-queue are
* executed out-of-order. Otherwise, commands are executed in-order.
*/
- OUT_OF_ORDER_EXEC_MODE(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
+ OUT_OF_ORDER_MODE(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
/**
* Enables profiling of commands in the command-queue.
@@ -862,14 +893,14 @@ public class CLCommandQueue implements CLResource {
public static Mode valueOf(int queueMode) {
switch(queueMode) {
case(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE):
- return OUT_OF_ORDER_EXEC_MODE;
+ return OUT_OF_ORDER_MODE;
case(CL_QUEUE_PROFILING_ENABLE):
return PROFILING_MODE;
}
return null;
}
- public static EnumSet<Mode> valuesOf(int bitfield) {
+ public static EnumSet<Mode> valuesOf(long bitfield) {
List<Mode> matching = new ArrayList<Mode>();
Mode[] values = Mode.values();
for (Mode value : values) {
diff --git a/src/com/mbien/opencl/CLContext.java b/src/com/mbien/opencl/CLContext.java
index f92213fc..bab61c19 100644
--- a/src/com/mbien/opencl/CLContext.java
+++ b/src/com/mbien/opencl/CLContext.java
@@ -45,11 +45,13 @@ public class CLContext implements CLResource {
protected final List<CLSampler> samplers;
protected final List<CLMemory<? extends Buffer>> memoryObjects;
protected final Map<CLDevice, List<CLCommandQueue>> queuesMap;
+ protected final CLPlatform platform;
- protected CLContext(long contextID) {
- this.cl = CLPlatform.getLowLevelBinding();
+ protected CLContext(CLPlatform platform, long contextID) {
+ this.cl = CLPlatform.getLowLevelCLInterface();
this.ID = contextID;
+ this.platform = platform;
this.programs = new ArrayList<CLProgram>();
this.samplers = new ArrayList<CLSampler>();
this.memoryObjects = new ArrayList<CLMemory<? extends Buffer>>();
@@ -82,8 +84,7 @@ public class CLContext implements CLResource {
* The platform to be used is implementation dependent.
*/
public static final CLContext create() {
- PointerBuffer properties = setupContextProperties(null);
- return new CLContext(createContextFromType(properties, CL.CL_DEVICE_TYPE_ALL));
+ return create((CLPlatform)null, Type.ALL);
}
/**
@@ -115,10 +116,14 @@ public class CLContext implements CLResource {
*/
public static final CLContext create(CLPlatform platform, CLDevice.Type... deviceTypes) {
+ if(platform == null) {
+ platform = CLPlatform.getDefault();
+ }
+
long type = toDeviceBitmap(deviceTypes);
PointerBuffer properties = setupContextProperties(platform);
- return new CLContext(createContextFromType(properties, type));
+ return new CLContext(platform, createContextFromType(properties, type));
}
/**
@@ -127,8 +132,12 @@ public class CLContext implements CLResource {
*/
public static final CLContext create(CLPlatform platform, CLDevice... devices) {
+ if(platform == null) {
+ platform = CLPlatform.getDefault();
+ }
+
PointerBuffer properties = setupContextProperties(platform);
- CLContext context = new CLContext(createContext(properties, devices));
+ CLContext context = new CLContext(platform, createContext(properties, devices));
if(devices != null) {
for (int i = 0; i < devices.length; i++) {
devices[i].setContext(context);
@@ -140,7 +149,7 @@ public class CLContext implements CLResource {
protected static final long createContextFromType(PointerBuffer properties, long deviceType) {
IntBuffer status = IntBuffer.allocate(1);
- long context = CLPlatform.getLowLevelBinding().clCreateContextFromType(properties, deviceType, null, null, status);
+ long context = CLPlatform.getLowLevelCLInterface().clCreateContextFromType(properties, deviceType, null, null, status);
checkForError(status.get(), "can not create CL context");
@@ -157,7 +166,7 @@ public class CLContext implements CLResource {
pb.put(i, devices[i].ID);
}
}
- long context = CLPlatform.getLowLevelBinding().clCreateContext(properties, pb, null, null, status);
+ long context = CLPlatform.getLowLevelCLInterface().clCreateContext(properties, pb, null, null, status);
checkForError(status.get(), "can not create CL context");
@@ -167,10 +176,6 @@ public class CLContext implements CLResource {
private static final PointerBuffer setupContextProperties(CLPlatform platform) {
if(platform == null) {
- platform = CLPlatform.getDefault();
- }
-
- if(platform == null) {
throw new RuntimeException("no OpenCL installation found");
}
@@ -376,23 +381,30 @@ public class CLContext implements CLResource {
}
/**
+ * Returns the CLPlatform this context is running on.
+ */
+ public CLPlatform getPlatform() {
+ return platform;
+ }
+
+ /**
* Returns a read only view of all programs associated with this context.
*/
- public List<CLProgram> getCLPrograms() {
+ public List<CLProgram> getPrograms() {
return Collections.unmodifiableList(programs);
}
/**
* Returns a read only view of all allocated memory objects associated with this context.
*/
- public List<CLMemory<? extends Buffer>> getCLMemoryObjects() {
+ public List<CLMemory<? extends Buffer>> getMemoryObjects() {
return Collections.unmodifiableList(memoryObjects);
}
/**
* Returns a read only view of all samplers associated with this context.
*/
- public List<CLSampler> getCLSamplers() {
+ public List<CLSampler> getSamplers() {
return Collections.unmodifiableList(samplers);
}
@@ -403,7 +415,7 @@ public class CLContext implements CLResource {
* @see #getMaxFlopsDevice(com.mbien.opencl.CLDevice.Type)
*/
public CLDevice getMaxFlopsDevice() {
- return CLPlatform.findMaxFlopsDevice(getCLDevices());
+ return CLPlatform.findMaxFlopsDevice(getDevices());
}
/**
@@ -412,19 +424,19 @@ public class CLContext implements CLResource {
* MAX_COMPUTE_UNITS and MAX_CLOCK_FREQUENCY.
*/
public CLDevice getMaxFlopsDevice(CLDevice.Type type) {
- return CLPlatform.findMaxFlopsDevice(getCLDevices(), type);
+ return CLPlatform.findMaxFlopsDevice(getDevices(), type);
}
/**
* Returns all devices associated with this CLContext.
*/
- public CLDevice[] getCLDevices() {
+ public CLDevice[] getDevices() {
initDevices();
return devices;
}
- CLDevice getCLDevice(long dID) {
- CLDevice[] deviceArray = getCLDevices();
+ CLDevice getDevice(long dID) {
+ CLDevice[] deviceArray = getDevices();
for (int i = 0; i < deviceArray.length; i++) {
if(dID == deviceArray[i].ID)
return deviceArray[i];
@@ -445,7 +457,7 @@ public class CLContext implements CLResource {
@Override
public String toString() {
return "CLContext [id: " + ID
- + " #devices: " + getCLDevices().length
+ + " #devices: " + getDevices().length
+ "]";
}
diff --git a/src/com/mbien/opencl/CLDevice.java b/src/com/mbien/opencl/CLDevice.java
index cd569586..941b8560 100644
--- a/src/com/mbien/opencl/CLDevice.java
+++ b/src/com/mbien/opencl/CLDevice.java
@@ -15,7 +15,11 @@ import java.util.Set;
import static com.mbien.opencl.CL.*;
/**
- *
+ * This object represents an OpenCL device.
+ * @see CLPlatform#listCLDevices(com.mbien.opencl.CLDevice.Type)
+ * @see CLPlatform#getMaxFlopsDevice(com.mbien.opencl.CLDevice.Type)
+ * @see CLContext#getDevices()
+ * @see CLContext#getMaxFlopsDevice(com.mbien.opencl.CLDevice.Type)
* @author Michael Bien
*/
public final class CLDevice {
@@ -68,11 +72,11 @@ public final class CLDevice {
return context.createCommandQueue(this, properties);
}
- /*keep this package private for now, may be null*/
- CLContext getContext() {
+ public CLContext getContext() {
return context;
}
+ /*keep this package private*/
void setContext(CLContext context) {
this.context = context;
}
diff --git a/src/com/mbien/opencl/CLException.java b/src/com/mbien/opencl/CLException.java
index 81e96789..2f6a02a4 100644
--- a/src/com/mbien/opencl/CLException.java
+++ b/src/com/mbien/opencl/CLException.java
@@ -3,191 +3,702 @@ package com.mbien.opencl;
import static com.mbien.opencl.CL.*;
/**
- * Main Exception type for runtime OpenCL errors and unsuccessful function calls (e.g. returning not CL_SUCCESS).
+ * Main Exception type for runtime OpenCL errors and failed function calls (e.g. returning not CL_SUCCESS).
* @author Michael Bien
*/
public class CLException extends RuntimeException {
+ // must be positive
+ private static final long serialVersionUID = 6573520735486076436L;
+
public final int errorcode;
+ public final String error;
- private final static String ERROR_CODE_DOC = "http://www.khronos.org/opencl/sdk/1.0/docs/man/xhtml/errors.html";
+ private final static String ERROR_CODE_DOC =
+ "http://www.khronos.org/opencl/sdk/1.0/docs/man/xhtml/errors.html";
public CLException(String message) {
super(message);
errorcode = 0;
+ error = "none";
}
- public CLException(int error, String message) {
- super(message + "\nerror: " + identifyError(error) + " (man page: "+ERROR_CODE_DOC+")");
- errorcode = error;
+ private CLException(int errorcode, String errorStr, String message) {
+ super(message + "\nerror: " + errorStr + " (man page: "+ERROR_CODE_DOC+")");
+ this.error = errorStr;
+ this.errorcode = errorcode;
}
/**
* Throws a CLException when <code>status != CL_SUCCESS</code>.
*/
public static final void checkForError(int status, String message) {
- if(status != CL_SUCCESS)
- throw new CLException(status, message);
+ if(status != CL_SUCCESS) {
+ CLException ex = newException(status, message);
+ ex.fillInStackTrace();
+ throw ex;
+ }
+ }
+
+ /**
+ * Returns a CLException specific to the error code.
+ */
+ public static final CLException newException(int status, String message) {
+ CLException specificEx = createSpecificException(status, message);
+ if(specificEx != null) {
+ specificEx.fillInStackTrace();
+ return specificEx;
+ }
+ return new CLException(status, "unknown", "unknown cause: code" + status);
}
/**
* Returns a human readable String for the OpenCL error code.
*/
public String getCLErrorString() {
- return identifyError(errorcode);
+ return error;
}
- private static final String identifyError(int error) {
- switch (error) {
- case CL_DEVICE_NOT_FOUND:
- return "CL_DEVICE_NOT_FOUND";
+ // - - - generated code do not edit - - -
- case CL_DEVICE_NOT_AVAILABLE:
- return "CL_DEVICE_NOT_AVAILABLE";
+ /**
+ * Returns a human readable String for the OpenCL error code or null if not known.
+ */
+ public static String resolveErrorCode(int error) {
+ switch(error) {
+ case CL_DEVICE_NOT_FOUND: return "CL_DEVICE_NOT_FOUND";
+ case CL_DEVICE_NOT_AVAILABLE: return "CL_DEVICE_NOT_AVAILABLE";
+ case CL_COMPILER_NOT_AVAILABLE: return "CL_COMPILER_NOT_AVAILABLE";
+ case CL_MEM_OBJECT_ALLOCATION_FAILURE: return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+ case CL_OUT_OF_RESOURCES: return "CL_OUT_OF_RESOURCES";
+ case CL_OUT_OF_HOST_MEMORY: return "CL_OUT_OF_HOST_MEMORY";
+ case CL_PROFILING_INFO_NOT_AVAILABLE: return "CL_PROFILING_INFO_NOT_AVAILABLE";
+ case CL_MEM_COPY_OVERLAP: return "CL_MEM_COPY_OVERLAP";
+ case CL_IMAGE_FORMAT_MISMATCH: return "CL_IMAGE_FORMAT_MISMATCH";
+ case CL_IMAGE_FORMAT_NOT_SUPPORTED: return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+ case CL_BUILD_PROGRAM_FAILURE: return "CL_BUILD_PROGRAM_FAILURE";
+ case CL_MAP_FAILURE: return "CL_MAP_FAILURE";
+ case CL_INVALID_VALUE: return "CL_INVALID_VALUE";
+ case CL_INVALID_DEVICE_TYPE: return "CL_INVALID_DEVICE_TYPE";
+ case CL_INVALID_PLATFORM: return "CL_INVALID_PLATFORM";
+ case CL_INVALID_DEVICE: return "CL_INVALID_DEVICE";
+ case CL_INVALID_CONTEXT: return "CL_INVALID_CONTEXT";
+ case CL_INVALID_QUEUE_PROPERTIES: return "CL_INVALID_QUEUE_PROPERTIES";
+ case CL_INVALID_COMMAND_QUEUE: return "CL_INVALID_COMMAND_QUEUE";
+ case CL_INVALID_HOST_PTR: return "CL_INVALID_HOST_PTR";
+ case CL_INVALID_MEM_OBJECT: return "CL_INVALID_MEM_OBJECT";
+ case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+ case CL_INVALID_IMAGE_SIZE: return "CL_INVALID_IMAGE_SIZE";
+ case CL_INVALID_SAMPLER: return "CL_INVALID_SAMPLER";
+ case CL_INVALID_BINARY: return "CL_INVALID_BINARY";
+ case CL_INVALID_BUILD_OPTIONS: return "CL_INVALID_BUILD_OPTIONS";
+ case CL_INVALID_PROGRAM: return "CL_INVALID_PROGRAM";
+ case CL_INVALID_PROGRAM_EXECUTABLE: return "CL_INVALID_PROGRAM_EXECUTABLE";
+ case CL_INVALID_KERNEL_NAME: return "CL_INVALID_KERNEL_NAME";
+ case CL_INVALID_KERNEL_DEFINITION: return "CL_INVALID_KERNEL_DEFINITION";
+ case CL_INVALID_KERNEL: return "CL_INVALID_KERNEL";
+ case CL_INVALID_ARG_INDEX: return "CL_INVALID_ARG_INDEX";
+ case CL_INVALID_ARG_VALUE: return "CL_INVALID_ARG_VALUE";
+ case CL_INVALID_ARG_SIZE: return "CL_INVALID_ARG_SIZE";
+ case CL_INVALID_KERNEL_ARGS: return "CL_INVALID_KERNEL_ARGS";
+ case CL_INVALID_WORK_DIMENSION: return "CL_INVALID_WORK_DIMENSION";
+ case CL_INVALID_WORK_GROUP_SIZE: return "CL_INVALID_WORK_GROUP_SIZE";
+ case CL_INVALID_WORK_ITEM_SIZE: return "CL_INVALID_WORK_ITEM_SIZE";
+ case CL_INVALID_GLOBAL_OFFSET: return "CL_INVALID_GLOBAL_OFFSET";
+ case CL_INVALID_EVENT_WAIT_LIST: return "CL_INVALID_EVENT_WAIT_LIST";
+ case CL_INVALID_EVENT: return "CL_INVALID_EVENT";
+ case CL_INVALID_OPERATION: return "CL_INVALID_OPERATION";
+ case CL_INVALID_GL_OBJECT: return "CL_INVALID_GL_OBJECT";
+ case CL_INVALID_BUFFER_SIZE: return "CL_INVALID_BUFFER_SIZE";
+ case CL_INVALID_MIP_LEVEL: return "CL_INVALID_MIP_LEVEL";
+ case CL_INVALID_GLOBAL_WORK_SIZE: return "CL_INVALID_GLOBAL_WORK_SIZE";
+ case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
+ case CL_PLATFORM_NOT_FOUND_KHR: return "CL_PLATFORM_NOT_FOUND_KHR";
+ default: return null;
+ }
+ }
- case CL_COMPILER_NOT_AVAILABLE:
- return "CL_COMPILER_NOT_AVAILABLE";
+ private static CLException createSpecificException(int error, String message) {
+ switch(error) {
+ case CL_DEVICE_NOT_FOUND: return new CLDeviceNotFoundException(message);
+ case CL_DEVICE_NOT_AVAILABLE: return new CLDeviceNotAvailableException(message);
+ case CL_COMPILER_NOT_AVAILABLE: return new CLCompilerNotAvailableException(message);
+ case CL_MEM_OBJECT_ALLOCATION_FAILURE: return new CLMemObjectAllocationFailureException(message);
+ case CL_OUT_OF_RESOURCES: return new CLOutOfResourcesException(message);
+ case CL_OUT_OF_HOST_MEMORY: return new CLOutOfHostMemoryException(message);
+ case CL_PROFILING_INFO_NOT_AVAILABLE: return new CLProfilingInfoNotAvailableException(message);
+ case CL_MEM_COPY_OVERLAP: return new CLMemCopyOverlapException(message);
+ case CL_IMAGE_FORMAT_MISMATCH: return new CLImageFormatMismatchException(message);
+ case CL_IMAGE_FORMAT_NOT_SUPPORTED: return new CLImageFormatNotSupportedException(message);
+ case CL_BUILD_PROGRAM_FAILURE: return new CLBuildProgramFailureException(message);
+ case CL_MAP_FAILURE: return new CLMapFailureException(message);
+ case CL_INVALID_VALUE: return new CLInvalidValueException(message);
+ case CL_INVALID_DEVICE_TYPE: return new CLInvalidDeviceTypeException(message);
+ case CL_INVALID_PLATFORM: return new CLInvalidPlatformException(message);
+ case CL_INVALID_DEVICE: return new CLInvalidDeviceException(message);
+ case CL_INVALID_CONTEXT: return new CLInvalidContextException(message);
+ case CL_INVALID_QUEUE_PROPERTIES: return new CLInvalidQueuePropertiesException(message);
+ case CL_INVALID_COMMAND_QUEUE: return new CLInvalidCommandQueueException(message);
+ case CL_INVALID_HOST_PTR: return new CLInvalidHostPtrException(message);
+ case CL_INVALID_MEM_OBJECT: return new CLInvalidMemObjectException(message);
+ case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: return new CLInvalidImageFormatDescriptorException(message);
+ case CL_INVALID_IMAGE_SIZE: return new CLInvalidImageSizeException(message);
+ case CL_INVALID_SAMPLER: return new CLInvalidSamplerException(message);
+ case CL_INVALID_BINARY: return new CLInvalidBinaryException(message);
+ case CL_INVALID_BUILD_OPTIONS: return new CLInvalidBuildOptionsException(message);
+ case CL_INVALID_PROGRAM: return new CLInvalidProgramException(message);
+ case CL_INVALID_PROGRAM_EXECUTABLE: return new CLInvalidProgramExecutableException(message);
+ case CL_INVALID_KERNEL_NAME: return new CLInvalidKernelNameException(message);
+ case CL_INVALID_KERNEL_DEFINITION: return new CLInvalidKernelDefinitionException(message);
+ case CL_INVALID_KERNEL: return new CLInvalidKernelException(message);
+ case CL_INVALID_ARG_INDEX: return new CLInvalidArgIndexException(message);
+ case CL_INVALID_ARG_VALUE: return new CLInvalidArgValueException(message);
+ case CL_INVALID_ARG_SIZE: return new CLInvalidArgSizeException(message);
+ case CL_INVALID_KERNEL_ARGS: return new CLInvalidKernelArgsException(message);
+ case CL_INVALID_WORK_DIMENSION: return new CLInvalidWorkDimensionException(message);
+ case CL_INVALID_WORK_GROUP_SIZE: return new CLInvalidWorkGroupSizeException(message);
+ case CL_INVALID_WORK_ITEM_SIZE: return new CLInvalidWorkItemSizeException(message);
+ case CL_INVALID_GLOBAL_OFFSET: return new CLInvalidGlobalOffsetException(message);
+ case CL_INVALID_EVENT_WAIT_LIST: return new CLInvalidEventWaitListException(message);
+ case CL_INVALID_EVENT: return new CLInvalidEventException(message);
+ case CL_INVALID_OPERATION: return new CLInvalidOperationException(message);
+ case CL_INVALID_GL_OBJECT: return new CLInvalidGLObjectException(message);
+ case CL_INVALID_BUFFER_SIZE: return new CLInvalidBufferSizeException(message);
+ case CL_INVALID_MIP_LEVEL: return new CLInvalidMipLevelException(message);
+ case CL_INVALID_GLOBAL_WORK_SIZE: return new CLInvalidGlobalWorkSizeException(message);
+ case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR: return new CLInvalidGLSharegroupReferenceKhrException(message);
+ case CL_PLATFORM_NOT_FOUND_KHR: return new CLPlatformNotFoundKhrException(message);
+ default: return null;
+ }
+ }
- case CL_MEM_OBJECT_ALLOCATION_FAILURE:
- return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+ /**
+ * {@link CLException} thrown on CL.CL_DEVICE_NOT_FOUND errors.
+ * @author Michael Bien
+ */
+ public final static class CLDeviceNotFoundException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_DEVICE_NOT_FOUND;
+ public CLDeviceNotFoundException(String message) {
+ super(CL_DEVICE_NOT_FOUND, "CL_DEVICE_NOT_FOUND", message);
+ }
+ }
- case CL_OUT_OF_RESOURCES:
- return "CL_OUT_OF_RESOURCES";
+ /**
+ * {@link CLException} thrown on CL.CL_DEVICE_NOT_AVAILABLE errors.
+ * @author Michael Bien
+ */
+ public final static class CLDeviceNotAvailableException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_DEVICE_NOT_AVAILABLE;
+ public CLDeviceNotAvailableException(String message) {
+ super(CL_DEVICE_NOT_AVAILABLE, "CL_DEVICE_NOT_AVAILABLE", message);
+ }
+ }
- case CL_OUT_OF_HOST_MEMORY:
- return "CL_OUT_OF_HOST_MEMORY";
+ /**
+ * {@link CLException} thrown on CL.CL_COMPILER_NOT_AVAILABLE errors.
+ * @author Michael Bien
+ */
+ public final static class CLCompilerNotAvailableException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_COMPILER_NOT_AVAILABLE;
+ public CLCompilerNotAvailableException(String message) {
+ super(CL_COMPILER_NOT_AVAILABLE, "CL_COMPILER_NOT_AVAILABLE", message);
+ }
+ }
- case CL_PROFILING_INFO_NOT_AVAILABLE:
- return "CL_PROFILING_INFO_NOT_AVAILABLE";
+ /**
+ * {@link CLException} thrown on CL.CL_MEM_OBJECT_ALLOCATION_FAILURE errors.
+ * @author Michael Bien
+ */
+ public final static class CLMemObjectAllocationFailureException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_MEM_OBJECT_ALLOCATION_FAILURE;
+ public CLMemObjectAllocationFailureException(String message) {
+ super(CL_MEM_OBJECT_ALLOCATION_FAILURE, "CL_MEM_OBJECT_ALLOCATION_FAILURE", message);
+ }
+ }
- case CL_MEM_COPY_OVERLAP:
- return "CL_MEM_COPY_OVERLAP";
+ /**
+ * {@link CLException} thrown on CL.CL_OUT_OF_RESOURCES errors.
+ * @author Michael Bien
+ */
+ public final static class CLOutOfResourcesException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_OUT_OF_RESOURCES;
+ public CLOutOfResourcesException(String message) {
+ super(CL_OUT_OF_RESOURCES, "CL_OUT_OF_RESOURCES", message);
+ }
+ }
- case CL_IMAGE_FORMAT_MISMATCH:
- return "CL_IMAGE_FORMAT_MISMATCH";
+ /**
+ * {@link CLException} thrown on CL.CL_OUT_OF_HOST_MEMORY errors.
+ * @author Michael Bien
+ */
+ public final static class CLOutOfHostMemoryException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_OUT_OF_HOST_MEMORY;
+ public CLOutOfHostMemoryException(String message) {
+ super(CL_OUT_OF_HOST_MEMORY, "CL_OUT_OF_HOST_MEMORY", message);
+ }
+ }
- case CL_IMAGE_FORMAT_NOT_SUPPORTED:
- return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+ /**
+ * {@link CLException} thrown on CL.CL_PROFILING_INFO_NOT_AVAILABLE errors.
+ * @author Michael Bien
+ */
+ public final static class CLProfilingInfoNotAvailableException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_PROFILING_INFO_NOT_AVAILABLE;
+ public CLProfilingInfoNotAvailableException(String message) {
+ super(CL_PROFILING_INFO_NOT_AVAILABLE, "CL_PROFILING_INFO_NOT_AVAILABLE", message);
+ }
+ }
+
+ /**
+ * {@link CLException} thrown on CL.CL_MEM_COPY_OVERLAP errors.
+ * @author Michael Bien
+ */
+ public final static class CLMemCopyOverlapException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_MEM_COPY_OVERLAP;
+ public CLMemCopyOverlapException(String message) {
+ super(CL_MEM_COPY_OVERLAP, "CL_MEM_COPY_OVERLAP", message);
+ }
+ }
- case CL_BUILD_PROGRAM_FAILURE:
- return "CL_BUILD_PROGRAM_FAILURE";
+ /**
+ * {@link CLException} thrown on CL.CL_IMAGE_FORMAT_MISMATCH errors.
+ * @author Michael Bien
+ */
+ public final static class CLImageFormatMismatchException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_IMAGE_FORMAT_MISMATCH;
+ public CLImageFormatMismatchException(String message) {
+ super(CL_IMAGE_FORMAT_MISMATCH, "CL_IMAGE_FORMAT_MISMATCH", message);
+ }
+ }
- case CL_MAP_FAILURE:
- return "CL_MAP_FAILURE";
+ /**
+ * {@link CLException} thrown on CL.CL_IMAGE_FORMAT_NOT_SUPPORTED errors.
+ * @author Michael Bien
+ */
+ public final static class CLImageFormatNotSupportedException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_IMAGE_FORMAT_NOT_SUPPORTED;
+ public CLImageFormatNotSupportedException(String message) {
+ super(CL_IMAGE_FORMAT_NOT_SUPPORTED, "CL_IMAGE_FORMAT_NOT_SUPPORTED", message);
+ }
+ }
- case CL_INVALID_VALUE:
- return "CL_INVALID_VALUE";
+ /**
+ * {@link CLException} thrown on CL.CL_BUILD_PROGRAM_FAILURE errors.
+ * @author Michael Bien
+ */
+ public final static class CLBuildProgramFailureException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_BUILD_PROGRAM_FAILURE;
+ public CLBuildProgramFailureException(String message) {
+ super(CL_BUILD_PROGRAM_FAILURE, "CL_BUILD_PROGRAM_FAILURE", message);
+ }
+ }
- case CL_INVALID_DEVICE_TYPE:
- return "CL_INVALID_DEVICE_TYPE";
+ /**
+ * {@link CLException} thrown on CL.CL_MAP_FAILURE errors.
+ * @author Michael Bien
+ */
+ public final static class CLMapFailureException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_MAP_FAILURE;
+ public CLMapFailureException(String message) {
+ super(CL_MAP_FAILURE, "CL_MAP_FAILURE", message);
+ }
+ }
- case CL_INVALID_PLATFORM:
- return "CL_INVALID_PLATFORM";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_VALUE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidValueException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_VALUE;
+ public CLInvalidValueException(String message) {
+ super(CL_INVALID_VALUE, "CL_INVALID_VALUE", message);
+ }
+ }
- case CL_INVALID_DEVICE:
- return "CL_INVALID_DEVICE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_DEVICE_TYPE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidDeviceTypeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_DEVICE_TYPE;
+ public CLInvalidDeviceTypeException(String message) {
+ super(CL_INVALID_DEVICE_TYPE, "CL_INVALID_DEVICE_TYPE", message);
+ }
+ }
- case CL_INVALID_CONTEXT:
- return "CL_INVALID_CONTEXT";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_PLATFORM errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidPlatformException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PLATFORM;
+ public CLInvalidPlatformException(String message) {
+ super(CL_INVALID_PLATFORM, "CL_INVALID_PLATFORM", message);
+ }
+ }
- case CL_INVALID_QUEUE_PROPERTIES:
- return "CL_INVALID_QUEUE_PROPERTIES";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_DEVICE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidDeviceException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_DEVICE;
+ public CLInvalidDeviceException(String message) {
+ super(CL_INVALID_DEVICE, "CL_INVALID_DEVICE", message);
+ }
+ }
- case CL_INVALID_COMMAND_QUEUE:
- return "CL_INVALID_COMMAND_QUEUE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_CONTEXT errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidContextException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_CONTEXT;
+ public CLInvalidContextException(String message) {
+ super(CL_INVALID_CONTEXT, "CL_INVALID_CONTEXT", message);
+ }
+ }
- case CL_INVALID_HOST_PTR:
- return "CL_INVALID_HOST_PTR";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_QUEUE_PROPERTIES errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidQueuePropertiesException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_QUEUE_PROPERTIES;
+ public CLInvalidQueuePropertiesException(String message) {
+ super(CL_INVALID_QUEUE_PROPERTIES, "CL_INVALID_QUEUE_PROPERTIES", message);
+ }
+ }
- case CL_INVALID_MEM_OBJECT:
- return "CL_INVALID_MEM_OBJECT";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_COMMAND_QUEUE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidCommandQueueException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_COMMAND_QUEUE;
+ public CLInvalidCommandQueueException(String message) {
+ super(CL_INVALID_COMMAND_QUEUE, "CL_INVALID_COMMAND_QUEUE", message);
+ }
+ }
- case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
- return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_HOST_PTR errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidHostPtrException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_HOST_PTR;
+ public CLInvalidHostPtrException(String message) {
+ super(CL_INVALID_HOST_PTR, "CL_INVALID_HOST_PTR", message);
+ }
+ }
- case CL_INVALID_IMAGE_SIZE:
- return "CL_INVALID_IMAGE_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_MEM_OBJECT errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidMemObjectException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_MEM_OBJECT;
+ public CLInvalidMemObjectException(String message) {
+ super(CL_INVALID_MEM_OBJECT, "CL_INVALID_MEM_OBJECT", message);
+ }
+ }
- case CL_INVALID_SAMPLER:
- return "CL_INVALID_SAMPLER";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidImageFormatDescriptorException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
+ public CLInvalidImageFormatDescriptorException(String message) {
+ super(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", message);
+ }
+ }
- case CL_INVALID_BINARY:
- return "CL_INVALID_BINARY";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_IMAGE_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidImageSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_IMAGE_SIZE;
+ public CLInvalidImageSizeException(String message) {
+ super(CL_INVALID_IMAGE_SIZE, "CL_INVALID_IMAGE_SIZE", message);
+ }
+ }
- case CL_INVALID_BUILD_OPTIONS:
- return "CL_INVALID_BUILD_OPTIONS";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_SAMPLER errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidSamplerException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_SAMPLER;
+ public CLInvalidSamplerException(String message) {
+ super(CL_INVALID_SAMPLER, "CL_INVALID_SAMPLER", message);
+ }
+ }
- case CL_INVALID_PROGRAM:
- return "CL_INVALID_PROGRAM";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_BINARY errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidBinaryException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BINARY;
+ public CLInvalidBinaryException(String message) {
+ super(CL_INVALID_BINARY, "CL_INVALID_BINARY", message);
+ }
+ }
- case CL_INVALID_PROGRAM_EXECUTABLE:
- return "CL_INVALID_PROGRAM_EXECUTABLE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_BUILD_OPTIONS errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidBuildOptionsException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BUILD_OPTIONS;
+ public CLInvalidBuildOptionsException(String message) {
+ super(CL_INVALID_BUILD_OPTIONS, "CL_INVALID_BUILD_OPTIONS", message);
+ }
+ }
- case CL_INVALID_KERNEL_NAME:
- return "CL_INVALID_KERNEL_NAME";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_PROGRAM errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidProgramException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PROGRAM;
+ public CLInvalidProgramException(String message) {
+ super(CL_INVALID_PROGRAM, "CL_INVALID_PROGRAM", message);
+ }
+ }
- case CL_INVALID_KERNEL_DEFINITION:
- return "CL_INVALID_KERNEL_DEFINITION";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_PROGRAM_EXECUTABLE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidProgramExecutableException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PROGRAM_EXECUTABLE;
+ public CLInvalidProgramExecutableException(String message) {
+ super(CL_INVALID_PROGRAM_EXECUTABLE, "CL_INVALID_PROGRAM_EXECUTABLE", message);
+ }
+ }
- case CL_INVALID_KERNEL:
- return "CL_INVALID_KERNEL";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_KERNEL_NAME errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidKernelNameException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_NAME;
+ public CLInvalidKernelNameException(String message) {
+ super(CL_INVALID_KERNEL_NAME, "CL_INVALID_KERNEL_NAME", message);
+ }
+ }
- case CL_INVALID_ARG_INDEX:
- return "CL_INVALID_ARG_INDEX";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_KERNEL_DEFINITION errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidKernelDefinitionException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_DEFINITION;
+ public CLInvalidKernelDefinitionException(String message) {
+ super(CL_INVALID_KERNEL_DEFINITION, "CL_INVALID_KERNEL_DEFINITION", message);
+ }
+ }
- case CL_INVALID_ARG_VALUE:
- return "CL_INVALID_ARG_VALUE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_KERNEL errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidKernelException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL;
+ public CLInvalidKernelException(String message) {
+ super(CL_INVALID_KERNEL, "CL_INVALID_KERNEL", message);
+ }
+ }
- case CL_INVALID_ARG_SIZE:
- return "CL_INVALID_ARG_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_ARG_INDEX errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidArgIndexException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_INDEX;
+ public CLInvalidArgIndexException(String message) {
+ super(CL_INVALID_ARG_INDEX, "CL_INVALID_ARG_INDEX", message);
+ }
+ }
- case CL_INVALID_KERNEL_ARGS:
- return "CL_INVALID_KERNEL_ARGS";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_ARG_VALUE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidArgValueException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_VALUE;
+ public CLInvalidArgValueException(String message) {
+ super(CL_INVALID_ARG_VALUE, "CL_INVALID_ARG_VALUE", message);
+ }
+ }
- case CL_INVALID_WORK_DIMENSION:
- return "CL_INVALID_WORK_DIMENSION";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_ARG_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidArgSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_SIZE;
+ public CLInvalidArgSizeException(String message) {
+ super(CL_INVALID_ARG_SIZE, "CL_INVALID_ARG_SIZE", message);
+ }
+ }
- case CL_INVALID_WORK_GROUP_SIZE:
- return "CL_INVALID_WORK_GROUP_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_KERNEL_ARGS errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidKernelArgsException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_ARGS;
+ public CLInvalidKernelArgsException(String message) {
+ super(CL_INVALID_KERNEL_ARGS, "CL_INVALID_KERNEL_ARGS", message);
+ }
+ }
- case CL_INVALID_WORK_ITEM_SIZE:
- return "CL_INVALID_WORK_ITEM_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_WORK_DIMENSION errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidWorkDimensionException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_DIMENSION;
+ public CLInvalidWorkDimensionException(String message) {
+ super(CL_INVALID_WORK_DIMENSION, "CL_INVALID_WORK_DIMENSION", message);
+ }
+ }
- case CL_INVALID_GLOBAL_OFFSET:
- return "CL_INVALID_GLOBAL_OFFSET";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_WORK_GROUP_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidWorkGroupSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_GROUP_SIZE;
+ public CLInvalidWorkGroupSizeException(String message) {
+ super(CL_INVALID_WORK_GROUP_SIZE, "CL_INVALID_WORK_GROUP_SIZE", message);
+ }
+ }
- case CL_INVALID_EVENT_WAIT_LIST:
- return "CL_INVALID_EVENT_WAIT_LIST";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_WORK_ITEM_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidWorkItemSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_ITEM_SIZE;
+ public CLInvalidWorkItemSizeException(String message) {
+ super(CL_INVALID_WORK_ITEM_SIZE, "CL_INVALID_WORK_ITEM_SIZE", message);
+ }
+ }
- case CL_INVALID_EVENT:
- return "CL_INVALID_EVENT";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_GLOBAL_OFFSET errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidGlobalOffsetException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GLOBAL_OFFSET;
+ public CLInvalidGlobalOffsetException(String message) {
+ super(CL_INVALID_GLOBAL_OFFSET, "CL_INVALID_GLOBAL_OFFSET", message);
+ }
+ }
- case CL_INVALID_OPERATION:
- return "CL_INVALID_OPERATION";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_EVENT_WAIT_LIST errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidEventWaitListException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_EVENT_WAIT_LIST;
+ public CLInvalidEventWaitListException(String message) {
+ super(CL_INVALID_EVENT_WAIT_LIST, "CL_INVALID_EVENT_WAIT_LIST", message);
+ }
+ }
- case CL_INVALID_GL_OBJECT:
- return "CL_INVALID_GL_OBJECT";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_EVENT errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidEventException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_EVENT;
+ public CLInvalidEventException(String message) {
+ super(CL_INVALID_EVENT, "CL_INVALID_EVENT", message);
+ }
+ }
- case CL_INVALID_BUFFER_SIZE:
- return "CL_INVALID_BUFFER_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_OPERATION errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidOperationException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_OPERATION;
+ public CLInvalidOperationException(String message) {
+ super(CL_INVALID_OPERATION, "CL_INVALID_OPERATION", message);
+ }
+ }
- case CL_INVALID_MIP_LEVEL:
- return "CL_INVALID_MIP_LEVEL";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_GL_OBJECT errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidGLObjectException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GL_OBJECT;
+ public CLInvalidGLObjectException(String message) {
+ super(CL_INVALID_GL_OBJECT, "CL_INVALID_GL_OBJECT", message);
+ }
+ }
- case CL_INVALID_GLOBAL_WORK_SIZE:
- return "CL_INVALID_GLOBAL_WORK_SIZE";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_BUFFER_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidBufferSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BUFFER_SIZE;
+ public CLInvalidBufferSizeException(String message) {
+ super(CL_INVALID_BUFFER_SIZE, "CL_INVALID_BUFFER_SIZE", message);
+ }
+ }
- case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:
- return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_MIP_LEVEL errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidMipLevelException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_MIP_LEVEL;
+ public CLInvalidMipLevelException(String message) {
+ super(CL_INVALID_MIP_LEVEL, "CL_INVALID_MIP_LEVEL", message);
+ }
+ }
- case CL_PLATFORM_NOT_FOUND_KHR:
- return "CL_PLATFORM_NOT_FOUND_KHR";
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_GLOBAL_WORK_SIZE errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidGlobalWorkSizeException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GLOBAL_WORK_SIZE;
+ public CLInvalidGlobalWorkSizeException(String message) {
+ super(CL_INVALID_GLOBAL_WORK_SIZE, "CL_INVALID_GLOBAL_WORK_SIZE", message);
+ }
+ }
- default:
- return "unknown cause: code" + error;
+ /**
+ * {@link CLException} thrown on CL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR errors.
+ * @author Michael Bien
+ */
+ public final static class CLInvalidGLSharegroupReferenceKhrException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR;
+ public CLInvalidGLSharegroupReferenceKhrException(String message) {
+ super(CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR, "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR", message);
}
}
+ /**
+ * {@link CLException} thrown on CL.CL_PLATFORM_NOT_FOUND_KHR errors.
+ * @author Michael Bien
+ */
+ public final static class CLPlatformNotFoundKhrException extends CLException {
+ private static final long serialVersionUID = CLException.serialVersionUID+CL_PLATFORM_NOT_FOUND_KHR;
+ public CLPlatformNotFoundKhrException(String message) {
+ super(CL_PLATFORM_NOT_FOUND_KHR, "CL_PLATFORM_NOT_FOUND_KHR", message);
+ }
+ }
} \ No newline at end of file
diff --git a/src/com/mbien/opencl/CLGLContext.java b/src/com/mbien/opencl/CLGLContext.java
index 6fb0251f..46f0dea3 100644
--- a/src/com/mbien/opencl/CLGLContext.java
+++ b/src/com/mbien/opencl/CLGLContext.java
@@ -20,8 +20,8 @@ public final class CLGLContext extends CLContext {
final long glID;
- private CLGLContext(long clContextID, long glContextID) {
- super(clContextID);
+ private CLGLContext(CLPlatform platform, long clContextID, long glContextID) {
+ super(platform, clContextID);
this.glID = glContextID;
}
@@ -61,11 +61,15 @@ public final class CLGLContext extends CLContext {
*/
public static final CLGLContext create(GLContext glContext, CLPlatform platform, CLDevice.Type... deviceTypes) {
+ if(platform == null) {
+ platform = CLPlatform.getDefault();
+ }
+
long[] glID = new long[1];
- PointerBuffer properties = setupContextProperties(glContext, platform, glID);
+ PointerBuffer properties = setupContextProperties(platform, glContext, glID);
long clID = createContextFromType(properties, toDeviceBitmap(deviceTypes));
- return new CLGLContext(clID, glID[0]);
+ return new CLGLContext(platform, clID, glID[0]);
}
@@ -75,11 +79,15 @@ public final class CLGLContext extends CLContext {
*/
public static final CLGLContext create(GLContext glContext, CLPlatform platform, CLDevice... devices) {
+ if(platform == null) {
+ platform = CLPlatform.getDefault();
+ }
+
long[] glID = new long[1];
- PointerBuffer properties = setupContextProperties(glContext, platform, glID);
+ PointerBuffer properties = setupContextProperties(platform, glContext, glID);
long clID = createContext(properties, devices);
- CLGLContext context = new CLGLContext(clID, glID[0]);
+ CLGLContext context = new CLGLContext(platform, clID, glID[0]);
if(devices != null) {
for (int i = 0; i < devices.length; i++) {
devices[i].setContext(context);
@@ -89,11 +97,7 @@ public final class CLGLContext extends CLContext {
}
- private static final PointerBuffer setupContextProperties(GLContext glContext, CLPlatform platform, long[] glID) {
-
- if(platform == null) {
- platform = CLPlatform.getDefault();
- }
+ private static final PointerBuffer setupContextProperties(CLPlatform platform, GLContext glContext, long[] glID) {
if(platform == null) {
throw new RuntimeException("no OpenCL installation found");
diff --git a/src/com/mbien/opencl/CLKernel.java b/src/com/mbien/opencl/CLKernel.java
index eb817f14..a8c1ff10 100644
--- a/src/com/mbien/opencl/CLKernel.java
+++ b/src/com/mbien/opencl/CLKernel.java
@@ -91,6 +91,11 @@ public class CLKernel implements CLResource, Cloneable {
return this;
}
+ public CLKernel rewind() {
+ argIndex = 0;
+ return this;
+ }
+
public CLKernel setArg(int argumentIndex, CLMemory<?> value) {
setArgument(argumentIndex, CPU.is32Bit()?4:8, wrap(value.ID));
return this;
@@ -157,6 +162,10 @@ public class CLKernel implements CLResource, Cloneable {
this.force32BitArgs = force;
return this;
}
+
+ public CLProgram getProgram() {
+ return program;
+ }
/**
* @see #setForce32BitArgs(boolean)
@@ -181,11 +190,6 @@ public class CLKernel implements CLResource, Cloneable {
return buffer.putLong(value).rewind();
}
- public CLKernel rewind() {
- argIndex = 0;
- return this;
- }
-
/**
* Releases all resources of this kernel from its context.
*/
diff --git a/src/com/mbien/opencl/CLMemory.java b/src/com/mbien/opencl/CLMemory.java
index 0c59e0c5..884744ad 100644
--- a/src/com/mbien/opencl/CLMemory.java
+++ b/src/com/mbien/opencl/CLMemory.java
@@ -91,6 +91,9 @@ public abstract class CLMemory <B extends Buffer> implements CLResource {
return sizeOfBufferElem(buffer) * buffer.capacity();
}
+ /**
+ * Returns the size of the allocated OpenCL memory.
+ */
public long getCLSize() {
PointerBuffer pb = PointerBuffer.allocateDirect(1);
int ret = cl.clGetMemObjectInfo(ID, CL_MEM_SIZE, PointerBuffer.elementSize(), pb.getBuffer(), null);
diff --git a/src/com/mbien/opencl/CLPlatform.java b/src/com/mbien/opencl/CLPlatform.java
index c3b1a1f2..687cf130 100644
--- a/src/com/mbien/opencl/CLPlatform.java
+++ b/src/com/mbien/opencl/CLPlatform.java
@@ -2,7 +2,6 @@ package com.mbien.opencl;
import com.mbien.opencl.impl.CLImpl;
import com.sun.gluegen.runtime.PointerBuffer;
-import com.sun.gluegen.runtime.ProcAddressHelper;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
@@ -77,11 +76,20 @@ public final class CLPlatform {
/**
* Returns the low level binding interface to the OpenCL APIs.
*/
- public static CL getLowLevelBinding() {
+ public static CL getLowLevelCLInterface() {
return cl;
}
/**
+ * Hint to allow the implementation to release the resources allocated by the OpenCL compiler.
+ * Calls to {@link CLProgram#build()} after unloadCompiler will reload the compiler if necessary.
+ */
+ public static void unloadCompiler() {
+ int ret = cl.clUnloadCompiler();
+ checkForError(ret, "error while sending unload compiler hint");
+ }
+
+ /**
* Lists all physical devices available on this platform.
* @see #listCLDevices(com.mbien.opencl.CLDevice.Type)
*/
diff --git a/src/com/mbien/opencl/CLProgram.java b/src/com/mbien/opencl/CLProgram.java
index dfe084c7..aafca855 100644
--- a/src/com/mbien/opencl/CLProgram.java
+++ b/src/com/mbien/opencl/CLProgram.java
@@ -17,6 +17,10 @@ import static com.mbien.opencl.CL.*;
/**
* Represents a OpenCL program executed on one or more {@link CLDevice}s.
+ * A CLProgram must be build using one of the build methods before creating {@link CLKernel}s.
+ * @see CLContext#createProgram(java.io.InputStream)
+ * @see CLContext#createProgram(java.lang.String)
+ * @see CLContext#createProgram(java.util.Map)
* @author Michael Bien
*/
public class CLProgram implements CLResource {
@@ -231,7 +235,7 @@ public class CLProgram implements CLResource {
int ret = cl.clBuildProgram(ID, count, deviceIDs, options, null, null);
if(ret != CL_SUCCESS) {
- throw new CLException(ret, "\n"+getBuildLog());
+ throw newException(ret, "\n"+getBuildLog());
}
return this;
@@ -304,7 +308,7 @@ public class CLProgram implements CLResource {
if(!isExecutable()) {
// It is illegal to create kernels from a not executable program.
// For consistency between AMD and NVIDIA drivers throw an exception at this point.
- throw new CLException(CL_INVALID_PROGRAM_EXECUTABLE,
+ throw newException(CL_INVALID_PROGRAM_EXECUTABLE,
"can not initialize kernels, program is not executable. status: "+buildStatusMap);
}
}
@@ -342,6 +346,10 @@ public class CLProgram implements CLResource {
}
}
+ public CLContext getContext() {
+ return context;
+ }
+
/**
* Returns all devices associated with this program.
*/
@@ -360,7 +368,7 @@ public class CLProgram implements CLResource {
int count = bb.capacity() / (CPU.is32Bit()?4:8);
CLDevice[] devices = new CLDevice[count];
for (int i = 0; i < count; i++) {
- devices[i] = context.getCLDevice(CPU.is32Bit()?bb.getInt():bb.getLong());
+ devices[i] = context.getDevice(CPU.is32Bit()?bb.getInt():bb.getLong());
}
return devices;
@@ -439,8 +447,8 @@ public class CLProgram implements CLResource {
}
/**
- * Returns the binaries for this program in a map containing the device as key
- * and the byte array as value.
+ * Returns the binaries for this program in a Map containing the device as key
+ * and the program binaries as value.
*/
public Map<CLDevice, byte[]> getBinaries() {
@@ -497,6 +505,20 @@ public class CLProgram implements CLResource {
return sb.toString();
}
+ /**
+ * Utility method for defining macros as build options (Returns "-D name").
+ */
+ public static String define(String name) {
+ return "-D "+name;
+ }
+
+ /**
+ * Utility method for defining macros as build options (Returns "-D name=value").
+ */
+ public static String define(String name, String value) {
+ return "-D "+name+"="+value;
+ }
+
@Override
public String toString() {
return "CLProgram [id: " + ID
diff --git a/test/com/mbien/opencl/CLBufferTest.java b/test/com/mbien/opencl/CLBufferTest.java
index f768c5ae..39f85a75 100644
--- a/test/com/mbien/opencl/CLBufferTest.java
+++ b/test/com/mbien/opencl/CLBufferTest.java
@@ -33,7 +33,7 @@ public class CLBufferTest {
// fill only first read buffer -> we will copy the payload to the second later.
fillBuffer(clBufferA.buffer, 12345);
- CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue();
+ CLCommandQueue queue = context.getDevices()[0].createCommandQueue();
// asynchronous write of data to GPU device, blocking read later to get the computed results back.
queue.putWriteBuffer(clBufferA, false) // write A
@@ -62,7 +62,7 @@ public class CLBufferTest {
// fill only first read buffer -> we will copy the payload to the second later.
fillBuffer(buffer, 12345);
- CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue();
+ CLCommandQueue queue = context.getDevices()[0].createCommandQueue();
Mem[] bufferConfig = new Mem[] {Mem.COPY_BUFFER, Mem.USE_BUFFER};
@@ -78,11 +78,11 @@ public class CLBufferTest {
.putReadBuffer(clBufferB, true) // read B
.finish();
- assertEquals(2, context.getCLMemoryObjects().size());
+ assertEquals(2, context.getMemoryObjects().size());
clBufferA.release();
- assertEquals(1, context.getCLMemoryObjects().size());
+ assertEquals(1, context.getMemoryObjects().size());
clBufferB.release();
- assertEquals(0, context.getCLMemoryObjects().size());
+ assertEquals(0, context.getMemoryObjects().size());
// uploading worked when a==b.
out.println("validating computed results...");
@@ -121,7 +121,7 @@ public class CLBufferTest {
clBufferB = context.createByteBuffer(sizeInBytes, Mem.READ_WRITE, Mem.USE_BUFFER);
}
- CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue();
+ CLCommandQueue queue = context.getDevices()[0].createCommandQueue();
// fill only first buffer -> we will copy the payload to the second later.
ByteBuffer mappedBufferA = queue.putMapBuffer(clBufferA, Map.READ_WRITE, true);
diff --git a/test/com/mbien/opencl/CLCommandQueueTest.java b/test/com/mbien/opencl/CLCommandQueueTest.java
index b52ef5ed..2cf9c1bf 100644
--- a/test/com/mbien/opencl/CLCommandQueueTest.java
+++ b/test/com/mbien/opencl/CLCommandQueueTest.java
@@ -26,7 +26,7 @@ public class CLCommandQueueTest {
//CLCommandQueueEnums
EnumSet<Mode> queueMode = Mode.valuesOf(CL.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL.CL_QUEUE_PROFILING_ENABLE);
- assertTrue(queueMode.contains(Mode.OUT_OF_ORDER_EXEC_MODE));
+ assertTrue(queueMode.contains(Mode.OUT_OF_ORDER_MODE));
assertTrue(queueMode.contains(Mode.PROFILING_MODE));
assertNotNull(Mode.valuesOf(0));
@@ -69,7 +69,7 @@ public class CLCommandQueueTest {
CLProgram program = context.createProgram(getClass().getResourceAsStream("testkernels.cl")).build();
CLKernel vectorAddKernel = program.createCLKernel("VectorAddGM").setArg(3, elements);
- CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue();
+ CLCommandQueue queue = context.getDevices()[0].createCommandQueue();
final CLEventList events = new CLEventList(2);
@@ -126,7 +126,7 @@ public class CLCommandQueueTest {
CLProgram program = context.createProgram(getClass().getResourceAsStream("testkernels.cl")).build();
CLKernel vectorAddKernel = program.createCLKernel("VectorAddGM").setArg(3, elements);
- CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue(Mode.PROFILING_MODE);
+ CLCommandQueue queue = context.getDevices()[0].createCommandQueue(Mode.PROFILING_MODE);
queue.putWriteBuffer(clBufferA, true) // write A
.putWriteBuffer(clBufferB, true);// write B
@@ -165,7 +165,7 @@ public class CLCommandQueueTest {
CLContext context = CLContext.create();
- CLDevice[] devices = context.getCLDevices();
+ CLDevice[] devices = context.getDevices();
if (devices.length < 2) {
out.println("aborting test... need at least 2 devices");
diff --git a/test/com/mbien/opencl/HighLevelBindingTest.java b/test/com/mbien/opencl/HighLevelBindingTest.java
index 21014e8a..3a75e03c 100644
--- a/test/com/mbien/opencl/HighLevelBindingTest.java
+++ b/test/com/mbien/opencl/HighLevelBindingTest.java
@@ -1,7 +1,10 @@
package com.mbien.opencl;
import com.mbien.opencl.CLMemory.Mem;
-import com.mbien.opencl.CLCommandQueue.Mode;
+import com.mbien.opencl.CLSampler.AddressingMode;
+import com.mbien.opencl.CLSampler.FilteringMode;
+import com.mbien.opencl.CLImageFormat.ChannelOrder;
+import com.mbien.opencl.CLImageFormat.ChannelType;
import com.mbien.opencl.CLDevice.FPConfig;
import com.mbien.opencl.CLDevice.GlobalMemCacheType;
import com.mbien.opencl.CLDevice.LocalMemType;
@@ -62,6 +65,22 @@ public class HighLevelBindingTest {
assertEquals(e, Mem.valueOf(e.CONFIG));
}
+ // CLSampler enums
+ for (AddressingMode e : AddressingMode.values()) {
+ assertEquals(e, AddressingMode.valueOf(e.MODE));
+ }
+ for (FilteringMode e : FilteringMode.values()) {
+ assertEquals(e, FilteringMode.valueOf(e.MODE));
+ }
+
+ // CLImage enums
+ for (ChannelOrder e : ChannelOrder.values()) {
+ assertEquals(e, ChannelOrder.valueOf(e.ORDER));
+ }
+ for (ChannelType e : ChannelType.values()) {
+ assertEquals(e, ChannelType.valueOf(e.TYPE));
+ }
+
}
@@ -142,32 +161,32 @@ public class HighLevelBindingTest {
CLContext c = CLContext.create();
assertNotNull(c);
- assertEquals(deviceCount, c.getCLDevices().length);
+ assertEquals(deviceCount, c.getDevices().length);
c.release();
c = CLContext.create(platform);
assertNotNull(c);
- assertEquals(deviceCount, c.getCLDevices().length);
+ assertEquals(deviceCount, c.getDevices().length);
c.release();
c = CLContext.create(firstDevice);
assertNotNull(c);
- assertEquals(1, c.getCLDevices().length);
+ assertEquals(1, c.getDevices().length);
c.release();
c = CLContext.create(CLDevice.Type.ALL);
assertNotNull(c);
- assertEquals(deviceCount, c.getCLDevices().length);
+ assertEquals(deviceCount, c.getDevices().length);
c.release();
c = CLContext.create(platform, firstDevice);
assertNotNull(c);
- assertEquals(1, c.getCLDevices().length);
+ assertEquals(1, c.getDevices().length);
c.release();
c = CLContext.create(platform, CLDevice.Type.ALL);
assertNotNull(c);
- assertEquals(deviceCount, c.getCLDevices().length);
+ assertEquals(deviceCount, c.getDevices().length);
c.release();
}
@@ -180,7 +199,7 @@ public class HighLevelBindingTest {
CLPlatform[] clPlatforms = CLPlatform.listCLPlatforms();
CLContext context = CLContext.create(clPlatforms[0]);
- CLDevice[] contextDevices = context.getCLDevices();
+ CLDevice[] contextDevices = context.getDevices();
out.println("context devices:");
for (CLDevice device : contextDevices) {
@@ -251,22 +270,22 @@ public class HighLevelBindingTest {
out.print(dest.getInt()+", ");
out.println("...; "+dest.remaining()/SIZEOF_INT + " more");
- assertTrue(3 == context.getCLMemoryObjects().size());
+ assertTrue(3 == context.getMemoryObjects().size());
clBufferA.release();
- assertTrue(2 == context.getCLMemoryObjects().size());
+ assertTrue(2 == context.getMemoryObjects().size());
- assertTrue(2 == context.getCLMemoryObjects().size());
+ assertTrue(2 == context.getMemoryObjects().size());
clBufferB.release();
- assertTrue(1 == context.getCLMemoryObjects().size());
+ assertTrue(1 == context.getMemoryObjects().size());
- assertTrue(1 == context.getCLMemoryObjects().size());
+ assertTrue(1 == context.getMemoryObjects().size());
clBufferC.release();
- assertTrue(0 == context.getCLMemoryObjects().size());
+ assertTrue(0 == context.getMemoryObjects().size());
- assertTrue(1 == context.getCLPrograms().size());
+ assertTrue(1 == context.getPrograms().size());
program.release();
- assertTrue(0 == context.getCLPrograms().size());
+ assertTrue(0 == context.getPrograms().size());
context.release();
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 18:48:31 +0000