gozel/core_memory.go

// Code generated by cmd/gen. DO NOT EDIT.

/*
 *
 * Copyright (C) 2019-2025 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 * @file ze_api.h
 * @version v1.15-r1.15.31
 *
 */

package gozel

import (
	"unsafe"

	"github.com/fumiama/gozel/internal/zecall"
)

// ZeDeviceMemAllocFlags (ze_device_mem_alloc_flags_t) Supported memory allocation flags
type ZeDeviceMemAllocFlags uint32

const (
	ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_CACHED            ZeDeviceMemAllocFlags = /* ZE_BIT(0) */ (1 << 0) // ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_CACHED device should cache allocation
	ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED          ZeDeviceMemAllocFlags = /* ZE_BIT(1) */ (1 << 1) // ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED device should not cache allocation (UC)
	ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT ZeDeviceMemAllocFlags = /* ZE_BIT(2) */ (1 << 2) // ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT optimize shared allocation for first access on the device
	ZE_DEVICE_MEM_ALLOC_FLAG_FORCE_UINT32           ZeDeviceMemAllocFlags = 0x7fffffff               // ZE_DEVICE_MEM_ALLOC_FLAG_FORCE_UINT32 Value marking end of ZE_DEVICE_MEM_ALLOC_FLAG_* ENUMs

)

// ZeDeviceMemAllocDesc (ze_device_mem_alloc_desc_t) Device memory allocation descriptor
type ZeDeviceMemAllocDesc struct {
	Stype   ZeStructureType       // Stype [in] type of this structure
	Pnext   unsafe.Pointer        // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags   ZeDeviceMemAllocFlags // Flags [in] flags specifying additional allocation controls. must be 0 (default) or a valid combination of ::ze_device_mem_alloc_flag_t; default behavior may use implicit driver-based heuristics.
	Ordinal uint32                // Ordinal [in] ordinal of the device's local memory to allocate from. must be less than the count returned from ::zeDeviceGetMemoryProperties.

}

// ZeHostMemAllocFlags (ze_host_mem_alloc_flags_t) Supported host memory allocation flags
type ZeHostMemAllocFlags uint32

const (
	ZE_HOST_MEM_ALLOC_FLAG_BIAS_CACHED            ZeHostMemAllocFlags = /* ZE_BIT(0) */ (1 << 0) // ZE_HOST_MEM_ALLOC_FLAG_BIAS_CACHED host should cache allocation
	ZE_HOST_MEM_ALLOC_FLAG_BIAS_UNCACHED          ZeHostMemAllocFlags = /* ZE_BIT(1) */ (1 << 1) // ZE_HOST_MEM_ALLOC_FLAG_BIAS_UNCACHED host should not cache allocation (UC)
	ZE_HOST_MEM_ALLOC_FLAG_BIAS_WRITE_COMBINED    ZeHostMemAllocFlags = /* ZE_BIT(2) */ (1 << 2) // ZE_HOST_MEM_ALLOC_FLAG_BIAS_WRITE_COMBINED host memory should be allocated write-combined (WC)
	ZE_HOST_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT ZeHostMemAllocFlags = /* ZE_BIT(3) */ (1 << 3) // ZE_HOST_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT optimize shared allocation for first access on the host
	ZE_HOST_MEM_ALLOC_FLAG_FORCE_UINT32           ZeHostMemAllocFlags = 0x7fffffff               // ZE_HOST_MEM_ALLOC_FLAG_FORCE_UINT32 Value marking end of ZE_HOST_MEM_ALLOC_FLAG_* ENUMs

)

// ZeHostMemAllocDesc (ze_host_mem_alloc_desc_t) Host memory allocation descriptor
type ZeHostMemAllocDesc struct {
	Stype ZeStructureType     // Stype [in] type of this structure
	Pnext unsafe.Pointer      // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags ZeHostMemAllocFlags // Flags [in] flags specifying additional allocation controls. must be 0 (default) or a valid combination of ::ze_host_mem_alloc_flag_t; default behavior may use implicit driver-based heuristics.

}

