CLContext (JavaCL Core / BridJ 1.0.0-RC4 API)

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

```
public class CLContext
extends Object
```
OpenCL context.
An OpenCL context is created with one or more devices.
Contexts are used by the OpenCL runtime for managing objects such as command-queues, memory, program and kernel objects and for executing kernels on one or more devices specified in the context.

Author:

Olivier Chafik

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class CLContext.GLTextureTarget

Nested Classes
Modifier and Type	Class and Description
`static class`	`CLContext.GLTextureTarget`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`<T> CLBuffer<T>`	`createBuffer(CLMem.Usage usage, Class<T> elementClass, long elementCount)` Calls clCreateBuffer.
`<T> CLBuffer<T>`	`createBuffer(CLMem.Usage usage, Pointer<T> data)` Calls clCreateBuffer.
`<T> CLBuffer<T>`	`createBuffer(CLMem.Usage usage, Pointer<T> data, boolean copy)` Calls clCreateBuffer.
`<T> CLBuffer<T>`	`createBuffer(CLMem.Usage usage, PointerIO<T> io, long elementCount)` Deprecated. Intended for advanced uses in conjunction with BridJ.
`CLBuffer<Byte>`	`createBufferFromGLBuffer(CLMem.Usage usage, int openGLBufferObject)` Calls clCreateFromGLBuffer.
`CLBuffer<Byte>`	`createByteBuffer(CLMem.Usage usage, Buffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Byte>`	`createByteBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Byte>`	`createByteBuffer(CLMem.Usage usage, Pointer<Byte> data)` Calls clCreateBuffer.
`CLBuffer<Byte>`	`createByteBuffer(CLMem.Usage usage, Pointer<Byte> data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Character>`	`createCharBuffer(CLMem.Usage usage, CharBuffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Character>`	`createCharBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Character>`	`createCharBuffer(CLMem.Usage usage, Pointer<Character> data)` Calls clCreateBuffer.
`CLBuffer<Character>`	`createCharBuffer(CLMem.Usage usage, Pointer<Character> data, boolean copy)` Calls clCreateBuffer.
`CLQueue`	`createDefaultOutOfOrderQueue()` Create an out-of-order OpenCL queue on the first device of this context.
`CLQueue`	`createDefaultOutOfOrderQueueIfPossible()`
`CLQueue`	`createDefaultProfilingQueue()` Create an profiling-enabled OpenCL queue on the first device of this context.
`CLQueue`	`createDefaultQueue(CLDevice.QueueProperties... queueProperties)` Create an OpenCL queue on the first device of this context.
`CLBuffer<Double>`	`createDoubleBuffer(CLMem.Usage usage, DoubleBuffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Double>`	`createDoubleBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Double>`	`createDoubleBuffer(CLMem.Usage usage, Pointer<Double> data)` Calls clCreateBuffer.
`CLBuffer<Double>`	`createDoubleBuffer(CLMem.Usage usage, Pointer<Double> data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Float>`	`createFloatBuffer(CLMem.Usage usage, FloatBuffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Float>`	`createFloatBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Float>`	`createFloatBuffer(CLMem.Usage usage, Pointer<Float> data)` Calls clCreateBuffer.
`CLBuffer<Float>`	`createFloatBuffer(CLMem.Usage usage, Pointer<Float> data, boolean copy)` Calls clCreateBuffer.
`CLImage2D`	`createImage2D(CLMem.Usage usage, CLImageFormat format, long width, long height)` Calls clCreateImage2D.
`CLImage2D`	`createImage2D(CLMem.Usage usage, CLImageFormat format, long width, long height, long rowPitch)` Calls clCreateImage2D.
`CLImage2D`	`createImage2D(CLMem.Usage usage, CLImageFormat format, long width, long height, long rowPitch, Buffer buffer, boolean copy)` Calls clCreateImage2D.
`CLImage2D`	`createImage2D(CLMem.Usage usage, Image image, boolean allowUnoptimizingDirectRead)` Create an ARGB input 2D image with the content provided
`CLImage2D`	`createImage2DFromGLRenderBuffer(CLMem.Usage usage, int openGLRenderBuffer)` Calls clCreateFromGLRenderbuffer.
`CLImage2D`	`createImage2DFromGLTexture2D(CLMem.Usage usage, CLContext.GLTextureTarget textureTarget, int texture, int mipLevel)` Calls clCreateFromGLTexture2D.
`CLImage3D`	`createImage3D(CLMem.Usage usage, CLImageFormat format, long width, long height, long depth)` Calls clCreateImage3D.
`CLImage3D`	`createImage3D(CLMem.Usage usage, CLImageFormat format, long width, long height, long depth, long rowPitch, long slicePitch)` Calls clCreateImage3D.
`CLImage3D`	`createImage3D(CLMem.Usage usage, CLImageFormat format, long width, long height, long depth, long rowPitch, long slicePitch, Buffer buffer, boolean copy)` Calls clCreateImage3D.
`CLImage3D`	`createImage3DFromGLTexture3D(CLMem.Usage usage, int texture, int mipLevel)` Calls clCreateFromGLTexture3D.
`CLBuffer<Integer>`	`createIntBuffer(CLMem.Usage usage, IntBuffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Integer>`	`createIntBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Integer>`	`createIntBuffer(CLMem.Usage usage, Pointer<Integer> data)` Calls clCreateBuffer.
`CLBuffer<Integer>`	`createIntBuffer(CLMem.Usage usage, Pointer<Integer> data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Long>`	`createLongBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Long>`	`createLongBuffer(CLMem.Usage usage, LongBuffer data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Long>`	`createLongBuffer(CLMem.Usage usage, Pointer<Long> data)` Calls clCreateBuffer.
`CLBuffer<Long>`	`createLongBuffer(CLMem.Usage usage, Pointer<Long> data, boolean copy)` Calls clCreateBuffer.
`CLProgram`	`createProgram(CLDevice[] devices, String... srcs)`
`CLProgram`	`createProgram(Map<CLDevice,byte[]> binaries, String source)`
`CLProgram`	`createProgram(String... srcs)` Create a program with all the C source code content provided as argument.
`CLSampler`	`createSampler(boolean normalized_coords, CLSampler.AddressingMode addressing_mode, CLSampler.FilterMode filter_mode)` Calls clCreateSampler.
`CLBuffer<Short>`	`createShortBuffer(CLMem.Usage usage, long elementCount)` Calls clCreateBuffer.
`CLBuffer<Short>`	`createShortBuffer(CLMem.Usage usage, Pointer<Short> data)` Calls clCreateBuffer.
`CLBuffer<Short>`	`createShortBuffer(CLMem.Usage usage, Pointer<Short> data, boolean copy)` Calls clCreateBuffer.
`CLBuffer<Short>`	`createShortBuffer(CLMem.Usage usage, ShortBuffer data, boolean copy)` Calls clCreateBuffer.
`CLUserEvent`	`createUserEvent()` Creates a user event object.
`boolean`	`equals(Object obj)` Underyling implementation pointer-based equality test
`int`	`getAddressBits()` Return the number of bits used to represent a pointer on all of the context's devices, or -1 if not all devices use the same number of bits.
`ByteOrder`	`getByteOrder()` Get the endianness common to all devices of this context, or null if the devices have mismatching endiannesses.
`boolean`	`getCacheBinaries()` Says whether program binaries are automatically cached or not.
`Object`	`getClientProperty(Object key)`
`int`	`getDeviceCount()`
`CLDevice[]`	`getDevices()` Lists the devices of this context
`static <E extends TypedPointer,A extends com.nativelibs4java.opencl.CLAbstractEntity> Pointer<E>`	`getEntities(A[] objects, Pointer<E> out)`
`ByteOrder`	`getKernelsDefaultByteOrder()`
`long`	`getMaxMemAllocSize()` Max size of memory object allocation in bytes.
`CLPlatform`	`getPlatform()`
`CLImageFormat[]`	`getSupportedImageFormats(CLMem.Flags flags, CLMem.ObjectType imageType)` Calls clGetSupportedImageFormats.
`CLDevice`	`guessCurrentGLDevice()` Deprecated.
`int`	`hashCode()` Underyling implementation pointer-based hashCode computation
`boolean`	`isByteAddressableStoreSupported()`
`boolean`	`isDoubleSupported()` Whether all the devices in this context support any double-precision numbers (see `CLDevice.isDoubleSupported()`).
`boolean`	`isHalfSupported()` Whether all the devices in this context support half-precision numbers (see `CLDevice.isHalfSupported()`).
`CLProgram`	`loadProgram(InputStream in)` Restore a program previously saved with `CLProgram.store(java.io.OutputStream)`
`Object`	`putClientProperty(Object key, Object value)`
`void`	`release()` Manual release of the OpenCL resources represented by this object.
`void`	`setCacheBinaries(boolean cacheBinaries)` Change whether program binaries are automatically cached or not.
`String`	`toString()`

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

