Class INTELUnifiedSharedMemory


  • public class INTELUnifiedSharedMemory
    extends java.lang.Object
    Native bindings to the intel_unified_shared_memory extension.

    This extension adds "Unified Shared Memory" (USM) to OpenCL. Unified Shared Memory provides:

    • Easier integration into existing code bases by representing OpenCL allocations as pointers rather than handles (`cl_mems`), with full support for pointer arithmetic into allocations.
    • Fine-grain control over ownership and accessibility of OpenCL allocations, to optimally choose between performance and programmer convenience.
    • A simpler programming model, by automatically migrating some allocations between OpenCL devices and the host.

    While Unified Shared Memory (USM) shares many features with Shared Virtual Memory (SVM), Unified Shared Memory provides a different mix of capabilities and control. Specifically:

    • The matrix of USM capabilities supports combinations of features beyond the SVM capability queries.
    • USM provides explicit control over memory placement and migration by supporting host allocations with wide visibility, devices allocations for best performance, and shared allocations that may migrate between devices and the host.
    • USM allocations may be associated with both a device and a context. The USM allocation APIs support additional memory flags and optional properties to affect how memory is allocated and migrated.
    • There is no need for APIs to map or unmap USM allocations, because host accessible USM allocations do not need to be mapped or unmapped to access the contents of a USM allocation on the host.
    • An application may indicate that a kernel may access categories of USM allocations indirectly, without passing a set of all indirectly accessed USM allocations to the kernel, improving usability and reducing driver overhead for kernels that access many USM allocations.
    • USM adds API functions to query properties of a USM allocation and to provide memory advice for an allocation.

    Unified Shared Memory and Shared Virtual Memory can and will coexist for many implementations. All implementations that support Shared Virtual Memory may support at least some types of Unified Shared Memory.

    Requires CL20.

    • Method Detail

      • nclHostMemAllocINTEL

        public static long nclHostMemAllocINTEL​(long context,
                                                long properties,
                                                long size,
                                                int alignment,
                                                long errcode_ret)
        Unsafe version of: HostMemAllocINTEL
      • clHostMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clHostMemAllocINTEL​(long context,
                                                              @Nullable
                                                              java.nio.LongBuffer properties,
                                                              long size,
                                                              int alignment,
                                                              @Nullable
                                                              java.nio.IntBuffer errcode_ret)
        Allocates host Unified Shared Memory.
        Parameters:
        context - a valid OpenCL context used to allocate the host memory
        properties - an optional list of allocation properties and their corresponding values.

        The list is terminated with the special property 0. If no allocation properties are required, properties may be NULL.

        size - the size in bytes of the requested host allocation
        alignment - the minimum alignment in bytes for the requested host allocation.

        It must be a power of two and must be equal to or smaller than the size of the largest data type supported by any OpenCL device in context. If alignment is 0, a default alignment will be used that is equal to the size of the largest data type supported by any OpenCL device in context.

        errcode_ret - will return an appropriate error code. If errcode_ret is NULL, no error code is returned.
        Returns:
        a valid non-NULL address and SUCCESS will be returned in errcode_ret if the host Unified Shared Memory is allocated successfully. Otherwise, NULL will be returned, and errcode_ret will be set to one of the following error values:
      • nclDeviceMemAllocINTEL

        public static long nclDeviceMemAllocINTEL​(long context,
                                                  long device,
                                                  long properties,
                                                  long size,
                                                  int alignment,
                                                  long errcode_ret)
        Unsafe version of: DeviceMemAllocINTEL
      • clDeviceMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clDeviceMemAllocINTEL​(long context,
                                                                long device,
                                                                @Nullable
                                                                java.nio.LongBuffer properties,
                                                                long size,
                                                                int alignment,
                                                                @Nullable
                                                                java.nio.IntBuffer errcode_ret)
        Allocates Unified Shared Memory specific to an OpenCL device.
        Parameters:
        context - a valid OpenCL context used to allocate the device memory
        device - a valid OpenCL device ID to associate with the allocation
        properties - an optional list of allocation properties and their corresponding values.

        The list is terminated with the special property 0. If no allocation properties are required, properties may be NULL.

        size - the size in bytes of the requested device allocation
        alignment - the minimum alignment in bytes for the requested device allocation.

        It must be a power of two and must be equal to or smaller than the size of the largest data type supported by device. If alignment is 0, a default alignment will be used that is equal to the size of largest data type supported by device.

        errcode_ret - will return an appropriate error code. If errcode_ret is NULL, no error code is returned.
        Returns:
        a valid non-NULL address and SUCCESS will be returned in errcode_ret if the device Unified Shared Memory is allocated successfully. Otherwise, NULL will be returned, and errcode_ret will be set to one of the following error values:
      • nclSharedMemAllocINTEL

        public static long nclSharedMemAllocINTEL​(long context,
                                                  long device,
                                                  long properties,
                                                  long size,
                                                  int alignment,
                                                  long errcode_ret)
        Unsafe version of: SharedMemAllocINTEL
      • clSharedMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clSharedMemAllocINTEL​(long context,
                                                                long device,
                                                                @Nullable
                                                                java.nio.LongBuffer properties,
                                                                long size,
                                                                int alignment,
                                                                @Nullable
                                                                java.nio.IntBuffer errcode_ret)
        Allocates Unified Shared Memory with shared ownership between the host and the specified OpenCL device.

        If the specified OpenCL device supports cross-device access capabilities, the allocation is also accessible by other OpenCL devices in the context that have cross-device access capabilities.

        Parameters:
        context - a valid OpenCL context used to allocate the Unified Shared Memory
        device - an optional OpenCL device ID to associate with the allocation.

        If device is NULL then the allocation is not associated with any device. Allocations with no associated device are accessible by the host and OpenCL devices in the context that have cross-device access capabilities.

        properties - an optional list of allocation properties and their corresponding values.

        The list is terminated with the special property 0. If no allocation properties are required, properties may be NULL.

        size - the size in bytes of the requested device allocation
        alignment - the minimum alignment in bytes for the requested shared allocation.

        It must be a power of two and must be equal to or smaller than the size of the largest data type supported by device. If alignment is 0, a default alignment will be used that is equal to the size of largest data type supported by device. If device is NULL, alignment must be a power of two equal to or smaller than the size of the largest data type supported by any OpenCL device in context, and the default alignment will be equal to the size of the largest data type supported by any OpenCL device in context.

        errcode_ret - will return an appropriate error code. If errcode_ret is NULL, no error code is returned.
        Returns:
        a valid non-NULL address and SUCCESS will be returned in errcode_ret if the shared Unified Shared Memory is allocated successfully. Otherwise, NULL will be returned, and errcode_ret will be set to one of the following error values:
      • nclMemFreeINTEL

        public static int nclMemFreeINTEL​(long context,
                                          long ptr)
        Unsafe version of: MemFreeINTEL
      • clMemFreeINTEL

        public static int clMemFreeINTEL​(long context,
                                         @Nullable
                                         java.nio.ByteBuffer ptr)
        Frees a Unified Shared Memory allocation.

        Note that clMemFreeINTEL may not wait for previously enqueued commands that may be using ptr to finish before freeing ptr. It is the responsibility of the application to make sure enqueued commands that use ptr are complete before freeing ptr. Applications should take particular care freeing memory allocations with kernels that may access memory indirectly, since a kernel with indirect memory access counts as using all memory allocations of the specified type or types.

        To wait for previously enqueued commands to finish that may be using ptr before freeing ptr, use the MemBlockingFreeINTEL function instead.

        Parameters:
        context - a valid OpenCL context used to free the Unified Shared Memory allocation
        ptr - the Unified Shared Memory allocation to free.

        It must be a value returned by HostMemAllocINTEL, DeviceMemAllocINTEL, or SharedMemAllocINTEL, or a NULL pointer. If ptr is NULL then no action occurs.

        Returns:
        SUCCESS if the function executes successfully. Otherwise, they will return one of the following error values:
      • nclMemBlockingFreeINTEL

        public static int nclMemBlockingFreeINTEL​(long context,
                                                  long ptr)
        Unsafe version of: MemBlockingFreeINTEL
      • clMemBlockingFreeINTEL

        public static int clMemBlockingFreeINTEL​(long context,
                                                 @Nullable
                                                 java.nio.ByteBuffer ptr)
        Frees a Unified Shared Memory allocation.
        Parameters:
        context - a valid OpenCL context used to free the Unified Shared Memory allocation
        ptr - the Unified Shared Memory allocation to free.

        It must be a value returned by HostMemAllocINTEL, DeviceMemAllocINTEL, or SharedMemAllocINTEL, or a NULL pointer. If ptr is NULL then no action occurs.

        Returns:
        SUCCESS if the function executes successfully. Otherwise, they will return one of the following error values:
      • nclGetMemAllocInfoINTEL

        public static int nclGetMemAllocInfoINTEL​(long context,
                                                  long ptr,
                                                  int param_name,
                                                  long param_value_size,
                                                  long param_value,
                                                  long param_value_size_ret)
        Unsafe version of: GetMemAllocInfoINTEL
        Parameters:
        param_value_size - the size in bytes of memory pointed to by param_value. This size must be ≥ size of return type. If param_value is NULL, it is ignored.
      • clGetMemAllocInfoINTEL

        public static int clGetMemAllocInfoINTEL​(long context,
                                                 java.nio.ByteBuffer ptr,
                                                 int param_name,
                                                 @Nullable
                                                 java.nio.ByteBuffer param_value,
                                                 @Nullable
                                                 org.lwjgl.PointerBuffer param_value_size_ret)
        
        public static int clGetMemAllocInfoINTEL​(long context,
                                                 java.nio.ByteBuffer ptr,
                                                 int param_name,
                                                 @Nullable
                                                 java.nio.IntBuffer param_value,
                                                 @Nullable
                                                 org.lwjgl.PointerBuffer param_value_size_ret)
        
        public static int clGetMemAllocInfoINTEL​(long context,
                                                 java.nio.ByteBuffer ptr,
                                                 int param_name,
                                                 @Nullable
                                                 org.lwjgl.PointerBuffer param_value,
                                                 @Nullable
                                                 org.lwjgl.PointerBuffer param_value_size_ret)
        
        Queries information about a Unified Shared Memory allocation.
        Parameters:
        context - a valid OpenCL context to query for information about the Unified Shared Memory allocation
        ptr - a pointer into a Unified Shared Memory allocation to query.

        ptr need not be a value returned by HostMemAllocINTEL, DeviceMemAllocINTEL, or SharedMemAllocINTEL, but the query may be faster if it is.

        param_name - the information to query. One of:
        MEM_ALLOC_TYPE_INTELMEM_ALLOC_BASE_PTR_INTELMEM_ALLOC_SIZE_INTEL
        MEM_ALLOC_DEVICE_INTEL
        param_value - a pointer to memory where the appropriate result being queried is returned.

        If param_value is NULL, it is ignored.

        param_value_size_ret - the actual size in bytes of data being queried by param_value. If NULL, it is ignored.
        Returns:
        SUCCESS if the function is executed successfully. Otherwise, it will return one of the following error values:
        • INVALID_CONTEXT if context is not a valid context.
        • INVALID_VALUE if param_name is not a valid Unified Shared Memory allocation query.
        • INVALID_VALUE` if param_value is not NULL and param_value_size is smaller than the size of the query return type.
        • OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
        • OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
      • nclSetKernelArgMemPointerINTEL

        public static int nclSetKernelArgMemPointerINTEL​(long kernel,
                                                         int arg_index,
                                                         long arg_value)
        Unsafe version of: SetKernelArgMemPointerINTEL
      • clSetKernelArgMemPointerINTEL

        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.ByteBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.ShortBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.IntBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.LongBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.FloatBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        java.nio.DoubleBuffer arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        org.lwjgl.PointerBuffer arg_value)
        
        Sets a pointer into a Unified Shared Memory allocation as an argument to a kernel.
        Parameters:
        kernel - a valid kernel object
        arg_index - the argument index to set.

        Arguments to the kernel are referred to by indices that go from 0 for the leftmost argument to n - 1, where n is the total number of arguments declared by a kernel.

        arg_value - the pointer value that should be used as the argument specified by arg_index.

        The pointer value will be used as the argument by all API calls that enqueue a kernel until the argument value is set to a different pointer value by a subsequent call. A pointer into Unified Shared Memory allocation may only be set as an argument value for an argument declared to be a pointer to global or constant memory. For devices supporting shared system allocations, any pointer value is valid. Otherwise, the pointer value must be NULL or must point into a Unified Shared Memory allocation returned by HostMemAllocINTEL, DeviceMemAllocINTEL, or SharedMemAllocINTEL.

        Returns:
        SUCCESS if the function is executed successfully. Otherwise, it will return one of the following errors:
      • nclEnqueueMemFillINTEL

        public static int nclEnqueueMemFillINTEL​(long command_queue,
                                                 long dst_ptr,
                                                 long pattern,
                                                 long pattern_size,
                                                 long size,
                                                 int num_events_in_wait_list,
                                                 long event_wait_list,
                                                 long event)
        Unsafe version of: EnqueueMemFillINTEL
        Parameters:
        pattern_size - the size of of the value to write to the Unified Shared Memory region, in bytes.

        Must be a power of two and must be less than or equal to the size of the largest integer or floating-point vector data type supported by the device.

        size - the size of the memory region to set, in bytes
        num_events_in_wait_list - the number of events in event_wait_list
      • clEnqueueMemFillINTEL

        public static int clEnqueueMemFillINTEL​(long command_queue,
                                                java.nio.ByteBuffer dst_ptr,
                                                java.nio.ByteBuffer pattern,
                                                @Nullable
                                                org.lwjgl.PointerBuffer event_wait_list,
                                                @Nullable
                                                org.lwjgl.PointerBuffer event)
        Fills a region of a memory with the specified pattern.
        Parameters:
        command_queue - a valid host command queue.

        The memory fill command will be queued for execution on the device associated with command_queue.

        dst_ptr - a pointer to the start of the memory region to fill.

        The Unified Shared Memory allocation pointed to by dst_ptr must be valid for the context associated with command_queue, must be accessible by the device associated with command_queue, and must be aligned to pattern_size bytes.

        pattern - a pointer to the value to write to the Unified Shared Memory region.

        The memory associated with pattern can be reused or freed after the function returns.

        event_wait_list - a list of events that need to complete before this particular command can be executed. If event_wait_list is NULL, then this particular command does not wait on any event to complete. The events specified in event_wait_list act as synchronization points. The context associated with events in event_wait_list and command_queue must be the same.
        event - Returns an event object that identifies this particular command and can be used to query or queue a wait for this particular command to complete. event can be NULL in which case it will not be possible for the application to query the status of this command or queue a wait for this command to complete. If the event_wait_list and the event arguments are not NULL, the event argument should not refer to an element of the event_wait_list array.
        Returns:
        SUCCESS if the command is queued successfully. Otherwise, it will return one of the following errors:
        • INVALID_COMMAND_QUEUE if command_queue is not a valid host command-queue.
        • INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
        • INVALID_VALUE if dst_ptr is NULL, or if dst_ptr is not aligned to pattern_size bytes.
        • INVALID_VALUE if pattern is NULL.
        • INVALID_VALUE if pattern_size is not a power of two or is greater than the size of the largest integer or floating-point vector data type supported by the device associated with command_queue.
        • INVALID_VALUE if size is not a multiple of pattern_size.
        • INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list is greater than zero, or if event_wait_list is not NULL and num_events_in_wait_list is zero, or if event objects in event_wait_list are not valid events.
        • OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
        • OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
      • nclEnqueueMemcpyINTEL

        public static int nclEnqueueMemcpyINTEL​(long command_queue,
                                                int blocking,
                                                long dst_ptr,
                                                long src_ptr,
                                                long size,
                                                int num_events_in_wait_list,
                                                long event_wait_list,
                                                long event)
        Unsafe version of: EnqueueMemcpyINTEL
        Parameters:
        num_events_in_wait_list - the number of events in event_wait_list
      • clEnqueueMemcpyINTEL

        public static int clEnqueueMemcpyINTEL​(long command_queue,
                                               boolean blocking,
                                               java.nio.ByteBuffer dst_ptr,
                                               java.nio.ByteBuffer src_ptr,
                                               long size,
                                               @Nullable
                                               org.lwjgl.PointerBuffer event_wait_list,
                                               @Nullable
                                               org.lwjgl.PointerBuffer event)
        Copies a region of memory from one location to another.
        Parameters:
        command_queue - a valid host command queue.

        The memory copy command will be queued for execution on the device associated with command_queue.

        blocking - indicates if the copy operation is blocking or non-blocking.

        If blocking is TRUE, the copy command is blocking, and the function will not return until the copy command is complete. Otherwise, if blocking is FALSE, the copy command is non-blocking, and the contents of the dst_ptr cannot be used nor can the contents of the src_ptr be overwritten until the copy command is complete.

        dst_ptr - a pointer to the start of the memory region to copy to.

        If dst_ptr is a pointer into a Unified Shared Memory allocation it must be valid for the context associated with command_queue.

        src_ptr - a pointer to the start of the memory region to copy from.

        If src_ptr is a pointer into a Unified Shared Memory allocation it must be valid for the context associated with command_queue.

        size - the size of the memory region to copy, in bytes
        event_wait_list - a list of events that need to complete before this particular command can be executed. If event_wait_list is NULL, then this particular command does not wait on any event to complete. The events specified in event_wait_list act as synchronization points. The context associated with events in event_wait_list and command_queue must be the same.
        event - Returns an event object that identifies this particular command and can be used to query or queue a wait for this particular command to complete. event can be NULL in which case it will not be possible for the application to query the status of this command or queue a wait for this command to complete. If the event_wait_list and the event arguments are not NULL, the event argument should not refer to an element of the event_wait_list array.
        Returns:
        SUCCESS if the command is queued successfully. Otherwise, it will return one of the following errors:
        • INVALID_COMMAND_QUEUE if command_queue is not a valid host command-queue.
        • INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
        • INVALID_VALUE if either dst_ptr or src_ptr are NULL.
        • INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list is greater than zero, or if event_wait_list is not NULL and num_events_in_wait_list is zero, or if event objects in event_wait_list are not valid events.
        • EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST if the copy operation is blocking and the execution status of any of the events in event_wait_list is a negative integer value.
        • MEM_COPY_OVERLAP if the values specified for dst_ptr, src_ptr and size result in an overlapping copy.
        • OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
        • OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
      • nclEnqueueMigrateMemINTEL

        public static int nclEnqueueMigrateMemINTEL​(long command_queue,
                                                    long ptr,
                                                    long size,
                                                    long flags,
                                                    int num_events_in_wait_list,
                                                    long event_wait_list,
                                                    long event)
        Unsafe version of: EnqueueMigrateMemINTEL
        Parameters:
        size - the size of the memory region to migrate
        num_events_in_wait_list - the number of events in event_wait_list
      • clEnqueueMigrateMemINTEL

        public static int clEnqueueMigrateMemINTEL​(long command_queue,
                                                   java.nio.ByteBuffer ptr,
                                                   long flags,
                                                   @Nullable
                                                   org.lwjgl.PointerBuffer event_wait_list,
                                                   @Nullable
                                                   org.lwjgl.PointerBuffer event)
        Explicitly migrates a region of a shared Unified Shared Memory allocation to the device associated with command_queue.

        This is a hint that may improve performance and is not required for correctness. Memory migration may not be supported for all allocation types for all devices. If memory migration is not supported for the specified memory range then the migration hint may be ignored. Memory migration may only be supported at a device-specific granularity, such as a page boundary. In this case, the memory range may be expanded such that the start and end of the range satisfy the granularity requirements.

        Parameters:
        command_queue - a valid host command queue.

        The memory migration command will be queued for execution on the device associated with command_queue.

        ptr - a pointer to the start of the shared Unified Shared Memory allocation to migrate
        flags - a bit-field that is used to specify memory migration options
        event_wait_list - a list of events that need to complete before this particular command can be executed. If event_wait_list is NULL, then this particular command does not wait on any event to complete. The events specified in event_wait_list act as synchronization points. The context associated with events in event_wait_list and command_queue must be the same.
        event - Returns an event object that identifies this particular command and can be used to query or queue a wait for this particular command to complete. event can be NULL in which case it will not be possible for the application to query the status of this command or queue a wait for this command to complete. If the event_wait_list and the event arguments are not NULL, the event argument should not refer to an element of the event_wait_list array.
        Returns:
        SUCCESS if the command is queued successfully. Otherwise, it will return one of the following errors:
        • INVALID_COMMAND_QUEUE if command_queue is not a valid host command-queue.
        • INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
        • INVALID_VALUE if flags is zero or is not a supported combination of memory migration flags.
        • INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list is greater than zero, or if event_wait_list is not NULL and num_events_in_wait_list is zero, or if event objects in event_wait_list are not valid events.
        • OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
        • OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
      • nclEnqueueMemAdviseINTEL

        public static int nclEnqueueMemAdviseINTEL​(long command_queue,
                                                   long ptr,
                                                   long size,
                                                   long advice,
                                                   int num_events_in_wait_list,
                                                   long event_wait_list,
                                                   long event)
        Unsafe version of: EnqueueMemAdviseINTEL
        Parameters:
        size - the size of the memory region
        num_events_in_wait_list - the number of events in event_wait_list
      • clEnqueueMemAdviseINTEL

        public static int clEnqueueMemAdviseINTEL​(long command_queue,
                                                  java.nio.ByteBuffer ptr,
                                                  long advice,
                                                  @Nullable
                                                  org.lwjgl.PointerBuffer event_wait_list,
                                                  @Nullable
                                                  org.lwjgl.PointerBuffer event)
        Provides advice about a region of a shared Unified Shared Memory allocation.

        Memory advice is a performance hint only and is not required for correctness. Providing memory advice hints may override driver heuristics that control shared memory behavior. Not all memory advice hints may be supported for all allocation types for all devices. If a memory advice hint is not supported by the device it will be ignored. Memory advice hints may only be supported at a device-specific granularity, such as at a page boundary. In this case, the memory range may be expanded such that the start and end of the range satisfy the granularity requirements.

        Parameters:
        command_queue - a valid host command queue.

        The memory advice hints will be queued for the device associated with command_queue.

        ptr - a pointer to the start of the shared Unified Shared Memory allocation
        advice - a bit-field describing the memory advice hints for the region
        event_wait_list - a list of events that need to complete before this particular command can be executed. If event_wait_list is NULL, then this particular command does not wait on any event to complete. The events specified in event_wait_list act as synchronization points. The context associated with events in event_wait_list and command_queue must be the same.
        event - Returns an event object that identifies this particular command and can be used to query or queue a wait for this particular command to complete. event can be NULL in which case it will not be possible for the application to query the status of this command or queue a wait for this command to complete. If the event_wait_list and the event arguments are not NULL, the event argument should not refer to an element of the event_wait_list array.
        Returns:
        SUCCESS if the command is queued successfully. Otherwise, it will return one of the following errors:
        • INVALID_COMMAND_QUEUE if command_queue is not a valid host command-queue.
        • INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
        • INVALID_VALUE if advice is not supported advice for the device associated with command_queue.
        • INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list is greater than zero, or if event_wait_list is not NULL and num_events_in_wait_list is zero, or if event objects in event_wait_list are not valid events.
        • OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
        • OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
      • clHostMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clHostMemAllocINTEL​(long context,
                                                              @Nullable
                                                              long[] properties,
                                                              long size,
                                                              int alignment,
                                                              @Nullable
                                                              int[] errcode_ret)
        Array version of: HostMemAllocINTEL
      • clDeviceMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clDeviceMemAllocINTEL​(long context,
                                                                long device,
                                                                @Nullable
                                                                long[] properties,
                                                                long size,
                                                                int alignment,
                                                                @Nullable
                                                                int[] errcode_ret)
        Array version of: DeviceMemAllocINTEL
      • clSharedMemAllocINTEL

        @Nullable
        public static java.nio.ByteBuffer clSharedMemAllocINTEL​(long context,
                                                                long device,
                                                                @Nullable
                                                                long[] properties,
                                                                long size,
                                                                int alignment,
                                                                @Nullable
                                                                int[] errcode_ret)
        Array version of: SharedMemAllocINTEL
      • clGetMemAllocInfoINTEL

        public static int clGetMemAllocInfoINTEL​(long context,
                                                 java.nio.ByteBuffer ptr,
                                                 int param_name,
                                                 @Nullable
                                                 int[] param_value,
                                                 @Nullable
                                                 org.lwjgl.PointerBuffer param_value_size_ret)
        Array version of: GetMemAllocInfoINTEL
      • clSetKernelArgMemPointerINTEL

        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        short[] arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        int[] arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        long[] arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        float[] arg_value)
        
        public static int clSetKernelArgMemPointerINTEL​(long kernel,
                                                        int arg_index,
                                                        double[] arg_value)
        
        Array version of: SetKernelArgMemPointerINTEL