// ZeMemAllocShared Allocates shared memory on the context.
// /
// / @details
// /     - Shared allocations share ownership between the host and one or more
// /       devices.
// /     - Shared allocations may optionally be associated with a device by
// /       passing a handle to the device.
// /     - Devices supporting only single-device shared access capabilities may
// /       access shared memory associated with the device.
// /       For these devices, ownership of the allocation is shared between the
// /       host and the associated device only.
// /     - Passing nullptr as the device handle does not associate the shared
// /       allocation with any device.
// /       For allocations with no associated device, ownership of the allocation
// /       is shared between the host and all devices supporting cross-device
// /       shared access capabilities.
// /     - The application must only use the memory allocation for the context
// /       and device, or its sub-devices, which was provided during allocation.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == device_desc`
// /         + `nullptr == host_desc`
// /         + `nullptr == pptr`
// /     - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
// /         + `0x7 < device_desc->flags`
// /         + `0xf < host_desc->flags`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE
// /         + `0 == size`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT
// /         + Must be zero or a power-of-two
// /         + `0 != (alignment & (alignment - 1))`
func ZeMemAllocShared(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	device_desc *ZeDeviceMemAllocDesc, // device_desc [in] pointer to device memory allocation descriptor
	host_desc *ZeHostMemAllocDesc, // host_desc [in] pointer to host memory allocation descriptor
	size uintptr, // size [in] size in bytes to allocate; must be less than or equal to the `maxMemAllocSize` member of ::ze_device_properties_t
	alignment uintptr, // alignment [in] minimum alignment in bytes for the allocation; must be a power of two
	hDevice ZeDeviceHandle, // hDevice [in][optional] device handle to associate with
	pptr *unsafe.Pointer, // pptr [out] pointer to shared allocation
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemAllocShared", uintptr(hContext), uintptr(unsafe.Pointer(device_desc)), uintptr(unsafe.Pointer(host_desc)), uintptr(size), uintptr(alignment), uintptr(hDevice), uintptr(unsafe.Pointer(pptr)))
}

// ZeMemAllocDevice Allocates device memory on the context.
// /
// / @details
// /     - Device allocations are owned by a specific device.
// /     - In general, a device allocation may only be accessed by the device
// /       that owns it.
// /     - The application must only use the memory allocation for the context
// /       and device, or its sub-devices, which was provided during allocation.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /         + `nullptr == hDevice`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == device_desc`
// /         + `nullptr == pptr`
// /     - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
// /         + `0x7 < device_desc->flags`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE
// /         + `0 == size`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT
// /         + Must be zero or a power-of-two
// /         + `0 != (alignment & (alignment - 1))`
func ZeMemAllocDevice(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	device_desc *ZeDeviceMemAllocDesc, // device_desc [in] pointer to device memory allocation descriptor
	size uintptr, // size [in] size in bytes to allocate; must be less than or equal to the `maxMemAllocSize` member of ::ze_device_properties_t
	alignment uintptr, // alignment [in] minimum alignment in bytes for the allocation; must be a power of two
	hDevice ZeDeviceHandle, // hDevice [in] handle of the device
	pptr *unsafe.Pointer, // pptr [out] pointer to device allocation
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemAllocDevice", uintptr(hContext), uintptr(unsafe.Pointer(device_desc)), uintptr(size), uintptr(alignment), uintptr(hDevice), uintptr(unsafe.Pointer(pptr)))
}

// ZeMemAllocHost Allocates host memory on the context.
// /
// / @details
// /     - Host allocations are owned by the host process.
// /     - Host allocations are accessible by the host and all devices within the
// /       driver's context.
// /     - Host allocations are frequently used as staging areas to transfer data
// /       to or from devices.
// /     - The application must only use the memory allocation for the context
// /       which was provided during allocation.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == host_desc`
// /         + `nullptr == pptr`
// /     - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
// /         + `0xf < host_desc->flags`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE
// /         + `0 == size`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT
// /         + Must be zero or a power-of-two
// /         + `0 != (alignment & (alignment - 1))`
func ZeMemAllocHost(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	host_desc *ZeHostMemAllocDesc, // host_desc [in] pointer to host memory allocation descriptor
	size uintptr, // size [in] size in bytes to allocate; must be less than or equal to the `maxMemAllocSize` member of ::ze_device_properties_t
	alignment uintptr, // alignment [in] minimum alignment in bytes for the allocation; must be a power of two
	pptr *unsafe.Pointer, // pptr [out] pointer to host allocation
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemAllocHost", uintptr(hContext), uintptr(unsafe.Pointer(host_desc)), uintptr(size), uintptr(alignment), uintptr(unsafe.Pointer(pptr)))
}