- Method Detail
  - getClientProperty
```
public Object getClientProperty(Object key)
```
  - putClientProperty
```
public Object putClientProperty(Object key,
                                Object value)
```
  - getMaxMemAllocSize
```
public long getMaxMemAllocSize()
```
    Max size of memory object allocation in bytes. The minimum value is max (1/4th of CL_DEVICE_GLOBAL_MEM_SIZE , 128*1024*1024)
  - setCacheBinaries
```
public void setCacheBinaries(boolean cacheBinaries)
```
    Change whether program binaries are automatically cached or not.
    By default it is true, it can be set to false with the "javacl.cacheBinaries" Java property or the "JAVACL_CACHE_BINARIES" environment variable (when set to "0").
    Each program can be set to be cached or not using CLProgram.setCached(boolean).
    Caching of binaries might be disabled by default on some platforms (ATI Stream, for instance).
  - getCacheBinaries
```
public boolean getCacheBinaries()
```
    Says whether program binaries are automatically cached or not.
    By default it is true, it can be set to false with the "javacl.cacheBinaries" Java property, the "JAVACL_CACHE_BINARIES" environment variable (when set to "0") or the setCacheBinaries(boolean) method.
    Each program can be set to be cached or not using CLProgram.setCached(boolean).
    Caching of binaries might be disabled by default on some platforms (ATI Stream, for instance).
  - createUserEvent
