Applied-Software/ZLUDA
5
0
Fork 0
mirror of https://github.com/vosen/ZLUDA.git synced 2025-04-20 00:19:20 +03:00
Code Issues Packages Projects Releases Wiki Activity
ZLUDA/level_zero-sys/src/ze_api.rs
Andrzej Janik 58a7fe53c6 Emit Default impl for properties types
2021-05-23 16:05:32 +02:00

24409 lines
879 KiB
Rust
Raw Blame History

/* automatically generated by rust-bindgen 0.58.1 */
#[doc = ""]
#[doc = " @brief compiler-independent type"]
pub type ze_bool_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of a driver instance"]
pub type ze_driver_handle_t = *mut _ze_driver_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's device object"]
pub type ze_device_handle_t = *mut _ze_device_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's context object"]
pub type ze_context_handle_t = *mut _ze_context_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's command queue object"]
pub type ze_command_queue_handle_t = *mut _ze_command_queue_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's command list object"]
pub type ze_command_list_handle_t = *mut _ze_command_list_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's fence object"]
pub type ze_fence_handle_t = *mut _ze_fence_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's event pool object"]
pub type ze_event_pool_handle_t = *mut _ze_event_pool_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's event object"]
pub type ze_event_handle_t = *mut _ze_event_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's image object"]
pub type ze_image_handle_t = *mut _ze_image_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's module object"]
pub type ze_module_handle_t = *mut _ze_module_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_build_log_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of module's build log object"]
pub type ze_module_build_log_handle_t = *mut _ze_module_build_log_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's kernel object"]
pub type ze_kernel_handle_t = *mut _ze_kernel_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_sampler_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of driver's sampler object"]
pub type ze_sampler_handle_t = *mut _ze_sampler_handle_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_physical_mem_handle_t {
_unused: [u8; 0],
}
#[doc = ""]
#[doc = " @brief Handle of physical memory object"]
pub type ze_physical_mem_handle_t = *mut _ze_physical_mem_handle_t;
#[doc = ""]
#[doc = " @brief IPC handle to a memory allocation"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ze_ipc_mem_handle_t {
#[doc = "< [out] Opaque data representing an IPC handle"]
pub data: [::std::os::raw::c_char; 64usize],
}
#[test]
fn bindgen_test_layout__ze_ipc_mem_handle_t() {
assert_eq!(
::std::mem::size_of::<_ze_ipc_mem_handle_t>(),
64usize,
concat!("Size of: ", stringify!(_ze_ipc_mem_handle_t))
);
assert_eq!(
::std::mem::align_of::<_ze_ipc_mem_handle_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_ipc_mem_handle_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_ipc_mem_handle_t>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_ipc_mem_handle_t),
"::",
stringify!(data)
)
);
}
#[doc = ""]
#[doc = " @brief IPC handle to a memory allocation"]
pub type ze_ipc_mem_handle_t = _ze_ipc_mem_handle_t;
#[doc = ""]
#[doc = " @brief IPC handle to a event pool allocation"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ze_ipc_event_pool_handle_t {
#[doc = "< [out] Opaque data representing an IPC handle"]
pub data: [::std::os::raw::c_char; 64usize],
}
#[test]
fn bindgen_test_layout__ze_ipc_event_pool_handle_t() {
assert_eq!(
::std::mem::size_of::<_ze_ipc_event_pool_handle_t>(),
64usize,
concat!("Size of: ", stringify!(_ze_ipc_event_pool_handle_t))
);
assert_eq!(
::std::mem::align_of::<_ze_ipc_event_pool_handle_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_ipc_event_pool_handle_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_ipc_event_pool_handle_t>())).data as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_ipc_event_pool_handle_t),
"::",
stringify!(data)
)
);
}
#[doc = ""]
#[doc = " @brief IPC handle to a event pool allocation"]
pub type ze_ipc_event_pool_handle_t = _ze_ipc_event_pool_handle_t;
impl _ze_result_t {
#[doc = "< [Core] success"]
pub const ZE_RESULT_SUCCESS: _ze_result_t = _ze_result_t(0);
}
impl _ze_result_t {
#[doc = "< [Core] synchronization primitive not signaled"]
pub const ZE_RESULT_NOT_READY: _ze_result_t = _ze_result_t(1);
}
impl _ze_result_t {
#[doc = "< [Core] device hung, reset, was removed, or driver update occurred"]
pub const ZE_RESULT_ERROR_DEVICE_LOST: _ze_result_t = _ze_result_t(1879048193);
}
impl _ze_result_t {
#[doc = "< [Core] insufficient host memory to satisfy call"]
pub const ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY: _ze_result_t = _ze_result_t(1879048194);
}
impl _ze_result_t {
#[doc = "< [Core] insufficient device memory to satisfy call"]
pub const ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY: _ze_result_t = _ze_result_t(1879048195);
}
impl _ze_result_t {
#[doc = "< [Core] error occurred when building module, see build log for details"]
pub const ZE_RESULT_ERROR_MODULE_BUILD_FAILURE: _ze_result_t = _ze_result_t(1879048196);
}
impl _ze_result_t {
#[doc = "< [Core] error occurred when linking modules, see build log for details"]
pub const ZE_RESULT_ERROR_MODULE_LINK_FAILURE: _ze_result_t = _ze_result_t(1879048197);
}
impl _ze_result_t {
#[doc = "< [Sysman] access denied due to permission level"]
pub const ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS: _ze_result_t = _ze_result_t(1879113728);
}
impl _ze_result_t {
#[doc = "< [Sysman] resource already in use and simultaneous access not allowed"]
#[doc = "< or resource was removed"]
pub const ZE_RESULT_ERROR_NOT_AVAILABLE: _ze_result_t = _ze_result_t(1879113729);
}
impl _ze_result_t {
#[doc = "< [Tools] external required dependency is unavailable or missing"]
pub const ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE: _ze_result_t = _ze_result_t(1879179264);
}
impl _ze_result_t {
#[doc = "< [Validation] driver is not initialized"]
pub const ZE_RESULT_ERROR_UNINITIALIZED: _ze_result_t = _ze_result_t(2013265921);
}
impl _ze_result_t {
#[doc = "< [Validation] generic error code for unsupported versions"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_VERSION: _ze_result_t = _ze_result_t(2013265922);
}
impl _ze_result_t {
#[doc = "< [Validation] generic error code for unsupported features"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_FEATURE: _ze_result_t = _ze_result_t(2013265923);
}
impl _ze_result_t {
#[doc = "< [Validation] generic error code for invalid arguments"]
pub const ZE_RESULT_ERROR_INVALID_ARGUMENT: _ze_result_t = _ze_result_t(2013265924);
}
impl _ze_result_t {
#[doc = "< [Validation] handle argument is not valid"]
pub const ZE_RESULT_ERROR_INVALID_NULL_HANDLE: _ze_result_t = _ze_result_t(2013265925);
}
impl _ze_result_t {
#[doc = "< [Validation] object pointed to by handle still in-use by device"]
pub const ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE: _ze_result_t = _ze_result_t(2013265926);
}
impl _ze_result_t {
#[doc = "< [Validation] pointer argument may not be nullptr"]
pub const ZE_RESULT_ERROR_INVALID_NULL_POINTER: _ze_result_t = _ze_result_t(2013265927);
}
impl _ze_result_t {
#[doc = "< [Validation] size argument is invalid (e.g., must not be zero)"]
pub const ZE_RESULT_ERROR_INVALID_SIZE: _ze_result_t = _ze_result_t(2013265928);
}
impl _ze_result_t {
#[doc = "< [Validation] size argument is not supported by the device (e.g., too"]
#[doc = "< large)"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_SIZE: _ze_result_t = _ze_result_t(2013265929);
}
impl _ze_result_t {
#[doc = "< [Validation] alignment argument is not supported by the device (e.g.,"]
#[doc = "< too small)"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT: _ze_result_t = _ze_result_t(2013265930);
}
impl _ze_result_t {
#[doc = "< [Validation] synchronization object in invalid state"]
pub const ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT: _ze_result_t =
_ze_result_t(2013265931);
}
impl _ze_result_t {
#[doc = "< [Validation] enumerator argument is not valid"]
pub const ZE_RESULT_ERROR_INVALID_ENUMERATION: _ze_result_t = _ze_result_t(2013265932);
}
impl _ze_result_t {
#[doc = "< [Validation] enumerator argument is not supported by the device"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION: _ze_result_t = _ze_result_t(2013265933);
}
impl _ze_result_t {
#[doc = "< [Validation] image format is not supported by the device"]
pub const ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT: _ze_result_t = _ze_result_t(2013265934);
}
impl _ze_result_t {
#[doc = "< [Validation] native binary is not supported by the device"]
pub const ZE_RESULT_ERROR_INVALID_NATIVE_BINARY: _ze_result_t = _ze_result_t(2013265935);
}
impl _ze_result_t {
#[doc = "< [Validation] global variable is not found in the module"]
pub const ZE_RESULT_ERROR_INVALID_GLOBAL_NAME: _ze_result_t = _ze_result_t(2013265936);
}
impl _ze_result_t {
#[doc = "< [Validation] kernel name is not found in the module"]
pub const ZE_RESULT_ERROR_INVALID_KERNEL_NAME: _ze_result_t = _ze_result_t(2013265937);
}
impl _ze_result_t {
#[doc = "< [Validation] function name is not found in the module"]
pub const ZE_RESULT_ERROR_INVALID_FUNCTION_NAME: _ze_result_t = _ze_result_t(2013265938);
}
impl _ze_result_t {
#[doc = "< [Validation] group size dimension is not valid for the kernel or"]
#[doc = "< device"]
pub const ZE_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION: _ze_result_t = _ze_result_t(2013265939);
}
impl _ze_result_t {
#[doc = "< [Validation] global width dimension is not valid for the kernel or"]
#[doc = "< device"]
pub const ZE_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION: _ze_result_t =
_ze_result_t(2013265940);
}
impl _ze_result_t {
#[doc = "< [Validation] kernel argument index is not valid for kernel"]
pub const ZE_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX: _ze_result_t =
_ze_result_t(2013265941);
}
impl _ze_result_t {
#[doc = "< [Validation] kernel argument size does not match kernel"]
pub const ZE_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE: _ze_result_t = _ze_result_t(2013265942);
}
impl _ze_result_t {
#[doc = "< [Validation] value of kernel attribute is not valid for the kernel or"]
#[doc = "< device"]
pub const ZE_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE: _ze_result_t =
_ze_result_t(2013265943);
}
impl _ze_result_t {
#[doc = "< [Validation] module with imports needs to be linked before kernels can"]
#[doc = "< be created from it."]
pub const ZE_RESULT_ERROR_INVALID_MODULE_UNLINKED: _ze_result_t = _ze_result_t(2013265944);
}
impl _ze_result_t {
#[doc = "< [Validation] command list type does not match command queue type"]
pub const ZE_RESULT_ERROR_INVALID_COMMAND_LIST_TYPE: _ze_result_t = _ze_result_t(2013265945);
}
impl _ze_result_t {
#[doc = "< [Validation] copy operations do not support overlapping regions of"]
#[doc = "< memory"]
pub const ZE_RESULT_ERROR_OVERLAPPING_REGIONS: _ze_result_t = _ze_result_t(2013265946);
}
impl _ze_result_t {
#[doc = "< [Core] unknown or internal error"]
pub const ZE_RESULT_ERROR_UNKNOWN: _ze_result_t = _ze_result_t(2147483646);
}
impl _ze_result_t {
pub const ZE_RESULT_FORCE_UINT32: _ze_result_t = _ze_result_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Defines Return/Error codes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
#[must_use]
pub struct _ze_result_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Defines Return/Error codes"]
pub use self::_ze_result_t as ze_result_t;
impl _ze_structure_type_t {
#[doc = "< ::ze_driver_properties_t"]
pub const ZE_STRUCTURE_TYPE_DRIVER_PROPERTIES: _ze_structure_type_t = _ze_structure_type_t(1);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_driver_ipc_properties_t"]
pub const ZE_STRUCTURE_TYPE_DRIVER_IPC_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(2);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES: _ze_structure_type_t = _ze_structure_type_t(3);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_compute_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_COMPUTE_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(4);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_module_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(5);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_command_queue_group_properties_t"]
pub const ZE_STRUCTURE_TYPE_COMMAND_QUEUE_GROUP_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(6);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_memory_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_MEMORY_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(7);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_memory_access_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_MEMORY_ACCESS_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(8);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_cache_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_CACHE_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(9);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_image_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_IMAGE_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(10);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_p2p_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_P2P_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(11);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_external_memory_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_EXTERNAL_MEMORY_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(12);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_context_desc_t"]
pub const ZE_STRUCTURE_TYPE_CONTEXT_DESC: _ze_structure_type_t = _ze_structure_type_t(13);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_command_queue_desc_t"]
pub const ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC: _ze_structure_type_t = _ze_structure_type_t(14);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_command_list_desc_t"]
pub const ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC: _ze_structure_type_t = _ze_structure_type_t(15);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_event_pool_desc_t"]
pub const ZE_STRUCTURE_TYPE_EVENT_POOL_DESC: _ze_structure_type_t = _ze_structure_type_t(16);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_event_desc_t"]
pub const ZE_STRUCTURE_TYPE_EVENT_DESC: _ze_structure_type_t = _ze_structure_type_t(17);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_fence_desc_t"]
pub const ZE_STRUCTURE_TYPE_FENCE_DESC: _ze_structure_type_t = _ze_structure_type_t(18);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_image_desc_t"]
pub const ZE_STRUCTURE_TYPE_IMAGE_DESC: _ze_structure_type_t = _ze_structure_type_t(19);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_image_properties_t"]
pub const ZE_STRUCTURE_TYPE_IMAGE_PROPERTIES: _ze_structure_type_t = _ze_structure_type_t(20);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_mem_alloc_desc_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC: _ze_structure_type_t =
_ze_structure_type_t(21);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_host_mem_alloc_desc_t"]
pub const ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC: _ze_structure_type_t =
_ze_structure_type_t(22);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_memory_allocation_properties_t"]
pub const ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(23);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_external_memory_export_desc_t"]
pub const ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC: _ze_structure_type_t =
_ze_structure_type_t(24);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_external_memory_import_fd_t"]
pub const ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD: _ze_structure_type_t =
_ze_structure_type_t(25);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_external_memory_export_fd_t"]
pub const ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_FD: _ze_structure_type_t =
_ze_structure_type_t(26);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_module_desc_t"]
pub const ZE_STRUCTURE_TYPE_MODULE_DESC: _ze_structure_type_t = _ze_structure_type_t(27);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_module_properties_t"]
pub const ZE_STRUCTURE_TYPE_MODULE_PROPERTIES: _ze_structure_type_t = _ze_structure_type_t(28);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_kernel_desc_t"]
pub const ZE_STRUCTURE_TYPE_KERNEL_DESC: _ze_structure_type_t = _ze_structure_type_t(29);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_kernel_properties_t"]
pub const ZE_STRUCTURE_TYPE_KERNEL_PROPERTIES: _ze_structure_type_t = _ze_structure_type_t(30);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_sampler_desc_t"]
pub const ZE_STRUCTURE_TYPE_SAMPLER_DESC: _ze_structure_type_t = _ze_structure_type_t(31);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_physical_mem_desc_t"]
pub const ZE_STRUCTURE_TYPE_PHYSICAL_MEM_DESC: _ze_structure_type_t = _ze_structure_type_t(32);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_device_raytracing_ext_properties_t"]
pub const ZE_STRUCTURE_TYPE_DEVICE_RAYTRACING_EXT_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(65537);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_raytracing_mem_alloc_ext_desc_t"]
pub const ZE_STRUCTURE_TYPE_RAYTRACING_MEM_ALLOC_EXT_DESC: _ze_structure_type_t =
_ze_structure_type_t(65538);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_float_atomic_ext_properties_t"]
pub const ZE_STRUCTURE_TYPE_FLOAT_ATOMIC_EXT_PROPERTIES: _ze_structure_type_t =
_ze_structure_type_t(65539);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_relaxed_allocation_limits_exp_desc_t"]
pub const ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC: _ze_structure_type_t =
_ze_structure_type_t(131073);
}
impl _ze_structure_type_t {
#[doc = "< ::ze_module_program_exp_desc_t"]
pub const ZE_STRUCTURE_TYPE_MODULE_PROGRAM_EXP_DESC: _ze_structure_type_t =
_ze_structure_type_t(131074);
}
impl _ze_structure_type_t {
pub const ZE_STRUCTURE_TYPE_FORCE_UINT32: _ze_structure_type_t =
_ze_structure_type_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Defines structure types"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_structure_type_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Defines structure types"]
pub use self::_ze_structure_type_t as ze_structure_type_t;
impl _ze_external_memory_type_flags_t {
#[doc = "< an opaque POSIX file descriptor handle"]
pub const ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD: _ze_external_memory_type_flags_t =
_ze_external_memory_type_flags_t(1);
}
impl _ze_external_memory_type_flags_t {
#[doc = "< a file descriptor handle for a Linux dma_buf"]
pub const ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF: _ze_external_memory_type_flags_t =
_ze_external_memory_type_flags_t(2);
}
impl _ze_external_memory_type_flags_t {
pub const ZE_EXTERNAL_MEMORY_TYPE_FLAG_FORCE_UINT32: _ze_external_memory_type_flags_t =
_ze_external_memory_type_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_external_memory_type_flags_t> for _ze_external_memory_type_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_external_memory_type_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_external_memory_type_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_external_memory_type_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_external_memory_type_flags_t> for _ze_external_memory_type_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_external_memory_type_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_external_memory_type_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_external_memory_type_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief External memory type flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_external_memory_type_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief External memory type flags"]
pub use self::_ze_external_memory_type_flags_t as ze_external_memory_type_flags_t;
#[doc = ""]
#[doc = " @brief Base for all properties types"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_base_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_base_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_base_properties_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_base_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_base_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_base_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_base_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_base_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_base_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_base_properties_t),
"::",
stringify!(pNext)
)
);
}
impl Default for _ze_base_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = ""]
#[doc = " @brief Base for all properties types"]
pub type ze_base_properties_t = _ze_base_properties_t;
#[doc = ""]
#[doc = " @brief Base for all descriptor types"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_base_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_base_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_base_desc_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_base_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_base_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_base_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_base_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_base_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_base_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_base_desc_t),
"::",
stringify!(pNext)
)
);
}
#[doc = ""]
#[doc = " @brief Base for all descriptor types"]
pub type ze_base_desc_t = _ze_base_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_driver_uuid_t"]
pub type ze_driver_uuid_t = _ze_driver_uuid_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_driver_properties_t"]
pub type ze_driver_properties_t = _ze_driver_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_driver_ipc_properties_t"]
pub type ze_driver_ipc_properties_t = _ze_driver_ipc_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_driver_extension_properties_t"]
pub type ze_driver_extension_properties_t = _ze_driver_extension_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_uuid_t"]
pub type ze_device_uuid_t = _ze_device_uuid_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_properties_t"]
pub type ze_device_properties_t = _ze_device_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_thread_t"]
pub type ze_device_thread_t = _ze_device_thread_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_compute_properties_t"]
pub type ze_device_compute_properties_t = _ze_device_compute_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_native_kernel_uuid_t"]
pub type ze_native_kernel_uuid_t = _ze_native_kernel_uuid_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_module_properties_t"]
pub type ze_device_module_properties_t = _ze_device_module_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_command_queue_group_properties_t"]
pub type ze_command_queue_group_properties_t = _ze_command_queue_group_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_memory_properties_t"]
pub type ze_device_memory_properties_t = _ze_device_memory_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_memory_access_properties_t"]
pub type ze_device_memory_access_properties_t = _ze_device_memory_access_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_cache_properties_t"]
pub type ze_device_cache_properties_t = _ze_device_cache_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_image_properties_t"]
pub type ze_device_image_properties_t = _ze_device_image_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_external_memory_properties_t"]
pub type ze_device_external_memory_properties_t = _ze_device_external_memory_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_p2p_properties_t"]
pub type ze_device_p2p_properties_t = _ze_device_p2p_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_context_desc_t"]
pub type ze_context_desc_t = _ze_context_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_command_queue_desc_t"]
pub type ze_command_queue_desc_t = _ze_command_queue_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_command_list_desc_t"]
pub type ze_command_list_desc_t = _ze_command_list_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_copy_region_t"]
pub type ze_copy_region_t = _ze_copy_region_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_image_region_t"]
pub type ze_image_region_t = _ze_image_region_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_event_pool_desc_t"]
pub type ze_event_pool_desc_t = _ze_event_pool_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_event_desc_t"]
pub type ze_event_desc_t = _ze_event_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_kernel_timestamp_data_t"]
pub type ze_kernel_timestamp_data_t = _ze_kernel_timestamp_data_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_kernel_timestamp_result_t"]
pub type ze_kernel_timestamp_result_t = _ze_kernel_timestamp_result_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_fence_desc_t"]
pub type ze_fence_desc_t = _ze_fence_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_image_format_t"]
pub type ze_image_format_t = _ze_image_format_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_image_desc_t"]
pub type ze_image_desc_t = _ze_image_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_image_properties_t"]
pub type ze_image_properties_t = _ze_image_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_mem_alloc_desc_t"]
pub type ze_device_mem_alloc_desc_t = _ze_device_mem_alloc_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_host_mem_alloc_desc_t"]
pub type ze_host_mem_alloc_desc_t = _ze_host_mem_alloc_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_memory_allocation_properties_t"]
pub type ze_memory_allocation_properties_t = _ze_memory_allocation_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_external_memory_export_desc_t"]
pub type ze_external_memory_export_desc_t = _ze_external_memory_export_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_external_memory_import_fd_t"]
pub type ze_external_memory_import_fd_t = _ze_external_memory_import_fd_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_external_memory_export_fd_t"]
pub type ze_external_memory_export_fd_t = _ze_external_memory_export_fd_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_module_constants_t"]
pub type ze_module_constants_t = _ze_module_constants_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_module_desc_t"]
pub type ze_module_desc_t = _ze_module_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_module_properties_t"]
pub type ze_module_properties_t = _ze_module_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_kernel_desc_t"]
pub type ze_kernel_desc_t = _ze_kernel_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_kernel_uuid_t"]
pub type ze_kernel_uuid_t = _ze_kernel_uuid_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_kernel_properties_t"]
pub type ze_kernel_properties_t = _ze_kernel_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_group_count_t"]
pub type ze_group_count_t = _ze_group_count_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_module_program_exp_desc_t"]
pub type ze_module_program_exp_desc_t = _ze_module_program_exp_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_device_raytracing_ext_properties_t"]
pub type ze_device_raytracing_ext_properties_t = _ze_device_raytracing_ext_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_raytracing_mem_alloc_ext_desc_t"]
pub type ze_raytracing_mem_alloc_ext_desc_t = _ze_raytracing_mem_alloc_ext_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_sampler_desc_t"]
pub type ze_sampler_desc_t = _ze_sampler_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_physical_mem_desc_t"]
pub type ze_physical_mem_desc_t = _ze_physical_mem_desc_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_float_atomic_ext_properties_t"]
pub type ze_float_atomic_ext_properties_t = _ze_float_atomic_ext_properties_t;
#[doc = ""]
#[doc = " @brief Forward-declare ze_relaxed_allocation_limits_exp_desc_t"]
pub type ze_relaxed_allocation_limits_exp_desc_t = _ze_relaxed_allocation_limits_exp_desc_t;
impl _ze_init_flags_t {
#[doc = "< only initialize GPU drivers"]
pub const ZE_INIT_FLAG_GPU_ONLY: _ze_init_flags_t = _ze_init_flags_t(1);
}
impl _ze_init_flags_t {
pub const ZE_INIT_FLAG_FORCE_UINT32: _ze_init_flags_t = _ze_init_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_init_flags_t> for _ze_init_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_init_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_init_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_init_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_init_flags_t> for _ze_init_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_init_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_init_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_init_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported initialization flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_init_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported initialization flags"]
pub use self::_ze_init_flags_t as ze_init_flags_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Initialize the 'oneAPI' driver(s)"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must call this function before calling any other"]
#[doc = " function."]
#[doc = " - If this function is not called then all other functions will return"]
#[doc = " ::ZE_RESULT_ERROR_UNINITIALIZED."]
#[doc = " - Only one instance of each driver will be initialized per process."]
#[doc = " - The application may call this function multiple times with different"]
#[doc = " flags or environment variables enabled."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe for scenarios"]
#[doc = " where multiple libraries may initialize the driver(s) simultaneously."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
pub fn zeInit(flags: ze_init_flags_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves driver instances"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - A driver represents a collection of physical devices."]
#[doc = " - Multiple calls to this function will return identical driver handles,"]
#[doc = " in the same order."]
#[doc = " - The application may pass nullptr for pDrivers when only querying the"]
#[doc = " number of drivers."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetPlatformIDs"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDriverGet(pCount: *mut u32, phDrivers: *mut ze_driver_handle_t) -> ze_result_t;
}
impl _ze_api_version_t {
#[doc = "< version 1.0"]
pub const ZE_API_VERSION_1_0: _ze_api_version_t = _ze_api_version_t(65536);
}
impl _ze_api_version_t {
#[doc = "< version 1.1"]
pub const ZE_API_VERSION_1_1: _ze_api_version_t = _ze_api_version_t(65537);
}
impl _ze_api_version_t {
#[doc = "< latest known version"]
pub const ZE_API_VERSION_CURRENT: _ze_api_version_t = _ze_api_version_t(65537);
}
impl _ze_api_version_t {
pub const ZE_API_VERSION_FORCE_UINT32: _ze_api_version_t = _ze_api_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported API versions"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - API versions contain major and minor attributes, use"]
#[doc = " ::ZE_MAJOR_VERSION and ::ZE_MINOR_VERSION"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_api_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported API versions"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - API versions contain major and minor attributes, use"]
#[doc = " ::ZE_MAJOR_VERSION and ::ZE_MINOR_VERSION"]
pub use self::_ze_api_version_t as ze_api_version_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Returns the API version supported by the specified driver"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == version`"]
pub fn zeDriverGetApiVersion(
hDriver: ze_driver_handle_t,
version: *mut ze_api_version_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Driver universal unique id (UUID)"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_driver_uuid_t {
#[doc = "< [out] opaque data representing a driver UUID"]
pub id: [u8; 16usize],
}
#[test]
fn bindgen_test_layout__ze_driver_uuid_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_uuid_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_driver_uuid_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_uuid_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_driver_uuid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_uuid_t>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_uuid_t),
"::",
stringify!(id)
)
);
}
#[doc = ""]
#[doc = " @brief Driver properties queried using ::zeDriverGetProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] universal unique identifier."]
pub uuid: ze_driver_uuid_t,
#[doc = "< [out] driver version"]
#[doc = "< The driver version is a non-zero, monotonically increasing value where"]
#[doc = "< higher values always indicate a more recent version."]
pub driverVersion: u32,
}
#[test]
fn bindgen_test_layout__ze_driver_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_properties_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_driver_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_driver_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_properties_t>())).uuid as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_properties_t),
"::",
stringify!(uuid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_properties_t>())).driverVersion as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_properties_t),
"::",
stringify!(driverVersion)
)
);
}
impl Default for _ze_driver_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves properties of the driver."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clGetPlatformInfo**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pDriverProperties`"]
pub fn zeDriverGetProperties(
hDriver: ze_driver_handle_t,
pDriverProperties: *mut ze_driver_properties_t,
) -> ze_result_t;
}
impl _ze_ipc_property_flags_t {
#[doc = "< Supports passing memory allocations between processes. See"]
#[doc = "< ::zeMemGetIpcHandle."]
pub const ZE_IPC_PROPERTY_FLAG_MEMORY: _ze_ipc_property_flags_t = _ze_ipc_property_flags_t(1);
}
impl _ze_ipc_property_flags_t {
#[doc = "< Supports passing event pools between processes. See"]
#[doc = "< ::zeEventPoolGetIpcHandle."]
pub const ZE_IPC_PROPERTY_FLAG_EVENT_POOL: _ze_ipc_property_flags_t =
_ze_ipc_property_flags_t(2);
}
impl _ze_ipc_property_flags_t {
pub const ZE_IPC_PROPERTY_FLAG_FORCE_UINT32: _ze_ipc_property_flags_t =
_ze_ipc_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_ipc_property_flags_t> for _ze_ipc_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_ipc_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_ipc_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_ipc_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_ipc_property_flags_t> for _ze_ipc_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_ipc_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_ipc_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_ipc_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported IPC property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_ipc_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported IPC property flags"]
pub use self::_ze_ipc_property_flags_t as ze_ipc_property_flags_t;
#[doc = ""]
#[doc = " @brief IPC properties queried using ::zeDriverGetIpcProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_ipc_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of ::ze_ipc_property_flags_t"]
pub flags: ze_ipc_property_flags_t,
}
#[test]
fn bindgen_test_layout__ze_driver_ipc_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_ipc_properties_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_driver_ipc_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_ipc_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_driver_ipc_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_ipc_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_ipc_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_ipc_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_ipc_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_ipc_properties_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_ipc_properties_t),
"::",
stringify!(flags)
)
);
}
impl Default for _ze_driver_ipc_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves IPC attributes of the driver"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pIpcProperties`"]
pub fn zeDriverGetIpcProperties(
hDriver: ze_driver_handle_t,
pIpcProperties: *mut ze_driver_ipc_properties_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Extension properties queried using ::zeDriverGetExtensionProperties"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ze_driver_extension_properties_t {
#[doc = "< [out] extension name"]
pub name: [::std::os::raw::c_char; 256usize],
#[doc = "< [out] extension version using ::ZE_MAKE_VERSION"]
pub version: u32,
}
#[test]
fn bindgen_test_layout__ze_driver_extension_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_extension_properties_t>(),
260usize,
concat!("Size of: ", stringify!(_ze_driver_extension_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_extension_properties_t>(),
4usize,
concat!(
"Alignment of ",
stringify!(_ze_driver_extension_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_extension_properties_t>())).name as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_extension_properties_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_extension_properties_t>())).version as *const _
as usize
},
256usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_extension_properties_t),
"::",
stringify!(version)
)
);
}
impl Default for _ze_driver_extension_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves extension properties"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkEnumerateInstanceExtensionProperties**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDriverGetExtensionProperties(
hDriver: ze_driver_handle_t,
pCount: *mut u32,
pExtensionProperties: *mut ze_driver_extension_properties_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves function pointer for vendor-specific or experimental"]
#[doc = " extensions"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == name`"]
#[doc = " + `nullptr == ppFunctionAddress`"]
pub fn zeDriverGetExtensionFunctionAddress(
hDriver: ze_driver_handle_t,
name: *const ::std::os::raw::c_char,
ppFunctionAddress: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves devices within a driver"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Multiple calls to this function will return identical device handles,"]
#[doc = " in the same order."]
#[doc = " - The number and order of handles returned from this function is"]
#[doc = " affected by the ::ZE_AFFINITY_MASK and ::ZE_ENABLE_PCI_ID_DEVICE_ORDER"]
#[doc = " environment variables."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDeviceGet(
hDriver: ze_driver_handle_t,
pCount: *mut u32,
phDevices: *mut ze_device_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves a sub-device from a device"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Multiple calls to this function will return identical device handles,"]
#[doc = " in the same order."]
#[doc = " - The number of handles returned from this function is affected by the"]
#[doc = " ::ZE_AFFINITY_MASK environment variable."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clCreateSubDevices"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDeviceGetSubDevices(
hDevice: ze_device_handle_t,
pCount: *mut u32,
phSubdevices: *mut ze_device_handle_t,
) -> ze_result_t;
}
impl _ze_device_type_t {
#[doc = "< Graphics Processing Unit"]
pub const ZE_DEVICE_TYPE_GPU: _ze_device_type_t = _ze_device_type_t(1);
}
impl _ze_device_type_t {
#[doc = "< Central Processing Unit"]
pub const ZE_DEVICE_TYPE_CPU: _ze_device_type_t = _ze_device_type_t(2);
}
impl _ze_device_type_t {
#[doc = "< Field Programmable Gate Array"]
pub const ZE_DEVICE_TYPE_FPGA: _ze_device_type_t = _ze_device_type_t(3);
}
impl _ze_device_type_t {
#[doc = "< Memory Copy Accelerator"]
pub const ZE_DEVICE_TYPE_MCA: _ze_device_type_t = _ze_device_type_t(4);
}
impl _ze_device_type_t {
pub const ZE_DEVICE_TYPE_FORCE_UINT32: _ze_device_type_t = _ze_device_type_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported device types"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_type_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported device types"]
pub use self::_ze_device_type_t as ze_device_type_t;
#[doc = ""]
#[doc = " @brief Device universal unique id (UUID)"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_device_uuid_t {
#[doc = "< [out] opaque data representing a device UUID"]
pub id: [u8; 16usize],
}
#[test]
fn bindgen_test_layout__ze_device_uuid_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_uuid_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_device_uuid_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_uuid_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_device_uuid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_uuid_t>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_uuid_t),
"::",
stringify!(id)
)
);
}
impl _ze_device_property_flags_t {
#[doc = "< Device is integrated with the Host."]
pub const ZE_DEVICE_PROPERTY_FLAG_INTEGRATED: _ze_device_property_flags_t =
_ze_device_property_flags_t(1);
}
impl _ze_device_property_flags_t {
#[doc = "< Device handle used for query represents a sub-device."]
pub const ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE: _ze_device_property_flags_t =
_ze_device_property_flags_t(2);
}
impl _ze_device_property_flags_t {
#[doc = "< Device supports error correction memory access."]
pub const ZE_DEVICE_PROPERTY_FLAG_ECC: _ze_device_property_flags_t =
_ze_device_property_flags_t(4);
}
impl _ze_device_property_flags_t {
#[doc = "< Device supports on-demand page-faulting."]
pub const ZE_DEVICE_PROPERTY_FLAG_ONDEMANDPAGING: _ze_device_property_flags_t =
_ze_device_property_flags_t(8);
}
impl _ze_device_property_flags_t {
pub const ZE_DEVICE_PROPERTY_FLAG_FORCE_UINT32: _ze_device_property_flags_t =
_ze_device_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_property_flags_t> for _ze_device_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_property_flags_t> for _ze_device_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported device property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported device property flags"]
pub use self::_ze_device_property_flags_t as ze_device_property_flags_t;
#[doc = ""]
#[doc = " @brief Device properties queried using ::zeDeviceGetProperties"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ze_device_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] generic device type"]
pub type_: ze_device_type_t,
#[doc = "< [out] vendor id from PCI configuration"]
pub vendorId: u32,
#[doc = "< [out] device id from PCI configuration"]
pub deviceId: u32,
#[doc = "< [out] 0 (none) or a valid combination of ::ze_device_property_flags_t"]
pub flags: ze_device_property_flags_t,
#[doc = "< [out] sub-device id. Only valid if ::ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE"]
#[doc = "< is set."]
pub subdeviceId: u32,
#[doc = "< [out] Clock rate for device core."]
pub coreClockRate: u32,
#[doc = "< [out] Maximum memory allocation size."]
pub maxMemAllocSize: u64,
#[doc = "< [out] Maximum number of logical hardware contexts."]
pub maxHardwareContexts: u32,
#[doc = "< [out] Maximum priority for command queues. Higher value is higher"]
#[doc = "< priority."]
pub maxCommandQueuePriority: u32,
#[doc = "< [out] Number of threads per EU."]
pub numThreadsPerEU: u32,
#[doc = "< [out] The physical EU simd width."]
pub physicalEUSimdWidth: u32,
#[doc = "< [out] Number of EUs per sub-slice."]
pub numEUsPerSubslice: u32,
#[doc = "< [out] Number of sub-slices per slice."]
pub numSubslicesPerSlice: u32,
#[doc = "< [out] Number of slices."]
pub numSlices: u32,
#[doc = "< [out] Returns the resolution of device timer in cycles per second used"]
#[doc = "< for profiling, timestamps, etc."]
pub timerResolution: u64,
#[doc = "< [out] Returns the number of valid bits in the timestamp value."]
pub timestampValidBits: u32,
#[doc = "< [out] Returns the number of valid bits in the kernel timestamp values"]
pub kernelTimestampValidBits: u32,
#[doc = "< [out] universal unique identifier. Note: Subdevices will have their"]
#[doc = "< own uuid."]
pub uuid: ze_device_uuid_t,
#[doc = "< [out] Device name"]
pub name: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout__ze_device_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_properties_t>(),
368usize,
concat!("Size of: ", stringify!(_ze_device_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).type_ as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).vendorId as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(vendorId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).deviceId as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(deviceId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).flags as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).subdeviceId as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(subdeviceId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).coreClockRate as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(coreClockRate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).maxMemAllocSize as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(maxMemAllocSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).maxHardwareContexts as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(maxHardwareContexts)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).maxCommandQueuePriority as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(maxCommandQueuePriority)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).numThreadsPerEU as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(numThreadsPerEU)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).physicalEUSimdWidth as *const _
as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(physicalEUSimdWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).numEUsPerSubslice as *const _
as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(numEUsPerSubslice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).numSubslicesPerSlice as *const _
as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(numSubslicesPerSlice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).numSlices as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(numSlices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).timerResolution as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(timerResolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).timestampValidBits as *const _
as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(timestampValidBits)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_properties_t>())).kernelTimestampValidBits as *const _
as usize
},
92usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(kernelTimestampValidBits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).uuid as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(uuid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_properties_t>())).name as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_properties_t),
"::",
stringify!(name)
)
);
}
impl Default for _ze_device_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = ""]
#[doc = " @brief Device thread identifier."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_device_thread_t {
#[doc = "< [in,out] the slice number."]
#[doc = "< Must be UINT32_MAX (all) or less than ::ze_device_properties_t.numSlices."]
pub slice: u32,
#[doc = "< [in,out] the sub-slice number within its slice."]
#[doc = "< Must be UINT32_MAX (all) or less than ::ze_device_properties_t.numSubslicesPerSlice."]
pub subslice: u32,
#[doc = "< [in,out] the EU number within its sub-slice."]
#[doc = "< Must be UINT32_MAX (all) or less than ::ze_device_properties_t.numEUsPerSubslice."]
pub eu: u32,
#[doc = "< [in,out] the thread number within its EU."]
#[doc = "< Must be UINT32_MAX (all) or less than ::ze_device_properties_t.numThreadsPerEU."]
pub thread: u32,
}
#[test]
fn bindgen_test_layout__ze_device_thread_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_thread_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_device_thread_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_thread_t>(),
4usize,
concat!("Alignment of ", stringify!(_ze_device_thread_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_thread_t>())).slice as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_thread_t),
"::",
stringify!(slice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_thread_t>())).subslice as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_thread_t),
"::",
stringify!(subslice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_thread_t>())).eu as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_thread_t),
"::",
stringify!(eu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_thread_t>())).thread as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_thread_t),
"::",
stringify!(thread)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves properties of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetDeviceInfo"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pDeviceProperties`"]
pub fn zeDeviceGetProperties(
hDevice: ze_device_handle_t,
pDeviceProperties: *mut ze_device_properties_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Device compute properties queried using ::zeDeviceGetComputeProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_compute_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] Maximum items per compute group. (groupSizeX * groupSizeY *"]
#[doc = "< groupSizeZ) <= maxTotalGroupSize"]
pub maxTotalGroupSize: u32,
#[doc = "< [out] Maximum items for X dimension in group"]
pub maxGroupSizeX: u32,
#[doc = "< [out] Maximum items for Y dimension in group"]
pub maxGroupSizeY: u32,
#[doc = "< [out] Maximum items for Z dimension in group"]
pub maxGroupSizeZ: u32,
#[doc = "< [out] Maximum groups that can be launched for x dimension"]
pub maxGroupCountX: u32,
#[doc = "< [out] Maximum groups that can be launched for y dimension"]
pub maxGroupCountY: u32,
#[doc = "< [out] Maximum groups that can be launched for z dimension"]
pub maxGroupCountZ: u32,
#[doc = "< [out] Maximum shared local memory per group."]
pub maxSharedLocalMemory: u32,
#[doc = "< [out] Number of subgroup sizes supported. This indicates number of"]
#[doc = "< entries in subGroupSizes."]
pub numSubGroupSizes: u32,
#[doc = "< [out] Size group sizes supported."]
pub subGroupSizes: [u32; 8usize],
}
#[test]
fn bindgen_test_layout__ze_device_compute_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_compute_properties_t>(),
88usize,
concat!("Size of: ", stringify!(_ze_device_compute_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_compute_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_compute_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxTotalGroupSize
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxTotalGroupSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupSizeX as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupSizeX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupSizeY as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupSizeY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupSizeZ as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupSizeZ)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupCountX as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupCountX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupCountY as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupCountY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxGroupCountZ as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxGroupCountZ)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).maxSharedLocalMemory
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(maxSharedLocalMemory)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).numSubGroupSizes as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(numSubGroupSizes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_compute_properties_t>())).subGroupSizes as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_compute_properties_t),
"::",
stringify!(subGroupSizes)
)
);
}
impl Default for _ze_device_compute_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves compute properties of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetDeviceInfo"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pComputeProperties`"]
pub fn zeDeviceGetComputeProperties(
hDevice: ze_device_handle_t,
pComputeProperties: *mut ze_device_compute_properties_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Native kernel universal unique id (UUID)"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_native_kernel_uuid_t {
#[doc = "< [out] opaque data representing a native kernel UUID"]
pub id: [u8; 16usize],
}
#[test]
fn bindgen_test_layout__ze_native_kernel_uuid_t() {
assert_eq!(
::std::mem::size_of::<_ze_native_kernel_uuid_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_native_kernel_uuid_t))
);
assert_eq!(
::std::mem::align_of::<_ze_native_kernel_uuid_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_native_kernel_uuid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_native_kernel_uuid_t>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_native_kernel_uuid_t),
"::",
stringify!(id)
)
);
}
impl _ze_device_module_flags_t {
#[doc = "< Device supports 16-bit floating-point operations"]
pub const ZE_DEVICE_MODULE_FLAG_FP16: _ze_device_module_flags_t = _ze_device_module_flags_t(1);
}
impl _ze_device_module_flags_t {
#[doc = "< Device supports 64-bit floating-point operations"]
pub const ZE_DEVICE_MODULE_FLAG_FP64: _ze_device_module_flags_t = _ze_device_module_flags_t(2);
}
impl _ze_device_module_flags_t {
#[doc = "< Device supports 64-bit atomic operations"]
pub const ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS: _ze_device_module_flags_t =
_ze_device_module_flags_t(4);
}
impl _ze_device_module_flags_t {
#[doc = "< Device supports four component dot product and accumulate operations"]
pub const ZE_DEVICE_MODULE_FLAG_DP4A: _ze_device_module_flags_t = _ze_device_module_flags_t(8);
}
impl _ze_device_module_flags_t {
pub const ZE_DEVICE_MODULE_FLAG_FORCE_UINT32: _ze_device_module_flags_t =
_ze_device_module_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_module_flags_t> for _ze_device_module_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_module_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_module_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_module_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_module_flags_t> for _ze_device_module_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_module_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_module_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_module_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported device module flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_module_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported device module flags"]
pub use self::_ze_device_module_flags_t as ze_device_module_flags_t;
impl _ze_device_fp_flags_t {
#[doc = "< Supports denorms"]
pub const ZE_DEVICE_FP_FLAG_DENORM: _ze_device_fp_flags_t = _ze_device_fp_flags_t(1);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports INF and quiet NaNs"]
pub const ZE_DEVICE_FP_FLAG_INF_NAN: _ze_device_fp_flags_t = _ze_device_fp_flags_t(2);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports rounding to nearest even rounding mode"]
pub const ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST: _ze_device_fp_flags_t = _ze_device_fp_flags_t(4);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports rounding to zero."]
pub const ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO: _ze_device_fp_flags_t = _ze_device_fp_flags_t(8);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports rounding to both positive and negative INF."]
pub const ZE_DEVICE_FP_FLAG_ROUND_TO_INF: _ze_device_fp_flags_t = _ze_device_fp_flags_t(16);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports IEEE754-2008 fused multiply-add."]
pub const ZE_DEVICE_FP_FLAG_FMA: _ze_device_fp_flags_t = _ze_device_fp_flags_t(32);
}
impl _ze_device_fp_flags_t {
#[doc = "< Supports rounding as defined by IEEE754 for divide and sqrt"]
#[doc = "< operations."]
pub const ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT: _ze_device_fp_flags_t =
_ze_device_fp_flags_t(64);
}
impl _ze_device_fp_flags_t {
#[doc = "< Uses software implementation for basic floating-point operations."]
pub const ZE_DEVICE_FP_FLAG_SOFT_FLOAT: _ze_device_fp_flags_t = _ze_device_fp_flags_t(128);
}
impl _ze_device_fp_flags_t {
pub const ZE_DEVICE_FP_FLAG_FORCE_UINT32: _ze_device_fp_flags_t =
_ze_device_fp_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_fp_flags_t> for _ze_device_fp_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_fp_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_fp_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_fp_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_fp_flags_t> for _ze_device_fp_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_fp_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_fp_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_fp_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported floating-Point capability flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_fp_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported floating-Point capability flags"]
pub use self::_ze_device_fp_flags_t as ze_device_fp_flags_t;
#[doc = ""]
#[doc = " @brief Device module properties queried using ::zeDeviceGetModuleProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_module_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] Maximum supported SPIR-V version."]
#[doc = "< Returns zero if SPIR-V is not supported."]
#[doc = "< Contains major and minor attributes, use ::ZE_MAJOR_VERSION and ::ZE_MINOR_VERSION."]
pub spirvVersionSupported: u32,
#[doc = "< [out] 0 or a valid combination of ::ze_device_module_flags_t"]
pub flags: ze_device_module_flags_t,
#[doc = "< [out] Capabilities for half-precision floating-point operations."]
#[doc = "< returns 0 (if ::ZE_DEVICE_MODULE_FLAG_FP16 is not set) or a"]
#[doc = "< combination of ::ze_device_fp_flags_t."]
pub fp16flags: ze_device_fp_flags_t,
#[doc = "< [out] Capabilities for single-precision floating-point operations."]
#[doc = "< returns a combination of ::ze_device_fp_flags_t."]
pub fp32flags: ze_device_fp_flags_t,
#[doc = "< [out] Capabilities for double-precision floating-point operations."]
#[doc = "< returns 0 (if ::ZE_DEVICE_MODULE_FLAG_FP64 is not set) or a"]
#[doc = "< combination of ::ze_device_fp_flags_t."]
pub fp64flags: ze_device_fp_flags_t,
#[doc = "< [out] Maximum kernel argument size that is supported."]
pub maxArgumentsSize: u32,
#[doc = "< [out] Maximum size of internal buffer that holds output of printf"]
#[doc = "< calls from kernel."]
pub printfBufferSize: u32,
#[doc = "< [out] Compatibility UUID of supported native kernel."]
#[doc = "< UUID may or may not be the same across driver release, devices, or"]
#[doc = "< operating systems."]
#[doc = "< Application is responsible for ensuring UUID matches before creating"]
#[doc = "< module using"]
#[doc = "< previously created native kernel."]
pub nativeKernelSupported: ze_native_kernel_uuid_t,
}
#[test]
fn bindgen_test_layout__ze_device_module_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_module_properties_t>(),
64usize,
concat!("Size of: ", stringify!(_ze_device_module_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_module_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_module_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).spirvVersionSupported
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(spirvVersionSupported)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).flags as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).fp16flags as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(fp16flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).fp32flags as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(fp32flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).fp64flags as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(fp64flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).maxArgumentsSize as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(maxArgumentsSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).printfBufferSize as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(printfBufferSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_module_properties_t>())).nativeKernelSupported
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_module_properties_t),
"::",
stringify!(nativeKernelSupported)
)
);
}
impl Default for _ze_device_module_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves module properties of the device"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pModuleProperties`"]
pub fn zeDeviceGetModuleProperties(
hDevice: ze_device_handle_t,
pModuleProperties: *mut ze_device_module_properties_t,
) -> ze_result_t;
}
impl _ze_command_queue_group_property_flags_t {
#[doc = "< Command queue group supports enqueing compute commands."]
pub const ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE:
_ze_command_queue_group_property_flags_t = _ze_command_queue_group_property_flags_t(1);
}
impl _ze_command_queue_group_property_flags_t {
#[doc = "< Command queue group supports enqueing copy commands."]
pub const ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY: _ze_command_queue_group_property_flags_t =
_ze_command_queue_group_property_flags_t(2);
}
impl _ze_command_queue_group_property_flags_t {
#[doc = "< Command queue group supports cooperative kernels."]
#[doc = "< See ::zeCommandListAppendLaunchCooperativeKernel for more details."]
pub const ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS:
_ze_command_queue_group_property_flags_t = _ze_command_queue_group_property_flags_t(4);
}
impl _ze_command_queue_group_property_flags_t {
#[doc = "< Command queue groups supports metric queries."]
pub const ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS:
_ze_command_queue_group_property_flags_t = _ze_command_queue_group_property_flags_t(8);
}
impl _ze_command_queue_group_property_flags_t {
pub const ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_FORCE_UINT32:
_ze_command_queue_group_property_flags_t =
_ze_command_queue_group_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_command_queue_group_property_flags_t>
for _ze_command_queue_group_property_flags_t
{
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_command_queue_group_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_command_queue_group_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_command_queue_group_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_command_queue_group_property_flags_t>
for _ze_command_queue_group_property_flags_t
{
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_command_queue_group_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_command_queue_group_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_command_queue_group_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported command queue group property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_command_queue_group_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported command queue group property flags"]
pub use self::_ze_command_queue_group_property_flags_t as ze_command_queue_group_property_flags_t;
#[doc = ""]
#[doc = " @brief Command queue group properties queried using"]
#[doc = " ::zeDeviceGetCommandQueueGroupProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_group_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of"]
#[doc = "< ::ze_command_queue_group_property_flags_t"]
pub flags: ze_command_queue_group_property_flags_t,
#[doc = "< [out] maximum `pattern_size` supported by command queue group."]
#[doc = "< See ::zeCommandListAppendMemoryFill for more details."]
pub maxMemoryFillPatternSize: usize,
#[doc = "< [out] the number of physical engines within the group."]
pub numQueues: u32,
}
#[test]
fn bindgen_test_layout__ze_command_queue_group_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_group_properties_t>(),
40usize,
concat!(
"Size of: ",
stringify!(_ze_command_queue_group_properties_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_group_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_queue_group_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_group_properties_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_group_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_group_properties_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_group_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_group_properties_t>())).flags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_group_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_group_properties_t>()))
.maxMemoryFillPatternSize as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_group_properties_t),
"::",
stringify!(maxMemoryFillPatternSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_group_properties_t>())).numQueues as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_group_properties_t),
"::",
stringify!(numQueues)
)
);
}
impl Default for _ze_command_queue_group_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves command queue group properties of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Properties are reported for each physical command queue type supported"]
#[doc = " by the device."]
#[doc = " - Multiple calls to this function will return properties in the same"]
#[doc = " order."]
#[doc = " - The order in which the properties are returned defines the command"]
#[doc = " queue group's ordinal."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkGetPhysicalDeviceQueueFamilyProperties**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDeviceGetCommandQueueGroupProperties(
hDevice: ze_device_handle_t,
pCount: *mut u32,
pCommandQueueGroupProperties: *mut ze_command_queue_group_properties_t,
) -> ze_result_t;
}
impl _ze_device_memory_property_flags_t {
#[doc = "< reserved for future use"]
pub const ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD: _ze_device_memory_property_flags_t =
_ze_device_memory_property_flags_t(1);
}
impl _ze_device_memory_property_flags_t {
pub const ZE_DEVICE_MEMORY_PROPERTY_FLAG_FORCE_UINT32: _ze_device_memory_property_flags_t =
_ze_device_memory_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_memory_property_flags_t> for _ze_device_memory_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_memory_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_memory_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_memory_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_memory_property_flags_t> for _ze_device_memory_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_memory_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_memory_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_memory_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported device memory property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_memory_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported device memory property flags"]
pub use self::_ze_device_memory_property_flags_t as ze_device_memory_property_flags_t;
#[doc = ""]
#[doc = " @brief Device local memory properties queried using"]
#[doc = " ::zeDeviceGetMemoryProperties"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ze_device_memory_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of"]
#[doc = "< ::ze_device_memory_property_flags_t"]
pub flags: ze_device_memory_property_flags_t,
#[doc = "< [out] Maximum clock rate for device memory."]
pub maxClockRate: u32,
#[doc = "< [out] Maximum bus width between device and memory."]
pub maxBusWidth: u32,
#[doc = "< [out] Total memory size in bytes that is available to the device."]
pub totalSize: u64,
#[doc = "< [out] Memory name"]
pub name: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout__ze_device_memory_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_memory_properties_t>(),
296usize,
concat!("Size of: ", stringify!(_ze_device_memory_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_memory_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_memory_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).maxClockRate as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(maxClockRate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).maxBusWidth as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(maxBusWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).totalSize as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(totalSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_properties_t>())).name as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_properties_t),
"::",
stringify!(name)
)
);
}
impl Default for _ze_device_memory_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves local memory properties of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Properties are reported for each physical memory type supported by the"]
#[doc = " device."]
#[doc = " - Multiple calls to this function will return properties in the same"]
#[doc = " order."]
#[doc = " - The order in which the properties are returned defines the device's"]
#[doc = " local memory ordinal."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetDeviceInfo"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDeviceGetMemoryProperties(
hDevice: ze_device_handle_t,
pCount: *mut u32,
pMemProperties: *mut ze_device_memory_properties_t,
) -> ze_result_t;
}
impl _ze_memory_access_cap_flags_t {
#[doc = "< Supports load/store access"]
pub const ZE_MEMORY_ACCESS_CAP_FLAG_RW: _ze_memory_access_cap_flags_t =
_ze_memory_access_cap_flags_t(1);
}
impl _ze_memory_access_cap_flags_t {
#[doc = "< Supports atomic access"]
pub const ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC: _ze_memory_access_cap_flags_t =
_ze_memory_access_cap_flags_t(2);
}
impl _ze_memory_access_cap_flags_t {
#[doc = "< Supports concurrent access"]
pub const ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT: _ze_memory_access_cap_flags_t =
_ze_memory_access_cap_flags_t(4);
}
impl _ze_memory_access_cap_flags_t {
#[doc = "< Supports concurrent atomic access"]
pub const ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT_ATOMIC: _ze_memory_access_cap_flags_t =
_ze_memory_access_cap_flags_t(8);
}
impl _ze_memory_access_cap_flags_t {
pub const ZE_MEMORY_ACCESS_CAP_FLAG_FORCE_UINT32: _ze_memory_access_cap_flags_t =
_ze_memory_access_cap_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_memory_access_cap_flags_t> for _ze_memory_access_cap_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_memory_access_cap_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_memory_access_cap_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_memory_access_cap_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_memory_access_cap_flags_t> for _ze_memory_access_cap_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_memory_access_cap_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_memory_access_cap_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_memory_access_cap_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Memory access capability flags"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Supported access capabilities for different types of memory"]
#[doc = " allocations"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_memory_access_cap_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Memory access capability flags"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Supported access capabilities for different types of memory"]
#[doc = " allocations"]
pub use self::_ze_memory_access_cap_flags_t as ze_memory_access_cap_flags_t;
#[doc = ""]
#[doc = " @brief Device memory access properties queried using"]
#[doc = " ::zeDeviceGetMemoryAccessProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_memory_access_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] host memory capabilities."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_memory_access_cap_flags_t."]
pub hostAllocCapabilities: ze_memory_access_cap_flags_t,
#[doc = "< [out] device memory capabilities."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_memory_access_cap_flags_t."]
pub deviceAllocCapabilities: ze_memory_access_cap_flags_t,
#[doc = "< [out] shared, single-device memory capabilities."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_memory_access_cap_flags_t."]
pub sharedSingleDeviceAllocCapabilities: ze_memory_access_cap_flags_t,
#[doc = "< [out] shared, cross-device memory capabilities."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_memory_access_cap_flags_t."]
pub sharedCrossDeviceAllocCapabilities: ze_memory_access_cap_flags_t,
#[doc = "< [out] shared, system memory capabilities."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_memory_access_cap_flags_t."]
pub sharedSystemAllocCapabilities: ze_memory_access_cap_flags_t,
}
#[test]
fn bindgen_test_layout__ze_device_memory_access_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_memory_access_properties_t>(),
40usize,
concat!(
"Size of: ",
stringify!(_ze_device_memory_access_properties_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_memory_access_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_memory_access_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>())).hostAllocCapabilities
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(hostAllocCapabilities)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>()))
.deviceAllocCapabilities as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(deviceAllocCapabilities)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>()))
.sharedSingleDeviceAllocCapabilities as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(sharedSingleDeviceAllocCapabilities)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>()))
.sharedCrossDeviceAllocCapabilities as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(sharedCrossDeviceAllocCapabilities)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_memory_access_properties_t>()))
.sharedSystemAllocCapabilities as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_memory_access_properties_t),
"::",
stringify!(sharedSystemAllocCapabilities)
)
);
}
impl Default for _ze_device_memory_access_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves memory access properties of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetDeviceInfo"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pMemAccessProperties`"]
pub fn zeDeviceGetMemoryAccessProperties(
hDevice: ze_device_handle_t,
pMemAccessProperties: *mut ze_device_memory_access_properties_t,
) -> ze_result_t;
}
impl _ze_device_cache_property_flags_t {
#[doc = "< Device support User Cache Control (i.e. SLM section vs Generic Cache)"]
pub const ZE_DEVICE_CACHE_PROPERTY_FLAG_USER_CONTROL: _ze_device_cache_property_flags_t =
_ze_device_cache_property_flags_t(1);
}
impl _ze_device_cache_property_flags_t {
pub const ZE_DEVICE_CACHE_PROPERTY_FLAG_FORCE_UINT32: _ze_device_cache_property_flags_t =
_ze_device_cache_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_cache_property_flags_t> for _ze_device_cache_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_cache_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_cache_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_cache_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_cache_property_flags_t> for _ze_device_cache_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_cache_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_cache_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_cache_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported cache control property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_cache_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported cache control property flags"]
pub use self::_ze_device_cache_property_flags_t as ze_device_cache_property_flags_t;
#[doc = ""]
#[doc = " @brief Device cache properties queried using ::zeDeviceGetCacheProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_cache_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of"]
#[doc = "< ::ze_device_cache_property_flags_t"]
pub flags: ze_device_cache_property_flags_t,
#[doc = "< [out] Per-cache size, in bytes"]
pub cacheSize: usize,
}
#[test]
fn bindgen_test_layout__ze_device_cache_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_cache_properties_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_device_cache_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_cache_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_cache_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_cache_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_cache_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_cache_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_cache_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_cache_properties_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_cache_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_cache_properties_t>())).cacheSize as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_cache_properties_t),
"::",
stringify!(cacheSize)
)
);
}
impl Default for _ze_device_cache_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves cache properties of the device"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clGetDeviceInfo"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeDeviceGetCacheProperties(
hDevice: ze_device_handle_t,
pCount: *mut u32,
pCacheProperties: *mut ze_device_cache_properties_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Device image properties queried using ::zeDeviceGetImageProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_image_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] Maximum image dimensions for 1D resources. if 0, then 1D images"]
#[doc = "< are unsupported."]
pub maxImageDims1D: u32,
#[doc = "< [out] Maximum image dimensions for 2D resources. if 0, then 2D images"]
#[doc = "< are unsupported."]
pub maxImageDims2D: u32,
#[doc = "< [out] Maximum image dimensions for 3D resources. if 0, then 3D images"]
#[doc = "< are unsupported."]
pub maxImageDims3D: u32,
#[doc = "< [out] Maximum image buffer size in bytes. if 0, then buffer images are"]
#[doc = "< unsupported."]
pub maxImageBufferSize: u64,
#[doc = "< [out] Maximum image array slices. if 0, then image arrays are"]
#[doc = "< unsupported."]
pub maxImageArraySlices: u32,
#[doc = "< [out] Max samplers that can be used in kernel. if 0, then sampling is"]
#[doc = "< unsupported."]
pub maxSamplers: u32,
#[doc = "< [out] Returns the maximum number of simultaneous image objects that"]
#[doc = "< can be read from by a kernel. if 0, then reading images is"]
#[doc = "< unsupported."]
pub maxReadImageArgs: u32,
#[doc = "< [out] Returns the maximum number of simultaneous image objects that"]
#[doc = "< can be written to by a kernel. if 0, then writing images is"]
#[doc = "< unsupported."]
pub maxWriteImageArgs: u32,
}
#[test]
fn bindgen_test_layout__ze_device_image_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_image_properties_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_device_image_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_image_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_image_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxImageDims1D as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxImageDims1D)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxImageDims2D as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxImageDims2D)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxImageDims3D as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxImageDims3D)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxImageBufferSize as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxImageBufferSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxImageArraySlices
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxImageArraySlices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxSamplers as *const _
as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxSamplers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxReadImageArgs as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxReadImageArgs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_image_properties_t>())).maxWriteImageArgs as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_image_properties_t),
"::",
stringify!(maxWriteImageArgs)
)
);
}
impl Default for _ze_device_image_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves image properties of the device"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - See ::zeImageGetProperties for format-specific capabilities."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pImageProperties`"]
pub fn zeDeviceGetImageProperties(
hDevice: ze_device_handle_t,
pImageProperties: *mut ze_device_image_properties_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Device external memory import and export properties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_external_memory_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] Supported external memory import types for memory allocations."]
pub memoryAllocationImportTypes: ze_external_memory_type_flags_t,
#[doc = "< [out] Supported external memory export types for memory allocations."]
pub memoryAllocationExportTypes: ze_external_memory_type_flags_t,
#[doc = "< [out] Supported external memory import types for images."]
pub imageImportTypes: ze_external_memory_type_flags_t,
#[doc = "< [out] Supported external memory export types for images."]
pub imageExportTypes: ze_external_memory_type_flags_t,
}
#[test]
fn bindgen_test_layout__ze_device_external_memory_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_external_memory_properties_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_device_external_memory_properties_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_external_memory_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_external_memory_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>()))
.memoryAllocationImportTypes as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(memoryAllocationImportTypes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>()))
.memoryAllocationExportTypes as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(memoryAllocationExportTypes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>())).imageImportTypes
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(imageImportTypes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_external_memory_properties_t>())).imageExportTypes
as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_external_memory_properties_t),
"::",
stringify!(imageExportTypes)
)
);
}
impl Default for _ze_device_external_memory_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves external memory import and export of the device"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pExternalMemoryProperties`"]
pub fn zeDeviceGetExternalMemoryProperties(
hDevice: ze_device_handle_t,
pExternalMemoryProperties: *mut ze_device_external_memory_properties_t,
) -> ze_result_t;
}
impl _ze_device_p2p_property_flags_t {
#[doc = "< Device supports access between peer devices."]
pub const ZE_DEVICE_P2P_PROPERTY_FLAG_ACCESS: _ze_device_p2p_property_flags_t =
_ze_device_p2p_property_flags_t(1);
}
impl _ze_device_p2p_property_flags_t {
#[doc = "< Device supports atomics between peer devices."]
pub const ZE_DEVICE_P2P_PROPERTY_FLAG_ATOMICS: _ze_device_p2p_property_flags_t =
_ze_device_p2p_property_flags_t(2);
}
impl _ze_device_p2p_property_flags_t {
pub const ZE_DEVICE_P2P_PROPERTY_FLAG_FORCE_UINT32: _ze_device_p2p_property_flags_t =
_ze_device_p2p_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_p2p_property_flags_t> for _ze_device_p2p_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_p2p_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_p2p_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_p2p_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_p2p_property_flags_t> for _ze_device_p2p_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_p2p_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_p2p_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_p2p_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported device peer-to-peer property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_p2p_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported device peer-to-peer property flags"]
pub use self::_ze_device_p2p_property_flags_t as ze_device_p2p_property_flags_t;
#[doc = ""]
#[doc = " @brief Device peer-to-peer properties queried using"]
#[doc = " ::zeDeviceGetP2PProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_p2p_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of"]
#[doc = "< ::ze_device_p2p_property_flags_t"]
pub flags: ze_device_p2p_property_flags_t,
}
#[test]
fn bindgen_test_layout__ze_device_p2p_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_p2p_properties_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_device_p2p_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_p2p_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_p2p_properties_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_p2p_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_p2p_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_p2p_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_p2p_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_p2p_properties_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_p2p_properties_t),
"::",
stringify!(flags)
)
);
}
impl Default for _ze_device_p2p_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves peer-to-peer properties between one device and a peer"]
#[doc = " devices"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " + `nullptr == hPeerDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pP2PProperties`"]
pub fn zeDeviceGetP2PProperties(
hDevice: ze_device_handle_t,
hPeerDevice: ze_device_handle_t,
pP2PProperties: *mut ze_device_p2p_properties_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Queries if one device can directly access peer device allocations"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Any device can access any other device within a node through a"]
#[doc = " scale-up fabric."]
#[doc = " - The following are conditions for CanAccessPeer query."]
#[doc = " + If both device and peer device are the same then return true."]
#[doc = " + If both sub-device and peer sub-device are the same then return"]
#[doc = " true."]
#[doc = " + If both are sub-devices and share the same parent device then"]
#[doc = " return true."]
#[doc = " + If both device and remote device are connected by a direct or"]
#[doc = " indirect scale-up fabric or over PCIe (same root complex or shared"]
#[doc = " PCIe switch) then true."]
#[doc = " + If both sub-device and remote parent device (and vice-versa) are"]
#[doc = " connected by a direct or indirect scale-up fabric or over PCIe"]
#[doc = " (same root complex or shared PCIe switch) then true."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " + `nullptr == hPeerDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == value`"]
pub fn zeDeviceCanAccessPeer(
hDevice: ze_device_handle_t,
hPeerDevice: ze_device_handle_t,
value: *mut ze_bool_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Returns current status of the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Once a device is reset, this call will update the OS handle attached"]
#[doc = " to the device handle."]
#[doc = " - The application may call this function from simultaneous threads with"]
#[doc = " the same device handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " + Device is available for use."]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " + Device is lost; must be reset for use."]
pub fn zeDeviceGetStatus(hDevice: ze_device_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Returns synchronized Host and device global timestamps."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads with"]
#[doc = " the same device handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == hostTimestamp`"]
#[doc = " + `nullptr == deviceTimestamp`"]
pub fn zeDeviceGetGlobalTimestamps(
hDevice: ze_device_handle_t,
hostTimestamp: *mut u64,
deviceTimestamp: *mut u64,
) -> ze_result_t;
}
impl _ze_context_flags_t {
#[doc = "< reserved for future use"]
pub const ZE_CONTEXT_FLAG_TBD: _ze_context_flags_t = _ze_context_flags_t(1);
}
impl _ze_context_flags_t {
pub const ZE_CONTEXT_FLAG_FORCE_UINT32: _ze_context_flags_t = _ze_context_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_context_flags_t> for _ze_context_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_context_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_context_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_context_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_context_flags_t> for _ze_context_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_context_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_context_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_context_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported context creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_context_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported context creation flags"]
pub use self::_ze_context_flags_t as ze_context_flags_t;
#[doc = ""]
#[doc = " @brief Context descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_context_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics."]
pub flags: ze_context_flags_t,
}
#[test]
fn bindgen_test_layout__ze_context_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_context_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_context_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_context_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_context_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_context_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_desc_t),
"::",
stringify!(flags)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a context for the driver."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the context for the driver which was"]
#[doc = " provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeContextCreate(
hDriver: ze_driver_handle_t,
desc: *const ze_context_desc_t,
phContext: *mut ze_context_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a context for the driver."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the context for the driver which was"]
#[doc = " provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDriver`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phDevices) && (0 < numDevices)`"]
pub fn zeContextCreateEx(
hDriver: ze_driver_handle_t,
desc: *const ze_context_desc_t,
numDevices: u32,
phDevices: *mut ze_device_handle_t,
phContext: *mut ze_context_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys a context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the context before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same context handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeContextDestroy(hContext: ze_context_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Returns current status of the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads with"]
#[doc = " the same context handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " + Context is available for use."]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " + Context is invalid; due to device lost or reset."]
pub fn zeContextGetStatus(hContext: ze_context_handle_t) -> ze_result_t;
}
impl _ze_command_queue_flags_t {
#[doc = "< command queue should be optimized for submission to a single device engine."]
#[doc = "< driver **must** disable any implicit optimizations for distributing"]
#[doc = "< work across multiple engines."]
#[doc = "< this flag should be used when applications want full control over"]
#[doc = "< multi-engine submission and scheduling."]
pub const ZE_COMMAND_QUEUE_FLAG_EXPLICIT_ONLY: _ze_command_queue_flags_t =
_ze_command_queue_flags_t(1);
}
impl _ze_command_queue_flags_t {
pub const ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32: _ze_command_queue_flags_t =
_ze_command_queue_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_command_queue_flags_t> for _ze_command_queue_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_command_queue_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_command_queue_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_command_queue_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_command_queue_flags_t> for _ze_command_queue_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_command_queue_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_command_queue_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_command_queue_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported command queue flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_command_queue_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported command queue flags"]
pub use self::_ze_command_queue_flags_t as ze_command_queue_flags_t;
impl _ze_command_queue_mode_t {
#[doc = "< implicit default behavior; uses driver-based heuristics"]
pub const ZE_COMMAND_QUEUE_MODE_DEFAULT: _ze_command_queue_mode_t = _ze_command_queue_mode_t(0);
}
impl _ze_command_queue_mode_t {
#[doc = "< Device execution always completes immediately on execute;"]
#[doc = "< Host thread is blocked using wait on implicit synchronization object"]
pub const ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS: _ze_command_queue_mode_t =
_ze_command_queue_mode_t(1);
}
impl _ze_command_queue_mode_t {
#[doc = "< Device execution is scheduled and will complete in future;"]
#[doc = "< explicit synchronization object must be used to determine completeness"]
pub const ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS: _ze_command_queue_mode_t =
_ze_command_queue_mode_t(2);
}
impl _ze_command_queue_mode_t {
pub const ZE_COMMAND_QUEUE_MODE_FORCE_UINT32: _ze_command_queue_mode_t =
_ze_command_queue_mode_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported command queue modes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_command_queue_mode_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported command queue modes"]
pub use self::_ze_command_queue_mode_t as ze_command_queue_mode_t;
impl _ze_command_queue_priority_t {
#[doc = "< [default] normal priority"]
pub const ZE_COMMAND_QUEUE_PRIORITY_NORMAL: _ze_command_queue_priority_t =
_ze_command_queue_priority_t(0);
}
impl _ze_command_queue_priority_t {
#[doc = "< lower priority than normal"]
pub const ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_LOW: _ze_command_queue_priority_t =
_ze_command_queue_priority_t(1);
}
impl _ze_command_queue_priority_t {
#[doc = "< higher priority than normal"]
pub const ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH: _ze_command_queue_priority_t =
_ze_command_queue_priority_t(2);
}
impl _ze_command_queue_priority_t {
pub const ZE_COMMAND_QUEUE_PRIORITY_FORCE_UINT32: _ze_command_queue_priority_t =
_ze_command_queue_priority_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported command queue priorities"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_command_queue_priority_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported command queue priorities"]
pub use self::_ze_command_queue_priority_t as ze_command_queue_priority_t;
#[doc = ""]
#[doc = " @brief Command Queue descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] command queue group ordinal"]
pub ordinal: u32,
#[doc = "< [in] command queue index within the group;"]
#[doc = "< must be zero if ::ZE_COMMAND_QUEUE_FLAG_EXPLICIT_ONLY is not set"]
pub index: u32,
#[doc = "< [in] usage flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_command_queue_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics to balance"]
#[doc = "< latency and throughput."]
pub flags: ze_command_queue_flags_t,
#[doc = "< [in] operation mode"]
pub mode: ze_command_queue_mode_t,
#[doc = "< [in] priority"]
pub priority: ze_command_queue_priority_t,
}
#[test]
fn bindgen_test_layout__ze_command_queue_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_desc_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_command_queue_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_queue_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_queue_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_queue_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_desc_t>())).ordinal as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(ordinal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_queue_desc_t>())).index as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_queue_desc_t>())).flags as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_queue_desc_t>())).mode as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_desc_t>())).priority as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_desc_t),
"::",
stringify!(priority)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a command queue on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - A command queue represents a logical input stream to the device, tied"]
#[doc = " to a physical input stream."]
#[doc = " - The application must only use the command queue for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clCreateCommandQueue**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phCommandQueue`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < desc->flags`"]
#[doc = " + `::ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < desc->mode`"]
#[doc = " + `::ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < desc->priority`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeCommandQueueCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *const ze_command_queue_desc_t,
phCommandQueue: *mut ze_command_queue_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys a command queue."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must destroy all fence handles created from the"]
#[doc = " command queue before destroying the command queue itself"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the command queue before it is deleted"]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this command queue"]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command queue handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clReleaseCommandQueue**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandQueue`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeCommandQueueDestroy(hCommandQueue: ze_command_queue_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Executes a command list in a command queue."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The command lists are submitted to the device in the order they are"]
#[doc = " received, whether from multiple calls (on the same or different"]
#[doc = " threads) or a single call with multiple command lists."]
#[doc = " - The application must ensure the command lists are accessible by the"]
#[doc = " device on which the command queue was created."]
#[doc = " - The application must ensure the command lists are not currently"]
#[doc = " referencing the command list since the implementation is allowed to"]
#[doc = " modify the contents of the command list for submission."]
#[doc = " - The application must only execute command lists created with an"]
#[doc = " identical command queue group ordinal to the command queue."]
#[doc = " - The application must use a fence created using the same command queue."]
#[doc = " - The application must ensure the command queue, command list and fence"]
#[doc = " were created on the same context."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - vkQueueSubmit"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandQueue`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phCommandLists`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `0 == numCommandLists`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_COMMAND_LIST_TYPE"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeCommandQueueExecuteCommandLists(
hCommandQueue: ze_command_queue_handle_t,
numCommandLists: u32,
phCommandLists: *mut ze_command_list_handle_t,
hFence: ze_fence_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Synchronizes a command queue by waiting on the host."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandQueue`"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + timeout expired"]
pub fn zeCommandQueueSynchronize(
hCommandQueue: ze_command_queue_handle_t,
timeout: u64,
) -> ze_result_t;
}
impl _ze_command_list_flags_t {
#[doc = "< driver may reorder commands (e.g., kernels, copies) between barriers"]
#[doc = "< and synchronization primitives."]
#[doc = "< using this flag may increase Host overhead of ::zeCommandListClose."]
#[doc = "< therefore, this flag should **not** be set for low-latency usage-models."]
pub const ZE_COMMAND_LIST_FLAG_RELAXED_ORDERING: _ze_command_list_flags_t =
_ze_command_list_flags_t(1);
}
impl _ze_command_list_flags_t {
#[doc = "< driver may perform additional optimizations that increase execution"]
#[doc = "< throughput."]
#[doc = "< using this flag may increase Host overhead of ::zeCommandListClose and ::zeCommandQueueExecuteCommandLists."]
#[doc = "< therefore, this flag should **not** be set for low-latency usage-models."]
pub const ZE_COMMAND_LIST_FLAG_MAXIMIZE_THROUGHPUT: _ze_command_list_flags_t =
_ze_command_list_flags_t(2);
}
impl _ze_command_list_flags_t {
#[doc = "< command list should be optimized for submission to a single command"]
#[doc = "< queue and device engine."]
#[doc = "< driver **must** disable any implicit optimizations for distributing"]
#[doc = "< work across multiple engines."]
#[doc = "< this flag should be used when applications want full control over"]
#[doc = "< multi-engine submission and scheduling."]
pub const ZE_COMMAND_LIST_FLAG_EXPLICIT_ONLY: _ze_command_list_flags_t =
_ze_command_list_flags_t(4);
}
impl _ze_command_list_flags_t {
pub const ZE_COMMAND_LIST_FLAG_FORCE_UINT32: _ze_command_list_flags_t =
_ze_command_list_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_command_list_flags_t> for _ze_command_list_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_command_list_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_command_list_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_command_list_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_command_list_flags_t> for _ze_command_list_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_command_list_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_command_list_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_command_list_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported command list creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_command_list_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported command list creation flags"]
pub use self::_ze_command_list_flags_t as ze_command_list_flags_t;
#[doc = ""]
#[doc = " @brief Command List descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] command queue group ordinal to which this command list will be"]
#[doc = "< submitted"]
pub commandQueueGroupOrdinal: u32,
#[doc = "< [in] usage flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_command_list_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics to balance"]
#[doc = "< latency and throughput."]
pub flags: ze_command_list_flags_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_command_list_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_list_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_list_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_list_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_desc_t>())).commandQueueGroupOrdinal as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_desc_t),
"::",
stringify!(commandQueueGroupOrdinal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_command_list_desc_t>())).flags as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_desc_t),
"::",
stringify!(flags)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a command list on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - A command list represents a sequence of commands for execution on a"]
#[doc = " command queue."]
#[doc = " - The command list is created in the 'open' state."]
#[doc = " - The application must only use the command list for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x7 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeCommandListCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *const ze_command_list_desc_t,
phCommandList: *mut ze_command_list_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates an immediate command list on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - An immediate command list is used for low-latency submission of"]
#[doc = " commands."]
#[doc = " - An immediate command list creates an implicit command queue."]
#[doc = " - The command list is created in the 'open' state and never needs to be"]
#[doc = " closed."]
#[doc = " - The application must only use the command list for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == altdesc`"]
#[doc = " + `nullptr == phCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < altdesc->flags`"]
#[doc = " + `::ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < altdesc->mode`"]
#[doc = " + `::ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < altdesc->priority`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeCommandListCreateImmediate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
altdesc: *const ze_command_queue_desc_t,
phCommandList: *mut ze_command_list_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the command list before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this command list."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeCommandListDestroy(hCommandList: ze_command_list_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Closes a command list; ready to be executed by a command queue."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
pub fn zeCommandListClose(hCommandList: ze_command_list_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Reset a command list to initial (empty) state; ready for appending"]
#[doc = " commands."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the command list before it is reset"]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
pub fn zeCommandListReset(hCommandList: ze_command_list_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends a memory write of the device's global timestamp value into a"]
#[doc = " command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The timestamp frequency can be queried from"]
#[doc = " ::ze_device_properties_t.timerResolution."]
#[doc = " - The number of valid bits in the timestamp value can be queried from"]
#[doc = " ::ze_device_properties_t.timestampValidBits."]
#[doc = " - The application must ensure the memory pointed to by dstptr is"]
#[doc = " accessible by the device on which the command list was created."]
#[doc = " - The application must ensure the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendWriteGlobalTimestamp(
hCommandList: ze_command_list_handle_t,
dstptr: *mut u64,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends an execution and global memory barrier into a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - If numWaitEvents is zero, then all previous commands are completed"]
#[doc = " prior to the execution of the barrier."]
#[doc = " - If numWaitEvents is non-zero, then then all phWaitEvents must be"]
#[doc = " signaled prior to the execution of the barrier."]
#[doc = " - This command blocks all following commands from beginning until the"]
#[doc = " execution of the barrier completes."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkCmdPipelineBarrier**"]
#[doc = " - clEnqueueBarrierWithWaitList"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendBarrier(
hCommandList: ze_command_list_handle_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends a global memory ranges barrier into a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - If numWaitEvents is zero, then all previous commands are completed"]
#[doc = " prior to the execution of the barrier."]
#[doc = " - If numWaitEvents is non-zero, then then all phWaitEvents must be"]
#[doc = " signaled prior to the execution of the barrier."]
#[doc = " - This command blocks all following commands from beginning until the"]
#[doc = " execution of the barrier completes."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pRangeSizes`"]
#[doc = " + `nullptr == pRanges`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendMemoryRangesBarrier(
hCommandList: ze_command_list_handle_t,
numRanges: u32,
pRangeSizes: *const usize,
pRanges: *mut *const ::std::os::raw::c_void,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Ensures in-bound writes to the device are globally observable."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This is a special-case system level barrier that can be used to ensure"]
#[doc = " global observability of writes;"]
#[doc = " typically needed after a producer (e.g., NIC) performs direct writes"]
#[doc = " to the device's memory (e.g., Direct RDMA writes)."]
#[doc = " This is typically required when the memory corresponding to the writes"]
#[doc = " is subsequently accessed from a remote device."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
pub fn zeContextSystemBarrier(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies host, device, or shared memory."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory pointed to by dstptr and srcptr"]
#[doc = " is accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by dstptr and"]
#[doc = " srcptr as they are free to be modified by either the Host or device up"]
#[doc = " until execution."]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clEnqueueCopyBuffer**"]
#[doc = " - **clEnqueueReadBuffer**"]
#[doc = " - **clEnqueueWriteBuffer**"]
#[doc = " - **clEnqueueSVMMemcpy**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " + `nullptr == srcptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendMemoryCopy(
hCommandList: ze_command_list_handle_t,
dstptr: *mut ::std::os::raw::c_void,
srcptr: *const ::std::os::raw::c_void,
size: usize,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Initializes host, device, or shared memory."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory pointed to by dstptr is"]
#[doc = " accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by dstptr as"]
#[doc = " it is free to be modified by either the Host or device up until"]
#[doc = " execution."]
#[doc = " - The value to initialize memory to is described by the pattern and the"]
#[doc = " pattern size."]
#[doc = " - The pattern size must be a power-of-two and less than"]
#[doc = " ::ze_command_queue_group_properties_t.maxMemoryFillPatternSize."]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must enusre the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clEnqueueFillBuffer**"]
#[doc = " - **clEnqueueSVMMemFill**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " + `nullptr == pattern`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendMemoryFill(
hCommandList: ze_command_list_handle_t,
ptr: *mut ::std::os::raw::c_void,
pattern: *const ::std::os::raw::c_void,
pattern_size: usize,
size: usize,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Copy region descriptor"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_copy_region_t {
#[doc = "< [in] The origin x offset for region in bytes"]
pub originX: u32,
#[doc = "< [in] The origin y offset for region in rows"]
pub originY: u32,
#[doc = "< [in] The origin z offset for region in slices"]
pub originZ: u32,
#[doc = "< [in] The region width relative to origin in bytes"]
pub width: u32,
#[doc = "< [in] The region height relative to origin in rows"]
pub height: u32,
#[doc = "< [in] The region depth relative to origin in slices. Set this to 0 for"]
#[doc = "< 2D copy."]
pub depth: u32,
}
#[test]
fn bindgen_test_layout__ze_copy_region_t() {
assert_eq!(
::std::mem::size_of::<_ze_copy_region_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_copy_region_t))
);
assert_eq!(
::std::mem::align_of::<_ze_copy_region_t>(),
4usize,
concat!("Alignment of ", stringify!(_ze_copy_region_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).originX as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(originX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).originY as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(originY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).originZ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(originZ)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).width as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).height as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_copy_region_t>())).depth as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_copy_region_t),
"::",
stringify!(depth)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies a region from a 2D or 3D array of host, device, or shared"]
#[doc = " memory."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory pointed to by dstptr and srcptr"]
#[doc = " is accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by dstptr and"]
#[doc = " srcptr as they are free to be modified by either the Host or device up"]
#[doc = " until execution."]
#[doc = " - The region width, height, and depth for both src and dst must be same."]
#[doc = " The origins can be different."]
#[doc = " - The src and dst regions cannot be overlapping."]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " + `nullptr == dstRegion`"]
#[doc = " + `nullptr == srcptr`"]
#[doc = " + `nullptr == srcRegion`"]
#[doc = " - ::ZE_RESULT_ERROR_OVERLAPPING_REGIONS"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendMemoryCopyRegion(
hCommandList: ze_command_list_handle_t,
dstptr: *mut ::std::os::raw::c_void,
dstRegion: *const ze_copy_region_t,
dstPitch: u32,
dstSlicePitch: u32,
srcptr: *const ::std::os::raw::c_void,
srcRegion: *const ze_copy_region_t,
srcPitch: u32,
srcSlicePitch: u32,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies host, device, or shared memory from another context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The current active and source context must be from the same driver."]
#[doc = " - The application must ensure the memory pointed to by dstptr and srcptr"]
#[doc = " is accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by dstptr and"]
#[doc = " srcptr as they are free to be modified by either the Host or device up"]
#[doc = " until execution."]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hContextSrc`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " + `nullptr == srcptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendMemoryCopyFromContext(
hCommandList: ze_command_list_handle_t,
dstptr: *mut ::std::os::raw::c_void,
hContextSrc: ze_context_handle_t,
srcptr: *const ::std::os::raw::c_void,
size: usize,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies an image."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the image and events are accessible by the"]
#[doc = " device on which the command list was created."]
#[doc = " - The application must ensure the image format descriptors for both"]
#[doc = " source and destination images are the same."]
#[doc = " - The application must ensure the command list, images and events were"]
#[doc = " created on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clEnqueueCopyImage**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hDstImage`"]
#[doc = " + `nullptr == hSrcImage`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendImageCopy(
hCommandList: ze_command_list_handle_t,
hDstImage: ze_image_handle_t,
hSrcImage: ze_image_handle_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Region descriptor"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_image_region_t {
#[doc = "< [in] The origin x offset for region in pixels"]
pub originX: u32,
#[doc = "< [in] The origin y offset for region in pixels"]
pub originY: u32,
#[doc = "< [in] The origin z offset for region in pixels"]
pub originZ: u32,
#[doc = "< [in] The region width relative to origin in pixels"]
pub width: u32,
#[doc = "< [in] The region height relative to origin in pixels"]
pub height: u32,
#[doc = "< [in] The region depth relative to origin. For 1D or 2D images, set"]
#[doc = "< this to 1."]
pub depth: u32,
}
#[test]
fn bindgen_test_layout__ze_image_region_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_region_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_image_region_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_region_t>(),
4usize,
concat!("Alignment of ", stringify!(_ze_image_region_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).originX as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(originX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).originY as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(originY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).originZ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(originZ)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).width as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).height as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_region_t>())).depth as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_region_t),
"::",
stringify!(depth)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies a region of an image to another image."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the image and events are accessible by the"]
#[doc = " device on which the command list was created."]
#[doc = " - The region width and height for both src and dst must be same. The"]
#[doc = " origins can be different."]
#[doc = " - The src and dst regions cannot be overlapping."]
#[doc = " - The application must ensure the image format descriptors for both"]
#[doc = " source and destination images are the same."]
#[doc = " - The application must ensure the command list, images and events were"]
#[doc = " created, and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hDstImage`"]
#[doc = " + `nullptr == hSrcImage`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_OVERLAPPING_REGIONS"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendImageCopyRegion(
hCommandList: ze_command_list_handle_t,
hDstImage: ze_image_handle_t,
hSrcImage: ze_image_handle_t,
pDstRegion: *const ze_image_region_t,
pSrcRegion: *const ze_image_region_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies from an image to device or shared memory."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory pointed to by dstptr is"]
#[doc = " accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by dstptr as"]
#[doc = " it is free to be modified by either the Host or device up until"]
#[doc = " execution."]
#[doc = " - The application must ensure the image and events are accessible by the"]
#[doc = " device on which the command list was created."]
#[doc = " - The application must ensure the image format descriptor for the source"]
#[doc = " image is not a media format."]
#[doc = " - The application must ensure the command list, image and events were"]
#[doc = " created, and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clEnqueueReadImage"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hSrcImage`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendImageCopyToMemory(
hCommandList: ze_command_list_handle_t,
dstptr: *mut ::std::os::raw::c_void,
hSrcImage: ze_image_handle_t,
pSrcRegion: *const ze_image_region_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Copies to an image from device or shared memory."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory pointed to by srcptr is"]
#[doc = " accessible by the device on which the command list was created."]
#[doc = " - The implementation must not access the memory pointed to by srcptr as"]
#[doc = " it is free to be modified by either the Host or device up until"]
#[doc = " execution."]
#[doc = " - The application must ensure the image and events are accessible by the"]
#[doc = " device on which the command list was created."]
#[doc = " - The application must ensure the image format descriptor for the"]
#[doc = " destination image is not a media format."]
#[doc = " - The application must ensure the command list, image and events were"]
#[doc = " created, and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clEnqueueWriteImage"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hDstImage`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == srcptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendImageCopyFromMemory(
hCommandList: ze_command_list_handle_t,
hDstImage: ze_image_handle_t,
srcptr: *const ::std::os::raw::c_void,
pDstRegion: *const ze_image_region_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Asynchronously prefetches shared memory to the device associated with"]
#[doc = " the specified command list"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This is a hint to improve performance only and is not required for"]
#[doc = " correctness."]
#[doc = " - Only prefetching to the device associated with the specified command"]
#[doc = " list is supported."]
#[doc = " Prefetching to the host or to a peer device is not supported."]
#[doc = " - Prefetching may not be supported for all allocation types for all devices."]
#[doc = " If memory prefetching is not supported for the specified memory range"]
#[doc = " the prefetch hint may be ignored."]
#[doc = " - Prefetching may only be supported at a device-specific granularity,"]
#[doc = " such as at a page boundary."]
#[doc = " In this case, the memory range may be expanded such that the start and"]
#[doc = " end of the range satisfy granularity requirements."]
#[doc = " - The application must ensure the memory pointed to by ptr is accessible"]
#[doc = " by the device on which the command list was created."]
#[doc = " - The application must ensure the command list was created, and the"]
#[doc = " memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clEnqueueSVMMigrateMem"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
pub fn zeCommandListAppendMemoryPrefetch(
hCommandList: ze_command_list_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
) -> ze_result_t;
}
impl _ze_memory_advice_t {
#[doc = "< hint that memory will be read from frequently and written to rarely"]
pub const ZE_MEMORY_ADVICE_SET_READ_MOSTLY: _ze_memory_advice_t = _ze_memory_advice_t(0);
}
impl _ze_memory_advice_t {
#[doc = "< removes the affect of ::ZE_MEMORY_ADVICE_SET_READ_MOSTLY"]
pub const ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY: _ze_memory_advice_t = _ze_memory_advice_t(1);
}
impl _ze_memory_advice_t {
#[doc = "< hint that the preferred memory location is the specified device"]
pub const ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION: _ze_memory_advice_t = _ze_memory_advice_t(2);
}
impl _ze_memory_advice_t {
#[doc = "< removes the affect of ::ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION"]
pub const ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION: _ze_memory_advice_t =
_ze_memory_advice_t(3);
}
impl _ze_memory_advice_t {
#[doc = "< hints that memory will mostly be accessed non-atomically"]
pub const ZE_MEMORY_ADVICE_SET_NON_ATOMIC_MOSTLY: _ze_memory_advice_t = _ze_memory_advice_t(4);
}
impl _ze_memory_advice_t {
#[doc = "< removes the affect of ::ZE_MEMORY_ADVICE_SET_NON_ATOMIC_MOSTLY"]
pub const ZE_MEMORY_ADVICE_CLEAR_NON_ATOMIC_MOSTLY: _ze_memory_advice_t =
_ze_memory_advice_t(5);
}
impl _ze_memory_advice_t {
#[doc = "< hints that memory should be cached"]
pub const ZE_MEMORY_ADVICE_BIAS_CACHED: _ze_memory_advice_t = _ze_memory_advice_t(6);
}
impl _ze_memory_advice_t {
#[doc = "< hints that memory should be not be cached"]
pub const ZE_MEMORY_ADVICE_BIAS_UNCACHED: _ze_memory_advice_t = _ze_memory_advice_t(7);
}
impl _ze_memory_advice_t {
pub const ZE_MEMORY_ADVICE_FORCE_UINT32: _ze_memory_advice_t = _ze_memory_advice_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported memory advice hints"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_memory_advice_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported memory advice hints"]
pub use self::_ze_memory_advice_t as ze_memory_advice_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Provides advice about the use of a shared memory range"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Memory advice is a performance hint only and is not required for"]
#[doc = " functional correctness."]
#[doc = " - Memory advice can be used to override driver heuristics to explicitly"]
#[doc = " control shared memory behavior."]
#[doc = " - Not all memory advice hints may be supported for all allocation types"]
#[doc = " for all devices."]
#[doc = " If a memory advice hint is not supported by the device it will be ignored."]
#[doc = " - Memory advice may only be supported at a device-specific granularity,"]
#[doc = " such as at a page boundary."]
#[doc = " In this case, the memory range may be expanded such that the start and"]
#[doc = " end of the range satisfy granularity requirements."]
#[doc = " - The application must ensure the memory pointed to by ptr is accessible"]
#[doc = " by the device on which the command list was created."]
#[doc = " - The application must ensure the command list was created, and memory"]
#[doc = " was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle, and the memory was"]
#[doc = " allocated."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `::ZE_MEMORY_ADVICE_BIAS_UNCACHED < advice`"]
pub fn zeCommandListAppendMemAdvise(
hCommandList: ze_command_list_handle_t,
hDevice: ze_device_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
advice: ze_memory_advice_t,
) -> ze_result_t;
}
impl _ze_event_pool_flags_t {
#[doc = "< signals and waits are also visible to host"]
pub const ZE_EVENT_POOL_FLAG_HOST_VISIBLE: _ze_event_pool_flags_t = _ze_event_pool_flags_t(1);
}
impl _ze_event_pool_flags_t {
#[doc = "< signals and waits may be shared across processes"]
pub const ZE_EVENT_POOL_FLAG_IPC: _ze_event_pool_flags_t = _ze_event_pool_flags_t(2);
}
impl _ze_event_pool_flags_t {
#[doc = "< Indicates all events in pool will contain kernel timestamps; cannot be"]
#[doc = "< combined with ::ZE_EVENT_POOL_FLAG_IPC"]
pub const ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP: _ze_event_pool_flags_t =
_ze_event_pool_flags_t(4);
}
impl _ze_event_pool_flags_t {
pub const ZE_EVENT_POOL_FLAG_FORCE_UINT32: _ze_event_pool_flags_t =
_ze_event_pool_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_event_pool_flags_t> for _ze_event_pool_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_event_pool_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_event_pool_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_event_pool_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_event_pool_flags_t> for _ze_event_pool_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_event_pool_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_event_pool_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_event_pool_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported event pool creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_event_pool_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported event pool creation flags"]
pub use self::_ze_event_pool_flags_t as ze_event_pool_flags_t;
#[doc = ""]
#[doc = " @brief Event pool descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_event_pool_flags_t;"]
#[doc = "< default behavior is signals and waits are visible to the entire device"]
#[doc = "< and peer devices."]
pub flags: ze_event_pool_flags_t,
#[doc = "< [in] number of events within the pool; must be greater than 0"]
pub count: u32,
}
#[test]
fn bindgen_test_layout__ze_event_pool_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_event_pool_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_pool_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_pool_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_pool_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_pool_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_pool_desc_t>())).count as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_desc_t),
"::",
stringify!(count)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a pool of events on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use events within the pool for the"]
#[doc = " device(s), or their sub-devices, which were provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phEventPool`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x7 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `0 == desc->count`"]
#[doc = " + `(nullptr == phDevices) && (0 < numDevices)`"]
pub fn zeEventPoolCreate(
hContext: ze_context_handle_t,
desc: *const ze_event_pool_desc_t,
numDevices: u32,
phDevices: *mut ze_device_handle_t,
phEventPool: *mut ze_event_pool_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Deletes an event pool object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must destroy all event handles created from the pool"]
#[doc = " before destroying the pool itself."]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the any event within the pool before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this event pool."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same event pool handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEventPool`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeEventPoolDestroy(hEventPool: ze_event_pool_handle_t) -> ze_result_t;
}
impl _ze_event_scope_flags_t {
#[doc = "< cache hierarchies are flushed or invalidated sufficient for local"]
#[doc = "< sub-device access"]
pub const ZE_EVENT_SCOPE_FLAG_SUBDEVICE: _ze_event_scope_flags_t = _ze_event_scope_flags_t(1);
}
impl _ze_event_scope_flags_t {
#[doc = "< cache hierarchies are flushed or invalidated sufficient for global"]
#[doc = "< device access and peer device access"]
pub const ZE_EVENT_SCOPE_FLAG_DEVICE: _ze_event_scope_flags_t = _ze_event_scope_flags_t(2);
}
impl _ze_event_scope_flags_t {
#[doc = "< cache hierarchies are flushed or invalidated sufficient for device and"]
#[doc = "< host access"]
pub const ZE_EVENT_SCOPE_FLAG_HOST: _ze_event_scope_flags_t = _ze_event_scope_flags_t(4);
}
impl _ze_event_scope_flags_t {
pub const ZE_EVENT_SCOPE_FLAG_FORCE_UINT32: _ze_event_scope_flags_t =
_ze_event_scope_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_event_scope_flags_t> for _ze_event_scope_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_event_scope_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_event_scope_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_event_scope_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_event_scope_flags_t> for _ze_event_scope_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_event_scope_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_event_scope_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_event_scope_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported event scope flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_event_scope_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported event scope flags"]
pub use self::_ze_event_scope_flags_t as ze_event_scope_flags_t;
#[doc = ""]
#[doc = " @brief Event descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] index of the event within the pool; must be less-than the count"]
#[doc = "< specified during pool creation"]
pub index: u32,
#[doc = "< [in] defines the scope of relevant cache hierarchies to flush on a"]
#[doc = "< signal action before the event is triggered."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_event_scope_flags_t;"]
#[doc = "< default behavior is synchronization within the command list only, no"]
#[doc = "< additional cache hierarchies are flushed."]
pub signal: ze_event_scope_flags_t,
#[doc = "< [in] defines the scope of relevant cache hierarchies to invalidate on"]
#[doc = "< a wait action after the event is complete."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_event_scope_flags_t;"]
#[doc = "< default behavior is synchronization within the command list only, no"]
#[doc = "< additional cache hierarchies are invalidated."]
pub wait: ze_event_scope_flags_t,
}
#[test]
fn bindgen_test_layout__ze_event_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_desc_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_event_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_desc_t>())).index as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_desc_t),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_desc_t>())).signal as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_desc_t),
"::",
stringify!(signal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_desc_t>())).wait as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_desc_t),
"::",
stringify!(wait)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates an event from the pool."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - An event is used to communicate fine-grain host-to-device,"]
#[doc = " device-to-host or device-to-device dependencies have completed."]
#[doc = " - The application must ensure the location in the pool is not being used"]
#[doc = " by another event."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same event pool handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clCreateUserEvent**"]
#[doc = " - vkCreateEvent"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEventPool`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x7 < desc->signal`"]
#[doc = " + `0x7 < desc->wait`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
pub fn zeEventCreate(
hEventPool: ze_event_pool_handle_t,
desc: *const ze_event_desc_t,
phEvent: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Deletes an event object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the event before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this event."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same event handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clReleaseEvent**"]
#[doc = " - vkDestroyEvent"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeEventDestroy(hEvent: ze_event_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Gets an IPC event pool handle for the specified event handle that can"]
#[doc = " be shared with another process."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Event pool must have been created with ::ZE_EVENT_POOL_FLAG_IPC."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEventPool`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phIpc`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeEventPoolGetIpcHandle(
hEventPool: ze_event_pool_handle_t,
phIpc: *mut ze_ipc_event_pool_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Opens an IPC event pool handle to retrieve an event pool handle from"]
#[doc = " another process."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Multiple calls to this function with the same IPC handle will return"]
#[doc = " unique event pool handles."]
#[doc = " - The event handle in this process should not be freed with"]
#[doc = " ::zeEventPoolDestroy, but rather with ::zeEventPoolCloseIpcHandle."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phEventPool`"]
pub fn zeEventPoolOpenIpcHandle(
hContext: ze_context_handle_t,
hIpc: ze_ipc_event_pool_handle_t,
phEventPool: *mut ze_event_pool_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Closes an IPC event handle in the current process."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Closes an IPC event handle by destroying events that were opened in"]
#[doc = " this process using ::zeEventPoolOpenIpcHandle."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same event pool handle."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEventPool`"]
pub fn zeEventPoolCloseIpcHandle(hEventPool: ze_event_pool_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends a signal of the event from the device into a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The duration of an event created from an event pool that was created"]
#[doc = " using ::ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined."]
#[doc = " However, for consistency and orthogonality the event will report"]
#[doc = " correctly as signaled when used by other event API functionality."]
#[doc = " - The application must ensure the command list and events were created"]
#[doc = " on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clSetUserEventStatus**"]
#[doc = " - vkCmdSetEvent"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeCommandListAppendSignalEvent(
hCommandList: ze_command_list_handle_t,
hEvent: ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends wait on event(s) on the device into a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the command list and events were created"]
#[doc = " on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phEvents`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeCommandListAppendWaitOnEvents(
hCommandList: ze_command_list_handle_t,
numEvents: u32,
phEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Signals a event from host."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The duration of an event created from an event pool that was created"]
#[doc = " using ::ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined."]
#[doc = " However, for consistency and orthogonality the event will report"]
#[doc = " correctly as signaled when used by other event API functionality."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clSetUserEventStatus"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeEventHostSignal(hEvent: ze_event_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief The current host thread waits on an event to be signaled."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clWaitForEvents"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + timeout expired"]
pub fn zeEventHostSynchronize(hEvent: ze_event_handle_t, timeout: u64) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Queries an event object's status on the host."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **clGetEventInfo**"]
#[doc = " - vkGetEventStatus"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + not signaled"]
pub fn zeEventQueryStatus(hEvent: ze_event_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends a reset of an event back to not signaled state into a command"]
#[doc = " list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the command list and events were created"]
#[doc = " on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - vkResetEvent"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeCommandListAppendEventReset(
hCommandList: ze_command_list_handle_t,
hEvent: ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief The current host thread resets an event back to not signaled state."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - vkResetEvent"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
pub fn zeEventHostReset(hEvent: ze_event_handle_t) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Kernel timestamp clock data"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The timestamp frequency can be queried from"]
#[doc = " ::ze_device_properties_t.timerResolution."]
#[doc = " - The number of valid bits in the timestamp value can be queried from"]
#[doc = " ::ze_device_properties_t.kernelTimestampValidBits."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_kernel_timestamp_data_t {
#[doc = "< [out] device clock at start of kernel execution"]
pub kernelStart: u64,
#[doc = "< [out] device clock at end of kernel execution"]
pub kernelEnd: u64,
}
#[test]
fn bindgen_test_layout__ze_kernel_timestamp_data_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_timestamp_data_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_kernel_timestamp_data_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_timestamp_data_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_timestamp_data_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_timestamp_data_t>())).kernelStart as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_timestamp_data_t),
"::",
stringify!(kernelStart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_timestamp_data_t>())).kernelEnd as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_timestamp_data_t),
"::",
stringify!(kernelEnd)
)
);
}
#[doc = ""]
#[doc = " @brief Kernel timestamp result"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_kernel_timestamp_result_t {
#[doc = "< [out] wall-clock data"]
pub global: ze_kernel_timestamp_data_t,
#[doc = "< [out] context-active data; only includes clocks while device context"]
#[doc = "< was actively executing."]
pub context: ze_kernel_timestamp_data_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_timestamp_result_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_timestamp_result_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_kernel_timestamp_result_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_timestamp_result_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_timestamp_result_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_timestamp_result_t>())).global as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_timestamp_result_t),
"::",
stringify!(global)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_timestamp_result_t>())).context as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_timestamp_result_t),
"::",
stringify!(context)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Queries an event's timestamp value on the host."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the event was created from an event pool"]
#[doc = " that was created using ::ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag."]
#[doc = " - The destination memory will be unmodified if the event has not been"]
#[doc = " signaled."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hEvent`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + not signaled"]
pub fn zeEventQueryKernelTimestamp(
hEvent: ze_event_handle_t,
dstptr: *mut ze_kernel_timestamp_result_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Appends a query of an events' timestamp value(s) into a command list."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the events are accessible by the device on"]
#[doc = " which the command list was created."]
#[doc = " - The application must ensure the events were created from an event pool"]
#[doc = " that was created using ::ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag."]
#[doc = " - The application must ensure the memory pointed to by both dstptr and"]
#[doc = " pOffsets is accessible by the device on which the command list was"]
#[doc = " created."]
#[doc = " - The value(s) written to the destination buffer are undefined if any"]
#[doc = " timestamp event has not been signaled."]
#[doc = " - If pOffsets is nullptr, then multiple results will be appended"]
#[doc = " sequentially into memory in the same order as phEvents."]
#[doc = " - The application must ensure the command list and events were created,"]
#[doc = " and the memory was allocated, on the same context."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phEvents`"]
#[doc = " + `nullptr == dstptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendQueryKernelTimestamps(
hCommandList: ze_command_list_handle_t,
numEvents: u32,
phEvents: *mut ze_event_handle_t,
dstptr: *mut ::std::os::raw::c_void,
pOffsets: *const usize,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
impl _ze_fence_flags_t {
#[doc = "< fence is created in the signaled state, otherwise not signaled."]
pub const ZE_FENCE_FLAG_SIGNALED: _ze_fence_flags_t = _ze_fence_flags_t(1);
}
impl _ze_fence_flags_t {
pub const ZE_FENCE_FLAG_FORCE_UINT32: _ze_fence_flags_t = _ze_fence_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_fence_flags_t> for _ze_fence_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_fence_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_fence_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_fence_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_fence_flags_t> for _ze_fence_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_fence_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_fence_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_fence_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported fence creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_fence_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported fence creation flags"]
pub use self::_ze_fence_flags_t as ze_fence_flags_t;
#[doc = ""]
#[doc = " @brief Fence descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_fence_flags_t."]
pub flags: ze_fence_flags_t,
}
#[test]
fn bindgen_test_layout__ze_fence_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_fence_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_fence_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_fence_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_fence_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_desc_t),
"::",
stringify!(flags)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a fence for the command queue."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - A fence is a heavyweight synchronization primitive used to communicate"]
#[doc = " to the host that command list execution has completed."]
#[doc = " - The application must only use the fence for the command queue which"]
#[doc = " was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkCreateFence**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandQueue`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phFence`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeFenceCreate(
hCommandQueue: ze_command_queue_handle_t,
desc: *const ze_fence_desc_t,
phFence: *mut ze_fence_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Deletes a fence object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the fence before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this fence."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same fence handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkDestroyFence**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hFence`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeFenceDestroy(hFence: ze_fence_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief The current host thread waits on a fence to be signaled."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkWaitForFences**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hFence`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + timeout expired"]
pub fn zeFenceHostSynchronize(hFence: ze_fence_handle_t, timeout: u64) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Queries a fence object's status."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkGetFenceStatus**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hFence`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_NOT_READY"]
#[doc = " + not signaled"]
pub fn zeFenceQueryStatus(hFence: ze_fence_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Reset a fence back to the not signaled state."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - **vkResetFences**"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hFence`"]
pub fn zeFenceReset(hFence: ze_fence_handle_t) -> ze_result_t;
}
impl _ze_image_flags_t {
#[doc = "< kernels will write contents"]
pub const ZE_IMAGE_FLAG_KERNEL_WRITE: _ze_image_flags_t = _ze_image_flags_t(1);
}
impl _ze_image_flags_t {
#[doc = "< device should not cache contents"]
pub const ZE_IMAGE_FLAG_BIAS_UNCACHED: _ze_image_flags_t = _ze_image_flags_t(2);
}
impl _ze_image_flags_t {
pub const ZE_IMAGE_FLAG_FORCE_UINT32: _ze_image_flags_t = _ze_image_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_image_flags_t> for _ze_image_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_image_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_image_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_image_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_image_flags_t> for _ze_image_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_image_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_image_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_image_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported image creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported image creation flags"]
pub use self::_ze_image_flags_t as ze_image_flags_t;
impl _ze_image_type_t {
#[doc = "< 1D"]
pub const ZE_IMAGE_TYPE_1D: _ze_image_type_t = _ze_image_type_t(0);
}
impl _ze_image_type_t {
#[doc = "< 1D array"]
pub const ZE_IMAGE_TYPE_1DARRAY: _ze_image_type_t = _ze_image_type_t(1);
}
impl _ze_image_type_t {
#[doc = "< 2D"]
pub const ZE_IMAGE_TYPE_2D: _ze_image_type_t = _ze_image_type_t(2);
}
impl _ze_image_type_t {
#[doc = "< 2D array"]
pub const ZE_IMAGE_TYPE_2DARRAY: _ze_image_type_t = _ze_image_type_t(3);
}
impl _ze_image_type_t {
#[doc = "< 3D"]
pub const ZE_IMAGE_TYPE_3D: _ze_image_type_t = _ze_image_type_t(4);
}
impl _ze_image_type_t {
#[doc = "< Buffer"]
pub const ZE_IMAGE_TYPE_BUFFER: _ze_image_type_t = _ze_image_type_t(5);
}
impl _ze_image_type_t {
pub const ZE_IMAGE_TYPE_FORCE_UINT32: _ze_image_type_t = _ze_image_type_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported image types"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_type_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported image types"]
pub use self::_ze_image_type_t as ze_image_type_t;
impl _ze_image_format_layout_t {
#[doc = "< 8-bit single component layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_8: _ze_image_format_layout_t = _ze_image_format_layout_t(0);
}
impl _ze_image_format_layout_t {
#[doc = "< 16-bit single component layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_16: _ze_image_format_layout_t = _ze_image_format_layout_t(1);
}
impl _ze_image_format_layout_t {
#[doc = "< 32-bit single component layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_32: _ze_image_format_layout_t = _ze_image_format_layout_t(2);
}
impl _ze_image_format_layout_t {
#[doc = "< 2-component 8-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_8_8: _ze_image_format_layout_t = _ze_image_format_layout_t(3);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 8-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8: _ze_image_format_layout_t =
_ze_image_format_layout_t(4);
}
impl _ze_image_format_layout_t {
#[doc = "< 2-component 16-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_16_16: _ze_image_format_layout_t =
_ze_image_format_layout_t(5);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 16-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16: _ze_image_format_layout_t =
_ze_image_format_layout_t(6);
}
impl _ze_image_format_layout_t {
#[doc = "< 2-component 32-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_32_32: _ze_image_format_layout_t =
_ze_image_format_layout_t(7);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 32-bit layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_32_32_32_32: _ze_image_format_layout_t =
_ze_image_format_layout_t(8);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 10_10_10_2 layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_10_10_10_2: _ze_image_format_layout_t =
_ze_image_format_layout_t(9);
}
impl _ze_image_format_layout_t {
#[doc = "< 3-component 11_11_10 layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_11_11_10: _ze_image_format_layout_t =
_ze_image_format_layout_t(10);
}
impl _ze_image_format_layout_t {
#[doc = "< 3-component 5_6_5 layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_5_6_5: _ze_image_format_layout_t =
_ze_image_format_layout_t(11);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 5_5_5_1 layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_5_5_5_1: _ze_image_format_layout_t =
_ze_image_format_layout_t(12);
}
impl _ze_image_format_layout_t {
#[doc = "< 4-component 4_4_4_4 layout"]
pub const ZE_IMAGE_FORMAT_LAYOUT_4_4_4_4: _ze_image_format_layout_t =
_ze_image_format_layout_t(13);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y8. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y8: _ze_image_format_layout_t = _ze_image_format_layout_t(14);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: NV12. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_NV12: _ze_image_format_layout_t =
_ze_image_format_layout_t(15);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: YUYV. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_YUYV: _ze_image_format_layout_t =
_ze_image_format_layout_t(16);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: VYUY. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_VYUY: _ze_image_format_layout_t =
_ze_image_format_layout_t(17);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: YVYU. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_YVYU: _ze_image_format_layout_t =
_ze_image_format_layout_t(18);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: UYVY. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_UYVY: _ze_image_format_layout_t =
_ze_image_format_layout_t(19);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: AYUV. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_AYUV: _ze_image_format_layout_t =
_ze_image_format_layout_t(20);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: P010. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_P010: _ze_image_format_layout_t =
_ze_image_format_layout_t(21);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y410. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y410: _ze_image_format_layout_t =
_ze_image_format_layout_t(22);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: P012. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_P012: _ze_image_format_layout_t =
_ze_image_format_layout_t(23);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y16. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y16: _ze_image_format_layout_t = _ze_image_format_layout_t(24);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: P016. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_P016: _ze_image_format_layout_t =
_ze_image_format_layout_t(25);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y216. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y216: _ze_image_format_layout_t =
_ze_image_format_layout_t(26);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: P216. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_P216: _ze_image_format_layout_t =
_ze_image_format_layout_t(27);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: P8. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_P8: _ze_image_format_layout_t = _ze_image_format_layout_t(28);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: YUY2. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_YUY2: _ze_image_format_layout_t =
_ze_image_format_layout_t(29);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: A8P8. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_A8P8: _ze_image_format_layout_t =
_ze_image_format_layout_t(30);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: IA44. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_IA44: _ze_image_format_layout_t =
_ze_image_format_layout_t(31);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: AI44. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_AI44: _ze_image_format_layout_t =
_ze_image_format_layout_t(32);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y416. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y416: _ze_image_format_layout_t =
_ze_image_format_layout_t(33);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: Y210. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_Y210: _ze_image_format_layout_t =
_ze_image_format_layout_t(34);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: I420. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_I420: _ze_image_format_layout_t =
_ze_image_format_layout_t(35);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: YV12. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_YV12: _ze_image_format_layout_t =
_ze_image_format_layout_t(36);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: 400P. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_400P: _ze_image_format_layout_t =
_ze_image_format_layout_t(37);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: 422H. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_422H: _ze_image_format_layout_t =
_ze_image_format_layout_t(38);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: 422V. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_422V: _ze_image_format_layout_t =
_ze_image_format_layout_t(39);
}
impl _ze_image_format_layout_t {
#[doc = "< Media Format: 444P. Format type and swizzle is ignored for this."]
pub const ZE_IMAGE_FORMAT_LAYOUT_444P: _ze_image_format_layout_t =
_ze_image_format_layout_t(40);
}
impl _ze_image_format_layout_t {
pub const ZE_IMAGE_FORMAT_LAYOUT_FORCE_UINT32: _ze_image_format_layout_t =
_ze_image_format_layout_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported image format layouts"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_format_layout_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported image format layouts"]
pub use self::_ze_image_format_layout_t as ze_image_format_layout_t;
impl _ze_image_format_type_t {
#[doc = "< Unsigned integer"]
pub const ZE_IMAGE_FORMAT_TYPE_UINT: _ze_image_format_type_t = _ze_image_format_type_t(0);
}
impl _ze_image_format_type_t {
#[doc = "< Signed integer"]
pub const ZE_IMAGE_FORMAT_TYPE_SINT: _ze_image_format_type_t = _ze_image_format_type_t(1);
}
impl _ze_image_format_type_t {
#[doc = "< Unsigned normalized integer"]
pub const ZE_IMAGE_FORMAT_TYPE_UNORM: _ze_image_format_type_t = _ze_image_format_type_t(2);
}
impl _ze_image_format_type_t {
#[doc = "< Signed normalized integer"]
pub const ZE_IMAGE_FORMAT_TYPE_SNORM: _ze_image_format_type_t = _ze_image_format_type_t(3);
}
impl _ze_image_format_type_t {
#[doc = "< Float"]
pub const ZE_IMAGE_FORMAT_TYPE_FLOAT: _ze_image_format_type_t = _ze_image_format_type_t(4);
}
impl _ze_image_format_type_t {
pub const ZE_IMAGE_FORMAT_TYPE_FORCE_UINT32: _ze_image_format_type_t =
_ze_image_format_type_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported image format types"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_format_type_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported image format types"]
pub use self::_ze_image_format_type_t as ze_image_format_type_t;
impl _ze_image_format_swizzle_t {
#[doc = "< Red component"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_R: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(0);
}
impl _ze_image_format_swizzle_t {
#[doc = "< Green component"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_G: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(1);
}
impl _ze_image_format_swizzle_t {
#[doc = "< Blue component"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_B: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(2);
}
impl _ze_image_format_swizzle_t {
#[doc = "< Alpha component"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_A: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(3);
}
impl _ze_image_format_swizzle_t {
#[doc = "< Zero"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_0: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(4);
}
impl _ze_image_format_swizzle_t {
#[doc = "< One"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_1: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(5);
}
impl _ze_image_format_swizzle_t {
#[doc = "< Don't care"]
pub const ZE_IMAGE_FORMAT_SWIZZLE_X: _ze_image_format_swizzle_t = _ze_image_format_swizzle_t(6);
}
impl _ze_image_format_swizzle_t {
pub const ZE_IMAGE_FORMAT_SWIZZLE_FORCE_UINT32: _ze_image_format_swizzle_t =
_ze_image_format_swizzle_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported image format component swizzle into channel"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_format_swizzle_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported image format component swizzle into channel"]
pub use self::_ze_image_format_swizzle_t as ze_image_format_swizzle_t;
#[doc = ""]
#[doc = " @brief Image format"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_format_t {
#[doc = "< [in] image format component layout"]
pub layout: ze_image_format_layout_t,
#[doc = "< [in] image format type. Media formats can't be used for"]
#[doc = "< ::ZE_IMAGE_TYPE_BUFFER."]
pub type_: ze_image_format_type_t,
#[doc = "< [in] image component swizzle into channel x"]
pub x: ze_image_format_swizzle_t,
#[doc = "< [in] image component swizzle into channel y"]
pub y: ze_image_format_swizzle_t,
#[doc = "< [in] image component swizzle into channel z"]
pub z: ze_image_format_swizzle_t,
#[doc = "< [in] image component swizzle into channel w"]
pub w: ze_image_format_swizzle_t,
}
#[test]
fn bindgen_test_layout__ze_image_format_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_format_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_image_format_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_format_t>(),
4usize,
concat!("Alignment of ", stringify!(_ze_image_format_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).layout as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(layout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).x as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).y as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).z as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_format_t>())).w as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_format_t),
"::",
stringify!(w)
)
);
}
#[doc = ""]
#[doc = " @brief Image descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_image_flags_t;"]
#[doc = "< default is read-only, cached access."]
pub flags: ze_image_flags_t,
#[doc = "< [in] image type"]
pub type_: ze_image_type_t,
#[doc = "< [in] image format"]
pub format: ze_image_format_t,
#[doc = "< [in] width dimension."]
#[doc = "< ::ZE_IMAGE_TYPE_BUFFER: size in bytes; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageBufferSize for limits."]
#[doc = "< ::ZE_IMAGE_TYPE_1D, ::ZE_IMAGE_TYPE_1DARRAY: width in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims1D for limits."]
#[doc = "< ::ZE_IMAGE_TYPE_2D, ::ZE_IMAGE_TYPE_2DARRAY: width in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims2D for limits."]
#[doc = "< ::ZE_IMAGE_TYPE_3D: width in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims3D for limits."]
pub width: u64,
#[doc = "< [in] height dimension."]
#[doc = "< ::ZE_IMAGE_TYPE_2D, ::ZE_IMAGE_TYPE_2DARRAY: height in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims2D for limits."]
#[doc = "< ::ZE_IMAGE_TYPE_3D: height in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims3D for limits."]
#[doc = "< other: ignored."]
pub height: u32,
#[doc = "< [in] depth dimension."]
#[doc = "< ::ZE_IMAGE_TYPE_3D: depth in pixels; see"]
#[doc = "< ::ze_device_image_properties_t.maxImageDims3D for limits."]
#[doc = "< other: ignored."]
pub depth: u32,
#[doc = "< [in] array levels."]
#[doc = "< ::ZE_IMAGE_TYPE_1DARRAY, ::ZE_IMAGE_TYPE_2DARRAY: see"]
#[doc = "< ::ze_device_image_properties_t.maxImageArraySlices for limits."]
#[doc = "< other: ignored."]
pub arraylevels: u32,
#[doc = "< [in] mipmap levels (must be 0)"]
pub miplevels: u32,
}
#[test]
fn bindgen_test_layout__ze_image_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_desc_t>(),
72usize,
concat!("Size of: ", stringify!(_ze_image_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_image_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).type_ as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).format as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).width as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).height as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).depth as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).arraylevels as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(arraylevels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_desc_t>())).miplevels as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_desc_t),
"::",
stringify!(miplevels)
)
);
}
impl _ze_image_sampler_filter_flags_t {
#[doc = "< device supports point filtering"]
pub const ZE_IMAGE_SAMPLER_FILTER_FLAG_POINT: _ze_image_sampler_filter_flags_t =
_ze_image_sampler_filter_flags_t(1);
}
impl _ze_image_sampler_filter_flags_t {
#[doc = "< device supports linear filtering"]
pub const ZE_IMAGE_SAMPLER_FILTER_FLAG_LINEAR: _ze_image_sampler_filter_flags_t =
_ze_image_sampler_filter_flags_t(2);
}
impl _ze_image_sampler_filter_flags_t {
pub const ZE_IMAGE_SAMPLER_FILTER_FLAG_FORCE_UINT32: _ze_image_sampler_filter_flags_t =
_ze_image_sampler_filter_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_image_sampler_filter_flags_t> for _ze_image_sampler_filter_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_image_sampler_filter_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_image_sampler_filter_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_image_sampler_filter_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_image_sampler_filter_flags_t> for _ze_image_sampler_filter_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_image_sampler_filter_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_image_sampler_filter_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_image_sampler_filter_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported sampler filtering flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_image_sampler_filter_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported sampler filtering flags"]
pub use self::_ze_image_sampler_filter_flags_t as ze_image_sampler_filter_flags_t;
#[doc = ""]
#[doc = " @brief Image properties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] supported sampler filtering."]
#[doc = "< returns 0 (unsupported) or a combination of ::ze_image_sampler_filter_flags_t."]
pub samplerFilterFlags: ze_image_sampler_filter_flags_t,
}
#[test]
fn bindgen_test_layout__ze_image_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_properties_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_image_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_image_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_properties_t>())).samplerFilterFlags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_properties_t),
"::",
stringify!(samplerFilterFlags)
)
);
}
impl Default for _ze_image_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves supported properties of an image."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == pImageProperties`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < desc->flags`"]
#[doc = " + `::ZE_IMAGE_TYPE_BUFFER < desc->type`"]
pub fn zeImageGetProperties(
hDevice: ze_device_handle_t,
desc: *const ze_image_desc_t,
pImageProperties: *mut ze_image_properties_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates an image on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the image for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @remarks"]
#[doc = " _Analogues_"]
#[doc = " - clCreateImage"]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phImage`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < desc->flags`"]
#[doc = " + `::ZE_IMAGE_TYPE_BUFFER < desc->type`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeImageCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *const ze_image_desc_t,
phImage: *mut ze_image_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Deletes an image object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the image before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this image."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same image handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hImage`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeImageDestroy(hImage: ze_image_handle_t) -> ze_result_t;
}
impl _ze_device_mem_alloc_flags_t {
#[doc = "< device should cache allocation"]
pub const ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_CACHED: _ze_device_mem_alloc_flags_t =
_ze_device_mem_alloc_flags_t(1);
}
impl _ze_device_mem_alloc_flags_t {
#[doc = "< device should not cache allocation (UC)"]
pub const ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED: _ze_device_mem_alloc_flags_t =
_ze_device_mem_alloc_flags_t(2);
}
impl _ze_device_mem_alloc_flags_t {
pub const ZE_DEVICE_MEM_ALLOC_FLAG_FORCE_UINT32: _ze_device_mem_alloc_flags_t =
_ze_device_mem_alloc_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_mem_alloc_flags_t> for _ze_device_mem_alloc_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_mem_alloc_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_mem_alloc_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_mem_alloc_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_mem_alloc_flags_t> for _ze_device_mem_alloc_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_mem_alloc_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_mem_alloc_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_mem_alloc_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported memory allocation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_mem_alloc_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported memory allocation flags"]
pub use self::_ze_device_mem_alloc_flags_t as ze_device_mem_alloc_flags_t;
#[doc = ""]
#[doc = " @brief Device memory allocation descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_mem_alloc_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying additional allocation controls."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_device_mem_alloc_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics."]
pub flags: ze_device_mem_alloc_flags_t,
#[doc = "< [in] ordinal of the device's local memory to allocate from."]
#[doc = "< must be less than the count returned from ::zeDeviceGetMemoryProperties."]
pub ordinal: u32,
}
#[test]
fn bindgen_test_layout__ze_device_mem_alloc_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_mem_alloc_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_device_mem_alloc_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_mem_alloc_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_mem_alloc_desc_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_mem_alloc_desc_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_mem_alloc_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_mem_alloc_desc_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_mem_alloc_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_mem_alloc_desc_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_mem_alloc_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_mem_alloc_desc_t>())).ordinal as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_mem_alloc_desc_t),
"::",
stringify!(ordinal)
)
);
}
impl _ze_host_mem_alloc_flags_t {
#[doc = "< host should cache allocation"]
pub const ZE_HOST_MEM_ALLOC_FLAG_BIAS_CACHED: _ze_host_mem_alloc_flags_t =
_ze_host_mem_alloc_flags_t(1);
}
impl _ze_host_mem_alloc_flags_t {
#[doc = "< host should not cache allocation (UC)"]
pub const ZE_HOST_MEM_ALLOC_FLAG_BIAS_UNCACHED: _ze_host_mem_alloc_flags_t =
_ze_host_mem_alloc_flags_t(2);
}
impl _ze_host_mem_alloc_flags_t {
#[doc = "< host memory should be allocated write-combined (WC)"]
pub const ZE_HOST_MEM_ALLOC_FLAG_BIAS_WRITE_COMBINED: _ze_host_mem_alloc_flags_t =
_ze_host_mem_alloc_flags_t(4);
}
impl _ze_host_mem_alloc_flags_t {
pub const ZE_HOST_MEM_ALLOC_FLAG_FORCE_UINT32: _ze_host_mem_alloc_flags_t =
_ze_host_mem_alloc_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_host_mem_alloc_flags_t> for _ze_host_mem_alloc_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_host_mem_alloc_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_host_mem_alloc_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_host_mem_alloc_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_host_mem_alloc_flags_t> for _ze_host_mem_alloc_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_host_mem_alloc_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_host_mem_alloc_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_host_mem_alloc_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported host memory allocation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_host_mem_alloc_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported host memory allocation flags"]
pub use self::_ze_host_mem_alloc_flags_t as ze_host_mem_alloc_flags_t;
#[doc = ""]
#[doc = " @brief Host memory allocation descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_host_mem_alloc_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying additional allocation controls."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_host_mem_alloc_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics."]
pub flags: ze_host_mem_alloc_flags_t,
}
#[test]
fn bindgen_test_layout__ze_host_mem_alloc_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_host_mem_alloc_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_host_mem_alloc_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_host_mem_alloc_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_host_mem_alloc_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_host_mem_alloc_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_host_mem_alloc_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_host_mem_alloc_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_host_mem_alloc_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_host_mem_alloc_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_host_mem_alloc_desc_t),
"::",
stringify!(flags)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Allocates shared memory on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Shared allocations share ownership between the host and one or more"]
#[doc = " devices."]
#[doc = " - Shared allocations may optionally be associated with a device by"]
#[doc = " passing a handle to the device."]
#[doc = " - Devices supporting only single-device shared access capabilities may"]
#[doc = " access shared memory associated with the device."]
#[doc = " For these devices, ownership of the allocation is shared between the"]
#[doc = " host and the associated device only."]
#[doc = " - Passing nullptr as the device handle does not associate the shared"]
#[doc = " allocation with any device."]
#[doc = " For allocations with no associated device, ownership of the allocation"]
#[doc = " is shared between the host and all devices supporting cross-device"]
#[doc = " shared access capabilities."]
#[doc = " - The application must only use the memory allocation for the context"]
#[doc = " and device, or its sub-devices, which was provided during allocation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == device_desc`"]
#[doc = " + `nullptr == host_desc`"]
#[doc = " + `nullptr == pptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < device_desc->flags`"]
#[doc = " + `0x7 < host_desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
#[doc = " + Must be zero or a power-of-two"]
#[doc = " + `0 != (alignment & (alignment - 1))`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeMemAllocShared(
hContext: ze_context_handle_t,
device_desc: *const ze_device_mem_alloc_desc_t,
host_desc: *const ze_host_mem_alloc_desc_t,
size: usize,
alignment: usize,
hDevice: ze_device_handle_t,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Allocates device memory on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Device allocations are owned by a specific device."]
#[doc = " - In general, a device allocation may only be accessed by the device"]
#[doc = " that owns it."]
#[doc = " - The application must only use the memory allocation for the context"]
#[doc = " and device, or its sub-devices, which was provided during allocation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == device_desc`"]
#[doc = " + `nullptr == pptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < device_desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
#[doc = " + Must be zero or a power-of-two"]
#[doc = " + `0 != (alignment & (alignment - 1))`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeMemAllocDevice(
hContext: ze_context_handle_t,
device_desc: *const ze_device_mem_alloc_desc_t,
size: usize,
alignment: usize,
hDevice: ze_device_handle_t,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Allocates host memory on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Host allocations are owned by the host process."]
#[doc = " - Host allocations are accessible by the host and all devices within the"]
#[doc = " driver's context."]
#[doc = " - Host allocations are frequently used as staging areas to transfer data"]
#[doc = " to or from devices."]
#[doc = " - The application must only use the memory allocation for the context"]
#[doc = " which was provided during allocation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == host_desc`"]
#[doc = " + `nullptr == pptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x7 < host_desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
#[doc = " + Must be zero or a power-of-two"]
#[doc = " + `0 != (alignment & (alignment - 1))`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeMemAllocHost(
hContext: ze_context_handle_t,
host_desc: *const ze_host_mem_alloc_desc_t,
size: usize,
alignment: usize,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Frees allocated host memory, device memory, or shared memory on the"]
#[doc = " context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the memory before it is freed"]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this memory"]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same pointer."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
pub fn zeMemFree(
hContext: ze_context_handle_t,
ptr: *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
impl _ze_memory_type_t {
#[doc = "< the memory pointed to is of unknown type"]
pub const ZE_MEMORY_TYPE_UNKNOWN: _ze_memory_type_t = _ze_memory_type_t(0);
}
impl _ze_memory_type_t {
#[doc = "< the memory pointed to is a host allocation"]
pub const ZE_MEMORY_TYPE_HOST: _ze_memory_type_t = _ze_memory_type_t(1);
}
impl _ze_memory_type_t {
#[doc = "< the memory pointed to is a device allocation"]
pub const ZE_MEMORY_TYPE_DEVICE: _ze_memory_type_t = _ze_memory_type_t(2);
}
impl _ze_memory_type_t {
#[doc = "< the memory pointed to is a shared ownership allocation"]
pub const ZE_MEMORY_TYPE_SHARED: _ze_memory_type_t = _ze_memory_type_t(3);
}
impl _ze_memory_type_t {
pub const ZE_MEMORY_TYPE_FORCE_UINT32: _ze_memory_type_t = _ze_memory_type_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Memory allocation type"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_memory_type_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Memory allocation type"]
pub use self::_ze_memory_type_t as ze_memory_type_t;
#[doc = ""]
#[doc = " @brief Memory allocation properties queried using ::zeMemGetAllocProperties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_memory_allocation_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] type of allocated memory"]
pub type_: ze_memory_type_t,
#[doc = "< [out] identifier for this allocation"]
pub id: u64,
#[doc = "< [out] page size used for allocation"]
pub pageSize: u64,
}
#[test]
fn bindgen_test_layout__ze_memory_allocation_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_memory_allocation_properties_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_memory_allocation_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_memory_allocation_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_memory_allocation_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_memory_allocation_properties_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_memory_allocation_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_memory_allocation_properties_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_memory_allocation_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_memory_allocation_properties_t>())).type_ as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_memory_allocation_properties_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_memory_allocation_properties_t>())).id as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_memory_allocation_properties_t),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_memory_allocation_properties_t>())).pageSize as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_memory_allocation_properties_t),
"::",
stringify!(pageSize)
)
);
}
impl Default for _ze_memory_allocation_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves attributes of a memory allocation"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The application may query attributes of a memory allocation unrelated"]
#[doc = " to the context."]
#[doc = " When this occurs, the returned allocation type will be"]
#[doc = " ::ZE_MEMORY_TYPE_UNKNOWN, and the returned identifier and associated"]
#[doc = " device is unspecified."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " + `nullptr == pMemAllocProperties`"]
pub fn zeMemGetAllocProperties(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
pMemAllocProperties: *mut ze_memory_allocation_properties_t,
phDevice: *mut ze_device_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves the base address and/or size of an allocation"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
pub fn zeMemGetAddressRange(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
pBase: *mut *mut ::std::os::raw::c_void,
pSize: *mut usize,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates an IPC memory handle for the specified allocation"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Takes a pointer to a device memory allocation and creates an IPC"]
#[doc = " memory handle for exporting it for use in another process."]
#[doc = " - The pointer must be base pointer of the device memory allocation; i.e."]
#[doc = " the value returned from ::zeMemAllocDevice."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " + `nullptr == pIpcHandle`"]
pub fn zeMemGetIpcHandle(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
pIpcHandle: *mut ze_ipc_mem_handle_t,
) -> ze_result_t;
}
impl _ze_ipc_memory_flags_t {
#[doc = "< reserved for future use"]
pub const ZE_IPC_MEMORY_FLAG_TBD: _ze_ipc_memory_flags_t = _ze_ipc_memory_flags_t(1);
}
impl _ze_ipc_memory_flags_t {
pub const ZE_IPC_MEMORY_FLAG_FORCE_UINT32: _ze_ipc_memory_flags_t =
_ze_ipc_memory_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_ipc_memory_flags_t> for _ze_ipc_memory_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_ipc_memory_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_ipc_memory_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_ipc_memory_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_ipc_memory_flags_t> for _ze_ipc_memory_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_ipc_memory_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_ipc_memory_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_ipc_memory_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported IPC memory flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_ipc_memory_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported IPC memory flags"]
pub use self::_ze_ipc_memory_flags_t as ze_ipc_memory_flags_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Opens an IPC memory handle to retrieve a device pointer on the"]
#[doc = " context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Takes an IPC memory handle from a remote process and associates it"]
#[doc = " with a device pointer usable in this process."]
#[doc = " - The device pointer in this process should not be freed with"]
#[doc = " ::zeMemFree, but rather with ::zeMemCloseIpcHandle."]
#[doc = " - Multiple calls to this function with the same IPC handle will return"]
#[doc = " unique pointers."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < flags`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pptr`"]
pub fn zeMemOpenIpcHandle(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
handle: ze_ipc_mem_handle_t,
flags: ze_ipc_memory_flags_t,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Closes an IPC memory handle"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Closes an IPC memory handle by unmapping memory that was opened in"]
#[doc = " this process using ::zeMemOpenIpcHandle."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same pointer."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
pub fn zeMemCloseIpcHandle(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Additional allocation descriptor for exporting external memory"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be passed to ::zeMemAllocDevice, via the `pNext`"]
#[doc = " member of ::ze_device_mem_alloc_desc_t, to indicate an exportable"]
#[doc = " memory allocation."]
#[doc = " - This structure may be passed to ::zeImageCreate, via the `pNext`"]
#[doc = " member of ::ze_image_desc_t, to indicate an exportable image."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_external_memory_export_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying memory export types for this allocation."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t"]
pub flags: ze_external_memory_type_flags_t,
}
#[test]
fn bindgen_test_layout__ze_external_memory_export_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_external_memory_export_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_external_memory_export_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_external_memory_export_desc_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_external_memory_export_desc_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_desc_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_desc_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_desc_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_desc_t),
"::",
stringify!(flags)
)
);
}
#[doc = ""]
#[doc = " @brief Additional allocation descriptor for importing external memory as a"]
#[doc = " file descriptor"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be passed to ::zeMemAllocDevice, via the `pNext`"]
#[doc = " member of ::ze_device_mem_alloc_desc_t, to import memory from a file"]
#[doc = " descriptor."]
#[doc = " - This structure may be passed to ::zeImageCreate, via the `pNext`"]
#[doc = " member of ::ze_image_desc_t, to import memory from a file descriptor."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_external_memory_import_fd_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying the memory import type for the file descriptor."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t"]
pub flags: ze_external_memory_type_flags_t,
#[doc = "< [in] the file descriptor handle to import"]
pub fd: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__ze_external_memory_import_fd_t() {
assert_eq!(
::std::mem::size_of::<_ze_external_memory_import_fd_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_external_memory_import_fd_t))
);
assert_eq!(
::std::mem::align_of::<_ze_external_memory_import_fd_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_external_memory_import_fd_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_import_fd_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_import_fd_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_import_fd_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_import_fd_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_import_fd_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_import_fd_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_import_fd_t>())).fd as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_import_fd_t),
"::",
stringify!(fd)
)
);
}
#[doc = ""]
#[doc = " @brief Exports an allocation as a file descriptor"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be passed to ::zeMemGetAllocProperties, via the"]
#[doc = " `pNext` member of ::ze_memory_allocation_properties_t, to export a"]
#[doc = " memory allocation as a file descriptor."]
#[doc = " - This structure may be passed to ::zeImageGetProperties, via the"]
#[doc = " `pNext` member of ::ze_image_properties_t, to export an image as a"]
#[doc = " file descriptor."]
#[doc = " - The requested memory export type must have been specified when the"]
#[doc = " allocation was made."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_external_memory_export_fd_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying the memory export type for the file descriptor."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_external_memory_type_flags_t"]
pub flags: ze_external_memory_type_flags_t,
#[doc = "< [out] the exported file descriptor handle representing the allocation."]
pub fd: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__ze_external_memory_export_fd_t() {
assert_eq!(
::std::mem::size_of::<_ze_external_memory_export_fd_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_external_memory_export_fd_t))
);
assert_eq!(
::std::mem::align_of::<_ze_external_memory_export_fd_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_external_memory_export_fd_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_fd_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_fd_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_fd_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_fd_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_fd_t>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_fd_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_external_memory_export_fd_t>())).fd as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_external_memory_export_fd_t),
"::",
stringify!(fd)
)
);
}
impl _ze_module_format_t {
#[doc = "< Format is SPIRV IL format"]
pub const ZE_MODULE_FORMAT_IL_SPIRV: _ze_module_format_t = _ze_module_format_t(0);
}
impl _ze_module_format_t {
#[doc = "< Format is device native format"]
pub const ZE_MODULE_FORMAT_NATIVE: _ze_module_format_t = _ze_module_format_t(1);
}
impl _ze_module_format_t {
pub const ZE_MODULE_FORMAT_FORCE_UINT32: _ze_module_format_t = _ze_module_format_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported module creation input formats"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_module_format_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported module creation input formats"]
pub use self::_ze_module_format_t as ze_module_format_t;
#[doc = ""]
#[doc = " @brief Specialization constants - User defined constants"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_constants_t {
#[doc = "< [in] Number of specialization constants."]
pub numConstants: u32,
#[doc = "< [in][range(0, numConstants)] Array of IDs that is sized to"]
#[doc = "< numConstants."]
pub pConstantIds: *const u32,
#[doc = "< [in][range(0, numConstants)] Array of pointers to values that is sized"]
#[doc = "< to numConstants."]
pub pConstantValues: *mut *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_module_constants_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_constants_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_module_constants_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_constants_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_constants_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_constants_t>())).numConstants as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_constants_t),
"::",
stringify!(numConstants)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_constants_t>())).pConstantIds as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_constants_t),
"::",
stringify!(pConstantIds)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_constants_t>())).pConstantValues as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_constants_t),
"::",
stringify!(pConstantValues)
)
);
}
#[doc = ""]
#[doc = " @brief Module descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] Module format passed in with pInputModule"]
pub format: ze_module_format_t,
#[doc = "< [in] size of input IL or ISA from pInputModule."]
pub inputSize: usize,
#[doc = "< [in] pointer to IL or ISA"]
pub pInputModule: *const u8,
#[doc = "< [in][optional] string containing compiler flags. Following options are supported."]
#[doc = "< - \"-ze-opt-disable\""]
#[doc = "< - Disable optimizations"]
#[doc = "< - \"-ze-opt-greater-than-4GB-buffer-required\""]
#[doc = "< - Use 64-bit offset calculations for buffers."]
#[doc = "< - \"-ze-opt-large-register-file\""]
#[doc = "< - Increase number of registers available to threads."]
#[doc = "< - \"-ze-opt-has-buffer-offset-arg\""]
#[doc = "< - Extend stateless to stateful optimization to more"]
#[doc = "< cases with the use of additional offset (e.g. 64-bit"]
#[doc = "< pointer to binding table with 32-bit offset)."]
#[doc = "< - \"-g\""]
#[doc = "< - Include debugging information."]
pub pBuildFlags: *const ::std::os::raw::c_char,
#[doc = "< [in][optional] pointer to specialization constants. Valid only for"]
#[doc = "< SPIR-V input. This must be set to nullptr if no specialization"]
#[doc = "< constants are provided."]
pub pConstants: *const ze_module_constants_t,
}
#[test]
fn bindgen_test_layout__ze_module_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_desc_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_module_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).format as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).inputSize as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(inputSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).pInputModule as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(pInputModule)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).pBuildFlags as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(pBuildFlags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_desc_t>())).pConstants as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_desc_t),
"::",
stringify!(pConstants)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a module on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Compiles the module for execution on the device."]
#[doc = " - The application must only use the module for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The module can be copied to other devices and contexts within the same"]
#[doc = " driver instance by using ::zeModuleGetNativeBinary."]
#[doc = " - A build log can optionally be returned to the caller. The caller is"]
#[doc = " responsible for destroying build log using ::zeModuleBuildLogDestroy."]
#[doc = " - The module descriptor constants are only supported for SPIR-V"]
#[doc = " specialization constants."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == desc->pInputModule`"]
#[doc = " + `nullptr == phModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `::ZE_MODULE_FORMAT_NATIVE < desc->format`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NATIVE_BINARY"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `0 == desc->inputSize`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_MODULE_BUILD_FAILURE"]
pub fn zeModuleCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *const ze_module_desc_t,
phModule: *mut ze_module_handle_t,
phBuildLog: *mut ze_module_build_log_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys module"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must destroy all kernel and build log handles created"]
#[doc = " from the module before destroying the module itself."]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the module before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this module."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same module handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeModuleDestroy(hModule: ze_module_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Dynamically link modules together that share import/export linkage"]
#[doc = " dependencies."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Modules support import and export linkage for functions and global"]
#[doc = " variables."]
#[doc = " - Modules that have imports can be dynamically linked to export modules"]
#[doc = " that satisfy those import requirements."]
#[doc = " - Modules can have both import and export linkages."]
#[doc = " - Modules that do not have any imports or exports do not need to be"]
#[doc = " linked."]
#[doc = " - Modules cannot be partially linked. All modules needed to satisfy all"]
#[doc = " import dependencies for a module must be passed in or"]
#[doc = " ::ZE_RESULT_ERROR_MODULE_LINK_FAILURE will returned."]
#[doc = " - Modules with imports need to be linked before kernel objects can be"]
#[doc = " created from them."]
#[doc = " - Modules will only be linked once. A module can be used in multiple"]
#[doc = " link calls if it has exports but it's imports will not be re-linked."]
#[doc = " - Ambiguous dependencies, where multiple modules satisfy the import"]
#[doc = " dependencies for another module, is not allowed."]
#[doc = " - ModuleGetNativeBinary can be called on any module regardless of"]
#[doc = " whether it is linked or not."]
#[doc = " - A link log can optionally be returned to the caller. The caller is"]
#[doc = " responsible for destroying build log using ::zeModuleBuildLogDestroy."]
#[doc = " - See SPIR-V specification for linkage details."]
#[doc = " - The application must ensure the modules being linked were created on"]
#[doc = " the same context."]
#[doc = " - The application may call this function from simultaneous threads as"]
#[doc = " long as the import modules being linked are not the same."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phModules`"]
#[doc = " - ::ZE_RESULT_ERROR_MODULE_LINK_FAILURE"]
pub fn zeModuleDynamicLink(
numModules: u32,
phModules: *mut ze_module_handle_t,
phLinkLog: *mut ze_module_build_log_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys module build log object"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The implementation of this function may immediately free all Host"]
#[doc = " allocations associated with this object."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same build log handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = " - This function can be called before or after ::zeModuleDestroy for the"]
#[doc = " associated module."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModuleBuildLog`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeModuleBuildLogDestroy(hModuleBuildLog: ze_module_build_log_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieves text string for build log."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The caller can pass nullptr for pBuildLog when querying only for size."]
#[doc = " - The caller must provide memory for build log."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModuleBuildLog`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pSize`"]
pub fn zeModuleBuildLogGetString(
hModuleBuildLog: ze_module_build_log_handle_t,
pSize: *mut usize,
pBuildLog: *mut ::std::os::raw::c_char,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve native binary from Module."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The native binary output can be cached to disk and new modules can be"]
#[doc = " later constructed from the cached copy."]
#[doc = " - The native binary will retain debugging information that is associated"]
#[doc = " with a module."]
#[doc = " - The caller can pass nullptr for pModuleNativeBinary when querying only"]
#[doc = " for size."]
#[doc = " - The implementation will copy the native binary into a buffer supplied"]
#[doc = " by the caller."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pSize`"]
pub fn zeModuleGetNativeBinary(
hModule: ze_module_handle_t,
pSize: *mut usize,
pModuleNativeBinary: *mut u8,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve global variable pointer from Module."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may query global pointer from any module that either"]
#[doc = " exports or imports it."]
#[doc = " - The application must dynamically link a module that imports a global"]
#[doc = " before the global pointer can be queried from it."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pGlobalName`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_GLOBAL_NAME"]
pub fn zeModuleGetGlobalPointer(
hModule: ze_module_handle_t,
pGlobalName: *const ::std::os::raw::c_char,
pSize: *mut usize,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve all kernel names in the module."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pCount`"]
pub fn zeModuleGetKernelNames(
hModule: ze_module_handle_t,
pCount: *mut u32,
pNames: *mut *const ::std::os::raw::c_char,
) -> ze_result_t;
}
impl _ze_module_property_flags_t {
#[doc = "< Module has imports (i.e. imported global variables and/or kernels)."]
#[doc = "< See ::zeModuleDynamicLink."]
pub const ZE_MODULE_PROPERTY_FLAG_IMPORTS: _ze_module_property_flags_t =
_ze_module_property_flags_t(1);
}
impl _ze_module_property_flags_t {
pub const ZE_MODULE_PROPERTY_FLAG_FORCE_UINT32: _ze_module_property_flags_t =
_ze_module_property_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_module_property_flags_t> for _ze_module_property_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_module_property_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_module_property_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_module_property_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_module_property_flags_t> for _ze_module_property_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_module_property_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_module_property_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_module_property_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported module property flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_module_property_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported module property flags"]
pub use self::_ze_module_property_flags_t as ze_module_property_flags_t;
#[doc = ""]
#[doc = " @brief Module properties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 (none) or a valid combination of ::ze_module_property_flags_t"]
pub flags: ze_module_property_flags_t,
}
#[test]
fn bindgen_test_layout__ze_module_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_properties_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_module_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_module_properties_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_properties_t),
"::",
stringify!(flags)
)
);
}
impl Default for _ze_module_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve module properties."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pModuleProperties`"]
pub fn zeModuleGetProperties(
hModule: ze_module_handle_t,
pModuleProperties: *mut ze_module_properties_t,
) -> ze_result_t;
}
impl _ze_kernel_flags_t {
#[doc = "< force all device allocations to be resident during execution"]
pub const ZE_KERNEL_FLAG_FORCE_RESIDENCY: _ze_kernel_flags_t = _ze_kernel_flags_t(1);
}
impl _ze_kernel_flags_t {
#[doc = "< application is responsible for all residency of device allocations."]
#[doc = "< driver may disable implicit residency management."]
pub const ZE_KERNEL_FLAG_EXPLICIT_RESIDENCY: _ze_kernel_flags_t = _ze_kernel_flags_t(2);
}
impl _ze_kernel_flags_t {
pub const ZE_KERNEL_FLAG_FORCE_UINT32: _ze_kernel_flags_t = _ze_kernel_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_kernel_flags_t> for _ze_kernel_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_kernel_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_kernel_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_kernel_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_kernel_flags_t> for _ze_kernel_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_kernel_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_kernel_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_kernel_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported kernel creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_kernel_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported kernel creation flags"]
pub use self::_ze_kernel_flags_t as ze_kernel_flags_t;
#[doc = ""]
#[doc = " @brief Kernel descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_kernel_flags_t;"]
#[doc = "< default behavior may use driver-based residency."]
pub flags: ze_kernel_flags_t,
#[doc = "< [in] null-terminated name of kernel in module"]
pub pKernelName: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__ze_kernel_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_desc_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_kernel_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_desc_t>())).pKernelName as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_desc_t),
"::",
stringify!(pKernelName)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Create a kernel from the module."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Modules that have unresolved imports need to be dynamically linked"]
#[doc = " before a kernel can be created from them. (See ::zeModuleDynamicLink)"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == desc->pKernelName`"]
#[doc = " + `nullptr == phKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_KERNEL_NAME"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_MODULE_UNLINKED"]
pub fn zeKernelCreate(
hModule: ze_module_handle_t,
desc: *const ze_kernel_desc_t,
phKernel: *mut ze_kernel_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys a kernel object"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the kernel before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this kernel."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same kernel handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeKernelDestroy(hKernel: ze_kernel_handle_t) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve a function pointer from a module by name"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The function pointer is unique for the device on which the module was"]
#[doc = " created."]
#[doc = " - The function pointer is no longer valid if module is destroyed."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hModule`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pFunctionName`"]
#[doc = " + `nullptr == pfnFunction`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_FUNCTION_NAME"]
pub fn zeModuleGetFunctionPointer(
hModule: ze_module_handle_t,
pFunctionName: *const ::std::os::raw::c_char,
pfnFunction: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Set group size for a kernel on the current Host thread."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The group size will be used when a ::zeCommandListAppendLaunchKernel"]
#[doc = " variant is called."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION"]
pub fn zeKernelSetGroupSize(
hKernel: ze_kernel_handle_t,
groupSizeX: u32,
groupSizeY: u32,
groupSizeZ: u32,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Query a suggested group size for a kernel given a global size for each"]
#[doc = " dimension."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This function ignores the group size that is set using"]
#[doc = " ::zeKernelSetGroupSize."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == groupSizeX`"]
#[doc = " + `nullptr == groupSizeY`"]
#[doc = " + `nullptr == groupSizeZ`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION"]
pub fn zeKernelSuggestGroupSize(
hKernel: ze_kernel_handle_t,
globalSizeX: u32,
globalSizeY: u32,
globalSizeZ: u32,
groupSizeX: *mut u32,
groupSizeY: *mut u32,
groupSizeZ: *mut u32,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Query a suggested max group count for a cooperative kernel."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == totalGroupCount`"]
pub fn zeKernelSuggestMaxCooperativeGroupCount(
hKernel: ze_kernel_handle_t,
totalGroupCount: *mut u32,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Set kernel argument for a kernel on the current Host thread."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The argument values will be used when a"]
#[doc = " ::zeCommandListAppendLaunchKernel variant is called."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE"]
pub fn zeKernelSetArgumentValue(
hKernel: ze_kernel_handle_t,
argIndex: u32,
argSize: usize,
pArgValue: *const ::std::os::raw::c_void,
) -> ze_result_t;
}
impl _ze_kernel_indirect_access_flags_t {
#[doc = "< Indicates that the kernel accesses host allocations indirectly."]
pub const ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST: _ze_kernel_indirect_access_flags_t =
_ze_kernel_indirect_access_flags_t(1);
}
impl _ze_kernel_indirect_access_flags_t {
#[doc = "< Indicates that the kernel accesses device allocations indirectly."]
pub const ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE: _ze_kernel_indirect_access_flags_t =
_ze_kernel_indirect_access_flags_t(2);
}
impl _ze_kernel_indirect_access_flags_t {
#[doc = "< Indicates that the kernel accesses shared allocations indirectly."]
pub const ZE_KERNEL_INDIRECT_ACCESS_FLAG_SHARED: _ze_kernel_indirect_access_flags_t =
_ze_kernel_indirect_access_flags_t(4);
}
impl _ze_kernel_indirect_access_flags_t {
pub const ZE_KERNEL_INDIRECT_ACCESS_FLAG_FORCE_UINT32: _ze_kernel_indirect_access_flags_t =
_ze_kernel_indirect_access_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_kernel_indirect_access_flags_t> for _ze_kernel_indirect_access_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_kernel_indirect_access_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_kernel_indirect_access_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_kernel_indirect_access_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_kernel_indirect_access_flags_t> for _ze_kernel_indirect_access_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_kernel_indirect_access_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_kernel_indirect_access_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_kernel_indirect_access_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Kernel indirect access flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_kernel_indirect_access_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Kernel indirect access flags"]
pub use self::_ze_kernel_indirect_access_flags_t as ze_kernel_indirect_access_flags_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Sets kernel indirect access flags."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application should specify which allocations will be indirectly"]
#[doc = " accessed by the kernel to allow driver to optimize which allocations"]
#[doc = " are made resident"]
#[doc = " - This function may **not** be called from simultaneous threads with the"]
#[doc = " same Kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x7 < flags`"]
pub fn zeKernelSetIndirectAccess(
hKernel: ze_kernel_handle_t,
flags: ze_kernel_indirect_access_flags_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve kernel indirect access flags."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This function may be called from simultaneous threads with the same"]
#[doc = " Kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pFlags`"]
pub fn zeKernelGetIndirectAccess(
hKernel: ze_kernel_handle_t,
pFlags: *mut ze_kernel_indirect_access_flags_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve all declared kernel attributes (i.e. can be specified with"]
#[doc = " __attribute__ in runtime language)."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This function may be called from simultaneous threads with the same"]
#[doc = " Kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pSize`"]
#[doc = " + `nullptr == pString`"]
pub fn zeKernelGetSourceAttributes(
hKernel: ze_kernel_handle_t,
pSize: *mut u32,
pString: *mut *mut ::std::os::raw::c_char,
) -> ze_result_t;
}
impl _ze_cache_config_flags_t {
#[doc = "< Large SLM size"]
pub const ZE_CACHE_CONFIG_FLAG_LARGE_SLM: _ze_cache_config_flags_t =
_ze_cache_config_flags_t(1);
}
impl _ze_cache_config_flags_t {
#[doc = "< Large General Data size"]
pub const ZE_CACHE_CONFIG_FLAG_LARGE_DATA: _ze_cache_config_flags_t =
_ze_cache_config_flags_t(2);
}
impl _ze_cache_config_flags_t {
pub const ZE_CACHE_CONFIG_FLAG_FORCE_UINT32: _ze_cache_config_flags_t =
_ze_cache_config_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_cache_config_flags_t> for _ze_cache_config_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_cache_config_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_cache_config_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_cache_config_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_cache_config_flags_t> for _ze_cache_config_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_cache_config_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_cache_config_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_cache_config_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported Cache Config flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_cache_config_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported Cache Config flags"]
pub use self::_ze_cache_config_flags_t as ze_cache_config_flags_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Sets the preferred cache configuration for a kernel on the current"]
#[doc = " Host thread."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The cache configuration will be used when a"]
#[doc = " ::zeCommandListAppendLaunchKernel variant is called."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x3 < flags`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE"]
pub fn zeKernelSetCacheConfig(
hKernel: ze_kernel_handle_t,
flags: ze_cache_config_flags_t,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Kernel universal unique id (UUID)"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_kernel_uuid_t {
#[doc = "< [out] opaque data representing a kernel UUID"]
pub kid: [u8; 16usize],
#[doc = "< [out] opaque data representing the kernel's module UUID"]
pub mid: [u8; 16usize],
}
#[test]
fn bindgen_test_layout__ze_kernel_uuid_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_uuid_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_kernel_uuid_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_uuid_t>(),
1usize,
concat!("Alignment of ", stringify!(_ze_kernel_uuid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_uuid_t>())).kid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_uuid_t),
"::",
stringify!(kid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_uuid_t>())).mid as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_uuid_t),
"::",
stringify!(mid)
)
);
}
#[doc = ""]
#[doc = " @brief Kernel properties"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] number of kernel arguments."]
pub numKernelArgs: u32,
#[doc = "< [out] required group size in the X dimension,"]
#[doc = "< or zero if there is no required group size"]
pub requiredGroupSizeX: u32,
#[doc = "< [out] required group size in the Y dimension,"]
#[doc = "< or zero if there is no required group size"]
pub requiredGroupSizeY: u32,
#[doc = "< [out] required group size in the Z dimension,"]
#[doc = "< or zero if there is no required group size"]
pub requiredGroupSizeZ: u32,
#[doc = "< [out] required number of subgroups per thread group,"]
#[doc = "< or zero if there is no required number of subgroups"]
pub requiredNumSubGroups: u32,
#[doc = "< [out] required subgroup size,"]
#[doc = "< or zero if there is no required subgroup size"]
pub requiredSubgroupSize: u32,
#[doc = "< [out] maximum subgroup size"]
pub maxSubgroupSize: u32,
#[doc = "< [out] maximum number of subgroups per thread group"]
pub maxNumSubgroups: u32,
#[doc = "< [out] local memory size used by each thread group"]
pub localMemSize: u32,
#[doc = "< [out] private memory size allocated by compiler used by each thread"]
pub privateMemSize: u32,
#[doc = "< [out] spill memory size allocated by compiler"]
pub spillMemSize: u32,
#[doc = "< [out] universal unique identifier."]
pub uuid: ze_kernel_uuid_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_properties_t>(),
96usize,
concat!("Size of: ", stringify!(_ze_kernel_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_properties_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_properties_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_properties_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_properties_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).numKernelArgs as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(numKernelArgs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).requiredGroupSizeX as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(requiredGroupSizeX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).requiredGroupSizeY as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(requiredGroupSizeY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).requiredGroupSizeZ as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(requiredGroupSizeZ)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).requiredNumSubGroups as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(requiredNumSubGroups)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).requiredSubgroupSize as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(requiredSubgroupSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).maxSubgroupSize as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(maxSubgroupSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).maxNumSubgroups as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(maxNumSubgroups)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).localMemSize as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(localMemSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).privateMemSize as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(privateMemSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_properties_t>())).spillMemSize as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(spillMemSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_kernel_properties_t>())).uuid as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_properties_t),
"::",
stringify!(uuid)
)
);
}
impl Default for _ze_kernel_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve kernel properties."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pKernelProperties`"]
pub fn zeKernelGetProperties(
hKernel: ze_kernel_handle_t,
pKernelProperties: *mut ze_kernel_properties_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Retrieve kernel name from Kernel."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The caller can pass nullptr for pName when querying only for size."]
#[doc = " - The implementation will copy the kernel name into a buffer supplied by"]
#[doc = " the caller."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pSize`"]
pub fn zeKernelGetName(
hKernel: ze_kernel_handle_t,
pSize: *mut usize,
pName: *mut ::std::os::raw::c_char,
) -> ze_result_t;
}
#[doc = ""]
#[doc = " @brief Kernel dispatch group count."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_group_count_t {
#[doc = "< [in] number of thread groups in X dimension"]
pub groupCountX: u32,
#[doc = "< [in] number of thread groups in Y dimension"]
pub groupCountY: u32,
#[doc = "< [in] number of thread groups in Z dimension"]
pub groupCountZ: u32,
}
#[test]
fn bindgen_test_layout__ze_group_count_t() {
assert_eq!(
::std::mem::size_of::<_ze_group_count_t>(),
12usize,
concat!("Size of: ", stringify!(_ze_group_count_t))
);
assert_eq!(
::std::mem::align_of::<_ze_group_count_t>(),
4usize,
concat!("Alignment of ", stringify!(_ze_group_count_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_group_count_t>())).groupCountX as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_group_count_t),
"::",
stringify!(groupCountX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_group_count_t>())).groupCountY as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ze_group_count_t),
"::",
stringify!(groupCountY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_group_count_t>())).groupCountZ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_group_count_t),
"::",
stringify!(groupCountZ)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Launch kernel over one or more work groups."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the kernel and events are accessible by"]
#[doc = " the device on which the command list was created."]
#[doc = " - This may **only** be called for a command list created with command"]
#[doc = " queue group ordinal that supports compute."]
#[doc = " - The application must ensure the command list, kernel and events were"]
#[doc = " created on the same context."]
#[doc = " - This function may **not** be called from simultaneous threads with the"]
#[doc = " same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pLaunchFuncArgs`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendLaunchKernel(
hCommandList: ze_command_list_handle_t,
hKernel: ze_kernel_handle_t,
pLaunchFuncArgs: *const ze_group_count_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Launch kernel cooperatively over one or more work groups."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the kernel and events are accessible by"]
#[doc = " the device on which the command list was created."]
#[doc = " - This may **only** be called for a command list created with command"]
#[doc = " queue group ordinal that supports compute."]
#[doc = " - This may only be used for a command list that are submitted to command"]
#[doc = " queue with cooperative flag set."]
#[doc = " - The application must ensure the command list, kernel and events were"]
#[doc = " created on the same context."]
#[doc = " - This function may **not** be called from simultaneous threads with the"]
#[doc = " same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = " - Use ::zeKernelSuggestMaxCooperativeGroupCount to recommend max group"]
#[doc = " count for device for cooperative functions that device supports."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pLaunchFuncArgs`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendLaunchCooperativeKernel(
hCommandList: ze_command_list_handle_t,
hKernel: ze_kernel_handle_t,
pLaunchFuncArgs: *const ze_group_count_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Launch kernel over one or more work groups using indirect arguments."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the kernel and events are accessible by"]
#[doc = " the device on which the command list was created."]
#[doc = " - The application must ensure the launch arguments are visible to the"]
#[doc = " device on which the command list was created."]
#[doc = " - The implementation must not access the contents of the launch"]
#[doc = " arguments as they are free to be modified by either the Host or device"]
#[doc = " up until execution."]
#[doc = " - This may **only** be called for a command list created with command"]
#[doc = " queue group ordinal that supports compute."]
#[doc = " - The application must ensure the command list, kernel and events were"]
#[doc = " created, and the memory was allocated, on the same context."]
#[doc = " - This function may **not** be called from simultaneous threads with the"]
#[doc = " same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " + `nullptr == hKernel`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pLaunchArgumentsBuffer`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendLaunchKernelIndirect(
hCommandList: ze_command_list_handle_t,
hKernel: ze_kernel_handle_t,
pLaunchArgumentsBuffer: *const ze_group_count_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Launch multiple kernels over one or more work groups using an array of"]
#[doc = " indirect arguments."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the kernel and events are accessible by"]
#[doc = " the device on which the command list was created."]
#[doc = " - The application must ensure the array of launch arguments and count"]
#[doc = " buffer are visible to the device on which the command list was"]
#[doc = " created."]
#[doc = " - The implementation must not access the contents of the array of launch"]
#[doc = " arguments or count buffer as they are free to be modified by either"]
#[doc = " the Host or device up until execution."]
#[doc = " - This may **only** be called for a command list created with command"]
#[doc = " queue group ordinal that supports compute."]
#[doc = " - The application must enusre the command list, kernel and events were"]
#[doc = " created, and the memory was allocated, on the same context."]
#[doc = " - This function may **not** be called from simultaneous threads with the"]
#[doc = " same command list handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hCommandList`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == phKernels`"]
#[doc = " + `nullptr == pCountBuffer`"]
#[doc = " + `nullptr == pLaunchArgumentsBuffer`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_SIZE"]
#[doc = " + `(nullptr == phWaitEvents) && (0 < numWaitEvents)`"]
pub fn zeCommandListAppendLaunchMultipleKernelsIndirect(
hCommandList: ze_command_list_handle_t,
numKernels: u32,
phKernels: *mut ze_kernel_handle_t,
pCountBuffer: *const u32,
pLaunchArgumentsBuffer: *const ze_group_count_t,
hSignalEvent: ze_event_handle_t,
numWaitEvents: u32,
phWaitEvents: *mut ze_event_handle_t,
) -> ze_result_t;
}
impl _ze_module_program_exp_version_t {
#[doc = "< version 1.0"]
pub const ZE_MODULE_PROGRAM_EXP_VERSION_1_0: _ze_module_program_exp_version_t =
_ze_module_program_exp_version_t(65536);
}
impl _ze_module_program_exp_version_t {
#[doc = "< latest known version"]
pub const ZE_MODULE_PROGRAM_EXP_VERSION_CURRENT: _ze_module_program_exp_version_t =
_ze_module_program_exp_version_t(65536);
}
impl _ze_module_program_exp_version_t {
pub const ZE_MODULE_PROGRAM_EXP_VERSION_FORCE_UINT32: _ze_module_program_exp_version_t =
_ze_module_program_exp_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Module Program Extension Version(s)"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_module_program_exp_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Module Program Extension Version(s)"]
pub use self::_ze_module_program_exp_version_t as ze_module_program_exp_version_t;
#[doc = ""]
#[doc = " @brief Module extended descriptor to support multiple input modules."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Implementation must support ::ZE_experimental_module_program extension"]
#[doc = " - pInputModules, pBuildFlags, and pConstants from ::ze_module_desc_t is"]
#[doc = " ignored."]
#[doc = " - Format in ::ze_module_desc_t needs to be set to"]
#[doc = " ::ZE_MODULE_FORMAT_IL_SPIRV."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_program_exp_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] Count of input modules"]
pub count: u32,
#[doc = "< [in][range(0, count)] sizes of each input IL module in pInputModules."]
pub inputSizes: *const usize,
#[doc = "< [in][range(0, count)] pointer to an array of IL (e.g. SPIR-V modules)."]
#[doc = "< Valid only for SPIR-V input."]
pub pInputModules: *mut *const u8,
#[doc = "< [in][optional][range(0, count)] array of strings containing build"]
#[doc = "< flags. See pBuildFlags in ::ze_module_desc_t."]
pub pBuildFlags: *mut *const ::std::os::raw::c_char,
#[doc = "< [in][optional][range(0, count)] pointer to array of specialization"]
#[doc = "< constant strings. Valid only for SPIR-V input. This must be set to"]
#[doc = "< nullptr if no specialization constants are provided."]
pub pConstants: *mut *const ze_module_constants_t,
}
#[test]
fn bindgen_test_layout__ze_module_program_exp_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_program_exp_desc_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_module_program_exp_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_program_exp_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_program_exp_desc_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).count as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).inputSizes as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(inputSizes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).pInputModules as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(pInputModules)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).pBuildFlags as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(pBuildFlags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_program_exp_desc_t>())).pConstants as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_program_exp_desc_t),
"::",
stringify!(pConstants)
)
);
}
impl _ze_raytracing_ext_version_t {
#[doc = "< version 1.0"]
pub const ZE_RAYTRACING_EXT_VERSION_1_0: _ze_raytracing_ext_version_t =
_ze_raytracing_ext_version_t(65536);
}
impl _ze_raytracing_ext_version_t {
#[doc = "< latest known version"]
pub const ZE_RAYTRACING_EXT_VERSION_CURRENT: _ze_raytracing_ext_version_t =
_ze_raytracing_ext_version_t(65536);
}
impl _ze_raytracing_ext_version_t {
pub const ZE_RAYTRACING_EXT_VERSION_FORCE_UINT32: _ze_raytracing_ext_version_t =
_ze_raytracing_ext_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Raytracing Extension Version(s)"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_raytracing_ext_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Raytracing Extension Version(s)"]
pub use self::_ze_raytracing_ext_version_t as ze_raytracing_ext_version_t;
impl _ze_device_raytracing_ext_flags_t {
#[doc = "< Supports rayquery"]
pub const ZE_DEVICE_RAYTRACING_EXT_FLAG_RAYQUERY: _ze_device_raytracing_ext_flags_t =
_ze_device_raytracing_ext_flags_t(1);
}
impl _ze_device_raytracing_ext_flags_t {
pub const ZE_DEVICE_RAYTRACING_EXT_FLAG_FORCE_UINT32: _ze_device_raytracing_ext_flags_t =
_ze_device_raytracing_ext_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_raytracing_ext_flags_t> for _ze_device_raytracing_ext_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_raytracing_ext_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_raytracing_ext_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_raytracing_ext_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_raytracing_ext_flags_t> for _ze_device_raytracing_ext_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_raytracing_ext_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_raytracing_ext_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_raytracing_ext_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported raytracing capability flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_raytracing_ext_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported raytracing capability flags"]
pub use self::_ze_device_raytracing_ext_flags_t as ze_device_raytracing_ext_flags_t;
#[doc = ""]
#[doc = " @brief Raytracing properties queried using ::zeDeviceGetModuleProperties"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be returned from ::zeDeviceGetModuleProperties, via"]
#[doc = " `pNext` member of ::ze_device_module_properties_t."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_raytracing_ext_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] 0 or a valid combination of ::ze_device_raytracing_ext_flags_t"]
pub flags: ze_device_raytracing_ext_flags_t,
#[doc = "< [out] Maximum number of BVH levels supported"]
pub maxBVHLevels: u32,
}
#[test]
fn bindgen_test_layout__ze_device_raytracing_ext_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_raytracing_ext_properties_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_device_raytracing_ext_properties_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_raytracing_ext_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_raytracing_ext_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_raytracing_ext_properties_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_raytracing_ext_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_raytracing_ext_properties_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_raytracing_ext_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_raytracing_ext_properties_t>())).flags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_raytracing_ext_properties_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_raytracing_ext_properties_t>())).maxBVHLevels
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_raytracing_ext_properties_t),
"::",
stringify!(maxBVHLevels)
)
);
}
impl Default for _ze_device_raytracing_ext_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl _ze_raytracing_mem_alloc_ext_flags_t {
#[doc = "< reserved for future use"]
pub const ZE_RAYTRACING_MEM_ALLOC_EXT_FLAG_TBD: _ze_raytracing_mem_alloc_ext_flags_t =
_ze_raytracing_mem_alloc_ext_flags_t(1);
}
impl _ze_raytracing_mem_alloc_ext_flags_t {
pub const ZE_RAYTRACING_MEM_ALLOC_EXT_FLAG_FORCE_UINT32: _ze_raytracing_mem_alloc_ext_flags_t =
_ze_raytracing_mem_alloc_ext_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_raytracing_mem_alloc_ext_flags_t>
for _ze_raytracing_mem_alloc_ext_flags_t
{
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_raytracing_mem_alloc_ext_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_raytracing_mem_alloc_ext_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_raytracing_mem_alloc_ext_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_raytracing_mem_alloc_ext_flags_t>
for _ze_raytracing_mem_alloc_ext_flags_t
{
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_raytracing_mem_alloc_ext_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_raytracing_mem_alloc_ext_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_raytracing_mem_alloc_ext_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported raytracing memory allocation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_raytracing_mem_alloc_ext_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported raytracing memory allocation flags"]
pub use self::_ze_raytracing_mem_alloc_ext_flags_t as ze_raytracing_mem_alloc_ext_flags_t;
#[doc = ""]
#[doc = " @brief Raytracing memory allocation descriptor"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure must be passed to ::zeMemAllocShared or"]
#[doc = " ::zeMemAllocDevice, via `pNext` member of"]
#[doc = " ::ze_device_mem_alloc_desc_t, for any memory allocation that is to be"]
#[doc = " accessed by raytracing fixed-function of the device."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_raytracing_mem_alloc_ext_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying additional allocation controls."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_raytracing_mem_alloc_ext_flags_t;"]
#[doc = "< default behavior may use implicit driver-based heuristics."]
pub flags: ze_raytracing_mem_alloc_ext_flags_t,
}
#[test]
fn bindgen_test_layout__ze_raytracing_mem_alloc_ext_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_raytracing_mem_alloc_ext_desc_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_raytracing_mem_alloc_ext_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_raytracing_mem_alloc_ext_desc_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_raytracing_mem_alloc_ext_desc_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_raytracing_mem_alloc_ext_desc_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_raytracing_mem_alloc_ext_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_raytracing_mem_alloc_ext_desc_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_raytracing_mem_alloc_ext_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_raytracing_mem_alloc_ext_desc_t>())).flags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_raytracing_mem_alloc_ext_desc_t),
"::",
stringify!(flags)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Makes memory resident for the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the memory is resident before being"]
#[doc = " referenced by the device"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeContextMakeMemoryResident(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
ptr: *mut ::std::os::raw::c_void,
size: usize,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Allows memory to be evicted from the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the memory before it is evicted"]
#[doc = " - The application may free the memory without evicting; the memory is"]
#[doc = " implicitly evicted when freed."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeContextEvictMemory(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
ptr: *mut ::std::os::raw::c_void,
size: usize,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Makes image resident for the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the image is resident before being"]
#[doc = " referenced by the device"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " + `nullptr == hImage`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeContextMakeImageResident(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
hImage: ze_image_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Allows image to be evicted from the device."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the image before it is evicted"]
#[doc = " - The application may destroy the image without evicting; the image is"]
#[doc = " implicitly evicted when destroyed."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " + `nullptr == hImage`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeContextEvictImage(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
hImage: ze_image_handle_t,
) -> ze_result_t;
}
impl _ze_sampler_address_mode_t {
#[doc = "< No coordinate modifications for out-of-bounds image access."]
pub const ZE_SAMPLER_ADDRESS_MODE_NONE: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(0);
}
impl _ze_sampler_address_mode_t {
#[doc = "< Out-of-bounds coordinates are wrapped back around."]
pub const ZE_SAMPLER_ADDRESS_MODE_REPEAT: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(1);
}
impl _ze_sampler_address_mode_t {
#[doc = "< Out-of-bounds coordinates are clamped to edge."]
pub const ZE_SAMPLER_ADDRESS_MODE_CLAMP: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(2);
}
impl _ze_sampler_address_mode_t {
#[doc = "< Out-of-bounds coordinates are clamped to border color which is (0.0f,"]
#[doc = "< 0.0f, 0.0f, 0.0f) if image format swizzle contains alpha, otherwise"]
#[doc = "< (0.0f, 0.0f, 0.0f, 1.0f)."]
pub const ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(3);
}
impl _ze_sampler_address_mode_t {
#[doc = "< Out-of-bounds coordinates are mirrored starting from edge."]
pub const ZE_SAMPLER_ADDRESS_MODE_MIRROR: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(4);
}
impl _ze_sampler_address_mode_t {
pub const ZE_SAMPLER_ADDRESS_MODE_FORCE_UINT32: _ze_sampler_address_mode_t =
_ze_sampler_address_mode_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Sampler addressing modes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_sampler_address_mode_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Sampler addressing modes"]
pub use self::_ze_sampler_address_mode_t as ze_sampler_address_mode_t;
impl _ze_sampler_filter_mode_t {
#[doc = "< No coordinate modifications for out of bounds image access."]
pub const ZE_SAMPLER_FILTER_MODE_NEAREST: _ze_sampler_filter_mode_t =
_ze_sampler_filter_mode_t(0);
}
impl _ze_sampler_filter_mode_t {
#[doc = "< Out-of-bounds coordinates are wrapped back around."]
pub const ZE_SAMPLER_FILTER_MODE_LINEAR: _ze_sampler_filter_mode_t =
_ze_sampler_filter_mode_t(1);
}
impl _ze_sampler_filter_mode_t {
pub const ZE_SAMPLER_FILTER_MODE_FORCE_UINT32: _ze_sampler_filter_mode_t =
_ze_sampler_filter_mode_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Sampler filtering modes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_sampler_filter_mode_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Sampler filtering modes"]
pub use self::_ze_sampler_filter_mode_t as ze_sampler_filter_mode_t;
#[doc = ""]
#[doc = " @brief Sampler descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_sampler_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] Sampler addressing mode to determine how out-of-bounds"]
#[doc = "< coordinates are handled."]
pub addressMode: ze_sampler_address_mode_t,
#[doc = "< [in] Sampler filter mode to determine how samples are filtered."]
pub filterMode: ze_sampler_filter_mode_t,
#[doc = "< [in] Are coordinates normalized [0, 1] or not."]
pub isNormalized: ze_bool_t,
}
#[test]
fn bindgen_test_layout__ze_sampler_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_sampler_desc_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_sampler_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_sampler_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_sampler_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_sampler_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_sampler_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_sampler_desc_t>())).addressMode as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_desc_t),
"::",
stringify!(addressMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_sampler_desc_t>())).filterMode as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_desc_t),
"::",
stringify!(filterMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_sampler_desc_t>())).isNormalized as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_desc_t),
"::",
stringify!(isNormalized)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates sampler on the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the sampler for the device, or its"]
#[doc = " sub-devices, which was provided during creation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phSampler`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `::ZE_SAMPLER_ADDRESS_MODE_MIRROR < desc->addressMode`"]
#[doc = " + `::ZE_SAMPLER_FILTER_MODE_LINEAR < desc->filterMode`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
pub fn zeSamplerCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *const ze_sampler_desc_t,
phSampler: *mut ze_sampler_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys sampler object"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the sampler before it is deleted."]
#[doc = " - The implementation of this function may immediately free all Host and"]
#[doc = " Device allocations associated with this sampler."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same sampler handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hSampler`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zeSamplerDestroy(hSampler: ze_sampler_handle_t) -> ze_result_t;
}
impl _ze_memory_access_attribute_t {
#[doc = "< Indicates the memory page is inaccessible."]
pub const ZE_MEMORY_ACCESS_ATTRIBUTE_NONE: _ze_memory_access_attribute_t =
_ze_memory_access_attribute_t(0);
}
impl _ze_memory_access_attribute_t {
#[doc = "< Indicates the memory page supports read write access."]
pub const ZE_MEMORY_ACCESS_ATTRIBUTE_READWRITE: _ze_memory_access_attribute_t =
_ze_memory_access_attribute_t(1);
}
impl _ze_memory_access_attribute_t {
#[doc = "< Indicates the memory page supports read-only access."]
pub const ZE_MEMORY_ACCESS_ATTRIBUTE_READONLY: _ze_memory_access_attribute_t =
_ze_memory_access_attribute_t(2);
}
impl _ze_memory_access_attribute_t {
pub const ZE_MEMORY_ACCESS_ATTRIBUTE_FORCE_UINT32: _ze_memory_access_attribute_t =
_ze_memory_access_attribute_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Virtual memory page access attributes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_memory_access_attribute_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Virtual memory page access attributes"]
pub use self::_ze_memory_access_attribute_t as ze_memory_access_attribute_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Reserves pages in virtual address space."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the memory allocation on the context for"]
#[doc = " which it was created."]
#[doc = " - The starting address and size must be page aligned. See"]
#[doc = " ::zeVirtualMemQueryPageSize."]
#[doc = " - If pStart is not null then implementation will attempt to reserve"]
#[doc = " starting from that address. If not available then will find another"]
#[doc = " suitable starting address."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The access attributes will default to none to indicate reservation is"]
#[doc = " inaccessible."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pStart`"]
#[doc = " + `nullptr == pptr`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
pub fn zeVirtualMemReserve(
hContext: ze_context_handle_t,
pStart: *const ::std::os::raw::c_void,
size: usize,
pptr: *mut *mut ::std::os::raw::c_void,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Free pages in a reserved virtual address range."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - Any existing virtual mappings for the range will be unmapped."]
#[doc = " - Physical allocations objects that were mapped to this range will not"]
#[doc = " be destroyed. These need to be destroyed explicitly."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
pub fn zeVirtualMemFree(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Queries page size to use for aligning virtual memory reservations and"]
#[doc = " physical memory allocations."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == pagesize`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
pub fn zeVirtualMemQueryPageSize(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
size: usize,
pagesize: *mut usize,
) -> ze_result_t;
}
impl _ze_physical_mem_flags_t {
#[doc = "< reserved for future use."]
pub const ZE_PHYSICAL_MEM_FLAG_TBD: _ze_physical_mem_flags_t = _ze_physical_mem_flags_t(1);
}
impl _ze_physical_mem_flags_t {
pub const ZE_PHYSICAL_MEM_FLAG_FORCE_UINT32: _ze_physical_mem_flags_t =
_ze_physical_mem_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_physical_mem_flags_t> for _ze_physical_mem_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_physical_mem_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_physical_mem_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_physical_mem_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_physical_mem_flags_t> for _ze_physical_mem_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_physical_mem_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_physical_mem_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_physical_mem_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported physical memory creation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_physical_mem_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported physical memory creation flags"]
pub use self::_ze_physical_mem_flags_t as ze_physical_mem_flags_t;
#[doc = ""]
#[doc = " @brief Physical memory descriptor"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_physical_mem_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] creation flags."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_physical_mem_flags_t."]
pub flags: ze_physical_mem_flags_t,
#[doc = "< [in] size in bytes to reserve; must be page aligned."]
pub size: usize,
}
#[test]
fn bindgen_test_layout__ze_physical_mem_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_physical_mem_desc_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_physical_mem_desc_t))
);
assert_eq!(
::std::mem::align_of::<_ze_physical_mem_desc_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_physical_mem_desc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_physical_mem_desc_t>())).stype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_physical_mem_desc_t>())).pNext as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_physical_mem_desc_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_desc_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_physical_mem_desc_t>())).size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_desc_t),
"::",
stringify!(size)
)
);
}
extern "C" {
#[doc = ""]
#[doc = " @brief Creates a physical memory object for the context."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must only use the physical memory object on the"]
#[doc = " context for which it was created."]
#[doc = " - The size must be page aligned. See ::zeVirtualMemQueryPageSize."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hDevice`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == desc`"]
#[doc = " + `nullptr == phPhysicalMemory`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `0x1 < desc->flags`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == desc->size`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
pub fn zePhysicalMemCreate(
hContext: ze_context_handle_t,
hDevice: ze_device_handle_t,
desc: *mut ze_physical_mem_desc_t,
phPhysicalMemory: *mut ze_physical_mem_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Destroys a physical memory object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The application must ensure the device is not currently referencing"]
#[doc = " the physical memory object before it is deleted"]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same physical memory handle."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hPhysicalMemory`"]
#[doc = " - ::ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE"]
pub fn zePhysicalMemDestroy(
hContext: ze_context_handle_t,
hPhysicalMemory: ze_physical_mem_handle_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Maps pages in virtual address space to pages from physical memory"]
#[doc = " object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The virtual address range must have been reserved using"]
#[doc = " ::zeVirtualMemReserve."]
#[doc = " - The application must only use the mapped memory allocation on the"]
#[doc = " context for which it was created."]
#[doc = " - The virtual start address and size must be page aligned. See"]
#[doc = " ::zeVirtualMemQueryPageSize."]
#[doc = " - The application should use, for the starting address and size, the"]
#[doc = " same size alignment used for the physical allocation."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " + `nullptr == hPhysicalMemory`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `::ZE_MEMORY_ACCESS_ATTRIBUTE_READONLY < access`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT"]
pub fn zeVirtualMemMap(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
hPhysicalMemory: ze_physical_mem_handle_t,
offset: usize,
access: ze_memory_access_attribute_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Unmaps pages in virtual address space from pages from a physical"]
#[doc = " memory object."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The page access attributes for virtual address range will revert back"]
#[doc = " to none."]
#[doc = " - The application may call this function from simultaneous threads."]
#[doc = " - The implementation of this function must be thread-safe."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT - \"Address must be page aligned\""]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " + Size must be page aligned"]
pub fn zeVirtualMemUnmap(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Set memory access attributes for a virtual address range."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This function may be called from simultaneous threads with the same"]
#[doc = " function handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_ENUMERATION"]
#[doc = " + `::ZE_MEMORY_ACCESS_ATTRIBUTE_READONLY < access`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT - \"Address must be page aligned\""]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " + Size must be page aligned"]
pub fn zeVirtualMemSetAccessAttribute(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
access: ze_memory_access_attribute_t,
) -> ze_result_t;
}
extern "C" {
#[doc = ""]
#[doc = " @brief Get memory access attribute for a virtual address range."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - If size and outSize are equal then the pages in the specified virtual"]
#[doc = " address range have the same access attributes."]
#[doc = " - This function may be called from simultaneous threads with the same"]
#[doc = " function handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hContext`"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER"]
#[doc = " + `nullptr == ptr`"]
#[doc = " + `nullptr == access`"]
#[doc = " + `nullptr == outSize`"]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT - \"Address must be page aligned\""]
#[doc = " - ::ZE_RESULT_ERROR_UNSUPPORTED_SIZE"]
#[doc = " + `0 == size`"]
#[doc = " + Size must be page aligned"]
pub fn zeVirtualMemGetAccessAttribute(
hContext: ze_context_handle_t,
ptr: *const ::std::os::raw::c_void,
size: usize,
access: *mut ze_memory_access_attribute_t,
outSize: *mut usize,
) -> ze_result_t;
}
impl _ze_float_atomics_ext_version_t {
#[doc = "< version 1.0"]
pub const ZE_FLOAT_ATOMICS_EXT_VERSION_1_0: _ze_float_atomics_ext_version_t =
_ze_float_atomics_ext_version_t(65536);
}
impl _ze_float_atomics_ext_version_t {
#[doc = "< latest known version"]
pub const ZE_FLOAT_ATOMICS_EXT_VERSION_CURRENT: _ze_float_atomics_ext_version_t =
_ze_float_atomics_ext_version_t(65536);
}
impl _ze_float_atomics_ext_version_t {
pub const ZE_FLOAT_ATOMICS_EXT_VERSION_FORCE_UINT32: _ze_float_atomics_ext_version_t =
_ze_float_atomics_ext_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Floating-Point Atomics Extension Version(s)"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_float_atomics_ext_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Floating-Point Atomics Extension Version(s)"]
pub use self::_ze_float_atomics_ext_version_t as ze_float_atomics_ext_version_t;
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic load, store, and exchange"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_LOAD_STORE: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(1);
}
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic add and subtract"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_ADD: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(2);
}
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic min and max"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_MIN_MAX: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(4);
}
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic load, store, and exchange"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_LOAD_STORE: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(65536);
}
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic add and subtract"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_ADD: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(131072);
}
impl _ze_device_fp_atomic_ext_flags_t {
#[doc = "< Supports atomic min and max"]
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_MIN_MAX: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(262144);
}
impl _ze_device_fp_atomic_ext_flags_t {
pub const ZE_DEVICE_FP_ATOMIC_EXT_FLAG_FORCE_UINT32: _ze_device_fp_atomic_ext_flags_t =
_ze_device_fp_atomic_ext_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_device_fp_atomic_ext_flags_t> for _ze_device_fp_atomic_ext_flags_t {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_device_fp_atomic_ext_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_device_fp_atomic_ext_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_device_fp_atomic_ext_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_device_fp_atomic_ext_flags_t> for _ze_device_fp_atomic_ext_flags_t {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_device_fp_atomic_ext_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_device_fp_atomic_ext_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_device_fp_atomic_ext_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported floating-point atomic capability flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_device_fp_atomic_ext_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported floating-point atomic capability flags"]
pub use self::_ze_device_fp_atomic_ext_flags_t as ze_device_fp_atomic_ext_flags_t;
#[doc = ""]
#[doc = " @brief Device floating-point atomic properties queried using"]
#[doc = " ::zeDeviceGetModuleProperties"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be returned from ::zeDeviceGetModuleProperties, via"]
#[doc = " `pNext` member of ::ze_device_module_properties_t."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_float_atomic_ext_properties_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in,out][optional] pointer to extension-specific structure"]
pub pNext: *mut ::std::os::raw::c_void,
#[doc = "< [out] Capabilities for half-precision floating-point atomic operations"]
pub fp16Flags: ze_device_fp_atomic_ext_flags_t,
#[doc = "< [out] Capabilities for single-precision floating-point atomic"]
#[doc = "< operations"]
pub fp32Flags: ze_device_fp_atomic_ext_flags_t,
#[doc = "< [out] Capabilities for double-precision floating-point atomic"]
#[doc = "< operations"]
pub fp64Flags: ze_device_fp_atomic_ext_flags_t,
}
#[test]
fn bindgen_test_layout__ze_float_atomic_ext_properties_t() {
assert_eq!(
::std::mem::size_of::<_ze_float_atomic_ext_properties_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_float_atomic_ext_properties_t))
);
assert_eq!(
::std::mem::align_of::<_ze_float_atomic_ext_properties_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_float_atomic_ext_properties_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_float_atomic_ext_properties_t>())).stype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_float_atomic_ext_properties_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_float_atomic_ext_properties_t>())).pNext as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_float_atomic_ext_properties_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_float_atomic_ext_properties_t>())).fp16Flags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_float_atomic_ext_properties_t),
"::",
stringify!(fp16Flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_float_atomic_ext_properties_t>())).fp32Flags as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ze_float_atomic_ext_properties_t),
"::",
stringify!(fp32Flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_float_atomic_ext_properties_t>())).fp64Flags as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_float_atomic_ext_properties_t),
"::",
stringify!(fp64Flags)
)
);
}
impl Default for _ze_float_atomic_ext_properties_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl _ze_global_offset_exp_version_t {
#[doc = "< version 1.0"]
pub const ZE_GLOBAL_OFFSET_EXP_VERSION_1_0: _ze_global_offset_exp_version_t =
_ze_global_offset_exp_version_t(65536);
}
impl _ze_global_offset_exp_version_t {
#[doc = "< latest known version"]
pub const ZE_GLOBAL_OFFSET_EXP_VERSION_CURRENT: _ze_global_offset_exp_version_t =
_ze_global_offset_exp_version_t(65536);
}
impl _ze_global_offset_exp_version_t {
pub const ZE_GLOBAL_OFFSET_EXP_VERSION_FORCE_UINT32: _ze_global_offset_exp_version_t =
_ze_global_offset_exp_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Global Offset Extension Version(s)"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_global_offset_exp_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Global Offset Extension Version(s)"]
pub use self::_ze_global_offset_exp_version_t as ze_global_offset_exp_version_t;
extern "C" {
#[doc = ""]
#[doc = " @brief Set global work offset for a kernel on the current Host thread."]
#[doc = ""]
#[doc = " @details"]
#[doc = " - The global work offset will be used when"]
#[doc = " a ::zeCommandListAppendLaunchKernel() variant is called."]
#[doc = " - The application must **not** call this function from simultaneous"]
#[doc = " threads with the same kernel handle."]
#[doc = " - The implementation of this function should be lock-free."]
#[doc = ""]
#[doc = " @returns"]
#[doc = " - ::ZE_RESULT_SUCCESS"]
#[doc = " - ::ZE_RESULT_ERROR_UNINITIALIZED"]
#[doc = " - ::ZE_RESULT_ERROR_DEVICE_LOST"]
#[doc = " - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE"]
#[doc = " + `nullptr == hKernel`"]
pub fn zeKernelSetGlobalOffsetExp(
hKernel: ze_kernel_handle_t,
offsetX: u32,
offsetY: u32,
offsetZ: u32,
) -> ze_result_t;
}
impl _ze_relaxed_allocation_limits_exp_version_t {
#[doc = "< version 1.0"]
pub const ZE_RELAXED_ALLOCATION_LIMITS_EXP_VERSION_1_0:
_ze_relaxed_allocation_limits_exp_version_t =
_ze_relaxed_allocation_limits_exp_version_t(65536);
}
impl _ze_relaxed_allocation_limits_exp_version_t {
#[doc = "< latest known version"]
pub const ZE_RELAXED_ALLOCATION_LIMITS_EXP_VERSION_CURRENT:
_ze_relaxed_allocation_limits_exp_version_t =
_ze_relaxed_allocation_limits_exp_version_t(65536);
}
impl _ze_relaxed_allocation_limits_exp_version_t {
pub const ZE_RELAXED_ALLOCATION_LIMITS_EXP_VERSION_FORCE_UINT32:
_ze_relaxed_allocation_limits_exp_version_t =
_ze_relaxed_allocation_limits_exp_version_t(2147483647);
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Relaxed Allocation Limits Extension Version(s)"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_relaxed_allocation_limits_exp_version_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Relaxed Allocation Limits Extension Version(s)"]
pub use self::_ze_relaxed_allocation_limits_exp_version_t as ze_relaxed_allocation_limits_exp_version_t;
impl _ze_relaxed_allocation_limits_exp_flags_t {
#[doc = "< Allocation size may exceed ::ze_device_properties_t.maxMemAllocSize"]
pub const ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE:
_ze_relaxed_allocation_limits_exp_flags_t = _ze_relaxed_allocation_limits_exp_flags_t(1);
}
impl _ze_relaxed_allocation_limits_exp_flags_t {
pub const ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_FORCE_UINT32:
_ze_relaxed_allocation_limits_exp_flags_t =
_ze_relaxed_allocation_limits_exp_flags_t(2147483647);
}
impl ::std::ops::BitOr<_ze_relaxed_allocation_limits_exp_flags_t>
for _ze_relaxed_allocation_limits_exp_flags_t
{
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_ze_relaxed_allocation_limits_exp_flags_t(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _ze_relaxed_allocation_limits_exp_flags_t {
#[inline]
fn bitor_assign(&mut self, rhs: _ze_relaxed_allocation_limits_exp_flags_t) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_ze_relaxed_allocation_limits_exp_flags_t>
for _ze_relaxed_allocation_limits_exp_flags_t
{
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_ze_relaxed_allocation_limits_exp_flags_t(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _ze_relaxed_allocation_limits_exp_flags_t {
#[inline]
fn bitand_assign(&mut self, rhs: _ze_relaxed_allocation_limits_exp_flags_t) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[doc = ""]
#[doc = " @brief Supported relaxed memory allocation flags"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct _ze_relaxed_allocation_limits_exp_flags_t(pub ::std::os::raw::c_uint);
#[doc = ""]
#[doc = " @brief Supported relaxed memory allocation flags"]
pub use self::_ze_relaxed_allocation_limits_exp_flags_t as ze_relaxed_allocation_limits_exp_flags_t;
#[doc = ""]
#[doc = " @brief Relaxed limits memory allocation descriptor"]
#[doc = ""]
#[doc = " @details"]
#[doc = " - This structure may be passed to ::zeMemAllocShared or"]
#[doc = " ::zeMemAllocDevice, via `pNext` member of"]
#[doc = " ::ze_device_mem_alloc_desc_t."]
#[doc = " - This structure may also be passed to ::zeMemAllocHost, via `pNext`"]
#[doc = " member of ::ze_host_mem_alloc_desc_t."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_relaxed_allocation_limits_exp_desc_t {
#[doc = "< [in] type of this structure"]
pub stype: ze_structure_type_t,
#[doc = "< [in][optional] pointer to extension-specific structure"]
pub pNext: *const ::std::os::raw::c_void,
#[doc = "< [in] flags specifying allocation limits to relax."]
#[doc = "< must be 0 (default) or a valid combination of ::ze_relaxed_allocation_limits_exp_flags_t;"]
pub flags: ze_relaxed_allocation_limits_exp_flags_t,
}
#[test]
fn bindgen_test_layout__ze_relaxed_allocation_limits_exp_desc_t() {
assert_eq!(
::std::mem::size_of::<_ze_relaxed_allocation_limits_exp_desc_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_relaxed_allocation_limits_exp_desc_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_relaxed_allocation_limits_exp_desc_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_relaxed_allocation_limits_exp_desc_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_relaxed_allocation_limits_exp_desc_t>())).stype as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_relaxed_allocation_limits_exp_desc_t),
"::",
stringify!(stype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_relaxed_allocation_limits_exp_desc_t>())).pNext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_relaxed_allocation_limits_exp_desc_t),
"::",
stringify!(pNext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_relaxed_allocation_limits_exp_desc_t>())).flags as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_relaxed_allocation_limits_exp_desc_t),
"::",
stringify!(flags)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeInit"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_init_params_t {
pub pflags: *mut ze_init_flags_t,
}
#[test]
fn bindgen_test_layout__ze_init_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_init_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_init_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_init_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_init_params_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_init_params_t>())).pflags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_init_params_t),
"::",
stringify!(pflags)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeInit"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_init_params_t = _ze_init_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeInit"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnInitCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_init_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Global callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_global_callbacks_t {
pub pfnInitCb: ze_pfnInitCb_t,
}
#[test]
fn bindgen_test_layout__ze_global_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_global_callbacks_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_global_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_global_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_global_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_global_callbacks_t>())).pfnInitCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_global_callbacks_t),
"::",
stringify!(pfnInitCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Global callback functions pointers"]
pub type ze_global_callbacks_t = _ze_global_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGet"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_get_params_t {
pub ppCount: *mut *mut u32,
pub pphDrivers: *mut *mut ze_driver_handle_t,
}
#[test]
fn bindgen_test_layout__ze_driver_get_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_get_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_driver_get_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_get_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_driver_get_params_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_get_params_t>())).ppCount as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_params_t>())).pphDrivers as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_params_t),
"::",
stringify!(pphDrivers)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGet"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_driver_get_params_t = _ze_driver_get_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDriverGet"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDriverGetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_driver_get_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetApiVersion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_get_api_version_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub pversion: *mut *mut ze_api_version_t,
}
#[test]
fn bindgen_test_layout__ze_driver_get_api_version_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_get_api_version_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_driver_get_api_version_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_get_api_version_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_driver_get_api_version_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_api_version_params_t>())).phDriver as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_api_version_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_api_version_params_t>())).pversion as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_api_version_params_t),
"::",
stringify!(pversion)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetApiVersion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_driver_get_api_version_params_t = _ze_driver_get_api_version_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDriverGetApiVersion"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDriverGetApiVersionCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_driver_get_api_version_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_get_properties_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub ppDriverProperties: *mut *mut ze_driver_properties_t,
}
#[test]
fn bindgen_test_layout__ze_driver_get_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_get_properties_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_driver_get_properties_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_get_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_driver_get_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_properties_params_t>())).phDriver as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_properties_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_properties_params_t>())).ppDriverProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_properties_params_t),
"::",
stringify!(ppDriverProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_driver_get_properties_params_t = _ze_driver_get_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDriverGetProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDriverGetPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_driver_get_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetIpcProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_get_ipc_properties_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub ppIpcProperties: *mut *mut ze_driver_ipc_properties_t,
}
#[test]
fn bindgen_test_layout__ze_driver_get_ipc_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_get_ipc_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_driver_get_ipc_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_driver_get_ipc_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_driver_get_ipc_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_ipc_properties_params_t>())).phDriver as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_ipc_properties_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_ipc_properties_params_t>())).ppIpcProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_ipc_properties_params_t),
"::",
stringify!(ppIpcProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetIpcProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_driver_get_ipc_properties_params_t = _ze_driver_get_ipc_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDriverGetIpcProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDriverGetIpcPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_driver_get_ipc_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetExtensionProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_driver_get_extension_properties_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub ppCount: *mut *mut u32,
pub ppExtensionProperties: *mut *mut ze_driver_extension_properties_t,
}
#[test]
fn bindgen_test_layout__ze_driver_get_extension_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_get_extension_properties_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_driver_get_extension_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_driver_get_extension_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_driver_get_extension_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_extension_properties_params_t>())).phDriver
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_extension_properties_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_extension_properties_params_t>())).ppCount
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_extension_properties_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_get_extension_properties_params_t>()))
.ppExtensionProperties as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_get_extension_properties_params_t),
"::",
stringify!(ppExtensionProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDriverGetExtensionProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_driver_get_extension_properties_params_t = _ze_driver_get_extension_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDriverGetExtensionProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDriverGetExtensionPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_driver_get_extension_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Driver callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_driver_callbacks_t {
pub pfnGetCb: ze_pfnDriverGetCb_t,
pub pfnGetApiVersionCb: ze_pfnDriverGetApiVersionCb_t,
pub pfnGetPropertiesCb: ze_pfnDriverGetPropertiesCb_t,
pub pfnGetIpcPropertiesCb: ze_pfnDriverGetIpcPropertiesCb_t,
pub pfnGetExtensionPropertiesCb: ze_pfnDriverGetExtensionPropertiesCb_t,
}
#[test]
fn bindgen_test_layout__ze_driver_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_driver_callbacks_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_driver_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_driver_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_driver_callbacks_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_driver_callbacks_t>())).pfnGetCb as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_callbacks_t),
"::",
stringify!(pfnGetCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_callbacks_t>())).pfnGetApiVersionCb as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_callbacks_t),
"::",
stringify!(pfnGetApiVersionCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_callbacks_t>())).pfnGetPropertiesCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_callbacks_t),
"::",
stringify!(pfnGetPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_callbacks_t>())).pfnGetIpcPropertiesCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_callbacks_t),
"::",
stringify!(pfnGetIpcPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_driver_callbacks_t>())).pfnGetExtensionPropertiesCb
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_driver_callbacks_t),
"::",
stringify!(pfnGetExtensionPropertiesCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Driver callback functions pointers"]
pub type ze_driver_callbacks_t = _ze_driver_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGet"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub ppCount: *mut *mut u32,
pub pphDevices: *mut *mut ze_device_handle_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_device_get_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_get_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_params_t>())).phDriver as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_get_params_t>())).ppCount as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_params_t>())).pphDevices as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_params_t),
"::",
stringify!(pphDevices)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGet"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_params_t = _ze_device_get_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGet"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetSubDevices"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_sub_devices_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppCount: *mut *mut u32,
pub pphSubdevices: *mut *mut ze_device_handle_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_sub_devices_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_sub_devices_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_device_get_sub_devices_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_sub_devices_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_sub_devices_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_sub_devices_params_t>())).phDevice as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_sub_devices_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_sub_devices_params_t>())).ppCount as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_sub_devices_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_sub_devices_params_t>())).pphSubdevices
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_sub_devices_params_t),
"::",
stringify!(pphSubdevices)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetSubDevices"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_sub_devices_params_t = _ze_device_get_sub_devices_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetSubDevices"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetSubDevicesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_sub_devices_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppDeviceProperties: *mut *mut ze_device_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_properties_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_device_get_properties_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_properties_params_t>())).phDevice as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_properties_params_t>())).ppDeviceProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_properties_params_t),
"::",
stringify!(ppDeviceProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_properties_params_t = _ze_device_get_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetComputeProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_compute_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppComputeProperties: *mut *mut ze_device_compute_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_compute_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_compute_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_compute_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_compute_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_compute_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_compute_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_compute_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_compute_properties_params_t>()))
.ppComputeProperties as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_compute_properties_params_t),
"::",
stringify!(ppComputeProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetComputeProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_compute_properties_params_t = _ze_device_get_compute_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetComputeProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetComputePropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_compute_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetModuleProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_module_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppModuleProperties: *mut *mut ze_device_module_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_module_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_module_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_module_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_module_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_module_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_module_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_module_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_module_properties_params_t>())).ppModuleProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_module_properties_params_t),
"::",
stringify!(ppModuleProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetModuleProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_module_properties_params_t = _ze_device_get_module_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetModuleProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetModulePropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_module_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetCommandQueueGroupProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_command_queue_group_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppCount: *mut *mut u32,
pub ppCommandQueueGroupProperties: *mut *mut ze_command_queue_group_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_command_queue_group_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_command_queue_group_properties_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_command_queue_group_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_command_queue_group_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_command_queue_group_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_command_queue_group_properties_params_t>()))
.phDevice as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_command_queue_group_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_command_queue_group_properties_params_t>()))
.ppCount as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_command_queue_group_properties_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_command_queue_group_properties_params_t>()))
.ppCommandQueueGroupProperties as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_command_queue_group_properties_params_t),
"::",
stringify!(ppCommandQueueGroupProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetCommandQueueGroupProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_command_queue_group_properties_params_t =
_ze_device_get_command_queue_group_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetCommandQueueGroupProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetCommandQueueGroupPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_command_queue_group_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetMemoryProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_memory_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppCount: *mut *mut u32,
pub ppMemProperties: *mut *mut ze_device_memory_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_memory_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_memory_properties_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_memory_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_memory_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_memory_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_memory_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_memory_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_memory_properties_params_t>())).ppCount
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_memory_properties_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_memory_properties_params_t>())).ppMemProperties
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_memory_properties_params_t),
"::",
stringify!(ppMemProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetMemoryProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_memory_properties_params_t = _ze_device_get_memory_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetMemoryProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetMemoryPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_memory_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetMemoryAccessProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_memory_access_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppMemAccessProperties: *mut *mut ze_device_memory_access_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_memory_access_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_memory_access_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_memory_access_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_memory_access_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_memory_access_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_memory_access_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_memory_access_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_memory_access_properties_params_t>()))
.ppMemAccessProperties as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_memory_access_properties_params_t),
"::",
stringify!(ppMemAccessProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetMemoryAccessProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_memory_access_properties_params_t =
_ze_device_get_memory_access_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetMemoryAccessProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetMemoryAccessPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_memory_access_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetCacheProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_cache_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppCount: *mut *mut u32,
pub ppCacheProperties: *mut *mut ze_device_cache_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_cache_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_cache_properties_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_cache_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_cache_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_cache_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_cache_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_cache_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_cache_properties_params_t>())).ppCount as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_cache_properties_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_cache_properties_params_t>())).ppCacheProperties
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_cache_properties_params_t),
"::",
stringify!(ppCacheProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetCacheProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_cache_properties_params_t = _ze_device_get_cache_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetCacheProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetCachePropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_cache_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetImageProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_image_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppImageProperties: *mut *mut ze_device_image_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_image_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_image_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_image_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_image_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_image_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_image_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_image_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_image_properties_params_t>())).ppImageProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_image_properties_params_t),
"::",
stringify!(ppImageProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetImageProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_image_properties_params_t = _ze_device_get_image_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetImageProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetImagePropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_image_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetExternalMemoryProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_external_memory_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub ppExternalMemoryProperties: *mut *mut ze_device_external_memory_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_external_memory_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_external_memory_properties_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_external_memory_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_external_memory_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_external_memory_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_external_memory_properties_params_t>())).phDevice
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_external_memory_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_external_memory_properties_params_t>()))
.ppExternalMemoryProperties as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_external_memory_properties_params_t),
"::",
stringify!(ppExternalMemoryProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetExternalMemoryProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_external_memory_properties_params_t =
_ze_device_get_external_memory_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetExternalMemoryProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetExternalMemoryPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_external_memory_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetP2PProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_p2_p_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub phPeerDevice: *mut ze_device_handle_t,
pub ppP2PProperties: *mut *mut ze_device_p2p_properties_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_p2_p_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_p2_p_properties_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_device_get_p2_p_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_p2_p_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_get_p2_p_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_p2_p_properties_params_t>())).phDevice as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_p2_p_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_p2_p_properties_params_t>())).phPeerDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_p2_p_properties_params_t),
"::",
stringify!(phPeerDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_p2_p_properties_params_t>())).ppP2PProperties
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_p2_p_properties_params_t),
"::",
stringify!(ppP2PProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetP2PProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_p2_p_properties_params_t = _ze_device_get_p2_p_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetP2PProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetP2PPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_p2_p_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceCanAccessPeer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_can_access_peer_params_t {
pub phDevice: *mut ze_device_handle_t,
pub phPeerDevice: *mut ze_device_handle_t,
pub pvalue: *mut *mut ze_bool_t,
}
#[test]
fn bindgen_test_layout__ze_device_can_access_peer_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_can_access_peer_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_device_can_access_peer_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_can_access_peer_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_device_can_access_peer_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_can_access_peer_params_t>())).phDevice as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_can_access_peer_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_can_access_peer_params_t>())).phPeerDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_can_access_peer_params_t),
"::",
stringify!(phPeerDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_can_access_peer_params_t>())).pvalue as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_can_access_peer_params_t),
"::",
stringify!(pvalue)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceCanAccessPeer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_can_access_peer_params_t = _ze_device_can_access_peer_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceCanAccessPeer"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceCanAccessPeerCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_can_access_peer_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_device_get_status_params_t {
pub phDevice: *mut ze_device_handle_t,
}
#[test]
fn bindgen_test_layout__ze_device_get_status_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_get_status_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_device_get_status_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_get_status_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_get_status_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_get_status_params_t>())).phDevice as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_get_status_params_t),
"::",
stringify!(phDevice)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeDeviceGetStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_device_get_status_params_t = _ze_device_get_status_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeDeviceGetStatus"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnDeviceGetStatusCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_device_get_status_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Device callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_device_callbacks_t {
pub pfnGetCb: ze_pfnDeviceGetCb_t,
pub pfnGetSubDevicesCb: ze_pfnDeviceGetSubDevicesCb_t,
pub pfnGetPropertiesCb: ze_pfnDeviceGetPropertiesCb_t,
pub pfnGetComputePropertiesCb: ze_pfnDeviceGetComputePropertiesCb_t,
pub pfnGetModulePropertiesCb: ze_pfnDeviceGetModulePropertiesCb_t,
pub pfnGetCommandQueueGroupPropertiesCb: ze_pfnDeviceGetCommandQueueGroupPropertiesCb_t,
pub pfnGetMemoryPropertiesCb: ze_pfnDeviceGetMemoryPropertiesCb_t,
pub pfnGetMemoryAccessPropertiesCb: ze_pfnDeviceGetMemoryAccessPropertiesCb_t,
pub pfnGetCachePropertiesCb: ze_pfnDeviceGetCachePropertiesCb_t,
pub pfnGetImagePropertiesCb: ze_pfnDeviceGetImagePropertiesCb_t,
pub pfnGetExternalMemoryPropertiesCb: ze_pfnDeviceGetExternalMemoryPropertiesCb_t,
pub pfnGetP2PPropertiesCb: ze_pfnDeviceGetP2PPropertiesCb_t,
pub pfnCanAccessPeerCb: ze_pfnDeviceCanAccessPeerCb_t,
pub pfnGetStatusCb: ze_pfnDeviceGetStatusCb_t,
}
#[test]
fn bindgen_test_layout__ze_device_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_device_callbacks_t>(),
112usize,
concat!("Size of: ", stringify!(_ze_device_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_device_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_device_callbacks_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetCb as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetSubDevicesCb as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetSubDevicesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetPropertiesCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetComputePropertiesCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetComputePropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetModulePropertiesCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetModulePropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetCommandQueueGroupPropertiesCb
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetCommandQueueGroupPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetMemoryPropertiesCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetMemoryPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetMemoryAccessPropertiesCb
as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetMemoryAccessPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetCachePropertiesCb as *const _
as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetCachePropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetImagePropertiesCb as *const _
as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetImagePropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetExternalMemoryPropertiesCb
as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetExternalMemoryPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetP2PPropertiesCb as *const _
as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetP2PPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnCanAccessPeerCb as *const _
as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnCanAccessPeerCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_device_callbacks_t>())).pfnGetStatusCb as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(_ze_device_callbacks_t),
"::",
stringify!(pfnGetStatusCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Device callback functions pointers"]
pub type ze_device_callbacks_t = _ze_device_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_create_params_t {
pub phDriver: *mut ze_driver_handle_t,
pub pdesc: *mut *const ze_context_desc_t,
pub pphContext: *mut *mut ze_context_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_create_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_context_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_context_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_create_params_t>())).phDriver as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_create_params_t),
"::",
stringify!(phDriver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_create_params_t>())).pdesc as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_create_params_t>())).pphContext as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_create_params_t),
"::",
stringify!(pphContext)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_create_params_t = _ze_context_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_destroy_params_t {
pub phContext: *mut ze_context_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_context_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_context_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_destroy_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_destroy_params_t),
"::",
stringify!(phContext)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_destroy_params_t = _ze_context_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextGetStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_get_status_params_t {
pub phContext: *mut ze_context_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_get_status_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_get_status_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_context_get_status_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_get_status_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_context_get_status_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_get_status_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_get_status_params_t),
"::",
stringify!(phContext)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextGetStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_get_status_params_t = _ze_context_get_status_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextGetStatus"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextGetStatusCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_get_status_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextSystemBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_system_barrier_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_system_barrier_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_system_barrier_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_context_system_barrier_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_system_barrier_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_context_system_barrier_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_system_barrier_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_system_barrier_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_system_barrier_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_system_barrier_params_t),
"::",
stringify!(phDevice)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextSystemBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_system_barrier_params_t = _ze_context_system_barrier_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextSystemBarrier"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextSystemBarrierCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_system_barrier_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextMakeMemoryResident"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_make_memory_resident_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pptr: *mut *mut ::std::os::raw::c_void,
pub psize: *mut usize,
}
#[test]
fn bindgen_test_layout__ze_context_make_memory_resident_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_make_memory_resident_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_context_make_memory_resident_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_context_make_memory_resident_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_context_make_memory_resident_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_memory_resident_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_memory_resident_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_memory_resident_params_t>())).phDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_memory_resident_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_memory_resident_params_t>())).pptr as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_memory_resident_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_memory_resident_params_t>())).psize as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_memory_resident_params_t),
"::",
stringify!(psize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextMakeMemoryResident"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_make_memory_resident_params_t = _ze_context_make_memory_resident_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextMakeMemoryResident"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextMakeMemoryResidentCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_make_memory_resident_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextEvictMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_evict_memory_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pptr: *mut *mut ::std::os::raw::c_void,
pub psize: *mut usize,
}
#[test]
fn bindgen_test_layout__ze_context_evict_memory_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_evict_memory_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_context_evict_memory_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_evict_memory_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_context_evict_memory_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_memory_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_memory_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_memory_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_memory_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_memory_params_t>())).pptr as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_memory_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_memory_params_t>())).psize as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_memory_params_t),
"::",
stringify!(psize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextEvictMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_evict_memory_params_t = _ze_context_evict_memory_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextEvictMemory"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextEvictMemoryCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_evict_memory_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextMakeImageResident"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_make_image_resident_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub phImage: *mut ze_image_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_make_image_resident_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_make_image_resident_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_context_make_image_resident_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_context_make_image_resident_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_context_make_image_resident_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_image_resident_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_image_resident_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_image_resident_params_t>())).phDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_image_resident_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_make_image_resident_params_t>())).phImage as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_make_image_resident_params_t),
"::",
stringify!(phImage)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextMakeImageResident"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_make_image_resident_params_t = _ze_context_make_image_resident_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextMakeImageResident"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextMakeImageResidentCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_make_image_resident_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextEvictImage"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_context_evict_image_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub phImage: *mut ze_image_handle_t,
}
#[test]
fn bindgen_test_layout__ze_context_evict_image_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_evict_image_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_context_evict_image_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_evict_image_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_context_evict_image_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_image_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_image_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_image_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_image_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_evict_image_params_t>())).phImage as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_evict_image_params_t),
"::",
stringify!(phImage)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeContextEvictImage"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_context_evict_image_params_t = _ze_context_evict_image_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeContextEvictImage"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnContextEvictImageCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_context_evict_image_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Context callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_context_callbacks_t {
pub pfnCreateCb: ze_pfnContextCreateCb_t,
pub pfnDestroyCb: ze_pfnContextDestroyCb_t,
pub pfnGetStatusCb: ze_pfnContextGetStatusCb_t,
pub pfnSystemBarrierCb: ze_pfnContextSystemBarrierCb_t,
pub pfnMakeMemoryResidentCb: ze_pfnContextMakeMemoryResidentCb_t,
pub pfnEvictMemoryCb: ze_pfnContextEvictMemoryCb_t,
pub pfnMakeImageResidentCb: ze_pfnContextMakeImageResidentCb_t,
pub pfnEvictImageCb: ze_pfnContextEvictImageCb_t,
}
#[test]
fn bindgen_test_layout__ze_context_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_context_callbacks_t>(),
64usize,
concat!("Size of: ", stringify!(_ze_context_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_context_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_context_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnGetStatusCb as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnGetStatusCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnSystemBarrierCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnSystemBarrierCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnMakeMemoryResidentCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnMakeMemoryResidentCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnEvictMemoryCb as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnEvictMemoryCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnMakeImageResidentCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnMakeImageResidentCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_context_callbacks_t>())).pfnEvictImageCb as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_context_callbacks_t),
"::",
stringify!(pfnEvictImageCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Context callback functions pointers"]
pub type ze_context_callbacks_t = _ze_context_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_command_queue_desc_t,
pub pphCommandQueue: *mut *mut ze_command_queue_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_queue_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_create_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_command_queue_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_create_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_queue_create_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_create_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_create_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_create_params_t>())).pdesc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_create_params_t>())).pphCommandQueue
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_create_params_t),
"::",
stringify!(pphCommandQueue)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_queue_create_params_t = _ze_command_queue_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandQueueCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandQueueCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_queue_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_destroy_params_t {
pub phCommandQueue: *mut ze_command_queue_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_queue_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_command_queue_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_destroy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_queue_destroy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_destroy_params_t>())).phCommandQueue
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_destroy_params_t),
"::",
stringify!(phCommandQueue)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_queue_destroy_params_t = _ze_command_queue_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandQueueDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandQueueDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_queue_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueExecuteCommandLists"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_execute_command_lists_params_t {
pub phCommandQueue: *mut ze_command_queue_handle_t,
pub pnumCommandLists: *mut u32,
pub pphCommandLists: *mut *mut ze_command_list_handle_t,
pub phFence: *mut ze_fence_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_queue_execute_command_lists_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_execute_command_lists_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_command_queue_execute_command_lists_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_execute_command_lists_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_queue_execute_command_lists_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_execute_command_lists_params_t>()))
.phCommandQueue as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_execute_command_lists_params_t),
"::",
stringify!(phCommandQueue)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_execute_command_lists_params_t>()))
.pnumCommandLists as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_execute_command_lists_params_t),
"::",
stringify!(pnumCommandLists)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_execute_command_lists_params_t>()))
.pphCommandLists as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_execute_command_lists_params_t),
"::",
stringify!(pphCommandLists)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_execute_command_lists_params_t>())).phFence
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_execute_command_lists_params_t),
"::",
stringify!(phFence)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueExecuteCommandLists"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_queue_execute_command_lists_params_t =
_ze_command_queue_execute_command_lists_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandQueueExecuteCommandLists"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandQueueExecuteCommandListsCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_queue_execute_command_lists_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_queue_synchronize_params_t {
pub phCommandQueue: *mut ze_command_queue_handle_t,
pub ptimeout: *mut u64,
}
#[test]
fn bindgen_test_layout__ze_command_queue_synchronize_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_synchronize_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_command_queue_synchronize_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_synchronize_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_queue_synchronize_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_synchronize_params_t>())).phCommandQueue
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_synchronize_params_t),
"::",
stringify!(phCommandQueue)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_synchronize_params_t>())).ptimeout as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_synchronize_params_t),
"::",
stringify!(ptimeout)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandQueueSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_queue_synchronize_params_t = _ze_command_queue_synchronize_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandQueueSynchronize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandQueueSynchronizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_queue_synchronize_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of CommandQueue callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_command_queue_callbacks_t {
pub pfnCreateCb: ze_pfnCommandQueueCreateCb_t,
pub pfnDestroyCb: ze_pfnCommandQueueDestroyCb_t,
pub pfnExecuteCommandListsCb: ze_pfnCommandQueueExecuteCommandListsCb_t,
pub pfnSynchronizeCb: ze_pfnCommandQueueSynchronizeCb_t,
}
#[test]
fn bindgen_test_layout__ze_command_queue_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_queue_callbacks_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_command_queue_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_queue_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_queue_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_callbacks_t>())).pfnCreateCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_callbacks_t>())).pfnDestroyCb as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_callbacks_t>())).pfnExecuteCommandListsCb
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_callbacks_t),
"::",
stringify!(pfnExecuteCommandListsCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_queue_callbacks_t>())).pfnSynchronizeCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_queue_callbacks_t),
"::",
stringify!(pfnSynchronizeCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of CommandQueue callback functions pointers"]
pub type ze_command_queue_callbacks_t = _ze_command_queue_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_command_list_desc_t,
pub pphCommandList: *mut *mut ze_command_list_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_create_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_command_list_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_create_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_create_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_params_t>())).pdesc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_params_t>())).pphCommandList as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_params_t),
"::",
stringify!(pphCommandList)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_create_params_t = _ze_command_list_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListCreateImmediate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_create_immediate_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub paltdesc: *mut *const ze_command_queue_desc_t,
pub pphCommandList: *mut *mut ze_command_list_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_create_immediate_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_create_immediate_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_create_immediate_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_create_immediate_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_create_immediate_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_immediate_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_immediate_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_immediate_params_t>())).phDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_immediate_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_immediate_params_t>())).paltdesc
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_immediate_params_t),
"::",
stringify!(paltdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_create_immediate_params_t>())).pphCommandList
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_create_immediate_params_t),
"::",
stringify!(pphCommandList)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListCreateImmediate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_create_immediate_params_t = _ze_command_list_create_immediate_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListCreateImmediate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListCreateImmediateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_create_immediate_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_destroy_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_command_list_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_destroy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_destroy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_destroy_params_t>())).phCommandList as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_destroy_params_t),
"::",
stringify!(phCommandList)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_destroy_params_t = _ze_command_list_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListClose"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_close_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_close_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_close_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_command_list_close_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_close_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_list_close_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_close_params_t>())).phCommandList as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_close_params_t),
"::",
stringify!(phCommandList)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListClose"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_close_params_t = _ze_command_list_close_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListClose"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListCloseCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_close_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_reset_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_reset_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_reset_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_command_list_reset_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_reset_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_list_reset_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_reset_params_t>())).phCommandList as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_reset_params_t),
"::",
stringify!(phCommandList)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_reset_params_t = _ze_command_list_reset_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListReset"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListResetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_reset_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendWriteGlobalTimestamp"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_write_global_timestamp_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pdstptr: *mut *mut u64,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_write_global_timestamp_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_write_global_timestamp_params_t>(),
40usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_write_global_timestamp_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_write_global_timestamp_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_write_global_timestamp_params_t>()))
.pdstptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_write_global_timestamp_params_t>()))
.phSignalEvent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_write_global_timestamp_params_t>()))
.pnumWaitEvents as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_write_global_timestamp_params_t>()))
.pphWaitEvents as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_write_global_timestamp_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendWriteGlobalTimestamp"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_write_global_timestamp_params_t =
_ze_command_list_append_write_global_timestamp_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendWriteGlobalTimestamp"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendWriteGlobalTimestampCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_write_global_timestamp_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_barrier_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_barrier_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_barrier_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_barrier_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_barrier_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_barrier_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_barrier_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_barrier_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_barrier_params_t>())).phSignalEvent
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_barrier_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_barrier_params_t>())).pnumWaitEvents
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_barrier_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_barrier_params_t>())).pphWaitEvents
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_barrier_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_barrier_params_t = _ze_command_list_append_barrier_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendBarrier"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendBarrierCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_barrier_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryRangesBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_ranges_barrier_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pnumRanges: *mut u32,
pub ppRangeSizes: *mut *const usize,
pub ppRanges: *mut *mut *const ::std::os::raw::c_void,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_ranges_barrier_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_ranges_barrier_params_t>(),
56usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_ranges_barrier_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.pnumRanges as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(pnumRanges)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.ppRangeSizes as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(ppRangeSizes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.ppRanges as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(ppRanges)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.phSignalEvent as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.pnumWaitEvents as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_ranges_barrier_params_t>()))
.pphWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_ranges_barrier_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryRangesBarrier"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_ranges_barrier_params_t =
_ze_command_list_append_memory_ranges_barrier_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryRangesBarrier"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryRangesBarrierCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_ranges_barrier_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_copy_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pdstptr: *mut *mut ::std::os::raw::c_void,
pub psrcptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_copy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_copy_params_t>(),
56usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_copy_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_copy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_copy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).pdstptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).psrcptr
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(psrcptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).psize
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).phSignalEvent
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).pnumWaitEvents
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_params_t>())).pphWaitEvents
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_copy_params_t = _ze_command_list_append_memory_copy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryCopy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryCopyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_copy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryFill"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_fill_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pptr: *mut *mut ::std::os::raw::c_void,
pub ppattern: *mut *const ::std::os::raw::c_void,
pub ppattern_size: *mut usize,
pub psize: *mut usize,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_fill_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_fill_params_t>(),
64usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_fill_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_fill_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_fill_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).pptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).ppattern
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(ppattern)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).ppattern_size
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(ppattern_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).psize
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).phSignalEvent
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).pnumWaitEvents
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_fill_params_t>())).pphWaitEvents
as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_fill_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryFill"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_fill_params_t = _ze_command_list_append_memory_fill_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryFill"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryFillCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_fill_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopyRegion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_copy_region_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pdstptr: *mut *mut ::std::os::raw::c_void,
pub pdstRegion: *mut *const ze_copy_region_t,
pub pdstPitch: *mut u32,
pub pdstSlicePitch: *mut u32,
pub psrcptr: *mut *const ::std::os::raw::c_void,
pub psrcRegion: *mut *const ze_copy_region_t,
pub psrcPitch: *mut u32,
pub psrcSlicePitch: *mut u32,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_copy_region_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_copy_region_params_t>(),
96usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_copy_region_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_copy_region_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>())).pdstptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.pdstRegion as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pdstRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.pdstPitch as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pdstPitch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.pdstSlicePitch as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pdstSlicePitch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>())).psrcptr
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(psrcptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.psrcRegion as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(psrcRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.psrcPitch as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(psrcPitch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.psrcSlicePitch as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(psrcSlicePitch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.phSignalEvent as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.pnumWaitEvents as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_region_params_t>()))
.pphWaitEvents as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_region_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopyRegion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_copy_region_params_t =
_ze_command_list_append_memory_copy_region_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryCopyRegion"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryCopyRegionCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_copy_region_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopyFromContext"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_copy_from_context_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pdstptr: *mut *mut ::std::os::raw::c_void,
pub phContextSrc: *mut ze_context_handle_t,
pub psrcptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_copy_from_context_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_copy_from_context_params_t>(),
64usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_copy_from_context_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.pdstptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.phContextSrc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(phContextSrc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.psrcptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(psrcptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.psize as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.phSignalEvent as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.pnumWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_copy_from_context_params_t>()))
.pphWaitEvents as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_copy_from_context_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryCopyFromContext"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_copy_from_context_params_t =
_ze_command_list_append_memory_copy_from_context_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryCopyFromContext"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryCopyFromContextCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_copy_from_context_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_image_copy_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phDstImage: *mut ze_image_handle_t,
pub phSrcImage: *mut ze_image_handle_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_image_copy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_image_copy_params_t>(),
48usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_image_copy_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_image_copy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_image_copy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).phDstImage
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(phDstImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).phSrcImage
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(phSrcImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).phSignalEvent
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).pnumWaitEvents
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_params_t>())).pphWaitEvents
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_image_copy_params_t = _ze_command_list_append_image_copy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendImageCopy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendImageCopyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_image_copy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyRegion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_image_copy_region_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phDstImage: *mut ze_image_handle_t,
pub phSrcImage: *mut ze_image_handle_t,
pub ppDstRegion: *mut *const ze_image_region_t,
pub ppSrcRegion: *mut *const ze_image_region_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_image_copy_region_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_image_copy_region_params_t>(),
64usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_image_copy_region_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_image_copy_region_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_image_copy_region_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.phDstImage as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(phDstImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.phSrcImage as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(phSrcImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.ppDstRegion as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(ppDstRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.ppSrcRegion as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(ppSrcRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.phSignalEvent as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.pnumWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_region_params_t>()))
.pphWaitEvents as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_region_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyRegion"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_image_copy_region_params_t =
_ze_command_list_append_image_copy_region_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendImageCopyRegion"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendImageCopyRegionCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_image_copy_region_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyToMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_image_copy_to_memory_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pdstptr: *mut *mut ::std::os::raw::c_void,
pub phSrcImage: *mut ze_image_handle_t,
pub ppSrcRegion: *mut *const ze_image_region_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_image_copy_to_memory_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_image_copy_to_memory_params_t>(),
56usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_image_copy_to_memory_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.pdstptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.phSrcImage as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(phSrcImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.ppSrcRegion as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(ppSrcRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.phSignalEvent as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.pnumWaitEvents as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_to_memory_params_t>()))
.pphWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_to_memory_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyToMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_image_copy_to_memory_params_t =
_ze_command_list_append_image_copy_to_memory_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendImageCopyToMemory"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendImageCopyToMemoryCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_image_copy_to_memory_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyFromMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_image_copy_from_memory_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phDstImage: *mut ze_image_handle_t,
pub psrcptr: *mut *const ::std::os::raw::c_void,
pub ppDstRegion: *mut *const ze_image_region_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_image_copy_from_memory_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_image_copy_from_memory_params_t>(),
56usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_image_copy_from_memory_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.phDstImage as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(phDstImage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.psrcptr as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(psrcptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.ppDstRegion as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(ppDstRegion)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.phSignalEvent as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.pnumWaitEvents as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_image_copy_from_memory_params_t>()))
.pphWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_image_copy_from_memory_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendImageCopyFromMemory"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_image_copy_from_memory_params_t =
_ze_command_list_append_image_copy_from_memory_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendImageCopyFromMemory"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendImageCopyFromMemoryCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_image_copy_from_memory_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryPrefetch"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_memory_prefetch_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_memory_prefetch_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_memory_prefetch_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_memory_prefetch_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_memory_prefetch_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_memory_prefetch_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_prefetch_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_prefetch_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_prefetch_params_t>())).pptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_prefetch_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_memory_prefetch_params_t>())).psize
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_memory_prefetch_params_t),
"::",
stringify!(psize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemoryPrefetch"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_memory_prefetch_params_t =
_ze_command_list_append_memory_prefetch_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemoryPrefetch"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemoryPrefetchCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_memory_prefetch_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemAdvise"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_mem_advise_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub padvice: *mut ze_memory_advice_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_mem_advise_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_mem_advise_params_t>(),
40usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_mem_advise_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_mem_advise_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_mem_advise_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_mem_advise_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_mem_advise_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_mem_advise_params_t>())).phDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_mem_advise_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_mem_advise_params_t>())).pptr as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_mem_advise_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_mem_advise_params_t>())).psize
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_mem_advise_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_mem_advise_params_t>())).padvice
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_mem_advise_params_t),
"::",
stringify!(padvice)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendMemAdvise"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_mem_advise_params_t = _ze_command_list_append_mem_advise_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendMemAdvise"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendMemAdviseCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_mem_advise_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendSignalEvent"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_signal_event_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_signal_event_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_signal_event_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_signal_event_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_signal_event_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_signal_event_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_signal_event_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_signal_event_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_signal_event_params_t>())).phEvent
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_signal_event_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendSignalEvent"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_signal_event_params_t =
_ze_command_list_append_signal_event_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendSignalEvent"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendSignalEventCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_signal_event_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendWaitOnEvents"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_wait_on_events_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pnumEvents: *mut u32,
pub pphEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_wait_on_events_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_wait_on_events_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_wait_on_events_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_wait_on_events_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_wait_on_events_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_wait_on_events_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_wait_on_events_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_wait_on_events_params_t>())).pnumEvents
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_wait_on_events_params_t),
"::",
stringify!(pnumEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_wait_on_events_params_t>())).pphEvents
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_wait_on_events_params_t),
"::",
stringify!(pphEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendWaitOnEvents"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_wait_on_events_params_t =
_ze_command_list_append_wait_on_events_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendWaitOnEvents"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendWaitOnEventsCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_wait_on_events_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendEventReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_event_reset_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_event_reset_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_event_reset_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_event_reset_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_event_reset_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_event_reset_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_event_reset_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_event_reset_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_event_reset_params_t>())).phEvent
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_event_reset_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendEventReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_event_reset_params_t = _ze_command_list_append_event_reset_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendEventReset"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendEventResetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_event_reset_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendQueryKernelTimestamps"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_query_kernel_timestamps_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pnumEvents: *mut u32,
pub pphEvents: *mut *mut ze_event_handle_t,
pub pdstptr: *mut *mut ::std::os::raw::c_void,
pub ppOffsets: *mut *const usize,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_query_kernel_timestamps_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_query_kernel_timestamps_params_t>(),
64usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_query_kernel_timestamps_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.pnumEvents as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(pnumEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.pphEvents as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(pphEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.pdstptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(pdstptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.ppOffsets as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(ppOffsets)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.phSignalEvent as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.pnumWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_query_kernel_timestamps_params_t>()))
.pphWaitEvents as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_query_kernel_timestamps_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendQueryKernelTimestamps"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_query_kernel_timestamps_params_t =
_ze_command_list_append_query_kernel_timestamps_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendQueryKernelTimestamps"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendQueryKernelTimestampsCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_query_kernel_timestamps_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchKernel"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_launch_kernel_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phKernel: *mut ze_kernel_handle_t,
pub ppLaunchFuncArgs: *mut *const ze_group_count_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_launch_kernel_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_launch_kernel_params_t>(),
48usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_launch_kernel_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_launch_kernel_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_launch_kernel_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>())).phCommandList
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>())).phKernel
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>()))
.ppLaunchFuncArgs as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(ppLaunchFuncArgs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>())).phSignalEvent
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>()))
.pnumWaitEvents as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_params_t>())).pphWaitEvents
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchKernel"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_launch_kernel_params_t =
_ze_command_list_append_launch_kernel_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendLaunchKernel"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendLaunchKernelCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_launch_kernel_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchCooperativeKernel"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_launch_cooperative_kernel_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phKernel: *mut ze_kernel_handle_t,
pub ppLaunchFuncArgs: *mut *const ze_group_count_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_launch_cooperative_kernel_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_launch_cooperative_kernel_params_t>(),
48usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_launch_cooperative_kernel_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.phKernel as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.ppLaunchFuncArgs as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(ppLaunchFuncArgs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.phSignalEvent as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.pnumWaitEvents as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_cooperative_kernel_params_t>()))
.pphWaitEvents as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_cooperative_kernel_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchCooperativeKernel"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_launch_cooperative_kernel_params_t =
_ze_command_list_append_launch_cooperative_kernel_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendLaunchCooperativeKernel"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendLaunchCooperativeKernelCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_launch_cooperative_kernel_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchKernelIndirect"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_launch_kernel_indirect_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub phKernel: *mut ze_kernel_handle_t,
pub ppLaunchArgumentsBuffer: *mut *const ze_group_count_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_launch_kernel_indirect_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_launch_kernel_indirect_params_t>(),
48usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_launch_kernel_indirect_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.phKernel as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.ppLaunchArgumentsBuffer as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(ppLaunchArgumentsBuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.phSignalEvent as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.pnumWaitEvents as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_append_launch_kernel_indirect_params_t>()))
.pphWaitEvents as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_kernel_indirect_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchKernelIndirect"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_launch_kernel_indirect_params_t =
_ze_command_list_append_launch_kernel_indirect_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendLaunchKernelIndirect"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendLaunchKernelIndirectCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_launch_kernel_indirect_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchMultipleKernelsIndirect"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_command_list_append_launch_multiple_kernels_indirect_params_t {
pub phCommandList: *mut ze_command_list_handle_t,
pub pnumKernels: *mut u32,
pub pphKernels: *mut *mut ze_kernel_handle_t,
pub ppCountBuffer: *mut *const u32,
pub ppLaunchArgumentsBuffer: *mut *const ze_group_count_t,
pub phSignalEvent: *mut ze_event_handle_t,
pub pnumWaitEvents: *mut u32,
pub pphWaitEvents: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_append_launch_multiple_kernels_indirect_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_append_launch_multiple_kernels_indirect_params_t>(),
64usize,
concat!(
"Size of: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_append_launch_multiple_kernels_indirect_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.phCommandList as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(phCommandList)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.pnumKernels as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(pnumKernels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.pphKernels as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(pphKernels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.ppCountBuffer as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(ppCountBuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.ppLaunchArgumentsBuffer as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(ppLaunchArgumentsBuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.phSignalEvent as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(phSignalEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.pnumWaitEvents as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(pnumWaitEvents)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
_ze_command_list_append_launch_multiple_kernels_indirect_params_t,
>()))
.pphWaitEvents as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_append_launch_multiple_kernels_indirect_params_t),
"::",
stringify!(pphWaitEvents)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeCommandListAppendLaunchMultipleKernelsIndirect"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_command_list_append_launch_multiple_kernels_indirect_params_t =
_ze_command_list_append_launch_multiple_kernels_indirect_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeCommandListAppendLaunchMultipleKernelsIndirect"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnCommandListAppendLaunchMultipleKernelsIndirectCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_command_list_append_launch_multiple_kernels_indirect_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of CommandList callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_command_list_callbacks_t {
pub pfnCreateCb: ze_pfnCommandListCreateCb_t,
pub pfnCreateImmediateCb: ze_pfnCommandListCreateImmediateCb_t,
pub pfnDestroyCb: ze_pfnCommandListDestroyCb_t,
pub pfnCloseCb: ze_pfnCommandListCloseCb_t,
pub pfnResetCb: ze_pfnCommandListResetCb_t,
pub pfnAppendWriteGlobalTimestampCb: ze_pfnCommandListAppendWriteGlobalTimestampCb_t,
pub pfnAppendBarrierCb: ze_pfnCommandListAppendBarrierCb_t,
pub pfnAppendMemoryRangesBarrierCb: ze_pfnCommandListAppendMemoryRangesBarrierCb_t,
pub pfnAppendMemoryCopyCb: ze_pfnCommandListAppendMemoryCopyCb_t,
pub pfnAppendMemoryFillCb: ze_pfnCommandListAppendMemoryFillCb_t,
pub pfnAppendMemoryCopyRegionCb: ze_pfnCommandListAppendMemoryCopyRegionCb_t,
pub pfnAppendMemoryCopyFromContextCb: ze_pfnCommandListAppendMemoryCopyFromContextCb_t,
pub pfnAppendImageCopyCb: ze_pfnCommandListAppendImageCopyCb_t,
pub pfnAppendImageCopyRegionCb: ze_pfnCommandListAppendImageCopyRegionCb_t,
pub pfnAppendImageCopyToMemoryCb: ze_pfnCommandListAppendImageCopyToMemoryCb_t,
pub pfnAppendImageCopyFromMemoryCb: ze_pfnCommandListAppendImageCopyFromMemoryCb_t,
pub pfnAppendMemoryPrefetchCb: ze_pfnCommandListAppendMemoryPrefetchCb_t,
pub pfnAppendMemAdviseCb: ze_pfnCommandListAppendMemAdviseCb_t,
pub pfnAppendSignalEventCb: ze_pfnCommandListAppendSignalEventCb_t,
pub pfnAppendWaitOnEventsCb: ze_pfnCommandListAppendWaitOnEventsCb_t,
pub pfnAppendEventResetCb: ze_pfnCommandListAppendEventResetCb_t,
pub pfnAppendQueryKernelTimestampsCb: ze_pfnCommandListAppendQueryKernelTimestampsCb_t,
pub pfnAppendLaunchKernelCb: ze_pfnCommandListAppendLaunchKernelCb_t,
pub pfnAppendLaunchCooperativeKernelCb: ze_pfnCommandListAppendLaunchCooperativeKernelCb_t,
pub pfnAppendLaunchKernelIndirectCb: ze_pfnCommandListAppendLaunchKernelIndirectCb_t,
pub pfnAppendLaunchMultipleKernelsIndirectCb:
ze_pfnCommandListAppendLaunchMultipleKernelsIndirectCb_t,
}
#[test]
fn bindgen_test_layout__ze_command_list_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_command_list_callbacks_t>(),
208usize,
concat!("Size of: ", stringify!(_ze_command_list_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_command_list_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_command_list_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnCreateCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnCreateImmediateCb
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnCreateImmediateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnDestroyCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnCloseCb as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnCloseCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnResetCb as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnResetCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendWriteGlobalTimestampCb
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendWriteGlobalTimestampCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendBarrierCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendBarrierCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemoryRangesBarrierCb
as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryRangesBarrierCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemoryCopyCb
as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryCopyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemoryFillCb
as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryFillCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemoryCopyRegionCb
as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryCopyRegionCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>()))
.pfnAppendMemoryCopyFromContextCb as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryCopyFromContextCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendImageCopyCb
as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendImageCopyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendImageCopyRegionCb
as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendImageCopyRegionCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendImageCopyToMemoryCb
as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendImageCopyToMemoryCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendImageCopyFromMemoryCb
as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendImageCopyFromMemoryCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemoryPrefetchCb
as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemoryPrefetchCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendMemAdviseCb
as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendMemAdviseCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendSignalEventCb
as *const _ as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendSignalEventCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendWaitOnEventsCb
as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendWaitOnEventsCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendEventResetCb
as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendEventResetCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>()))
.pfnAppendQueryKernelTimestampsCb as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendQueryKernelTimestampsCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendLaunchKernelCb
as *const _ as usize
},
176usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendLaunchKernelCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>()))
.pfnAppendLaunchCooperativeKernelCb as *const _ as usize
},
184usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendLaunchCooperativeKernelCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>())).pfnAppendLaunchKernelIndirectCb
as *const _ as usize
},
192usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendLaunchKernelIndirectCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_command_list_callbacks_t>()))
.pfnAppendLaunchMultipleKernelsIndirectCb as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(_ze_command_list_callbacks_t),
"::",
stringify!(pfnAppendLaunchMultipleKernelsIndirectCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of CommandList callback functions pointers"]
pub type ze_command_list_callbacks_t = _ze_command_list_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_create_params_t {
pub phCommandQueue: *mut ze_command_queue_handle_t,
pub pdesc: *mut *const ze_fence_desc_t,
pub pphFence: *mut *mut ze_fence_handle_t,
}
#[test]
fn bindgen_test_layout__ze_fence_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_create_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_fence_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_create_params_t>())).phCommandQueue as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_create_params_t),
"::",
stringify!(phCommandQueue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_fence_create_params_t>())).pdesc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_create_params_t>())).pphFence as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_create_params_t),
"::",
stringify!(pphFence)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_fence_create_params_t = _ze_fence_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeFenceCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnFenceCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_fence_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_destroy_params_t {
pub phFence: *mut ze_fence_handle_t,
}
#[test]
fn bindgen_test_layout__ze_fence_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_fence_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_destroy_params_t>())).phFence as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_destroy_params_t),
"::",
stringify!(phFence)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_fence_destroy_params_t = _ze_fence_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeFenceDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnFenceDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_fence_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceHostSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_host_synchronize_params_t {
pub phFence: *mut ze_fence_handle_t,
pub ptimeout: *mut u64,
}
#[test]
fn bindgen_test_layout__ze_fence_host_synchronize_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_host_synchronize_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_fence_host_synchronize_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_host_synchronize_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_fence_host_synchronize_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_host_synchronize_params_t>())).phFence as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_host_synchronize_params_t),
"::",
stringify!(phFence)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_host_synchronize_params_t>())).ptimeout as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_host_synchronize_params_t),
"::",
stringify!(ptimeout)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceHostSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_fence_host_synchronize_params_t = _ze_fence_host_synchronize_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeFenceHostSynchronize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnFenceHostSynchronizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_fence_host_synchronize_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceQueryStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_query_status_params_t {
pub phFence: *mut ze_fence_handle_t,
}
#[test]
fn bindgen_test_layout__ze_fence_query_status_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_query_status_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_fence_query_status_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_query_status_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_query_status_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_query_status_params_t>())).phFence as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_query_status_params_t),
"::",
stringify!(phFence)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceQueryStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_fence_query_status_params_t = _ze_fence_query_status_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeFenceQueryStatus"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnFenceQueryStatusCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_fence_query_status_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_fence_reset_params_t {
pub phFence: *mut ze_fence_handle_t,
}
#[test]
fn bindgen_test_layout__ze_fence_reset_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_reset_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_fence_reset_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_reset_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_reset_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_reset_params_t>())).phFence as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_reset_params_t),
"::",
stringify!(phFence)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeFenceReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_fence_reset_params_t = _ze_fence_reset_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeFenceReset"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnFenceResetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_fence_reset_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Fence callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_fence_callbacks_t {
pub pfnCreateCb: ze_pfnFenceCreateCb_t,
pub pfnDestroyCb: ze_pfnFenceDestroyCb_t,
pub pfnHostSynchronizeCb: ze_pfnFenceHostSynchronizeCb_t,
pub pfnQueryStatusCb: ze_pfnFenceQueryStatusCb_t,
pub pfnResetCb: ze_pfnFenceResetCb_t,
}
#[test]
fn bindgen_test_layout__ze_fence_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_fence_callbacks_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_fence_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_fence_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_fence_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_callbacks_t>())).pfnHostSynchronizeCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_callbacks_t),
"::",
stringify!(pfnHostSynchronizeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_callbacks_t>())).pfnQueryStatusCb as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_callbacks_t),
"::",
stringify!(pfnQueryStatusCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_fence_callbacks_t>())).pfnResetCb as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_fence_callbacks_t),
"::",
stringify!(pfnResetCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Fence callback functions pointers"]
pub type ze_fence_callbacks_t = _ze_fence_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub pdesc: *mut *const ze_event_pool_desc_t,
pub pnumDevices: *mut u32,
pub pphDevices: *mut *mut ze_device_handle_t,
pub pphEventPool: *mut *mut ze_event_pool_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_create_params_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_event_pool_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_pool_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_create_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_create_params_t>())).pdesc as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_create_params_t>())).pnumDevices as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_create_params_t),
"::",
stringify!(pnumDevices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_create_params_t>())).pphDevices as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_create_params_t),
"::",
stringify!(pphDevices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_create_params_t>())).pphEventPool as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_create_params_t),
"::",
stringify!(pphEventPool)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_pool_create_params_t = _ze_event_pool_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventPoolCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventPoolCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_pool_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_destroy_params_t {
pub phEventPool: *mut ze_event_pool_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_event_pool_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_pool_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_destroy_params_t>())).phEventPool as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_destroy_params_t),
"::",
stringify!(phEventPool)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_pool_destroy_params_t = _ze_event_pool_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventPoolDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventPoolDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_pool_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolGetIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_get_ipc_handle_params_t {
pub phEventPool: *mut ze_event_pool_handle_t,
pub pphIpc: *mut *mut ze_ipc_event_pool_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_get_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_get_ipc_handle_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_event_pool_get_ipc_handle_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_get_ipc_handle_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_event_pool_get_ipc_handle_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_get_ipc_handle_params_t>())).phEventPool
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_get_ipc_handle_params_t),
"::",
stringify!(phEventPool)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_get_ipc_handle_params_t>())).pphIpc as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_get_ipc_handle_params_t),
"::",
stringify!(pphIpc)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolGetIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_pool_get_ipc_handle_params_t = _ze_event_pool_get_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventPoolGetIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventPoolGetIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_pool_get_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolOpenIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_open_ipc_handle_params_t {
pub phContext: *mut ze_context_handle_t,
pub phIpc: *mut ze_ipc_event_pool_handle_t,
pub pphEventPool: *mut *mut ze_event_pool_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_open_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_open_ipc_handle_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_event_pool_open_ipc_handle_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_open_ipc_handle_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_event_pool_open_ipc_handle_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_open_ipc_handle_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_open_ipc_handle_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_open_ipc_handle_params_t>())).phIpc as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_open_ipc_handle_params_t),
"::",
stringify!(phIpc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_open_ipc_handle_params_t>())).pphEventPool
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_open_ipc_handle_params_t),
"::",
stringify!(pphEventPool)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolOpenIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_pool_open_ipc_handle_params_t = _ze_event_pool_open_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventPoolOpenIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventPoolOpenIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_pool_open_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolCloseIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_pool_close_ipc_handle_params_t {
pub phEventPool: *mut ze_event_pool_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_close_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_close_ipc_handle_params_t>(),
8usize,
concat!(
"Size of: ",
stringify!(_ze_event_pool_close_ipc_handle_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_close_ipc_handle_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_event_pool_close_ipc_handle_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_close_ipc_handle_params_t>())).phEventPool
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_close_ipc_handle_params_t),
"::",
stringify!(phEventPool)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventPoolCloseIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_pool_close_ipc_handle_params_t = _ze_event_pool_close_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventPoolCloseIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventPoolCloseIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_pool_close_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of EventPool callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_event_pool_callbacks_t {
pub pfnCreateCb: ze_pfnEventPoolCreateCb_t,
pub pfnDestroyCb: ze_pfnEventPoolDestroyCb_t,
pub pfnGetIpcHandleCb: ze_pfnEventPoolGetIpcHandleCb_t,
pub pfnOpenIpcHandleCb: ze_pfnEventPoolOpenIpcHandleCb_t,
pub pfnCloseIpcHandleCb: ze_pfnEventPoolCloseIpcHandleCb_t,
}
#[test]
fn bindgen_test_layout__ze_event_pool_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_pool_callbacks_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_event_pool_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_pool_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_pool_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_callbacks_t>())).pfnGetIpcHandleCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_callbacks_t),
"::",
stringify!(pfnGetIpcHandleCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_callbacks_t>())).pfnOpenIpcHandleCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_callbacks_t),
"::",
stringify!(pfnOpenIpcHandleCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_pool_callbacks_t>())).pfnCloseIpcHandleCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_pool_callbacks_t),
"::",
stringify!(pfnCloseIpcHandleCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of EventPool callback functions pointers"]
pub type ze_event_pool_callbacks_t = _ze_event_pool_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_create_params_t {
pub phEventPool: *mut ze_event_pool_handle_t,
pub pdesc: *mut *const ze_event_desc_t,
pub pphEvent: *mut *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_create_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_event_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_create_params_t>())).phEventPool as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_create_params_t),
"::",
stringify!(phEventPool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_event_create_params_t>())).pdesc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_create_params_t>())).pphEvent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_create_params_t),
"::",
stringify!(pphEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_create_params_t = _ze_event_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_destroy_params_t {
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_event_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_destroy_params_t>())).phEvent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_destroy_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_destroy_params_t = _ze_event_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostSignal"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_host_signal_params_t {
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_host_signal_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_host_signal_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_event_host_signal_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_host_signal_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_host_signal_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_host_signal_params_t>())).phEvent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_host_signal_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostSignal"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_host_signal_params_t = _ze_event_host_signal_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventHostSignal"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventHostSignalCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_host_signal_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_host_synchronize_params_t {
pub phEvent: *mut ze_event_handle_t,
pub ptimeout: *mut u64,
}
#[test]
fn bindgen_test_layout__ze_event_host_synchronize_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_host_synchronize_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_event_host_synchronize_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_host_synchronize_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_event_host_synchronize_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_host_synchronize_params_t>())).phEvent as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_host_synchronize_params_t),
"::",
stringify!(phEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_host_synchronize_params_t>())).ptimeout as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_host_synchronize_params_t),
"::",
stringify!(ptimeout)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostSynchronize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_host_synchronize_params_t = _ze_event_host_synchronize_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventHostSynchronize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventHostSynchronizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_host_synchronize_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventQueryStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_query_status_params_t {
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_query_status_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_query_status_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_event_query_status_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_query_status_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_query_status_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_query_status_params_t>())).phEvent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_query_status_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventQueryStatus"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_query_status_params_t = _ze_event_query_status_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventQueryStatus"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventQueryStatusCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_query_status_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_host_reset_params_t {
pub phEvent: *mut ze_event_handle_t,
}
#[test]
fn bindgen_test_layout__ze_event_host_reset_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_host_reset_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_event_host_reset_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_host_reset_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_host_reset_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_host_reset_params_t>())).phEvent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_host_reset_params_t),
"::",
stringify!(phEvent)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventHostReset"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_host_reset_params_t = _ze_event_host_reset_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventHostReset"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventHostResetCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_host_reset_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventQueryKernelTimestamp"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_event_query_kernel_timestamp_params_t {
pub phEvent: *mut ze_event_handle_t,
pub pdstptr: *mut *mut ze_kernel_timestamp_result_t,
}
#[test]
fn bindgen_test_layout__ze_event_query_kernel_timestamp_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_query_kernel_timestamp_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_event_query_kernel_timestamp_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_event_query_kernel_timestamp_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_event_query_kernel_timestamp_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_query_kernel_timestamp_params_t>())).phEvent
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_query_kernel_timestamp_params_t),
"::",
stringify!(phEvent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_query_kernel_timestamp_params_t>())).pdstptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_query_kernel_timestamp_params_t),
"::",
stringify!(pdstptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeEventQueryKernelTimestamp"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_event_query_kernel_timestamp_params_t = _ze_event_query_kernel_timestamp_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeEventQueryKernelTimestamp"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnEventQueryKernelTimestampCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_event_query_kernel_timestamp_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Event callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_event_callbacks_t {
pub pfnCreateCb: ze_pfnEventCreateCb_t,
pub pfnDestroyCb: ze_pfnEventDestroyCb_t,
pub pfnHostSignalCb: ze_pfnEventHostSignalCb_t,
pub pfnHostSynchronizeCb: ze_pfnEventHostSynchronizeCb_t,
pub pfnQueryStatusCb: ze_pfnEventQueryStatusCb_t,
pub pfnHostResetCb: ze_pfnEventHostResetCb_t,
pub pfnQueryKernelTimestampCb: ze_pfnEventQueryKernelTimestampCb_t,
}
#[test]
fn bindgen_test_layout__ze_event_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_event_callbacks_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_event_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_event_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_event_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnHostSignalCb as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnHostSignalCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnHostSynchronizeCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnHostSynchronizeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnQueryStatusCb as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnQueryStatusCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnHostResetCb as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnHostResetCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_event_callbacks_t>())).pfnQueryKernelTimestampCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_event_callbacks_t),
"::",
stringify!(pfnQueryKernelTimestampCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Event callback functions pointers"]
pub type ze_event_callbacks_t = _ze_event_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_get_properties_params_t {
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_image_desc_t,
pub ppImageProperties: *mut *mut ze_image_properties_t,
}
#[test]
fn bindgen_test_layout__ze_image_get_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_get_properties_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_image_get_properties_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_get_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_image_get_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_get_properties_params_t>())).phDevice as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_get_properties_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_get_properties_params_t>())).pdesc as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_get_properties_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_get_properties_params_t>())).ppImageProperties
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_get_properties_params_t),
"::",
stringify!(ppImageProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_image_get_properties_params_t = _ze_image_get_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeImageGetProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnImageGetPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_image_get_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_image_desc_t,
pub pphImage: *mut *mut ze_image_handle_t,
}
#[test]
fn bindgen_test_layout__ze_image_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_create_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_image_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_image_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_create_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_create_params_t>())).phDevice as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_image_create_params_t>())).pdesc as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_create_params_t>())).pphImage as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_create_params_t),
"::",
stringify!(pphImage)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_image_create_params_t = _ze_image_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeImageCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnImageCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_image_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_image_destroy_params_t {
pub phImage: *mut ze_image_handle_t,
}
#[test]
fn bindgen_test_layout__ze_image_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_image_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_image_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_destroy_params_t>())).phImage as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_destroy_params_t),
"::",
stringify!(phImage)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeImageDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_image_destroy_params_t = _ze_image_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeImageDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnImageDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_image_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Image callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_image_callbacks_t {
pub pfnGetPropertiesCb: ze_pfnImageGetPropertiesCb_t,
pub pfnCreateCb: ze_pfnImageCreateCb_t,
pub pfnDestroyCb: ze_pfnImageDestroyCb_t,
}
#[test]
fn bindgen_test_layout__ze_image_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_image_callbacks_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_image_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_image_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_image_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_callbacks_t>())).pfnGetPropertiesCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_callbacks_t),
"::",
stringify!(pfnGetPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_callbacks_t>())).pfnCreateCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_image_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_image_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Image callback functions pointers"]
pub type ze_image_callbacks_t = _ze_image_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_module_desc_t,
pub pphModule: *mut *mut ze_module_handle_t,
pub pphBuildLog: *mut *mut ze_module_build_log_handle_t,
}
#[test]
fn bindgen_test_layout__ze_module_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_create_params_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_module_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_create_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_create_params_t>())).phDevice as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_create_params_t>())).pdesc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_create_params_t>())).pphModule as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_create_params_t),
"::",
stringify!(pphModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_create_params_t>())).pphBuildLog as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_create_params_t),
"::",
stringify!(pphBuildLog)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_create_params_t = _ze_module_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_destroy_params_t {
pub phModule: *mut ze_module_handle_t,
}
#[test]
fn bindgen_test_layout__ze_module_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_module_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_destroy_params_t>())).phModule as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_destroy_params_t),
"::",
stringify!(phModule)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_destroy_params_t = _ze_module_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleDynamicLink"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_dynamic_link_params_t {
pub pnumModules: *mut u32,
pub pphModules: *mut *mut ze_module_handle_t,
pub pphLinkLog: *mut *mut ze_module_build_log_handle_t,
}
#[test]
fn bindgen_test_layout__ze_module_dynamic_link_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_dynamic_link_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_module_dynamic_link_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_dynamic_link_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_dynamic_link_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_dynamic_link_params_t>())).pnumModules as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_dynamic_link_params_t),
"::",
stringify!(pnumModules)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_dynamic_link_params_t>())).pphModules as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_dynamic_link_params_t),
"::",
stringify!(pphModules)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_dynamic_link_params_t>())).pphLinkLog as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_dynamic_link_params_t),
"::",
stringify!(pphLinkLog)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleDynamicLink"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_dynamic_link_params_t = _ze_module_dynamic_link_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleDynamicLink"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleDynamicLinkCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_dynamic_link_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetNativeBinary"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_get_native_binary_params_t {
pub phModule: *mut ze_module_handle_t,
pub ppSize: *mut *mut usize,
pub ppModuleNativeBinary: *mut *mut u8,
}
#[test]
fn bindgen_test_layout__ze_module_get_native_binary_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_get_native_binary_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_module_get_native_binary_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_get_native_binary_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_get_native_binary_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_native_binary_params_t>())).phModule as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_native_binary_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_native_binary_params_t>())).ppSize as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_native_binary_params_t),
"::",
stringify!(ppSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_native_binary_params_t>())).ppModuleNativeBinary
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_native_binary_params_t),
"::",
stringify!(ppModuleNativeBinary)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetNativeBinary"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_get_native_binary_params_t = _ze_module_get_native_binary_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleGetNativeBinary"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleGetNativeBinaryCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_get_native_binary_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetGlobalPointer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_get_global_pointer_params_t {
pub phModule: *mut ze_module_handle_t,
pub ppGlobalName: *mut *const ::std::os::raw::c_char,
pub ppSize: *mut *mut usize,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_module_get_global_pointer_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_get_global_pointer_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_module_get_global_pointer_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_get_global_pointer_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_get_global_pointer_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_global_pointer_params_t>())).phModule as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_global_pointer_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_global_pointer_params_t>())).ppGlobalName
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_global_pointer_params_t),
"::",
stringify!(ppGlobalName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_global_pointer_params_t>())).ppSize as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_global_pointer_params_t),
"::",
stringify!(ppSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_global_pointer_params_t>())).ppptr as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_global_pointer_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetGlobalPointer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_get_global_pointer_params_t = _ze_module_get_global_pointer_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleGetGlobalPointer"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleGetGlobalPointerCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_get_global_pointer_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetKernelNames"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_get_kernel_names_params_t {
pub phModule: *mut ze_module_handle_t,
pub ppCount: *mut *mut u32,
pub ppNames: *mut *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__ze_module_get_kernel_names_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_get_kernel_names_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_module_get_kernel_names_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_get_kernel_names_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_get_kernel_names_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_kernel_names_params_t>())).phModule as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_kernel_names_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_kernel_names_params_t>())).ppCount as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_kernel_names_params_t),
"::",
stringify!(ppCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_kernel_names_params_t>())).ppNames as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_kernel_names_params_t),
"::",
stringify!(ppNames)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetKernelNames"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_get_kernel_names_params_t = _ze_module_get_kernel_names_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleGetKernelNames"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleGetKernelNamesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_get_kernel_names_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_get_properties_params_t {
pub phModule: *mut ze_module_handle_t,
pub ppModuleProperties: *mut *mut ze_module_properties_t,
}
#[test]
fn bindgen_test_layout__ze_module_get_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_get_properties_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_module_get_properties_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_get_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_get_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_properties_params_t>())).phModule as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_properties_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_properties_params_t>())).ppModuleProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_properties_params_t),
"::",
stringify!(ppModuleProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_get_properties_params_t = _ze_module_get_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleGetProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleGetPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_get_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetFunctionPointer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_get_function_pointer_params_t {
pub phModule: *mut ze_module_handle_t,
pub ppFunctionName: *mut *const ::std::os::raw::c_char,
pub ppfnFunction: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_module_get_function_pointer_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_get_function_pointer_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_module_get_function_pointer_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_get_function_pointer_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_get_function_pointer_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_function_pointer_params_t>())).phModule
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_function_pointer_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_function_pointer_params_t>())).ppFunctionName
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_function_pointer_params_t),
"::",
stringify!(ppFunctionName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_get_function_pointer_params_t>())).ppfnFunction
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_get_function_pointer_params_t),
"::",
stringify!(ppfnFunction)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleGetFunctionPointer"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_get_function_pointer_params_t = _ze_module_get_function_pointer_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleGetFunctionPointer"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleGetFunctionPointerCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_get_function_pointer_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Module callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_module_callbacks_t {
pub pfnCreateCb: ze_pfnModuleCreateCb_t,
pub pfnDestroyCb: ze_pfnModuleDestroyCb_t,
pub pfnDynamicLinkCb: ze_pfnModuleDynamicLinkCb_t,
pub pfnGetNativeBinaryCb: ze_pfnModuleGetNativeBinaryCb_t,
pub pfnGetGlobalPointerCb: ze_pfnModuleGetGlobalPointerCb_t,
pub pfnGetKernelNamesCb: ze_pfnModuleGetKernelNamesCb_t,
pub pfnGetPropertiesCb: ze_pfnModuleGetPropertiesCb_t,
pub pfnGetFunctionPointerCb: ze_pfnModuleGetFunctionPointerCb_t,
}
#[test]
fn bindgen_test_layout__ze_module_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_callbacks_t>(),
64usize,
concat!("Size of: ", stringify!(_ze_module_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_module_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnDynamicLinkCb as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnDynamicLinkCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnGetNativeBinaryCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnGetNativeBinaryCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnGetGlobalPointerCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnGetGlobalPointerCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnGetKernelNamesCb as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnGetKernelNamesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnGetPropertiesCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnGetPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_callbacks_t>())).pfnGetFunctionPointerCb as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_callbacks_t),
"::",
stringify!(pfnGetFunctionPointerCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Module callback functions pointers"]
pub type ze_module_callbacks_t = _ze_module_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleBuildLogDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_build_log_destroy_params_t {
pub phModuleBuildLog: *mut ze_module_build_log_handle_t,
}
#[test]
fn bindgen_test_layout__ze_module_build_log_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_build_log_destroy_params_t>(),
8usize,
concat!(
"Size of: ",
stringify!(_ze_module_build_log_destroy_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_build_log_destroy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_build_log_destroy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_destroy_params_t>())).phModuleBuildLog
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_destroy_params_t),
"::",
stringify!(phModuleBuildLog)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleBuildLogDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_build_log_destroy_params_t = _ze_module_build_log_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleBuildLogDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleBuildLogDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_build_log_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleBuildLogGetString"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_module_build_log_get_string_params_t {
pub phModuleBuildLog: *mut ze_module_build_log_handle_t,
pub ppSize: *mut *mut usize,
pub ppBuildLog: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__ze_module_build_log_get_string_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_build_log_get_string_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_module_build_log_get_string_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_module_build_log_get_string_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_build_log_get_string_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_get_string_params_t>())).phModuleBuildLog
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_get_string_params_t),
"::",
stringify!(phModuleBuildLog)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_get_string_params_t>())).ppSize as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_get_string_params_t),
"::",
stringify!(ppSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_get_string_params_t>())).ppBuildLog
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_get_string_params_t),
"::",
stringify!(ppBuildLog)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeModuleBuildLogGetString"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_module_build_log_get_string_params_t = _ze_module_build_log_get_string_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeModuleBuildLogGetString"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnModuleBuildLogGetStringCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_module_build_log_get_string_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of ModuleBuildLog callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_module_build_log_callbacks_t {
pub pfnDestroyCb: ze_pfnModuleBuildLogDestroyCb_t,
pub pfnGetStringCb: ze_pfnModuleBuildLogGetStringCb_t,
}
#[test]
fn bindgen_test_layout__ze_module_build_log_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_module_build_log_callbacks_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_module_build_log_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_module_build_log_callbacks_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_module_build_log_callbacks_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_callbacks_t>())).pfnDestroyCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_module_build_log_callbacks_t>())).pfnGetStringCb as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_module_build_log_callbacks_t),
"::",
stringify!(pfnGetStringCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of ModuleBuildLog callback functions pointers"]
pub type ze_module_build_log_callbacks_t = _ze_module_build_log_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_create_params_t {
pub phModule: *mut ze_module_handle_t,
pub pdesc: *mut *const ze_kernel_desc_t,
pub pphKernel: *mut *mut ze_kernel_handle_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_create_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_kernel_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_create_params_t>())).phModule as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_create_params_t),
"::",
stringify!(phModule)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_create_params_t>())).pdesc as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_create_params_t>())).pphKernel as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_create_params_t),
"::",
stringify!(pphKernel)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_create_params_t = _ze_kernel_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_destroy_params_t {
pub phKernel: *mut ze_kernel_handle_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_kernel_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_destroy_params_t>())).phKernel as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_destroy_params_t),
"::",
stringify!(phKernel)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_destroy_params_t = _ze_kernel_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetCacheConfig"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_set_cache_config_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub pflags: *mut ze_cache_config_flags_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_set_cache_config_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_set_cache_config_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_set_cache_config_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_set_cache_config_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_set_cache_config_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_cache_config_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_cache_config_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_cache_config_params_t>())).pflags as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_cache_config_params_t),
"::",
stringify!(pflags)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetCacheConfig"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_set_cache_config_params_t = _ze_kernel_set_cache_config_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSetCacheConfig"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSetCacheConfigCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_set_cache_config_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetGroupSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_set_group_size_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub pgroupSizeX: *mut u32,
pub pgroupSizeY: *mut u32,
pub pgroupSizeZ: *mut u32,
}
#[test]
fn bindgen_test_layout__ze_kernel_set_group_size_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_set_group_size_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_kernel_set_group_size_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_set_group_size_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_set_group_size_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_group_size_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_group_size_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_group_size_params_t>())).pgroupSizeX as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_group_size_params_t),
"::",
stringify!(pgroupSizeX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_group_size_params_t>())).pgroupSizeY as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_group_size_params_t),
"::",
stringify!(pgroupSizeY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_group_size_params_t>())).pgroupSizeZ as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_group_size_params_t),
"::",
stringify!(pgroupSizeZ)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetGroupSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_set_group_size_params_t = _ze_kernel_set_group_size_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSetGroupSize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSetGroupSizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_set_group_size_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSuggestGroupSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_suggest_group_size_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub pglobalSizeX: *mut u32,
pub pglobalSizeY: *mut u32,
pub pglobalSizeZ: *mut u32,
pub pgroupSizeX: *mut *mut u32,
pub pgroupSizeY: *mut *mut u32,
pub pgroupSizeZ: *mut *mut u32,
}
#[test]
fn bindgen_test_layout__ze_kernel_suggest_group_size_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_suggest_group_size_params_t>(),
56usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_suggest_group_size_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_suggest_group_size_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_suggest_group_size_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pglobalSizeX
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pglobalSizeX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pglobalSizeY
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pglobalSizeY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pglobalSizeZ
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pglobalSizeZ)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pgroupSizeX
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pgroupSizeX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pgroupSizeY
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pgroupSizeY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_group_size_params_t>())).pgroupSizeZ
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_group_size_params_t),
"::",
stringify!(pgroupSizeZ)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSuggestGroupSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_suggest_group_size_params_t = _ze_kernel_suggest_group_size_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSuggestGroupSize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSuggestGroupSizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_suggest_group_size_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSuggestMaxCooperativeGroupCount"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_suggest_max_cooperative_group_count_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub ptotalGroupCount: *mut *mut u32,
}
#[test]
fn bindgen_test_layout__ze_kernel_suggest_max_cooperative_group_count_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_suggest_max_cooperative_group_count_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_suggest_max_cooperative_group_count_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_suggest_max_cooperative_group_count_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_suggest_max_cooperative_group_count_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_max_cooperative_group_count_params_t>()))
.phKernel as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_max_cooperative_group_count_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_suggest_max_cooperative_group_count_params_t>()))
.ptotalGroupCount as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_suggest_max_cooperative_group_count_params_t),
"::",
stringify!(ptotalGroupCount)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSuggestMaxCooperativeGroupCount"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_suggest_max_cooperative_group_count_params_t =
_ze_kernel_suggest_max_cooperative_group_count_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSuggestMaxCooperativeGroupCount"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSuggestMaxCooperativeGroupCountCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_suggest_max_cooperative_group_count_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetArgumentValue"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_set_argument_value_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub pargIndex: *mut u32,
pub pargSize: *mut usize,
pub ppArgValue: *mut *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_kernel_set_argument_value_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_set_argument_value_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_set_argument_value_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_set_argument_value_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_set_argument_value_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_argument_value_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_argument_value_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_argument_value_params_t>())).pargIndex as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_argument_value_params_t),
"::",
stringify!(pargIndex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_argument_value_params_t>())).pargSize as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_argument_value_params_t),
"::",
stringify!(pargSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_argument_value_params_t>())).ppArgValue
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_argument_value_params_t),
"::",
stringify!(ppArgValue)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetArgumentValue"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_set_argument_value_params_t = _ze_kernel_set_argument_value_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSetArgumentValue"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSetArgumentValueCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_set_argument_value_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetIndirectAccess"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_set_indirect_access_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub pflags: *mut ze_kernel_indirect_access_flags_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_set_indirect_access_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_set_indirect_access_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_set_indirect_access_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_set_indirect_access_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_set_indirect_access_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_indirect_access_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_indirect_access_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_set_indirect_access_params_t>())).pflags as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_set_indirect_access_params_t),
"::",
stringify!(pflags)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelSetIndirectAccess"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_set_indirect_access_params_t = _ze_kernel_set_indirect_access_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelSetIndirectAccess"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelSetIndirectAccessCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_set_indirect_access_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetIndirectAccess"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_get_indirect_access_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub ppFlags: *mut *mut ze_kernel_indirect_access_flags_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_get_indirect_access_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_get_indirect_access_params_t>(),
16usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_get_indirect_access_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_get_indirect_access_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_get_indirect_access_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_indirect_access_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_indirect_access_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_indirect_access_params_t>())).ppFlags as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_indirect_access_params_t),
"::",
stringify!(ppFlags)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetIndirectAccess"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_get_indirect_access_params_t = _ze_kernel_get_indirect_access_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelGetIndirectAccess"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelGetIndirectAccessCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_get_indirect_access_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetSourceAttributes"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_get_source_attributes_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub ppSize: *mut *mut u32,
pub ppString: *mut *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__ze_kernel_get_source_attributes_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_get_source_attributes_params_t>(),
24usize,
concat!(
"Size of: ",
stringify!(_ze_kernel_get_source_attributes_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_get_source_attributes_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_get_source_attributes_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_source_attributes_params_t>())).phKernel
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_source_attributes_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_source_attributes_params_t>())).ppSize as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_source_attributes_params_t),
"::",
stringify!(ppSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_source_attributes_params_t>())).ppString
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_source_attributes_params_t),
"::",
stringify!(ppString)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetSourceAttributes"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_get_source_attributes_params_t = _ze_kernel_get_source_attributes_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelGetSourceAttributes"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelGetSourceAttributesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_get_source_attributes_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_get_properties_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub ppKernelProperties: *mut *mut ze_kernel_properties_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_get_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_get_properties_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_kernel_get_properties_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_get_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_kernel_get_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_properties_params_t>())).phKernel as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_properties_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_properties_params_t>())).ppKernelProperties
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_properties_params_t),
"::",
stringify!(ppKernelProperties)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_get_properties_params_t = _ze_kernel_get_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelGetProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelGetPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_get_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetName"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_kernel_get_name_params_t {
pub phKernel: *mut ze_kernel_handle_t,
pub ppSize: *mut *mut usize,
pub ppName: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__ze_kernel_get_name_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_get_name_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_kernel_get_name_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_get_name_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_get_name_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_name_params_t>())).phKernel as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_name_params_t),
"::",
stringify!(phKernel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_name_params_t>())).ppSize as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_name_params_t),
"::",
stringify!(ppSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_get_name_params_t>())).ppName as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_get_name_params_t),
"::",
stringify!(ppName)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeKernelGetName"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_kernel_get_name_params_t = _ze_kernel_get_name_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeKernelGetName"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnKernelGetNameCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_kernel_get_name_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Kernel callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_kernel_callbacks_t {
pub pfnCreateCb: ze_pfnKernelCreateCb_t,
pub pfnDestroyCb: ze_pfnKernelDestroyCb_t,
pub pfnSetCacheConfigCb: ze_pfnKernelSetCacheConfigCb_t,
pub pfnSetGroupSizeCb: ze_pfnKernelSetGroupSizeCb_t,
pub pfnSuggestGroupSizeCb: ze_pfnKernelSuggestGroupSizeCb_t,
pub pfnSuggestMaxCooperativeGroupCountCb: ze_pfnKernelSuggestMaxCooperativeGroupCountCb_t,
pub pfnSetArgumentValueCb: ze_pfnKernelSetArgumentValueCb_t,
pub pfnSetIndirectAccessCb: ze_pfnKernelSetIndirectAccessCb_t,
pub pfnGetIndirectAccessCb: ze_pfnKernelGetIndirectAccessCb_t,
pub pfnGetSourceAttributesCb: ze_pfnKernelGetSourceAttributesCb_t,
pub pfnGetPropertiesCb: ze_pfnKernelGetPropertiesCb_t,
pub pfnGetNameCb: ze_pfnKernelGetNameCb_t,
}
#[test]
fn bindgen_test_layout__ze_kernel_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_kernel_callbacks_t>(),
96usize,
concat!("Size of: ", stringify!(_ze_kernel_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_kernel_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_kernel_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSetCacheConfigCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSetCacheConfigCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSetGroupSizeCb as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSetGroupSizeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSuggestGroupSizeCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSuggestGroupSizeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSuggestMaxCooperativeGroupCountCb
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSuggestMaxCooperativeGroupCountCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSetArgumentValueCb as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSetArgumentValueCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnSetIndirectAccessCb as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnSetIndirectAccessCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnGetIndirectAccessCb as *const _
as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnGetIndirectAccessCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnGetSourceAttributesCb as *const _
as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnGetSourceAttributesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnGetPropertiesCb as *const _
as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnGetPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_kernel_callbacks_t>())).pfnGetNameCb as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_ze_kernel_callbacks_t),
"::",
stringify!(pfnGetNameCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Kernel callback functions pointers"]
pub type ze_kernel_callbacks_t = _ze_kernel_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeSamplerCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_sampler_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *const ze_sampler_desc_t,
pub pphSampler: *mut *mut ze_sampler_handle_t,
}
#[test]
fn bindgen_test_layout__ze_sampler_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_sampler_create_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_sampler_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_sampler_create_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_sampler_create_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_create_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_create_params_t>())).phDevice as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_create_params_t>())).pdesc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_create_params_t>())).pphSampler as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_create_params_t),
"::",
stringify!(pphSampler)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeSamplerCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_sampler_create_params_t = _ze_sampler_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeSamplerCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnSamplerCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_sampler_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeSamplerDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_sampler_destroy_params_t {
pub phSampler: *mut ze_sampler_handle_t,
}
#[test]
fn bindgen_test_layout__ze_sampler_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_sampler_destroy_params_t>(),
8usize,
concat!("Size of: ", stringify!(_ze_sampler_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_sampler_destroy_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_sampler_destroy_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_destroy_params_t>())).phSampler as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_destroy_params_t),
"::",
stringify!(phSampler)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeSamplerDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_sampler_destroy_params_t = _ze_sampler_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeSamplerDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnSamplerDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_sampler_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Sampler callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_sampler_callbacks_t {
pub pfnCreateCb: ze_pfnSamplerCreateCb_t,
pub pfnDestroyCb: ze_pfnSamplerDestroyCb_t,
}
#[test]
fn bindgen_test_layout__ze_sampler_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_sampler_callbacks_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_sampler_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_sampler_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_sampler_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_callbacks_t>())).pfnCreateCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_sampler_callbacks_t>())).pfnDestroyCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_sampler_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Sampler callback functions pointers"]
pub type ze_sampler_callbacks_t = _ze_sampler_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zePhysicalMemCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_physical_mem_create_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub pdesc: *mut *mut ze_physical_mem_desc_t,
pub pphPhysicalMemory: *mut *mut ze_physical_mem_handle_t,
}
#[test]
fn bindgen_test_layout__ze_physical_mem_create_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_physical_mem_create_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_physical_mem_create_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_physical_mem_create_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_physical_mem_create_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_create_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_create_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_create_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_create_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_create_params_t>())).pdesc as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_create_params_t),
"::",
stringify!(pdesc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_create_params_t>())).pphPhysicalMemory
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_create_params_t),
"::",
stringify!(pphPhysicalMemory)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zePhysicalMemCreate"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_physical_mem_create_params_t = _ze_physical_mem_create_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zePhysicalMemCreate"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnPhysicalMemCreateCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_physical_mem_create_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zePhysicalMemDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_physical_mem_destroy_params_t {
pub phContext: *mut ze_context_handle_t,
pub phPhysicalMemory: *mut ze_physical_mem_handle_t,
}
#[test]
fn bindgen_test_layout__ze_physical_mem_destroy_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_physical_mem_destroy_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_physical_mem_destroy_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_physical_mem_destroy_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_physical_mem_destroy_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_destroy_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_destroy_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_destroy_params_t>())).phPhysicalMemory
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_destroy_params_t),
"::",
stringify!(phPhysicalMemory)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zePhysicalMemDestroy"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_physical_mem_destroy_params_t = _ze_physical_mem_destroy_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zePhysicalMemDestroy"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnPhysicalMemDestroyCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_physical_mem_destroy_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of PhysicalMem callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_physical_mem_callbacks_t {
pub pfnCreateCb: ze_pfnPhysicalMemCreateCb_t,
pub pfnDestroyCb: ze_pfnPhysicalMemDestroyCb_t,
}
#[test]
fn bindgen_test_layout__ze_physical_mem_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_physical_mem_callbacks_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_physical_mem_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_physical_mem_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_physical_mem_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_callbacks_t>())).pfnCreateCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_callbacks_t),
"::",
stringify!(pfnCreateCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_physical_mem_callbacks_t>())).pfnDestroyCb as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_physical_mem_callbacks_t),
"::",
stringify!(pfnDestroyCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of PhysicalMem callback functions pointers"]
pub type ze_physical_mem_callbacks_t = _ze_physical_mem_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocShared"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_alloc_shared_params_t {
pub phContext: *mut ze_context_handle_t,
pub pdevice_desc: *mut *const ze_device_mem_alloc_desc_t,
pub phost_desc: *mut *const ze_host_mem_alloc_desc_t,
pub psize: *mut usize,
pub palignment: *mut usize,
pub phDevice: *mut ze_device_handle_t,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_alloc_shared_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_alloc_shared_params_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_mem_alloc_shared_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_alloc_shared_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_alloc_shared_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).pdevice_desc as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(pdevice_desc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).phost_desc as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(phost_desc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).psize as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).palignment as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(palignment)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).phDevice as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_shared_params_t>())).ppptr as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_shared_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocShared"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_alloc_shared_params_t = _ze_mem_alloc_shared_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemAllocShared"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemAllocSharedCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_alloc_shared_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocDevice"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_alloc_device_params_t {
pub phContext: *mut ze_context_handle_t,
pub pdevice_desc: *mut *const ze_device_mem_alloc_desc_t,
pub psize: *mut usize,
pub palignment: *mut usize,
pub phDevice: *mut ze_device_handle_t,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_alloc_device_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_alloc_device_params_t>(),
48usize,
concat!("Size of: ", stringify!(_ze_mem_alloc_device_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_alloc_device_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_alloc_device_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).pdevice_desc as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(pdevice_desc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).palignment as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(palignment)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).phDevice as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_device_params_t>())).ppptr as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_device_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocDevice"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_alloc_device_params_t = _ze_mem_alloc_device_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemAllocDevice"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemAllocDeviceCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_alloc_device_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocHost"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_alloc_host_params_t {
pub phContext: *mut ze_context_handle_t,
pub phost_desc: *mut *const ze_host_mem_alloc_desc_t,
pub psize: *mut usize,
pub palignment: *mut usize,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_alloc_host_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_alloc_host_params_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_mem_alloc_host_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_alloc_host_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_alloc_host_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_host_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_host_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_host_params_t>())).phost_desc as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_host_params_t),
"::",
stringify!(phost_desc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_host_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_host_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_host_params_t>())).palignment as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_host_params_t),
"::",
stringify!(palignment)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_alloc_host_params_t>())).ppptr as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_alloc_host_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemAllocHost"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_alloc_host_params_t = _ze_mem_alloc_host_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemAllocHost"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemAllocHostCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_alloc_host_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemFree"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_free_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_free_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_free_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_mem_free_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_free_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_free_params_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_mem_free_params_t>())).phContext as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_free_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_mem_free_params_t>())).pptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_free_params_t),
"::",
stringify!(pptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemFree"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_free_params_t = _ze_mem_free_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemFree"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemFreeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_free_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetAllocProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_get_alloc_properties_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub ppMemAllocProperties: *mut *mut ze_memory_allocation_properties_t,
pub pphDevice: *mut *mut ze_device_handle_t,
}
#[test]
fn bindgen_test_layout__ze_mem_get_alloc_properties_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_get_alloc_properties_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_mem_get_alloc_properties_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_mem_get_alloc_properties_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_mem_get_alloc_properties_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_alloc_properties_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_alloc_properties_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_alloc_properties_params_t>())).pptr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_alloc_properties_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_alloc_properties_params_t>())).ppMemAllocProperties
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_alloc_properties_params_t),
"::",
stringify!(ppMemAllocProperties)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_alloc_properties_params_t>())).pphDevice as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_alloc_properties_params_t),
"::",
stringify!(pphDevice)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetAllocProperties"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_get_alloc_properties_params_t = _ze_mem_get_alloc_properties_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemGetAllocProperties"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemGetAllocPropertiesCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_get_alloc_properties_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetAddressRange"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_get_address_range_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub ppBase: *mut *mut *mut ::std::os::raw::c_void,
pub ppSize: *mut *mut usize,
}
#[test]
fn bindgen_test_layout__ze_mem_get_address_range_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_get_address_range_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_mem_get_address_range_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_get_address_range_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_mem_get_address_range_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_address_range_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_address_range_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_address_range_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_address_range_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_address_range_params_t>())).ppBase as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_address_range_params_t),
"::",
stringify!(ppBase)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_address_range_params_t>())).ppSize as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_address_range_params_t),
"::",
stringify!(ppSize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetAddressRange"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_get_address_range_params_t = _ze_mem_get_address_range_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemGetAddressRange"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemGetAddressRangeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_get_address_range_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_get_ipc_handle_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub ppIpcHandle: *mut *mut ze_ipc_mem_handle_t,
}
#[test]
fn bindgen_test_layout__ze_mem_get_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_get_ipc_handle_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_mem_get_ipc_handle_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_get_ipc_handle_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_get_ipc_handle_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_ipc_handle_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_ipc_handle_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_ipc_handle_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_ipc_handle_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_get_ipc_handle_params_t>())).ppIpcHandle as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_get_ipc_handle_params_t),
"::",
stringify!(ppIpcHandle)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemGetIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_get_ipc_handle_params_t = _ze_mem_get_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemGetIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemGetIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_get_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemOpenIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_open_ipc_handle_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub phandle: *mut ze_ipc_mem_handle_t,
pub pflags: *mut ze_ipc_memory_flags_t,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_open_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_open_ipc_handle_params_t>(),
40usize,
concat!("Size of: ", stringify!(_ze_mem_open_ipc_handle_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_open_ipc_handle_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_mem_open_ipc_handle_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_open_ipc_handle_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_open_ipc_handle_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_open_ipc_handle_params_t>())).phDevice as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_open_ipc_handle_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_open_ipc_handle_params_t>())).phandle as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_open_ipc_handle_params_t),
"::",
stringify!(phandle)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_open_ipc_handle_params_t>())).pflags as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_open_ipc_handle_params_t),
"::",
stringify!(pflags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_open_ipc_handle_params_t>())).ppptr as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_open_ipc_handle_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemOpenIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_open_ipc_handle_params_t = _ze_mem_open_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemOpenIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemOpenIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_open_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemCloseIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_mem_close_ipc_handle_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_mem_close_ipc_handle_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_close_ipc_handle_params_t>(),
16usize,
concat!("Size of: ", stringify!(_ze_mem_close_ipc_handle_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_close_ipc_handle_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_mem_close_ipc_handle_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_close_ipc_handle_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_close_ipc_handle_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_close_ipc_handle_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_close_ipc_handle_params_t),
"::",
stringify!(pptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeMemCloseIpcHandle"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_mem_close_ipc_handle_params_t = _ze_mem_close_ipc_handle_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeMemCloseIpcHandle"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnMemCloseIpcHandleCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_mem_close_ipc_handle_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of Mem callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_mem_callbacks_t {
pub pfnAllocSharedCb: ze_pfnMemAllocSharedCb_t,
pub pfnAllocDeviceCb: ze_pfnMemAllocDeviceCb_t,
pub pfnAllocHostCb: ze_pfnMemAllocHostCb_t,
pub pfnFreeCb: ze_pfnMemFreeCb_t,
pub pfnGetAllocPropertiesCb: ze_pfnMemGetAllocPropertiesCb_t,
pub pfnGetAddressRangeCb: ze_pfnMemGetAddressRangeCb_t,
pub pfnGetIpcHandleCb: ze_pfnMemGetIpcHandleCb_t,
pub pfnOpenIpcHandleCb: ze_pfnMemOpenIpcHandleCb_t,
pub pfnCloseIpcHandleCb: ze_pfnMemCloseIpcHandleCb_t,
}
#[test]
fn bindgen_test_layout__ze_mem_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_mem_callbacks_t>(),
72usize,
concat!("Size of: ", stringify!(_ze_mem_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_mem_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_mem_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnAllocSharedCb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnAllocSharedCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnAllocDeviceCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnAllocDeviceCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnAllocHostCb as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnAllocHostCb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnFreeCb as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnFreeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnGetAllocPropertiesCb as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnGetAllocPropertiesCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnGetAddressRangeCb as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnGetAddressRangeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnGetIpcHandleCb as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnGetIpcHandleCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnOpenIpcHandleCb as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnOpenIpcHandleCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_mem_callbacks_t>())).pfnCloseIpcHandleCb as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_ze_mem_callbacks_t),
"::",
stringify!(pfnCloseIpcHandleCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of Mem callback functions pointers"]
pub type ze_mem_callbacks_t = _ze_mem_callbacks_t;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemReserve"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_reserve_params_t {
pub phContext: *mut ze_context_handle_t,
pub ppStart: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub ppptr: *mut *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_reserve_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_reserve_params_t>(),
32usize,
concat!("Size of: ", stringify!(_ze_virtual_mem_reserve_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_reserve_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_virtual_mem_reserve_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_reserve_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_reserve_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_reserve_params_t>())).ppStart as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_reserve_params_t),
"::",
stringify!(ppStart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_reserve_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_reserve_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_reserve_params_t>())).ppptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_reserve_params_t),
"::",
stringify!(ppptr)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemReserve"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_reserve_params_t = _ze_virtual_mem_reserve_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemReserve"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemReserveCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_reserve_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemFree"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_free_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_free_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_free_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_virtual_mem_free_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_free_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_virtual_mem_free_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_free_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_free_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_free_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_free_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_free_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_free_params_t),
"::",
stringify!(psize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemFree"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_free_params_t = _ze_virtual_mem_free_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemFree"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemFreeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_free_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemQueryPageSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_query_page_size_params_t {
pub phContext: *mut ze_context_handle_t,
pub phDevice: *mut ze_device_handle_t,
pub psize: *mut usize,
pub ppagesize: *mut *mut usize,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_query_page_size_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_query_page_size_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_virtual_mem_query_page_size_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_query_page_size_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_virtual_mem_query_page_size_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_query_page_size_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_query_page_size_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_query_page_size_params_t>())).phDevice
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_query_page_size_params_t),
"::",
stringify!(phDevice)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_query_page_size_params_t>())).psize as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_query_page_size_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_query_page_size_params_t>())).ppagesize
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_query_page_size_params_t),
"::",
stringify!(ppagesize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemQueryPageSize"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_query_page_size_params_t = _ze_virtual_mem_query_page_size_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemQueryPageSize"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemQueryPageSizeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_query_page_size_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemMap"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_map_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub phPhysicalMemory: *mut ze_physical_mem_handle_t,
pub poffset: *mut usize,
pub paccess: *mut ze_memory_access_attribute_t,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_map_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_map_params_t>(),
48usize,
concat!("Size of: ", stringify!(_ze_virtual_mem_map_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_map_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_virtual_mem_map_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).phContext as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).phPhysicalMemory as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(phPhysicalMemory)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).poffset as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(poffset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_map_params_t>())).paccess as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_map_params_t),
"::",
stringify!(paccess)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemMap"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_map_params_t = _ze_virtual_mem_map_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemMap"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemMapCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_map_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemUnmap"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_unmap_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_unmap_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_unmap_params_t>(),
24usize,
concat!("Size of: ", stringify!(_ze_virtual_mem_unmap_params_t))
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_unmap_params_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_virtual_mem_unmap_params_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_unmap_params_t>())).phContext as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_unmap_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_unmap_params_t>())).pptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_unmap_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_unmap_params_t>())).psize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_unmap_params_t),
"::",
stringify!(psize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemUnmap"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_unmap_params_t = _ze_virtual_mem_unmap_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemUnmap"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemUnmapCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_unmap_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemSetAccessAttribute"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_set_access_attribute_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub paccess: *mut ze_memory_access_attribute_t,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_set_access_attribute_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_set_access_attribute_params_t>(),
32usize,
concat!(
"Size of: ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_set_access_attribute_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_set_access_attribute_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_set_access_attribute_params_t>())).pptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_set_access_attribute_params_t>())).psize
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_set_access_attribute_params_t>())).paccess
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_set_access_attribute_params_t),
"::",
stringify!(paccess)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemSetAccessAttribute"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_set_access_attribute_params_t =
_ze_virtual_mem_set_access_attribute_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemSetAccessAttribute"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemSetAccessAttributeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_set_access_attribute_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemGetAccessAttribute"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ze_virtual_mem_get_access_attribute_params_t {
pub phContext: *mut ze_context_handle_t,
pub pptr: *mut *const ::std::os::raw::c_void,
pub psize: *mut usize,
pub paccess: *mut *mut ze_memory_access_attribute_t,
pub poutSize: *mut *mut usize,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_get_access_attribute_params_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_get_access_attribute_params_t>(),
40usize,
concat!(
"Size of: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t)
)
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_get_access_attribute_params_t>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_get_access_attribute_params_t>())).phContext
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t),
"::",
stringify!(phContext)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_get_access_attribute_params_t>())).pptr
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t),
"::",
stringify!(pptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_get_access_attribute_params_t>())).psize
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t),
"::",
stringify!(psize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_get_access_attribute_params_t>())).paccess
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t),
"::",
stringify!(paccess)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_get_access_attribute_params_t>())).poutSize
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_get_access_attribute_params_t),
"::",
stringify!(poutSize)
)
);
}
#[doc = ""]
#[doc = " @brief Callback function parameters for zeVirtualMemGetAccessAttribute"]
#[doc = " @details Each entry is a pointer to the parameter passed to the function;"]
#[doc = " allowing the callback the ability to modify the parameter's value"]
pub type ze_virtual_mem_get_access_attribute_params_t =
_ze_virtual_mem_get_access_attribute_params_t;
#[doc = ""]
#[doc = " @brief Callback function-pointer for zeVirtualMemGetAccessAttribute"]
#[doc = " @param[in] params Parameters passed to this instance"]
#[doc = " @param[in] result Return value"]
#[doc = " @param[in] pTracerUserData Per-Tracer user data"]
#[doc = " @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data"]
pub type ze_pfnVirtualMemGetAccessAttributeCb_t = ::std::option::Option<
unsafe extern "C" fn(
params: *mut ze_virtual_mem_get_access_attribute_params_t,
result: ze_result_t,
pTracerUserData: *mut ::std::os::raw::c_void,
ppTracerInstanceUserData: *mut *mut ::std::os::raw::c_void,
),
>;
#[doc = ""]
#[doc = " @brief Table of VirtualMem callback functions pointers"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_virtual_mem_callbacks_t {
pub pfnReserveCb: ze_pfnVirtualMemReserveCb_t,
pub pfnFreeCb: ze_pfnVirtualMemFreeCb_t,
pub pfnQueryPageSizeCb: ze_pfnVirtualMemQueryPageSizeCb_t,
pub pfnMapCb: ze_pfnVirtualMemMapCb_t,
pub pfnUnmapCb: ze_pfnVirtualMemUnmapCb_t,
pub pfnSetAccessAttributeCb: ze_pfnVirtualMemSetAccessAttributeCb_t,
pub pfnGetAccessAttributeCb: ze_pfnVirtualMemGetAccessAttributeCb_t,
}
#[test]
fn bindgen_test_layout__ze_virtual_mem_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_virtual_mem_callbacks_t>(),
56usize,
concat!("Size of: ", stringify!(_ze_virtual_mem_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_virtual_mem_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_virtual_mem_callbacks_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnReserveCb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnReserveCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnFreeCb as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnFreeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnQueryPageSizeCb as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnQueryPageSizeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnMapCb as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnMapCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnUnmapCb as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnUnmapCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnSetAccessAttributeCb
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnSetAccessAttributeCb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ze_virtual_mem_callbacks_t>())).pfnGetAccessAttributeCb
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_virtual_mem_callbacks_t),
"::",
stringify!(pfnGetAccessAttributeCb)
)
);
}
#[doc = ""]
#[doc = " @brief Table of VirtualMem callback functions pointers"]
pub type ze_virtual_mem_callbacks_t = _ze_virtual_mem_callbacks_t;
#[doc = ""]
#[doc = " @brief Container for all callbacks"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ze_callbacks_t {
pub Global: ze_global_callbacks_t,
pub Driver: ze_driver_callbacks_t,
pub Device: ze_device_callbacks_t,
pub Context: ze_context_callbacks_t,
pub CommandQueue: ze_command_queue_callbacks_t,
pub CommandList: ze_command_list_callbacks_t,
pub Fence: ze_fence_callbacks_t,
pub EventPool: ze_event_pool_callbacks_t,
pub Event: ze_event_callbacks_t,
pub Image: ze_image_callbacks_t,
pub Module: ze_module_callbacks_t,
pub ModuleBuildLog: ze_module_build_log_callbacks_t,
pub Kernel: ze_kernel_callbacks_t,
pub Sampler: ze_sampler_callbacks_t,
pub PhysicalMem: ze_physical_mem_callbacks_t,
pub Mem: ze_mem_callbacks_t,
pub VirtualMem: ze_virtual_mem_callbacks_t,
}
#[test]
fn bindgen_test_layout__ze_callbacks_t() {
assert_eq!(
::std::mem::size_of::<_ze_callbacks_t>(),
960usize,
concat!("Size of: ", stringify!(_ze_callbacks_t))
);
assert_eq!(
::std::mem::align_of::<_ze_callbacks_t>(),
8usize,
concat!("Alignment of ", stringify!(_ze_callbacks_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Global as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Global)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Driver as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Driver)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Device as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Device)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Context as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Context)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).CommandQueue as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(CommandQueue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).CommandList as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(CommandList)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Fence as *const _ as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Fence)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).EventPool as *const _ as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(EventPool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Event as *const _ as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Event)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Image as *const _ as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Image)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Module as *const _ as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Module)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).ModuleBuildLog as *const _ as usize },
688usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(ModuleBuildLog)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Kernel as *const _ as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Kernel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Sampler as *const _ as usize },
800usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Sampler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).PhysicalMem as *const _ as usize },
816usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(PhysicalMem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).Mem as *const _ as usize },
832usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(Mem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ze_callbacks_t>())).VirtualMem as *const _ as usize },
904usize,
concat!(
"Offset of field: ",
stringify!(_ze_callbacks_t),
"::",
stringify!(VirtualMem)
)
);
}
#[doc = ""]
#[doc = " @brief Container for all callbacks"]
pub type ze_callbacks_t = _ze_callbacks_t;
Reference in New Issue View Git Blame Copy Permalink