// ZeMemFree Frees allocated host memory, device memory, or shared memory on the
// /        context.
// /
// / @details
// /     - The application must ensure the device is not currently referencing
// /       the memory before it is freed
// /     - The implementation will use the default and immediate policy to
// /       schedule all Host and Device allocations associated with this memory
// /       to be freed, without any safety checking. Actual freeing of memory is
// /       specific to user mode driver and kernel mode driver implementation and
// /       may be done asynchronously.
// /     - The application must **not** call this function from simultaneous
// /       threads with the same pointer.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
func ZeMemFree(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ptr unsafe.Pointer, // ptr [in][release] pointer to memory to free
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemFree", uintptr(hContext), uintptr(unsafe.Pointer(ptr)))
}

// ZeMemoryType (ze_memory_type_t) Memory allocation type
type ZeMemoryType uintptr

const (
	ZE_MEMORY_TYPE_UNKNOWN       ZeMemoryType = 0 // ZE_MEMORY_TYPE_UNKNOWN the memory pointed to is of unknown type
	ZE_MEMORY_TYPE_HOST          ZeMemoryType = 1 // ZE_MEMORY_TYPE_HOST the memory pointed to is a host allocation
	ZE_MEMORY_TYPE_DEVICE        ZeMemoryType = 2 // ZE_MEMORY_TYPE_DEVICE the memory pointed to is a device allocation
	ZE_MEMORY_TYPE_SHARED        ZeMemoryType = 3 // ZE_MEMORY_TYPE_SHARED the memory pointed to is a shared ownership allocation
	ZE_MEMORY_TYPE_HOST_IMPORTED ZeMemoryType = 4 // ZE_MEMORY_TYPE_HOST_IMPORTED the memory pointed to is a host allocation created from external

	///< system memory

	ZE_MEMORY_TYPE_FORCE_UINT32 ZeMemoryType = 0x7fffffff // ZE_MEMORY_TYPE_FORCE_UINT32 Value marking end of ZE_MEMORY_TYPE_* ENUMs

)

// ZeMemoryAllocationProperties (ze_memory_allocation_properties_t) Memory allocation properties queried using ::zeMemGetAllocProperties
type ZeMemoryAllocationProperties struct {
	Stype    ZeStructureType // Stype [in] type of this structure
	Pnext    unsafe.Pointer  // Pnext [in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Type     ZeMemoryType    // Type [out] type of allocated memory
	Id       uint64          // Id [out] identifier for this allocation
	Pagesize uint64          // Pagesize [out] page size used for allocation

}

// ZeMemGetAllocProperties Retrieves attributes of a memory allocation
// /
// / @details
// /     - The application may call this function from simultaneous threads.
// /     - The application may query attributes of a memory allocation unrelated
// /       to the context.
// /       When this occurs, the returned allocation type will be
// /       ::ZE_MEMORY_TYPE_UNKNOWN, and the returned identifier and associated
// /       device is unspecified.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
// /         + `nullptr == pMemAllocProperties`
func ZeMemGetAllocProperties(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ptr unsafe.Pointer, // ptr [in] memory pointer to query
	pMemAllocProperties *ZeMemoryAllocationProperties, // pMemAllocProperties [in,out] query result for memory allocation properties
	phDevice *ZeDeviceHandle, // phDevice [out][optional] device associated with this allocation
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetAllocProperties", uintptr(hContext), uintptr(unsafe.Pointer(ptr)), uintptr(unsafe.Pointer(pMemAllocProperties)), uintptr(unsafe.Pointer(phDevice)))
}

// ZeMemGetAddressRange Retrieves the base address and/or size of an allocation
// /
// / @details
// /     - The application may call this function from simultaneous threads.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
// /     - ::ZE_RESULT_ERROR_ADDRESS_NOT_FOUND
func ZeMemGetAddressRange(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ptr unsafe.Pointer, // ptr [in] memory pointer to query
	pBase *unsafe.Pointer, // pBase [in,out][optional] base address of the allocation
	pSize *uintptr, // pSize [in,out][optional] size of the allocation
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetAddressRange", uintptr(hContext), uintptr(unsafe.Pointer(ptr)), uintptr(unsafe.Pointer(pBase)), uintptr(unsafe.Pointer(pSize)))
}