```
public CLUserEvent createUserEvent()
```
    Creates a user event object.
    User events allow applications to enqueue commands that wait on a user event to finish before the command is executed by the device.
    
    Since:
    
    OpenCL 1.1
  - createDefaultQueue
```
public CLQueue createDefaultQueue(CLDevice.QueueProperties... queueProperties)
```
    Create an OpenCL queue on the first device of this context.
    Equivalent to calling getDevices()[0].createQueue(context)
    
    Returns:
    
    new OpenCL queue
  - createDefaultOutOfOrderQueue
```
public CLQueue createDefaultOutOfOrderQueue()
```
    Create an out-of-order OpenCL queue on the first device of this context.
    Equivalent to calling getDevices()[0].createOutOfOrderQueue(context)
    
    Returns:
    
    new out-of-order OpenCL queue
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - createDefaultOutOfOrderQueueIfPossible
```
public CLQueue createDefaultOutOfOrderQueueIfPossible()
```
  - createDefaultProfilingQueue
```
public CLQueue createDefaultProfilingQueue()
```
    Create an profiling-enabled OpenCL queue on the first device of this context.
    Equivalent to calling getDevices()[0].createProfilingQueue(context)
    
    Returns:
    
    new profiling-enabled OpenCL queue
  - getSupportedImageFormats
```
public CLImageFormat[] getSupportedImageFormats(CLMem.Flags flags,
                                                CLMem.ObjectType imageType)
```
    Calls clGetSupportedImageFormats.
  - createSampler
```
public CLSampler createSampler(boolean normalized_coords,
                               CLSampler.AddressingMode addressing_mode,
                               CLSampler.FilterMode filter_mode)
```
    Calls clCreateSampler.
  - getDeviceCount
```
public int getDeviceCount()
```
  - getDevices
```
public CLDevice[] getDevices()
```
    Lists the devices of this context
    
    Returns:
    
    array of the devices that form this context
  - createProgram
