Class INTELUnifiedSharedMemory

java.lang.Object
org.lwjgl.opencl.INTELUnifiedSharedMemory

public class INTELUnifiedSharedMemory extends 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.

  • Field Details

    • CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL

      public static final int CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL
      Accepted value for the param_name parameter to GetDeviceInfo to query the Unified Shared Memory capabilities of an OpenCL device.
      See Also:
    • CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL

      public static final int CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL
      Accepted value for the param_name parameter to GetDeviceInfo to query the Unified Shared Memory capabilities of an OpenCL device.
      See Also:
    • CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL

      public static final int CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL
      Accepted value for the param_name parameter to GetDeviceInfo to query the Unified Shared Memory capabilities of an OpenCL device.
      See Also:
    • CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL

      public static final int CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL
      Accepted value for the param_name parameter to GetDeviceInfo to query the Unified Shared Memory capabilities of an OpenCL device.
      See Also:
    • CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL

      public static final int CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL
      Accepted value for the param_name parameter to GetDeviceInfo to query the Unified Shared Memory capabilities of an OpenCL device.
      See Also:
    • CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL

      public static final int CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL
      Bitfield type and bits describing the Unified Shared Memory capabilities of an OpenCL device. (cl_device_unified_shared_memory_capabilities_intel)
      See Also:
    • CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL

      public static final int CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL
      Bitfield type and bits describing the Unified Shared Memory capabilities of an OpenCL device. (cl_device_unified_shared_memory_capabilities_intel)
      See Also:
    • CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL

      public static final int CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL
      Bitfield type and bits describing the Unified Shared Memory capabilities of an OpenCL device. (cl_device_unified_shared_memory_capabilities_intel)
      See Also:
    • CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL

      public static final int CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL
      Bitfield type and bits describing the Unified Shared Memory capabilities of an OpenCL device. (cl_device_unified_shared_memory_capabilities_intel)
      See Also:
    • CL_MEM_ALLOC_FLAGS_INTEL

      public static final int CL_MEM_ALLOC_FLAGS_INTEL
      Enumerant value requesting optional allocation properties for a Unified Shared Memory allocation.
      See Also:
    • CL_MEM_ALLOC_WRITE_COMBINED_INTEL

      public static final int CL_MEM_ALLOC_WRITE_COMBINED_INTEL
      Bitfield type and bits describing optional allocation properties for a Unified Shared Memory allocation. (cl_mem_alloc_flags_intel)
      Enum values:
      • MEM_ALLOC_WRITE_COMBINED_INTEL - Request write combined (WC) memory.

        Write combined memory may improve performance in some cases, however write combined memory must be used with care since it may hurt performance in other cases or use different coherency protocols than non-write combined memory.

      • MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL - Request the implementation to optimize for first access being done by the device.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

      • MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL - Request the implementation to optimize for first access being done by the host.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

        CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL and CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL are mutually exclusive.

      See Also:
    • CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL

      public static final int CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL
      Bitfield type and bits describing optional allocation properties for a Unified Shared Memory allocation. (cl_mem_alloc_flags_intel)
      Enum values:
      • MEM_ALLOC_WRITE_COMBINED_INTEL - Request write combined (WC) memory.

        Write combined memory may improve performance in some cases, however write combined memory must be used with care since it may hurt performance in other cases or use different coherency protocols than non-write combined memory.

      • MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL - Request the implementation to optimize for first access being done by the device.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

      • MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL - Request the implementation to optimize for first access being done by the host.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

        CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL and CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL are mutually exclusive.

      See Also:
    • CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL

      public static final int CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL
      Bitfield type and bits describing optional allocation properties for a Unified Shared Memory allocation. (cl_mem_alloc_flags_intel)
      Enum values:
      • MEM_ALLOC_WRITE_COMBINED_INTEL - Request write combined (WC) memory.

        Write combined memory may improve performance in some cases, however write combined memory must be used with care since it may hurt performance in other cases or use different coherency protocols than non-write combined memory.

      • MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL - Request the implementation to optimize for first access being done by the device.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

      • MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL - Request the implementation to optimize for first access being done by the host.

        This flag is valid only for SharedMemAllocINTEL. This flag does not affect functionality and is purely a performance hint.

        CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL and CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL are mutually exclusive.

      See Also:
    • CL_MEM_ALLOC_TYPE_INTEL

      public static final int CL_MEM_ALLOC_TYPE_INTEL
      Enumeration type and values for the param_name parameter to GetMemAllocInfoINTEL to query information about a Unified Shared Memory allocation. (cl_mem_info_intel)

      Optional allocation properties may also be queried using clGetMemAllocInfoINTEL.

      See Also:
    • CL_MEM_ALLOC_BASE_PTR_INTEL

      public static final int CL_MEM_ALLOC_BASE_PTR_INTEL
      Enumeration type and values for the param_name parameter to GetMemAllocInfoINTEL to query information about a Unified Shared Memory allocation. (cl_mem_info_intel)

      Optional allocation properties may also be queried using clGetMemAllocInfoINTEL.

      See Also:
    • CL_MEM_ALLOC_SIZE_INTEL

      public static final int CL_MEM_ALLOC_SIZE_INTEL
      Enumeration type and values for the param_name parameter to GetMemAllocInfoINTEL to query information about a Unified Shared Memory allocation. (cl_mem_info_intel)

      Optional allocation properties may also be queried using clGetMemAllocInfoINTEL.

      See Also:
    • CL_MEM_ALLOC_DEVICE_INTEL

      public static final int CL_MEM_ALLOC_DEVICE_INTEL
      Enumeration type and values for the param_name parameter to GetMemAllocInfoINTEL to query information about a Unified Shared Memory allocation. (cl_mem_info_intel)

      Optional allocation properties may also be queried using clGetMemAllocInfoINTEL.

      See Also:
    • CL_MEM_TYPE_UNKNOWN_INTEL

      public static final int CL_MEM_TYPE_UNKNOWN_INTEL
      Enumeration type and values describing the type of Unified Shared Memory allocation. Returned by GetMemAllocInfoINTEL when param_name is MEM_ALLOC_TYPE_INTEL. (cl_unified_shared_memory_type_intel)
      See Also:
    • CL_MEM_TYPE_HOST_INTEL

      public static final int CL_MEM_TYPE_HOST_INTEL
      Enumeration type and values describing the type of Unified Shared Memory allocation. Returned by GetMemAllocInfoINTEL when param_name is MEM_ALLOC_TYPE_INTEL. (cl_unified_shared_memory_type_intel)
      See Also:
    • CL_MEM_TYPE_DEVICE_INTEL

      public static final int CL_MEM_TYPE_DEVICE_INTEL
      Enumeration type and values describing the type of Unified Shared Memory allocation. Returned by GetMemAllocInfoINTEL when param_name is MEM_ALLOC_TYPE_INTEL. (cl_unified_shared_memory_type_intel)
      See Also:
    • CL_MEM_TYPE_SHARED_INTEL

      public static final int CL_MEM_TYPE_SHARED_INTEL
      Enumeration type and values describing the type of Unified Shared Memory allocation. Returned by GetMemAllocInfoINTEL when param_name is MEM_ALLOC_TYPE_INTEL. (cl_unified_shared_memory_type_intel)
      See Also:
    • CL_KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL

      public static final int CL_KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL
      Accepted value for the param_name parameter to SetKernelExecInfo to specify that the kernel may indirectly access Unified Shared Memory allocations of the specified type.
      See Also:
    • CL_KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL

      public static final int CL_KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL
      Accepted value for the param_name parameter to SetKernelExecInfo to specify that the kernel may indirectly access Unified Shared Memory allocations of the specified type.
      See Also:
    • CL_KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL

      public static final int CL_KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL
      Accepted value for the param_name parameter to SetKernelExecInfo to specify that the kernel may indirectly access Unified Shared Memory allocations of the specified type.
      See Also:
    • CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL

      public static final int CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL
      Accepted value for the param_name parameter to SetKernelExecInfo to specify a set of Unified Shared Memory allocations that the kernel may indirectly access.
      See Also:
    • CL_COMMAND_MEMFILL_INTEL

      public static final int CL_COMMAND_MEMFILL_INTEL
      New return values from GetEventInfo when param_name is EVENT_COMMAND_TYPE.
      See Also:
    • CL_COMMAND_MEMCPY_INTEL

      public static final int CL_COMMAND_MEMCPY_INTEL
      New return values from GetEventInfo when param_name is EVENT_COMMAND_TYPE.
      See Also:
    • CL_COMMAND_MIGRATEMEM_INTEL

      public static final int CL_COMMAND_MIGRATEMEM_INTEL
      New return values from GetEventInfo when param_name is EVENT_COMMAND_TYPE.
      See Also:
    • CL_COMMAND_MEMADVISE_INTEL

      public static final int CL_COMMAND_MEMADVISE_INTEL
      New return values from GetEventInfo when param_name is EVENT_COMMAND_TYPE.
      See Also:
  • Method Details

    • nclHostMemAllocINTEL

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

      public static @Nullable ByteBuffer clHostMemAllocINTEL(long context, @Nullable LongBuffer properties, long size, int alignment, @Nullable 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

      public static @Nullable ByteBuffer clDeviceMemAllocINTEL(long context, long device, @Nullable LongBuffer properties, long size, int alignment, @Nullable 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

      public static @Nullable ByteBuffer clSharedMemAllocINTEL(long context, long device, @Nullable LongBuffer properties, long size, int alignment, @Nullable 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 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 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, ByteBuffer ptr, int param_name, @Nullable ByteBuffer 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.
    • clGetMemAllocInfoINTEL

      public static int clGetMemAllocInfoINTEL(long context, ByteBuffer ptr, int param_name, @Nullable IntBuffer 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.
    • clGetMemAllocInfoINTEL

      public static int clGetMemAllocInfoINTEL(long context, 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, ByteBuffer 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:
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, ShortBuffer 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:
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, IntBuffer 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:
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, LongBuffer 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:
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, FloatBuffer 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:
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, DoubleBuffer 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:
    • clSetKernelArgMemPointerINTEL

      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, ByteBuffer dst_ptr, 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, ByteBuffer dst_ptr, 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, 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, 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

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

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

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

      public static int clGetMemAllocInfoINTEL(long context, ByteBuffer ptr, int param_name, int @Nullable [] 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)
      Array version of: SetKernelArgMemPointerINTEL
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, int[] arg_value)
      Array version of: SetKernelArgMemPointerINTEL
    • clSetKernelArgMemPointerINTEL

      public static int clSetKernelArgMemPointerINTEL(long kernel, int arg_index, long[] arg_value)
      Array version of: SetKernelArgMemPointerINTEL
    • clSetKernelArgMemPointerINTEL

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

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