// ZeMemGetIpcHandle Creates an IPC memory handle for the specified allocation
// /
// / @details
// /     - Takes a pointer to a device memory allocation and creates an IPC
// /       memory handle for exporting it for use in another process.
// /     - The pointer must be base pointer of a device or host memory
// /       allocation; i.e. the value returned from ::zeMemAllocDevice or from
// /       ::zeMemAllocHost, respectively.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
// /         + `nullptr == pIpcHandle`
func ZeMemGetIpcHandle(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ptr unsafe.Pointer, // ptr [in] pointer to the device memory allocation
	pIpcHandle *ZeIpcMemHandle, // pIpcHandle [out] Returned IPC memory handle
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetIpcHandle", uintptr(hContext), uintptr(unsafe.Pointer(ptr)), uintptr(unsafe.Pointer(pIpcHandle)))
}

// ZeMemGetIpcHandleFromFileDescriptorExp Creates an IPC memory handle out of a file descriptor
// /
// / @details
// /     - Handle passed must be a valid file descriptor obtained with
// /       ::ze_external_memory_export_fd_t via ::zeMemGetAllocProperties or
// /       ::zePhysicalMemGetProperties.
// /     - Returned IPC handle may contain metadata in addition to the file
// /       descriptor.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == pIpcHandle`
func ZeMemGetIpcHandleFromFileDescriptorExp(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	handle uint64, // handle [in] file descriptor
	pIpcHandle *ZeIpcMemHandle, // pIpcHandle [out] Returned IPC memory handle
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetIpcHandleFromFileDescriptorExp", uintptr(hContext), uintptr(handle), uintptr(unsafe.Pointer(pIpcHandle)))
}

// ZeMemGetFileDescriptorFromIpcHandleExp Gets the file descriptor contained in an IPC memory handle
// /
// / @details
// /     - IPC memory handle must be a valid handle obtained with
// /       ::zeMemGetIpcHandle.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == pHandle`
func ZeMemGetFileDescriptorFromIpcHandleExp(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ipcHandle *ZeIpcMemHandle, // ipcHandle [in] IPC memory handle (gozel hack: converted to a hidden pointer from a struct value)
	pHandle *uint64, // pHandle [out] Returned file descriptor
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetFileDescriptorFromIpcHandleExp", uintptr(hContext), uintptr(unsafe.Pointer(ipcHandle)), uintptr(unsafe.Pointer(pHandle)))
}

// ZeMemPutIpcHandle Returns an IPC memory handle to the driver
// /
// / @details
// /     - This call may be used for IPC handles previously obtained with either
// /       ::zeMemGetIpcHandle or with ::ze_external_memory_export_fd_t via
// /       ::zeMemGetAllocProperties or ::zePhysicalMemGetProperties.
// /     - Upon call, driver may release any underlying resources associated with
// /       the IPC handle.
// /       For instance, it may close the file descriptor contained in the IPC
// /       handle, if such type of handle is being used by the driver.
// /     - This call does not free the original allocation for which the IPC
// /       handle was created.
// /     - This function may **not** be called from simultaneous threads with the
// /       same IPC handle.
// /     - The implementation of this function should be lock-free.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
func ZeMemPutIpcHandle(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	handle *ZeIpcMemHandle, // handle [in] IPC memory handle (gozel hack: converted to a hidden pointer from a struct value)
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemPutIpcHandle", uintptr(hContext), uintptr(unsafe.Pointer(handle)))
}

// ZeIpcMemoryFlags (ze_ipc_memory_flags_t) Supported IPC memory flags
type ZeIpcMemoryFlags uint32

const (
	ZE_IPC_MEMORY_FLAG_BIAS_CACHED   ZeIpcMemoryFlags = /* ZE_BIT(0) */ (1 << 0) // ZE_IPC_MEMORY_FLAG_BIAS_CACHED device should cache allocation
	ZE_IPC_MEMORY_FLAG_BIAS_UNCACHED ZeIpcMemoryFlags = /* ZE_BIT(1) */ (1 << 1) // ZE_IPC_MEMORY_FLAG_BIAS_UNCACHED device should not cache allocation (UC)
	ZE_IPC_MEMORY_FLAG_FORCE_UINT32  ZeIpcMemoryFlags = 0x7fffffff               // ZE_IPC_MEMORY_FLAG_FORCE_UINT32 Value marking end of ZE_IPC_MEMORY_FLAG_* ENUMs

)