```
public CLProgram createProgram(String... srcs)
```
    Create a program with all the C source code content provided as argument.
    
    Parameters:
    
    srcs - list of the content of source code for the program
    
    Returns:
    
    a program that needs to be built
  - createProgram
```
public CLProgram createProgram(CLDevice[] devices,
                               String... srcs)
```
  - loadProgram
```
public CLProgram loadProgram(InputStream in)
                      throws IOException
```
    Restore a program previously saved with CLProgram.store(java.io.OutputStream)
    
    Parameters:
    
    in - will be closed
    
    Returns:
    
    a CLProgram object representing the previously saved program
    
    Throws:
    
    IOException
  - createProgram
```
public CLProgram createProgram(Map<CLDevice,byte[]> binaries,
                               String source)
```
  - guessCurrentGLDevice
```
@Deprecated
public CLDevice guessCurrentGLDevice()
```
    Deprecated.
  - createBufferFromGLBuffer
```
public CLBuffer<Byte> createBufferFromGLBuffer(CLMem.Usage usage,
                                               int openGLBufferObject)
```
    Calls clCreateFromGLBuffer.
    Makes an OpenGL Vertex Buffer Object (VBO) visible to OpenCL as a buffer object.
    Note that memory objects shared with OpenGL must be acquired / released before / after use from OpenCL. see CLMem.acquireGLObject(com.nativelibs4java.opencl.CLQueue, com.nativelibs4java.opencl.CLEvent[]) see CLMem.releaseGLObject(com.nativelibs4java.opencl.CLQueue, com.nativelibs4java.opencl.CLEvent[])
    
    Parameters:
    
    usage - flags
    
    openGLBufferObject - Identifier of a VBO, as generated by glGenBuffers
  - createImage2DFromGLRenderBuffer
```
public CLImage2D createImage2DFromGLRenderBuffer(CLMem.Usage usage,
                                                 int openGLRenderBuffer)
```
    Calls clCreateFromGLRenderbuffer.
    Makes an OpenGL Render Buffer visible to OpenCL as a 2D image.
    Note that memory objects shared with OpenGL must be acquired / released before / after use from OpenCL. see CLMem.acquireGLObject(com.nativelibs4java.opencl.CLQueue, com.nativelibs4java.opencl.CLEvent[]) see CLMem.releaseGLObject(com.nativelibs4java.opencl.CLQueue, com.nativelibs4java.opencl.CLEvent[])
    
    Parameters:
    
    openGLRenderBuffer - Identifier of an OpenGL render buffer
  - createImage2DFromGLTexture2D
```
public CLImage2D createImage2DFromGLTexture2D(CLMem.Usage usage,
                                              CLContext.GLTextureTarget textureTarget,
                                              int texture,
                                              int mipLevel)
```
    Calls clCreateFromGLTexture2D.
    Creates an OpenCL 2D image object from an OpenGL 2D texture object, or a single face of an OpenGL cubemap texture object.
    Note that memory objects shared with OpenGL must be acquired / released before / after use from OpenCL.
    
    Parameters:
    
    usage -
    
    textureTarget - Must be one of GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_TEXTURE_RECTANGLE47. texture_target is used only to define the image type of texture. No reference to a bound GL texture object is made or implied by this parameter.
    
    mipLevel - Mipmap level to be used (Implementations may return CL_INVALID_OPERATION for miplevel values > 0)
    
    texture - Name of a GL 2D, cubemap or rectangle texture object. The texture object must be a complete texture as per OpenGL rules on texture completeness. The texture format and dimensions defined by OpenGL for the specified miplevel of the texture will be used to create the 2D image object. Only GL texture objects with an internal format that maps to appropriate image channel order and data type specified in tables 5.4 and 5.5 may be used to create a 2D image object.
    
    Returns:
    
    valid OpenCL image object if the image object is created successfully
    
    Throws:
    
    CLException.InvalidMipLevel - if miplevel is less than the value of levelbase (for OpenGL implementations) or zero (for OpenGL ES implementations); or greater than the value of q (for both OpenGL and OpenGL ES). levelbase and q are defined for the texture in section 3.8.10 (Texture Completeness) of the OpenGL 2.1 specification and section 3.7.10 of the OpenGL ES 2.0, or if miplevel is greather than zero and the OpenGL implementation does not support creating from non-zero mipmap levels.
    
    CLException.InvalidGLObject - if texture is not a GL texture object whose type matches texture_target, if the specified miplevel of texture is not defined, or if the width or height of the specified miplevel is zero.
    
    CLException.InvalidImageFormatDescriptor - if the OpenGL texture internal format does not map to a supported OpenCL image format.
  - getPlatform
```
public CLPlatform getPlatform()
```
  - createImage3DFromGLTexture3D
```
public CLImage3D createImage3DFromGLTexture3D(CLMem.Usage usage,
                                              int texture,
                                              int mipLevel)
```
    Calls clCreateFromGLTexture3D.
    Creates an OpenCL 3D image object from an OpenGL 3D texture object
    Note that memory objects shared with OpenGL must be acquired / released before / after use from OpenCL.
    
    Parameters:
    
    usage -
    
    mipLevel - Mipmap level to be used (Implementations may return CL_INVALID_OPERATION for miplevel values > 0)
    
    texture - Name of a GL 3D texture object. The texture object must be a complete texture as per OpenGL rules on texture completeness. The texture format and dimensions defined by OpenGL for the specified miplevel of the texture will be used to create the 3D image object. Only GL texture objects with an internal format that maps to appropriate image channel order and data type specified in tables 5.4 and 5.5 can be used to create the 3D image object.
    
    Returns:
    
    valid OpenCL image object if the image object is created successfully
    
    Throws:
    
    CLException.InvalidMipLevel - if miplevel is less than the value of levelbase (for OpenGL implementations) or zero (for OpenGL ES implementations); or greater than the value of q (for both OpenGL and OpenGL ES). levelbase and q are defined for the texture in section 3.8.10 (Texture Completeness) of the OpenGL 2.1 specification and section 3.7.10 of the OpenGL ES 2.0, or if miplevel is greather than zero and the OpenGL implementation does not support creating from non-zero mipmap levels.
    
    CLException.InvalidGLObject - if texture is not a GL texture object whose type matches texture_target, if the specified miplevel of texture is not defined, or if the width or height of the specified miplevel is zero.
    
    CLException.InvalidImageFormatDescriptor - if the OpenGL texture internal format does not map to a supported OpenCL image format.
  - createImage2D
```
public CLImage2D createImage2D(CLMem.Usage usage,
                               Image image,
                               boolean allowUnoptimizingDirectRead)
```
    Create an ARGB input 2D image with the content provided
    
    Parameters:
    
    allowUnoptimizingDirectRead - Some images expose their internal data for direct read, leading to performance increase during the creation of the OpenCL image. However, direct access to the image data disables some Java2D optimizations for this image, leading to degraded performance in subsequent uses with AWT/Swing.
  - createImage2D
```
public CLImage2D createImage2D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height,
                               long rowPitch,
                               Buffer buffer,
                               boolean copy)
```
    Calls clCreateImage2D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    rowPitch - Row pitch.
    
    buffer - Image data buffer.
    
    copy - Whether to copy the input buffer.
    
    Returns:
    
    A new image allocated on this context.
  - createImage2D
```
public CLImage2D createImage2D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height,
                               long rowPitch)
```
    Calls clCreateImage2D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    rowPitch - Row pitch.
    
    Returns:
    
    A new image allocated on this context.
  - createImage2D
```
public CLImage2D createImage2D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height)
```
    Calls clCreateImage2D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    Returns:
    
    A new image allocated on this context.
  - createImage3D
```
public CLImage3D createImage3D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height,
                               long depth,
                               long rowPitch,
                               long slicePitch,
                               Buffer buffer,
                               boolean copy)
```
    Calls clCreateImage3D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    depth - Image depth
    
    rowPitch - Row pitch.
    
    slicePitch - Slice pitch.
    
    buffer - Image data buffer.
    
    copy - Whether to copy the input buffer.
    
    Returns:
    
    A new image allocated on this context.
  - createImage3D