// ZeMemOpenIpcHandle Opens an IPC memory handle to retrieve a device pointer on the
// /        context.
// /
// / @details
// /     - Takes an IPC memory handle from a remote process and associates it
// /       with a device pointer usable in this process.
// /     - The device pointer in this process should not be freed with
// /       ::zeMemFree, but rather with ::zeMemCloseIpcHandle.
// /     - Multiple calls to this function with the same IPC handle will return
// /       unique pointers.
// /     - The application may call this function from simultaneous threads.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /         + `nullptr == hDevice`
// /     - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
// /         + `0x3 < flags`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == pptr`
func ZeMemOpenIpcHandle(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	hDevice ZeDeviceHandle, // hDevice [in] handle of the device to associate with the IPC memory handle
	handle *ZeIpcMemHandle, // handle [in] IPC memory handle (gozel hack: converted to a hidden pointer from a struct value)
	flags ZeIpcMemoryFlags, // flags [in] flags controlling the operation. must be 0 (default) or a valid combination of ::ze_ipc_memory_flag_t.
	pptr *unsafe.Pointer, // pptr [out] pointer to device allocation in this process
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemOpenIpcHandle", uintptr(hContext), uintptr(hDevice), uintptr(unsafe.Pointer(handle)), uintptr(flags), uintptr(unsafe.Pointer(pptr)))
}

// ZeMemCloseIpcHandle Closes an IPC memory handle
// /
// / @details
// /     - Closes an IPC memory handle by unmapping memory that was opened in
// /       this process using ::zeMemOpenIpcHandle.
// /     - The application must **not** call this function from simultaneous
// /       threads with the same pointer.
// /     - The implementation of this function must be thread-safe.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
func ZeMemCloseIpcHandle(
	hContext ZeContextHandle, // hContext [in] handle of the context object
	ptr unsafe.Pointer, // ptr [in][release] pointer to device allocation in this process
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemCloseIpcHandle", uintptr(hContext), uintptr(unsafe.Pointer(ptr)))
}

// ZeExternalMemoryExportDesc (ze_external_memory_export_desc_t) Additional allocation descriptor for exporting external memory
// /
// / @details
// /     - This structure may be passed to ::zeMemAllocDevice, ::zeMemAllocHost,
// /       or ::zePhysicalMemCreate, via the `pNext` member of
// /       ::ze_device_mem_alloc_desc_t or ::ze_host_mem_alloc_desc_t, or
// /       ::ze_physical_mem_desc_t, respectively, to indicate an exportable
// /       memory allocation.
// /     - This structure may be passed to ::zeImageCreate, via the `pNext`
// /       member of ::ze_image_desc_t, to indicate an exportable image.
type ZeExternalMemoryExportDesc struct {
	Stype ZeStructureType           // Stype [in] type of this structure
	Pnext unsafe.Pointer            // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags ZeExternalMemoryTypeFlags // Flags [in] flags specifying memory export types for this allocation. must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t

}

// ZeExternalMemoryImportFd (ze_external_memory_import_fd_t) Additional allocation descriptor for importing external memory as a
// /        file descriptor
// /
// / @details
// /     - This structure may be passed to ::zeMemAllocDevice, ::zeMemAllocHost,
// /       or ::zePhysicalMemCreate, via the `pNext` member of
// /       ::ze_device_mem_alloc_desc_t or ::ze_host_mem_alloc_desc_t, or
// /       ::ze_physical_mem_desc_t, respectively, to import memory from a file
// /       descriptor.
// /     - This structure may be passed to ::zeImageCreate, via the `pNext`
// /       member of ::ze_image_desc_t, to import memory from a file descriptor.
type ZeExternalMemoryImportFd struct {
	Stype ZeStructureType           // Stype [in] type of this structure
	Pnext unsafe.Pointer            // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags ZeExternalMemoryTypeFlags // Flags [in] flags specifying the memory import type for the file descriptor. must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t
	Fd    int32                     // Fd [in] the file descriptor handle to import

}