```
public CLImage3D createImage3D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height,
                               long depth,
                               long rowPitch,
                               long slicePitch)
```
    Calls clCreateImage3D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    depth - Image depth
    
    rowPitch - Row pitch.
    
    slicePitch - Slice pitch.
    
    Returns:
    
    A new image allocated on this context.
  - createImage3D
```
public CLImage3D createImage3D(CLMem.Usage usage,
                               CLImageFormat format,
                               long width,
                               long height,
                               long depth)
```
    Calls clCreateImage3D.
    
    Parameters:
    
    usage - Usage intended for the image.
    
    format - Format of the image.
    
    width - Image width
    
    height - Image height
    
    depth - Image depth
    
    Returns:
    
    A new image allocated on this context.
  - createIntBuffer
```
public CLBuffer<Integer> createIntBuffer(CLMem.Usage usage,
                                         IntBuffer data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Integer> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createIntBuffer
```
public CLBuffer<Integer> createIntBuffer(CLMem.Usage usage,
                                         Pointer<Integer> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Integer> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createIntBuffer
```
public CLBuffer<Integer> createIntBuffer(CLMem.Usage usage,
                                         Pointer<Integer> data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Integer> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createIntBuffer
```
public CLBuffer<Integer> createIntBuffer(CLMem.Usage usage,
                                         long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Integer> OpenCL buffer big enough to hold 'length' values of type int.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Integer> of length 10 will actually contain 10 * 4 bytes, as ints are 4-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createLongBuffer
```
public CLBuffer<Long> createLongBuffer(CLMem.Usage usage,
                                       LongBuffer data,
                                       boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Long> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createLongBuffer
```
public CLBuffer<Long> createLongBuffer(CLMem.Usage usage,
                                       Pointer<Long> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Long> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createLongBuffer
```
public CLBuffer<Long> createLongBuffer(CLMem.Usage usage,
                                       Pointer<Long> data,
                                       boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Long> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createLongBuffer
```
public CLBuffer<Long> createLongBuffer(CLMem.Usage usage,
                                       long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Long> OpenCL buffer big enough to hold 'length' values of type long.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Long> of length 10 will actually contain 10 * 8 bytes, as longs are 8-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createShortBuffer
```
public CLBuffer<Short> createShortBuffer(CLMem.Usage usage,
                                         ShortBuffer data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Short> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createShortBuffer
```
public CLBuffer<Short> createShortBuffer(CLMem.Usage usage,
                                         Pointer<Short> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Short> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createShortBuffer
```
public CLBuffer<Short> createShortBuffer(CLMem.Usage usage,
                                         Pointer<Short> data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Short> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createShortBuffer
```
public CLBuffer<Short> createShortBuffer(CLMem.Usage usage,
                                         long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Short> OpenCL buffer big enough to hold 'length' values of type short.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Short> of length 10 will actually contain 10 * 2 bytes, as shorts are 2-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createByteBuffer
```
public CLBuffer<Byte> createByteBuffer(CLMem.Usage usage,
                                       Buffer data,
                                       boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Byte> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createByteBuffer
```
public CLBuffer<Byte> createByteBuffer(CLMem.Usage usage,
                                       Pointer<Byte> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Byte> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createByteBuffer
```
public CLBuffer<Byte> createByteBuffer(CLMem.Usage usage,
                                       Pointer<Byte> data,
                                       boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Byte> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createByteBuffer
```
public CLBuffer<Byte> createByteBuffer(CLMem.Usage usage,
                                       long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Byte> OpenCL buffer big enough to hold 'length' values of type byte.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Byte> of length 10 will actually contain 10 * 1 bytes, as bytes are 1-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createCharBuffer
```
public CLBuffer<Character> createCharBuffer(CLMem.Usage usage,
                                            CharBuffer data,
                                            boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Character> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createCharBuffer
```
public CLBuffer<Character> createCharBuffer(CLMem.Usage usage,
                                            Pointer<Character> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Character> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createCharBuffer
```
public CLBuffer<Character> createCharBuffer(CLMem.Usage usage,
                                            Pointer<Character> data,
                                            boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Character> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createCharBuffer
```
public CLBuffer<Character> createCharBuffer(CLMem.Usage usage,
                                            long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Character> OpenCL buffer big enough to hold 'length' values of type char.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Character> of length 10 will actually contain 10 * 2 bytes, as chars are 2-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createFloatBuffer
```
public CLBuffer<Float> createFloatBuffer(CLMem.Usage usage,
                                         FloatBuffer data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Float> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createFloatBuffer
```
public CLBuffer<Float> createFloatBuffer(CLMem.Usage usage,
                                         Pointer<Float> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Float> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createFloatBuffer
```
public CLBuffer<Float> createFloatBuffer(CLMem.Usage usage,
                                         Pointer<Float> data,
                                         boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Float> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createFloatBuffer
```
public CLBuffer<Float> createFloatBuffer(CLMem.Usage usage,
                                         long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Float> OpenCL buffer big enough to hold 'length' values of type float.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Float> of length 10 will actually contain 10 * 4 bytes, as floats are 4-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createDoubleBuffer
```
public CLBuffer<Double> createDoubleBuffer(CLMem.Usage usage,
                                           DoubleBuffer data,
                                           boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Double> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createDoubleBuffer
```
public CLBuffer<Double> createDoubleBuffer(CLMem.Usage usage,
                                           Pointer<Double> data)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Double> OpenCL buffer big enough to hold the valid values of the provided data pointer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Host data to copy to the buffer
    
    Returns:
    
    A new buffer allocated on this context.
  - createDoubleBuffer
```
public CLBuffer<Double> createDoubleBuffer(CLMem.Usage usage,
                                           Pointer<Double> data,
                                           boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Double> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createDoubleBuffer
```
public CLBuffer<Double> createDoubleBuffer(CLMem.Usage usage,
                                           long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<Double> OpenCL buffer big enough to hold 'length' values of type double.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Double> of length 10 will actually contain 10 * 8 bytes, as doubles are 8-bytes-long)
    
    Returns:
    
    A new buffer allocated on this context.
  - createBuffer
```
public <T> CLBuffer<T> createBuffer(CLMem.Usage usage,
                                    Pointer<T> data)
```
    Calls clCreateBuffer.
    Create an OpenCL buffer with the provided initial values, in copy mode (see CL_MEM_COPY_HOST_PTR).
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements())
  - createBuffer
```
public <T> CLBuffer<T> createBuffer(CLMem.Usage usage,
                                    Pointer<T> data,
                                    boolean copy)
```
    Calls clCreateBuffer.
    Create a CLBuffer<N> OpenCL buffer with the provided initial values.
    If copy is true (see CL_MEM_COPY_HOST_PTR), then the buffer will be hosted in OpenCL and will have the best performance, but any change done to the OpenCL buffer won't be propagated to the original data pointer.
    If copy is false (see CL_MEM_USE_HOST_PTR), then the provided data pointer will be used for storage of the OpenCL buffer. OpenCL might still cache the data in the OpenCL land, so careful use of CLBuffer#map(CLQueue, MapFlags, CLEvent...) is then necessary to ensure the data is properly synchronized with the buffer.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    data - Pointer to the initial values, must have known bounds (see Pointer.getValidElements()).
    
    data - Data buffer.
    
    copy - Whether to copy the input data.
    
    Returns:
    
    A new buffer allocated on this context.
  - createBuffer
```
public <T> CLBuffer<T> createBuffer(CLMem.Usage usage,
                                    Class<T> elementClass,
                                    long elementCount)
```
    Calls clCreateBuffer.
    Create a CLBuffer<N> OpenCL buffer big enough to hold 'length' values of type T.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    elementClass - Primitive type of the buffer. For instance a buffer of 'int' values can be created with elementClass being Integer.class or int.class indifferently.
    
    elementCount - Length of the buffer expressed in elements
    
    Returns:
    
    A new buffer allocated on this context.
  - createBuffer
```
@Deprecated
public <T> CLBuffer<T> createBuffer(CLMem.Usage usage,
                                                PointerIO<T> io,
                                                long elementCount)
```
    Deprecated. Intended for advanced uses in conjunction with BridJ.
    
    Calls clCreateBuffer.
    Create an OpenCL buffer big enough to hold the provided amount of values of the specified type.
    
    Parameters:
    
    usage - Usage intended for the pointer in OpenCL kernels : a pointer created with CLMem.Usage.Input cannot be written to in a kernel.
    
    io - Delegate responsible for reading and writing values.
    
    elementCount - Length of the buffer expressed in elements (for instance, a CLBuffer<Integer> of length 4 will actually contain 4 * 4 bytes, as ints are 4-bytes-long)
  - getKernelsDefaultByteOrder
```
public ByteOrder getKernelsDefaultByteOrder()
```
  - getByteOrder
```
public ByteOrder getByteOrder()
```
    Get the endianness common to all devices of this context, or null if the devices have mismatching endiannesses.
  - getAddressBits
```
public int getAddressBits()
```
    Return the number of bits used to represent a pointer on all of the context's devices, or -1 if not all devices use the same number of bits.
    Size of size_t type in OpenCL kernels can be obtained with getAddressBits() / 8.
    
    Returns:
    
    -1 if the address bits of the context's devices do not match, common address bits otherwise
  - isDoubleSupported
```
public boolean isDoubleSupported()
```
    Whether all the devices in this context support any double-precision numbers (see CLDevice.isDoubleSupported()).
  - isHalfSupported
```
public boolean isHalfSupported()
```
    Whether all the devices in this context support half-precision numbers (see CLDevice.isHalfSupported()).
  - isByteAddressableStoreSupported
```
public boolean isByteAddressableStoreSupported()
```
  - release
```
public void release()
```
    Manual release of the OpenCL resources represented by this object.
    Note that resources are automatically released by the garbage collector, so in general there's no need to call this method.
    In an environment with fast allocation/deallocation of large objects, it might be safer to call release() manually, though.
    Note that release() does not necessarily free the object immediately : OpenCL maintains a reference count for all its objects, and an object released on the Java side might still be pointed to by running kernels or queued operations.
  - getEntities
```
public static <E extends TypedPointer,A extends com.nativelibs4java.opencl.CLAbstractEntity> Pointer<E> getEntities(A[] objects,
                                                                                                                    Pointer<E> out)
```
  - hashCode
```
public int hashCode()
```
    Underyling implementation pointer-based hashCode computation
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Underyling implementation pointer-based equality test
    
    Overrides:
    
    equals in class Object

Class CLContext

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getClientProperty

putClientProperty

getMaxMemAllocSize

setCacheBinaries

getCacheBinaries

createUserEvent

createDefaultQueue

createDefaultOutOfOrderQueue

toString

createDefaultOutOfOrderQueueIfPossible

createDefaultProfilingQueue

getSupportedImageFormats

createSampler

getDeviceCount

getDevices

createProgram

createProgram

loadProgram

createProgram

guessCurrentGLDevice

createBufferFromGLBuffer

createImage2DFromGLRenderBuffer

createImage2DFromGLTexture2D

getPlatform

createImage3DFromGLTexture3D

createImage2D

createImage2D

createImage2D

createImage2D

createImage3D

createImage3D

createImage3D

createIntBuffer

createIntBuffer

createIntBuffer

createIntBuffer

createLongBuffer

createLongBuffer

createLongBuffer

createLongBuffer

createShortBuffer

createShortBuffer

createShortBuffer

createShortBuffer

createByteBuffer

createByteBuffer

createByteBuffer

createByteBuffer

createCharBuffer

createCharBuffer

createCharBuffer

createCharBuffer

createFloatBuffer

createFloatBuffer

createFloatBuffer

createFloatBuffer

createDoubleBuffer

createDoubleBuffer

createDoubleBuffer

createDoubleBuffer

createBuffer

createBuffer

createBuffer

createBuffer

getKernelsDefaultByteOrder

getByteOrder

getAddressBits

isDoubleSupported

isHalfSupported

isByteAddressableStoreSupported

release

getEntities

hashCode

equals