// ZeExternalMemoryExportFd (ze_external_memory_export_fd_t) Exports an allocation as a file descriptor
// /
// / @details
// /     - This structure may be passed to ::zeMemGetAllocProperties, via the
// /       `pNext` member of ::ze_memory_allocation_properties_t, to export a
// /       memory allocation as a file descriptor.
// /     - This structure may be passed to ::zeImageGetAllocPropertiesExt, via
// /       the `pNext` member of ::ze_image_allocation_ext_properties_t, to
// /       export an image as a file descriptor.
// /     - This structure may be passed to ::zePhysicalMemGetProperties, via the
// /       `pNext` member of ::ze_physical_mem_properties_t, to export physical
// /       memory as a file descriptor.
// /     - The requested memory export type must have been specified when the
// /       allocation was made.
type ZeExternalMemoryExportFd struct {
	Stype ZeStructureType           // Stype [in] type of this structure
	Pnext unsafe.Pointer            // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags ZeExternalMemoryTypeFlags // Flags [in] flags specifying the memory export type for the file descriptor. must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t
	Fd    int32                     // Fd [out] the exported file descriptor handle representing the allocation.

}

// ZeExternalMemoryImportWin32Handle (ze_external_memory_import_win32_handle_t) Additional allocation descriptor for importing external memory as a
// /        Win32 handle
// /
// / @details
// /     - When `handle` is `nullptr`, `name` must not be `nullptr`.
// /     - When `name` is `nullptr`, `handle` must not be `nullptr`.
// /     - When `flags` is ::ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32_KMT,
// /       `name` must be `nullptr`.
// /     - This structure may be passed to ::zeMemAllocDevice, ::zeMemAllocHost,
// /       or ::zePhysicalMemCreate, via the `pNext` member of
// /       ::ze_device_mem_alloc_desc_t or ::ze_host_mem_alloc_desc_t, or
// /       ::ze_physical_mem_desc_t, respectively, to import memory from a Win32
// /       handle.
// /     - This structure may be passed to ::zeImageCreate, via the `pNext`
// /       member of ::ze_image_desc_t, to import memory from a Win32 handle.
type ZeExternalMemoryImportWin32Handle struct {
	Stype  ZeStructureType           // Stype [in] type of this structure
	Pnext  unsafe.Pointer            // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags  ZeExternalMemoryTypeFlags // Flags [in] flags specifying the memory import type for the Win32 handle. must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t
	Handle unsafe.Pointer            // Handle [in][optional] the Win32 handle to import
	Name   unsafe.Pointer            // Name [in][optional] name of a memory object to import

}

// ZeExternalMemoryExportWin32Handle (ze_external_memory_export_win32_handle_t) Exports an allocation as a Win32 handle
// /
// / @details
// /     - This structure may be passed to ::zeMemGetAllocProperties, via the
// /       `pNext` member of ::ze_memory_allocation_properties_t, to export a
// /       memory allocation as a Win32 handle.
// /     - This structure may be passed to ::zeImageGetAllocPropertiesExt, via
// /       the `pNext` member of ::ze_image_allocation_ext_properties_t, to
// /       export an image as a Win32 handle.
// /     - This structure may be passed to ::zePhysicalMemGetProperties, via the
// /       `pNext` member of ::ze_physical_mem_properties_t, to export physical
// /       memory as a Win32 handle.
// /     - The requested memory export type must have been specified when the
// /       allocation was made.
type ZeExternalMemoryExportWin32Handle struct {
	Stype  ZeStructureType           // Stype [in] type of this structure
	Pnext  unsafe.Pointer            // Pnext [in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
	Flags  ZeExternalMemoryTypeFlags // Flags [in] flags specifying the memory export type for the Win32 handle. must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t
	Handle unsafe.Pointer            // Handle [out] the exported Win32 handle representing the allocation.

}

// ZeMemoryAtomicAttrExpFlags (ze_memory_atomic_attr_exp_flags_t) atomic access attribute flags
type ZeMemoryAtomicAttrExpFlags uint32

const (
	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_ATOMICS      ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(0) */ (1 << 0) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_ATOMICS Atomics on the pointer are not allowed
	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_HOST_ATOMICS ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(1) */ (1 << 1) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_HOST_ATOMICS Host atomics on the pointer are not allowed
	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_HOST_ATOMICS    ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(2) */ (1 << 2) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_HOST_ATOMICS Host atomics on the pointer are allowed. Requires

	///< ::ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC returned by
	///< ::zeDeviceGetMemoryAccessProperties.

	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_DEVICE_ATOMICS ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(3) */ (1 << 3) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_DEVICE_ATOMICS Device atomics on the pointer are not allowed
	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_DEVICE_ATOMICS    ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(4) */ (1 << 4) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_DEVICE_ATOMICS Device atomics on the pointer are allowed. Requires

	///< ::ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC returned by
	///< ::zeDeviceGetMemoryAccessProperties.

	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_SYSTEM_ATOMICS ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(5) */ (1 << 5) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_NO_SYSTEM_ATOMICS Concurrent atomics on the pointer from both host and device are not

	///< allowed

	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_SYSTEM_ATOMICS ZeMemoryAtomicAttrExpFlags = /* ZE_BIT(6) */ (1 << 6) // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_SYSTEM_ATOMICS Concurrent atomics on the pointer from both host and device are

	///< allowed. Requires ::ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT_ATOMIC
	///< returned by ::zeDeviceGetMemoryAccessProperties.

	ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_FORCE_UINT32 ZeMemoryAtomicAttrExpFlags = 0x7fffffff // ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_FORCE_UINT32 Value marking end of ZE_MEMORY_ATOMIC_ATTR_EXP_FLAG_* ENUMs

)

// ZeMemSetAtomicAccessAttributeExp Sets atomic access attributes for a shared allocation
// /
// / @details
// /     - If the shared-allocation is owned by multiple devices (i.e. nullptr
// /       was passed to ::zeMemAllocShared when creating it), then hDevice may be
// /       passed to set the attributes in that specific device. If nullptr is
// /       passed in hDevice, then the atomic attributes are set in all devices
// /       associated with the allocation.
// /     - If the atomic access attribute select is not supported by the driver,
// /       ::ZE_RESULT_ERROR_INVALID_ARGUMENT is returned.
// /     - The atomic access attribute may be only 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 granularity
// /       requirements.
// /     - When calling this function multiple times with different flags, only the
// /       attributes from last call are honored.
// /     - The application must not call this function for shared-allocations currently
// /       being used by the device.
// /     - The application must **not** call this function from simultaneous threads
// /       with the same pointer.
// /     - The implementation of this function should be lock-free.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /         + `nullptr == hDevice`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
// /     - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
// /         + `0x7f < attr`
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
func ZeMemSetAtomicAccessAttributeExp(
	hContext ZeContextHandle, // hContext [in] handle of context
	hDevice ZeDeviceHandle, // hDevice [in] device associated with the memory advice
	ptr unsafe.Pointer, // ptr [in] Pointer to the start of the memory range
	size uintptr, // size [in] Size in bytes of the memory range
	attr ZeMemoryAtomicAttrExpFlags, // attr [in] Atomic access attributes to set for the specified range. Must be 0 (default) or a valid combination of ::ze_memory_atomic_attr_exp_flag_t.
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemSetAtomicAccessAttributeExp", uintptr(hContext), uintptr(hDevice), uintptr(unsafe.Pointer(ptr)), uintptr(size), uintptr(attr))
}

// ZeMemGetAtomicAccessAttributeExp Retrieves the atomic access attributes previously set for a shared
// /        allocation
// /
// / @details
// /     - The application may call this function from simultaneous threads
// /       with the same pointer.
// /     - The implementation of this function should be lock-free.
// /
// / @returns
// /     - ::ZE_RESULT_SUCCESS
// /     - ::ZE_RESULT_ERROR_UNINITIALIZED
// /     - ::ZE_RESULT_ERROR_DEVICE_LOST
// /     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
// /     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
// /     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
// /     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
// /     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
// /     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
// /     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
// /     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
// /     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
// /     - ::ZE_RESULT_ERROR_UNKNOWN
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
// /         + `nullptr == hContext`
// /         + `nullptr == hDevice`
// /     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
// /         + `nullptr == ptr`
// /         + `nullptr == pAttr`
func ZeMemGetAtomicAccessAttributeExp(
	hContext ZeContextHandle, // hContext [in] handle of context
	hDevice ZeDeviceHandle, // hDevice [in] device associated with the memory advice
	ptr unsafe.Pointer, // ptr [in] Pointer to the start of the memory range
	size uintptr, // size [in] Size in bytes of the memory range
	pAttr *ZeMemoryAtomicAttrExpFlags, // pAttr [out] Atomic access attributes for the specified range
) (ZeResult, error) {
	return zecall.Call[ZeResult]("zeMemGetAtomicAccessAttributeExp", uintptr(hContext), uintptr(hDevice), uintptr(unsafe.Pointer(ptr)), uintptr(size), uintptr(unsafe.Pointer(pAttr)))
}