Implement enough nvml to make GeekBench happy

7 files changed, 3335 insertions, 2 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 038af15..9b5f261 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,10 +10,11 @@ members = [
     "zluda_lib",

     "zluda_inject",

     "zluda_redirect",

+    "zluda_ml",

     "ptx",

 ]

 

-default-members = ["zluda_lib", "zluda_inject", "zluda_redirect"]

+default-members = ["zluda_lib", "zluda_ml", "zluda_inject", "zluda_redirect"]

 

 [patch.crates-io]

 rspirv = { git = 'https://github.com/vosen/rspirv', rev = '40f5aa4dedb0d9f1ec24bdd8b6019e01996d1d74' }

diff --git a/level_zero/src/ze.rs b/level_zero/src/ze.rs
index ce675eb..d2b1115 100644
--- a/level_zero/src/ze.rs
+++ b/level_zero/src/ze.rs
@@ -81,6 +81,12 @@ impl Driver {
         }

         Ok(result)

     }

+

+    pub fn get_properties(&self) -> Result<sys::ze_driver_properties_t> {

+        let mut result = unsafe { mem::zeroed::<sys::ze_driver_properties_t>() };

+        check!(sys::zeDriverGetProperties(self.0, &mut result));

+        Ok(result)

+    }

 }

 

 #[repr(transparent)]

@@ -359,7 +365,11 @@ impl Module {
         Module::new_logged(ctx, true, d, bin, opts)

     }

 

-    pub fn build_native_logged(ctx: &mut Context, d: &Device, bin: &[u8]) -> (Result<Self>, BuildLog) {

+    pub fn build_native_logged(

+        ctx: &mut Context,

+        d: &Device,

+        bin: &[u8],

+    ) -> (Result<Self>, BuildLog) {

         Module::new_logged(ctx, false, d, bin, None)

     }

 

diff --git a/zluda_ml/Cargo.toml b/zluda_ml/Cargo.toml
new file mode 100644
index 0000000..7b29e8d
--- /dev/null
+++ b/zluda_ml/Cargo.toml
@@ -0,0 +1,12 @@
+[package]

+name = "zluda_ml"

+version = "0.0.0"

+authors = ["Andrzej Janik <[email protected]>"]

+edition = "2018"

+

+[lib]

+name = "nvml"

+crate-type = ["cdylib"]

+

+[dependencies]

+level_zero = { path = "../level_zero" }

diff --git a/zluda_ml/README b/zluda_ml/README
new file mode 100644
index 0000000..300a2a3
--- /dev/null
+++ b/zluda_ml/README
@@ -0,0 +1,3 @@
+bindgen "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.0\include\nvml.h" --whitelist-function="^nvml.*" --size_t-is-usize --default-enum-style=newtype --no-layout-tests --no-doc-comments --no-derive-debug -o src/nvml.rs

+sed -i -e 's/extern "C" {//g' -e 's/-> nvmlReturn_t;/-> nvmlReturn_t { impl_::unsupported()/g' -e 's/pub fn /#[no_mangle] pub extern "C" fn /g' src/nvml.rs

+rustfmt src/nvml.rs
\ No newline at end of file
diff --git a/zluda_ml/src/impl.rs b/zluda_ml/src/impl.rs
new file mode 100644
index 0000000..0fd0de1
--- /dev/null
+++ b/zluda_ml/src/impl.rs
@@ -0,0 +1,138 @@
+use level_zero as l0;

+use std::{io::Write, ops::Add};

+use std::{

+    os::raw::{c_char, c_uint},

+    ptr,

+};

+

+use crate::nvml::nvmlReturn_t;

+

+macro_rules! stringify_nmvlreturn_t {

+    ($x:ident => [ $($variant:ident),+ ]) => {

+        match $x {

+            $(

+                nvmlReturn_t::$variant => Some(concat!(stringify!($variant), "\0")),

+            )+

+            _ => None

+        }

+    }

+}

+

+#[cfg(debug_assertions)]

+pub(crate) fn unimplemented() -> nvmlReturn_t {

+    unimplemented!()

+}

+

+#[cfg(not(debug_assertions))]

+pub(crate) fn unimplemented() -> nvmlReturn_t {

+    nvmlReturn_t::NVML_ERROR_NOT_SUPPORTED

+}

+

+pub(crate) fn error_string(result: nvmlReturn_t) -> *const ::std::os::raw::c_char {

+    let text = stringify_nmvlreturn_t!(

+        result => [

+            NVML_SUCCESS,

+            NVML_ERROR_UNINITIALIZED,

+            NVML_ERROR_INVALID_ARGUMENT,

+            NVML_ERROR_NOT_SUPPORTED,

+            NVML_ERROR_NO_PERMISSION,

+            NVML_ERROR_ALREADY_INITIALIZED,

+            NVML_ERROR_NOT_FOUND,

+            NVML_ERROR_INSUFFICIENT_SIZE,

+            NVML_ERROR_INSUFFICIENT_POWER,

+            NVML_ERROR_DRIVER_NOT_LOADED,

+            NVML_ERROR_TIMEOUT,

+            NVML_ERROR_IRQ_ISSUE,

+            NVML_ERROR_LIBRARY_NOT_FOUND,

+            NVML_ERROR_FUNCTION_NOT_FOUND,

+            NVML_ERROR_CORRUPTED_INFOROM,

+            NVML_ERROR_GPU_IS_LOST,

+            NVML_ERROR_RESET_REQUIRED,

+            NVML_ERROR_OPERATING_SYSTEM,

+            NVML_ERROR_LIB_RM_VERSION_MISMATCH,

+            NVML_ERROR_IN_USE,

+            NVML_ERROR_MEMORY,

+            NVML_ERROR_NO_DATA,

+            NVML_ERROR_VGPU_ECC_NOT_SUPPORTED,

+            NVML_ERROR_INSUFFICIENT_RESOURCES,

+            NVML_ERROR_UNKNOWN

+        ]

+    );

+    match text {

+        Some(text) => text.as_ptr() as *const _,

+        None => ptr::null(),

+    }

+}

+

+pub(crate) fn shutdown() -> nvmlReturn_t {

+    nvmlReturn_t::NVML_SUCCESS

+}

+

+pub(crate) fn init_v2() -> Result<(), nvmlReturn_t> {

+    Ok(l0::init()?)

+}

+

+pub(crate) fn init_with_flags() -> Result<(), nvmlReturn_t> {

+    init_v2()

+}

+

+impl From<l0::sys::ze_result_t> for nvmlReturn_t {

+    fn from(l0_err: l0::sys::ze_result_t) -> Self {

+        match l0_err {

+            l0::sys::ze_result_t::ZE_RESULT_ERROR_UNINITIALIZED => {

+                nvmlReturn_t::NVML_ERROR_UNINITIALIZED

+            }

+            _ => nvmlReturn_t::NVML_ERROR_UNKNOWN,

+        }

+    }

+}

+

+impl From<Result<(), nvmlReturn_t>> for nvmlReturn_t {

+    fn from(result: Result<(), nvmlReturn_t>) -> Self {

+        match result {

+            Ok(()) => nvmlReturn_t::NVML_SUCCESS,

+            Err(e) => e,

+        }

+    }

+}

+

+struct CountingWriter<T: std::io::Write> {

+    pub base: T,

+    pub len: usize,

+}

+

+impl<T: std::io::Write> std::io::Write for CountingWriter<T> {

+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {

+        self.len += buf.len();

+        self.base.write(buf)

+    }

+

+    fn flush(&mut self) -> std::io::Result<()> {

+        self.base.flush()

+    }

+}

+

+pub(crate) fn system_get_driver_version(

+    version_ptr: *mut c_char,

+    length: c_uint,

+) -> Result<(), nvmlReturn_t> {

+    if version_ptr == ptr::null_mut() {

+        return Err(nvmlReturn_t::NVML_ERROR_INVALID_ARGUMENT);

+    }

+    let drivers = l0::Driver::get()?;

+    let output_slice =

+        unsafe { std::slice::from_raw_parts_mut(version_ptr as *mut u8, (length - 1) as usize) };

+    let mut output_write = CountingWriter {

+        base: output_slice,

+        len: 0,

+    };

+    for d in drivers {

+        let props = d.get_properties()?;

+        let driver_version = props.driverVersion;

+        write!(&mut output_write, "{}", driver_version)

+            .map_err(|_| nvmlReturn_t::NVML_ERROR_UNKNOWN)?;

+        unsafe { *(version_ptr.add(output_write.len)) = 0 };

+        return Ok(());

+    }

+    Err(nvmlReturn_t::NVML_ERROR_UNKNOWN)

+}

diff --git a/zluda_ml/src/lib.rs b/zluda_ml/src/lib.rs
new file mode 100644
index 0000000..bb62334
--- /dev/null
+++ b/zluda_ml/src/lib.rs
@@ -0,0 +1,3 @@
+pub mod r#impl;

+#[allow(warnings)]

+mod nvml;
\ No newline at end of file
diff --git a/zluda_ml/src/nvml.rs b/zluda_ml/src/nvml.rs
new file mode 100644
index 0000000..805a51c
--- /dev/null
+++ b/zluda_ml/src/nvml.rs
@@ -0,0 +1,3166 @@
+/* automatically generated by rust-bindgen 0.57.0 */
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlDevice_st {
+    _unused: [u8; 0],
+}
+pub type nvmlDevice_t = *mut nvmlDevice_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlPciInfo_st {
+    pub busIdLegacy: [::std::os::raw::c_char; 16usize],
+    pub domain: ::std::os::raw::c_uint,
+    pub bus: ::std::os::raw::c_uint,
+    pub device: ::std::os::raw::c_uint,
+    pub pciDeviceId: ::std::os::raw::c_uint,
+    pub pciSubSystemId: ::std::os::raw::c_uint,
+    pub busId: [::std::os::raw::c_char; 32usize],
+}
+pub type nvmlPciInfo_t = nvmlPciInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlEccErrorCounts_st {
+    pub l1Cache: ::std::os::raw::c_ulonglong,
+    pub l2Cache: ::std::os::raw::c_ulonglong,
+    pub deviceMemory: ::std::os::raw::c_ulonglong,
+    pub registerFile: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlEccErrorCounts_t = nvmlEccErrorCounts_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlUtilization_st {
+    pub gpu: ::std::os::raw::c_uint,
+    pub memory: ::std::os::raw::c_uint,
+}
+pub type nvmlUtilization_t = nvmlUtilization_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlMemory_st {
+    pub total: ::std::os::raw::c_ulonglong,
+    pub free: ::std::os::raw::c_ulonglong,
+    pub used: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlMemory_t = nvmlMemory_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlBAR1Memory_st {
+    pub bar1Total: ::std::os::raw::c_ulonglong,
+    pub bar1Free: ::std::os::raw::c_ulonglong,
+    pub bar1Used: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlBAR1Memory_t = nvmlBAR1Memory_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlProcessInfo_st {
+    pub pid: ::std::os::raw::c_uint,
+    pub usedGpuMemory: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlProcessInfo_t = nvmlProcessInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlDeviceAttributes_st {
+    pub multiprocessorCount: ::std::os::raw::c_uint,
+    pub sharedCopyEngineCount: ::std::os::raw::c_uint,
+    pub sharedDecoderCount: ::std::os::raw::c_uint,
+    pub sharedEncoderCount: ::std::os::raw::c_uint,
+    pub sharedJpegCount: ::std::os::raw::c_uint,
+    pub sharedOfaCount: ::std::os::raw::c_uint,
+}
+pub type nvmlDeviceAttributes_t = nvmlDeviceAttributes_st;
+impl nvmlBridgeChipType_enum {
+    pub const NVML_BRIDGE_CHIP_PLX: nvmlBridgeChipType_enum = nvmlBridgeChipType_enum(0);
+}
+impl nvmlBridgeChipType_enum {
+    pub const NVML_BRIDGE_CHIP_BRO4: nvmlBridgeChipType_enum = nvmlBridgeChipType_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlBridgeChipType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlBridgeChipType_enum as nvmlBridgeChipType_t;
+impl nvmlNvLinkUtilizationCountUnits_enum {
+    pub const NVML_NVLINK_COUNTER_UNIT_CYCLES: nvmlNvLinkUtilizationCountUnits_enum =
+        nvmlNvLinkUtilizationCountUnits_enum(0);
+}
+impl nvmlNvLinkUtilizationCountUnits_enum {
+    pub const NVML_NVLINK_COUNTER_UNIT_PACKETS: nvmlNvLinkUtilizationCountUnits_enum =
+        nvmlNvLinkUtilizationCountUnits_enum(1);
+}
+impl nvmlNvLinkUtilizationCountUnits_enum {
+    pub const NVML_NVLINK_COUNTER_UNIT_BYTES: nvmlNvLinkUtilizationCountUnits_enum =
+        nvmlNvLinkUtilizationCountUnits_enum(2);
+}
+impl nvmlNvLinkUtilizationCountUnits_enum {
+    pub const NVML_NVLINK_COUNTER_UNIT_RESERVED: nvmlNvLinkUtilizationCountUnits_enum =
+        nvmlNvLinkUtilizationCountUnits_enum(3);
+}
+impl nvmlNvLinkUtilizationCountUnits_enum {
+    pub const NVML_NVLINK_COUNTER_UNIT_COUNT: nvmlNvLinkUtilizationCountUnits_enum =
+        nvmlNvLinkUtilizationCountUnits_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlNvLinkUtilizationCountUnits_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlNvLinkUtilizationCountUnits_enum as nvmlNvLinkUtilizationCountUnits_t;
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_NOP: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(1);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_READ: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(2);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_WRITE: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(4);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_RATOM: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(8);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_NRATOM: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(16);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_FLUSH: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(32);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_RESPDATA: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(64);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_RESPNODATA: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(128);
+}
+impl nvmlNvLinkUtilizationCountPktTypes_enum {
+    pub const NVML_NVLINK_COUNTER_PKTFILTER_ALL: nvmlNvLinkUtilizationCountPktTypes_enum =
+        nvmlNvLinkUtilizationCountPktTypes_enum(255);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlNvLinkUtilizationCountPktTypes_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlNvLinkUtilizationCountPktTypes_enum as nvmlNvLinkUtilizationCountPktTypes_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlNvLinkUtilizationControl_st {
+    pub units: nvmlNvLinkUtilizationCountUnits_t,
+    pub pktfilter: nvmlNvLinkUtilizationCountPktTypes_t,
+}
+pub type nvmlNvLinkUtilizationControl_t = nvmlNvLinkUtilizationControl_st;
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_P2P_SUPPORTED: nvmlNvLinkCapability_enum =
+        nvmlNvLinkCapability_enum(0);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_SYSMEM_ACCESS: nvmlNvLinkCapability_enum =
+        nvmlNvLinkCapability_enum(1);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_P2P_ATOMICS: nvmlNvLinkCapability_enum = nvmlNvLinkCapability_enum(2);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_SYSMEM_ATOMICS: nvmlNvLinkCapability_enum =
+        nvmlNvLinkCapability_enum(3);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_SLI_BRIDGE: nvmlNvLinkCapability_enum = nvmlNvLinkCapability_enum(4);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_VALID: nvmlNvLinkCapability_enum = nvmlNvLinkCapability_enum(5);
+}
+impl nvmlNvLinkCapability_enum {
+    pub const NVML_NVLINK_CAP_COUNT: nvmlNvLinkCapability_enum = nvmlNvLinkCapability_enum(6);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlNvLinkCapability_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlNvLinkCapability_enum as nvmlNvLinkCapability_t;
+impl nvmlNvLinkErrorCounter_enum {
+    pub const NVML_NVLINK_ERROR_DL_REPLAY: nvmlNvLinkErrorCounter_enum =
+        nvmlNvLinkErrorCounter_enum(0);
+}
+impl nvmlNvLinkErrorCounter_enum {
+    pub const NVML_NVLINK_ERROR_DL_RECOVERY: nvmlNvLinkErrorCounter_enum =
+        nvmlNvLinkErrorCounter_enum(1);
+}
+impl nvmlNvLinkErrorCounter_enum {
+    pub const NVML_NVLINK_ERROR_DL_CRC_FLIT: nvmlNvLinkErrorCounter_enum =
+        nvmlNvLinkErrorCounter_enum(2);
+}
+impl nvmlNvLinkErrorCounter_enum {
+    pub const NVML_NVLINK_ERROR_DL_CRC_DATA: nvmlNvLinkErrorCounter_enum =
+        nvmlNvLinkErrorCounter_enum(3);
+}
+impl nvmlNvLinkErrorCounter_enum {
+    pub const NVML_NVLINK_ERROR_COUNT: nvmlNvLinkErrorCounter_enum = nvmlNvLinkErrorCounter_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlNvLinkErrorCounter_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlNvLinkErrorCounter_enum as nvmlNvLinkErrorCounter_t;
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_INTERNAL: nvmlGpuLevel_enum = nvmlGpuLevel_enum(0);
+}
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_SINGLE: nvmlGpuLevel_enum = nvmlGpuLevel_enum(10);
+}
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_MULTIPLE: nvmlGpuLevel_enum = nvmlGpuLevel_enum(20);
+}
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_HOSTBRIDGE: nvmlGpuLevel_enum = nvmlGpuLevel_enum(30);
+}
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_NODE: nvmlGpuLevel_enum = nvmlGpuLevel_enum(40);
+}
+impl nvmlGpuLevel_enum {
+    pub const NVML_TOPOLOGY_SYSTEM: nvmlGpuLevel_enum = nvmlGpuLevel_enum(50);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGpuLevel_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlGpuLevel_enum as nvmlGpuTopologyLevel_t;
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_OK: nvmlGpuP2PStatus_enum = nvmlGpuP2PStatus_enum(0);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED: nvmlGpuP2PStatus_enum =
+        nvmlGpuP2PStatus_enum(1);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_GPU_NOT_SUPPORTED: nvmlGpuP2PStatus_enum = nvmlGpuP2PStatus_enum(2);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_IOH_TOPOLOGY_NOT_SUPPORTED: nvmlGpuP2PStatus_enum =
+        nvmlGpuP2PStatus_enum(3);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_DISABLED_BY_REGKEY: nvmlGpuP2PStatus_enum = nvmlGpuP2PStatus_enum(4);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_NOT_SUPPORTED: nvmlGpuP2PStatus_enum = nvmlGpuP2PStatus_enum(5);
+}
+impl nvmlGpuP2PStatus_enum {
+    pub const NVML_P2P_STATUS_UNKNOWN: nvmlGpuP2PStatus_enum = nvmlGpuP2PStatus_enum(6);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGpuP2PStatus_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlGpuP2PStatus_enum as nvmlGpuP2PStatus_t;
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_READ: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(0);
+}
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_WRITE: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(1);
+}
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_NVLINK: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(2);
+}
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_ATOMICS: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(3);
+}
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_PROP: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(4);
+}
+impl nvmlGpuP2PCapsIndex_enum {
+    pub const NVML_P2P_CAPS_INDEX_UNKNOWN: nvmlGpuP2PCapsIndex_enum = nvmlGpuP2PCapsIndex_enum(5);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGpuP2PCapsIndex_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlGpuP2PCapsIndex_enum as nvmlGpuP2PCapsIndex_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlBridgeChipInfo_st {
+    pub type_: nvmlBridgeChipType_t,
+    pub fwVersion: ::std::os::raw::c_uint,
+}
+pub type nvmlBridgeChipInfo_t = nvmlBridgeChipInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlBridgeChipHierarchy_st {
+    pub bridgeCount: ::std::os::raw::c_uchar,
+    pub bridgeChipInfo: [nvmlBridgeChipInfo_t; 128usize],
+}
+pub type nvmlBridgeChipHierarchy_t = nvmlBridgeChipHierarchy_st;
+impl nvmlSamplingType_enum {
+    pub const NVML_TOTAL_POWER_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(0);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_GPU_UTILIZATION_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(1);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_MEMORY_UTILIZATION_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(2);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_ENC_UTILIZATION_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(3);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_DEC_UTILIZATION_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(4);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_PROCESSOR_CLK_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(5);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_MEMORY_CLK_SAMPLES: nvmlSamplingType_enum = nvmlSamplingType_enum(6);
+}
+impl nvmlSamplingType_enum {
+    pub const NVML_SAMPLINGTYPE_COUNT: nvmlSamplingType_enum = nvmlSamplingType_enum(7);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlSamplingType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlSamplingType_enum as nvmlSamplingType_t;
+impl nvmlPcieUtilCounter_enum {
+    pub const NVML_PCIE_UTIL_TX_BYTES: nvmlPcieUtilCounter_enum = nvmlPcieUtilCounter_enum(0);
+}
+impl nvmlPcieUtilCounter_enum {
+    pub const NVML_PCIE_UTIL_RX_BYTES: nvmlPcieUtilCounter_enum = nvmlPcieUtilCounter_enum(1);
+}
+impl nvmlPcieUtilCounter_enum {
+    pub const NVML_PCIE_UTIL_COUNT: nvmlPcieUtilCounter_enum = nvmlPcieUtilCounter_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlPcieUtilCounter_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlPcieUtilCounter_enum as nvmlPcieUtilCounter_t;
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_DOUBLE: nvmlValueType_enum = nvmlValueType_enum(0);
+}
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_UNSIGNED_INT: nvmlValueType_enum = nvmlValueType_enum(1);
+}
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_UNSIGNED_LONG: nvmlValueType_enum = nvmlValueType_enum(2);
+}
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_UNSIGNED_LONG_LONG: nvmlValueType_enum = nvmlValueType_enum(3);
+}
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_SIGNED_LONG_LONG: nvmlValueType_enum = nvmlValueType_enum(4);
+}
+impl nvmlValueType_enum {
+    pub const NVML_VALUE_TYPE_COUNT: nvmlValueType_enum = nvmlValueType_enum(5);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlValueType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlValueType_enum as nvmlValueType_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union nvmlValue_st {
+    pub dVal: f64,
+    pub uiVal: ::std::os::raw::c_uint,
+    pub ulVal: ::std::os::raw::c_ulong,
+    pub ullVal: ::std::os::raw::c_ulonglong,
+    pub sllVal: ::std::os::raw::c_longlong,
+    _bindgen_union_align: u64,
+}
+pub type nvmlValue_t = nvmlValue_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlSample_st {
+    pub timeStamp: ::std::os::raw::c_ulonglong,
+    pub sampleValue: nvmlValue_t,
+}
+pub type nvmlSample_t = nvmlSample_st;
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_POWER: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(0);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_THERMAL: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(1);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_SYNC_BOOST: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(2);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_BOARD_LIMIT: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(3);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_LOW_UTILIZATION: nvmlPerfPolicyType_enum =
+        nvmlPerfPolicyType_enum(4);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_RELIABILITY: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(5);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_TOTAL_APP_CLOCKS: nvmlPerfPolicyType_enum =
+        nvmlPerfPolicyType_enum(10);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_TOTAL_BASE_CLOCKS: nvmlPerfPolicyType_enum =
+        nvmlPerfPolicyType_enum(11);
+}
+impl nvmlPerfPolicyType_enum {
+    pub const NVML_PERF_POLICY_COUNT: nvmlPerfPolicyType_enum = nvmlPerfPolicyType_enum(12);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlPerfPolicyType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlPerfPolicyType_enum as nvmlPerfPolicyType_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlViolationTime_st {
+    pub referenceTime: ::std::os::raw::c_ulonglong,
+    pub violationTime: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlViolationTime_t = nvmlViolationTime_st;
+impl nvmlEnableState_enum {
+    pub const NVML_FEATURE_DISABLED: nvmlEnableState_enum = nvmlEnableState_enum(0);
+}
+impl nvmlEnableState_enum {
+    pub const NVML_FEATURE_ENABLED: nvmlEnableState_enum = nvmlEnableState_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlEnableState_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlEnableState_enum as nvmlEnableState_t;
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_UNKNOWN: nvmlBrandType_enum = nvmlBrandType_enum(0);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_QUADRO: nvmlBrandType_enum = nvmlBrandType_enum(1);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_TESLA: nvmlBrandType_enum = nvmlBrandType_enum(2);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_NVS: nvmlBrandType_enum = nvmlBrandType_enum(3);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_GRID: nvmlBrandType_enum = nvmlBrandType_enum(4);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_GEFORCE: nvmlBrandType_enum = nvmlBrandType_enum(5);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_TITAN: nvmlBrandType_enum = nvmlBrandType_enum(6);
+}
+impl nvmlBrandType_enum {
+    pub const NVML_BRAND_COUNT: nvmlBrandType_enum = nvmlBrandType_enum(7);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlBrandType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlBrandType_enum as nvmlBrandType_t;
+impl nvmlTemperatureThresholds_enum {
+    pub const NVML_TEMPERATURE_THRESHOLD_SHUTDOWN: nvmlTemperatureThresholds_enum =
+        nvmlTemperatureThresholds_enum(0);
+}
+impl nvmlTemperatureThresholds_enum {
+    pub const NVML_TEMPERATURE_THRESHOLD_SLOWDOWN: nvmlTemperatureThresholds_enum =
+        nvmlTemperatureThresholds_enum(1);
+}
+impl nvmlTemperatureThresholds_enum {
+    pub const NVML_TEMPERATURE_THRESHOLD_MEM_MAX: nvmlTemperatureThresholds_enum =
+        nvmlTemperatureThresholds_enum(2);
+}
+impl nvmlTemperatureThresholds_enum {
+    pub const NVML_TEMPERATURE_THRESHOLD_GPU_MAX: nvmlTemperatureThresholds_enum =
+        nvmlTemperatureThresholds_enum(3);
+}
+impl nvmlTemperatureThresholds_enum {
+    pub const NVML_TEMPERATURE_THRESHOLD_COUNT: nvmlTemperatureThresholds_enum =
+        nvmlTemperatureThresholds_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlTemperatureThresholds_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlTemperatureThresholds_enum as nvmlTemperatureThresholds_t;
+impl nvmlTemperatureSensors_enum {
+    pub const NVML_TEMPERATURE_GPU: nvmlTemperatureSensors_enum = nvmlTemperatureSensors_enum(0);
+}
+impl nvmlTemperatureSensors_enum {
+    pub const NVML_TEMPERATURE_COUNT: nvmlTemperatureSensors_enum = nvmlTemperatureSensors_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlTemperatureSensors_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlTemperatureSensors_enum as nvmlTemperatureSensors_t;
+impl nvmlComputeMode_enum {
+    pub const NVML_COMPUTEMODE_DEFAULT: nvmlComputeMode_enum = nvmlComputeMode_enum(0);
+}
+impl nvmlComputeMode_enum {
+    pub const NVML_COMPUTEMODE_EXCLUSIVE_THREAD: nvmlComputeMode_enum = nvmlComputeMode_enum(1);
+}
+impl nvmlComputeMode_enum {
+    pub const NVML_COMPUTEMODE_PROHIBITED: nvmlComputeMode_enum = nvmlComputeMode_enum(2);
+}
+impl nvmlComputeMode_enum {
+    pub const NVML_COMPUTEMODE_EXCLUSIVE_PROCESS: nvmlComputeMode_enum = nvmlComputeMode_enum(3);
+}
+impl nvmlComputeMode_enum {
+    pub const NVML_COMPUTEMODE_COUNT: nvmlComputeMode_enum = nvmlComputeMode_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlComputeMode_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlComputeMode_enum as nvmlComputeMode_t;
+impl nvmlMemoryErrorType_enum {
+    pub const NVML_MEMORY_ERROR_TYPE_CORRECTED: nvmlMemoryErrorType_enum =
+        nvmlMemoryErrorType_enum(0);
+}
+impl nvmlMemoryErrorType_enum {
+    pub const NVML_MEMORY_ERROR_TYPE_UNCORRECTED: nvmlMemoryErrorType_enum =
+        nvmlMemoryErrorType_enum(1);
+}
+impl nvmlMemoryErrorType_enum {
+    pub const NVML_MEMORY_ERROR_TYPE_COUNT: nvmlMemoryErrorType_enum = nvmlMemoryErrorType_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlMemoryErrorType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlMemoryErrorType_enum as nvmlMemoryErrorType_t;
+impl nvmlEccCounterType_enum {
+    pub const NVML_VOLATILE_ECC: nvmlEccCounterType_enum = nvmlEccCounterType_enum(0);
+}
+impl nvmlEccCounterType_enum {
+    pub const NVML_AGGREGATE_ECC: nvmlEccCounterType_enum = nvmlEccCounterType_enum(1);
+}
+impl nvmlEccCounterType_enum {
+    pub const NVML_ECC_COUNTER_TYPE_COUNT: nvmlEccCounterType_enum = nvmlEccCounterType_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlEccCounterType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlEccCounterType_enum as nvmlEccCounterType_t;
+impl nvmlClockType_enum {
+    pub const NVML_CLOCK_GRAPHICS: nvmlClockType_enum = nvmlClockType_enum(0);
+}
+impl nvmlClockType_enum {
+    pub const NVML_CLOCK_SM: nvmlClockType_enum = nvmlClockType_enum(1);
+}
+impl nvmlClockType_enum {
+    pub const NVML_CLOCK_MEM: nvmlClockType_enum = nvmlClockType_enum(2);
+}
+impl nvmlClockType_enum {
+    pub const NVML_CLOCK_VIDEO: nvmlClockType_enum = nvmlClockType_enum(3);
+}
+impl nvmlClockType_enum {
+    pub const NVML_CLOCK_COUNT: nvmlClockType_enum = nvmlClockType_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlClockType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlClockType_enum as nvmlClockType_t;
+impl nvmlClockId_enum {
+    pub const NVML_CLOCK_ID_CURRENT: nvmlClockId_enum = nvmlClockId_enum(0);
+}
+impl nvmlClockId_enum {
+    pub const NVML_CLOCK_ID_APP_CLOCK_TARGET: nvmlClockId_enum = nvmlClockId_enum(1);
+}
+impl nvmlClockId_enum {
+    pub const NVML_CLOCK_ID_APP_CLOCK_DEFAULT: nvmlClockId_enum = nvmlClockId_enum(2);
+}
+impl nvmlClockId_enum {
+    pub const NVML_CLOCK_ID_CUSTOMER_BOOST_MAX: nvmlClockId_enum = nvmlClockId_enum(3);
+}
+impl nvmlClockId_enum {
+    pub const NVML_CLOCK_ID_COUNT: nvmlClockId_enum = nvmlClockId_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlClockId_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlClockId_enum as nvmlClockId_t;
+impl nvmlDriverModel_enum {
+    pub const NVML_DRIVER_WDDM: nvmlDriverModel_enum = nvmlDriverModel_enum(0);
+}
+impl nvmlDriverModel_enum {
+    pub const NVML_DRIVER_WDM: nvmlDriverModel_enum = nvmlDriverModel_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlDriverModel_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlDriverModel_enum as nvmlDriverModel_t;
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_0: nvmlPStates_enum = nvmlPStates_enum(0);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_1: nvmlPStates_enum = nvmlPStates_enum(1);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_2: nvmlPStates_enum = nvmlPStates_enum(2);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_3: nvmlPStates_enum = nvmlPStates_enum(3);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_4: nvmlPStates_enum = nvmlPStates_enum(4);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_5: nvmlPStates_enum = nvmlPStates_enum(5);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_6: nvmlPStates_enum = nvmlPStates_enum(6);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_7: nvmlPStates_enum = nvmlPStates_enum(7);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_8: nvmlPStates_enum = nvmlPStates_enum(8);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_9: nvmlPStates_enum = nvmlPStates_enum(9);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_10: nvmlPStates_enum = nvmlPStates_enum(10);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_11: nvmlPStates_enum = nvmlPStates_enum(11);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_12: nvmlPStates_enum = nvmlPStates_enum(12);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_13: nvmlPStates_enum = nvmlPStates_enum(13);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_14: nvmlPStates_enum = nvmlPStates_enum(14);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_15: nvmlPStates_enum = nvmlPStates_enum(15);
+}
+impl nvmlPStates_enum {
+    pub const NVML_PSTATE_UNKNOWN: nvmlPStates_enum = nvmlPStates_enum(32);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlPStates_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlPStates_enum as nvmlPstates_t;
+impl nvmlGom_enum {
+    pub const NVML_GOM_ALL_ON: nvmlGom_enum = nvmlGom_enum(0);
+}
+impl nvmlGom_enum {
+    pub const NVML_GOM_COMPUTE: nvmlGom_enum = nvmlGom_enum(1);
+}
+impl nvmlGom_enum {
+    pub const NVML_GOM_LOW_DP: nvmlGom_enum = nvmlGom_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGom_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlGom_enum as nvmlGpuOperationMode_t;
+impl nvmlInforomObject_enum {
+    pub const NVML_INFOROM_OEM: nvmlInforomObject_enum = nvmlInforomObject_enum(0);
+}
+impl nvmlInforomObject_enum {
+    pub const NVML_INFOROM_ECC: nvmlInforomObject_enum = nvmlInforomObject_enum(1);
+}
+impl nvmlInforomObject_enum {
+    pub const NVML_INFOROM_POWER: nvmlInforomObject_enum = nvmlInforomObject_enum(2);
+}
+impl nvmlInforomObject_enum {
+    pub const NVML_INFOROM_COUNT: nvmlInforomObject_enum = nvmlInforomObject_enum(3);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlInforomObject_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlInforomObject_enum as nvmlInforomObject_t;
+impl nvmlReturn_enum {
+    pub const NVML_SUCCESS: nvmlReturn_enum = nvmlReturn_enum(0);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_UNINITIALIZED: nvmlReturn_enum = nvmlReturn_enum(1);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_INVALID_ARGUMENT: nvmlReturn_enum = nvmlReturn_enum(2);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_NOT_SUPPORTED: nvmlReturn_enum = nvmlReturn_enum(3);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_NO_PERMISSION: nvmlReturn_enum = nvmlReturn_enum(4);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_ALREADY_INITIALIZED: nvmlReturn_enum = nvmlReturn_enum(5);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_NOT_FOUND: nvmlReturn_enum = nvmlReturn_enum(6);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_INSUFFICIENT_SIZE: nvmlReturn_enum = nvmlReturn_enum(7);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_INSUFFICIENT_POWER: nvmlReturn_enum = nvmlReturn_enum(8);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_DRIVER_NOT_LOADED: nvmlReturn_enum = nvmlReturn_enum(9);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_TIMEOUT: nvmlReturn_enum = nvmlReturn_enum(10);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_IRQ_ISSUE: nvmlReturn_enum = nvmlReturn_enum(11);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_LIBRARY_NOT_FOUND: nvmlReturn_enum = nvmlReturn_enum(12);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_FUNCTION_NOT_FOUND: nvmlReturn_enum = nvmlReturn_enum(13);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_CORRUPTED_INFOROM: nvmlReturn_enum = nvmlReturn_enum(14);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_GPU_IS_LOST: nvmlReturn_enum = nvmlReturn_enum(15);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_RESET_REQUIRED: nvmlReturn_enum = nvmlReturn_enum(16);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_OPERATING_SYSTEM: nvmlReturn_enum = nvmlReturn_enum(17);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_LIB_RM_VERSION_MISMATCH: nvmlReturn_enum = nvmlReturn_enum(18);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_IN_USE: nvmlReturn_enum = nvmlReturn_enum(19);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_MEMORY: nvmlReturn_enum = nvmlReturn_enum(20);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_NO_DATA: nvmlReturn_enum = nvmlReturn_enum(21);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_VGPU_ECC_NOT_SUPPORTED: nvmlReturn_enum = nvmlReturn_enum(22);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_INSUFFICIENT_RESOURCES: nvmlReturn_enum = nvmlReturn_enum(23);
+}
+impl nvmlReturn_enum {
+    pub const NVML_ERROR_UNKNOWN: nvmlReturn_enum = nvmlReturn_enum(999);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlReturn_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlReturn_enum as nvmlReturn_t;
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_L1_CACHE: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(0);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_L2_CACHE: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(1);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_DRAM: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(2);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_DEVICE_MEMORY: nvmlMemoryLocation_enum =
+        nvmlMemoryLocation_enum(2);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_REGISTER_FILE: nvmlMemoryLocation_enum =
+        nvmlMemoryLocation_enum(3);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_TEXTURE_MEMORY: nvmlMemoryLocation_enum =
+        nvmlMemoryLocation_enum(4);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_TEXTURE_SHM: nvmlMemoryLocation_enum =
+        nvmlMemoryLocation_enum(5);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_CBU: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(6);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_SRAM: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(7);
+}
+impl nvmlMemoryLocation_enum {
+    pub const NVML_MEMORY_LOCATION_COUNT: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(8);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlMemoryLocation_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlMemoryLocation_enum as nvmlMemoryLocation_t;
+impl nvmlPageRetirementCause_enum {
+    pub const NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS:
+        nvmlPageRetirementCause_enum = nvmlPageRetirementCause_enum(0);
+}
+impl nvmlPageRetirementCause_enum {
+    pub const NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR: nvmlPageRetirementCause_enum =
+        nvmlPageRetirementCause_enum(1);
+}
+impl nvmlPageRetirementCause_enum {
+    pub const NVML_PAGE_RETIREMENT_CAUSE_COUNT: nvmlPageRetirementCause_enum =
+        nvmlPageRetirementCause_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlPageRetirementCause_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlPageRetirementCause_enum as nvmlPageRetirementCause_t;
+impl nvmlRestrictedAPI_enum {
+    pub const NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS: nvmlRestrictedAPI_enum =
+        nvmlRestrictedAPI_enum(0);
+}
+impl nvmlRestrictedAPI_enum {
+    pub const NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS: nvmlRestrictedAPI_enum =
+        nvmlRestrictedAPI_enum(1);
+}
+impl nvmlRestrictedAPI_enum {
+    pub const NVML_RESTRICTED_API_COUNT: nvmlRestrictedAPI_enum = nvmlRestrictedAPI_enum(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlRestrictedAPI_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlRestrictedAPI_enum as nvmlRestrictedAPI_t;
+impl nvmlGpuVirtualizationMode {
+    pub const NVML_GPU_VIRTUALIZATION_MODE_NONE: nvmlGpuVirtualizationMode =
+        nvmlGpuVirtualizationMode(0);
+}
+impl nvmlGpuVirtualizationMode {
+    pub const NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH: nvmlGpuVirtualizationMode =
+        nvmlGpuVirtualizationMode(1);
+}
+impl nvmlGpuVirtualizationMode {
+    pub const NVML_GPU_VIRTUALIZATION_MODE_VGPU: nvmlGpuVirtualizationMode =
+        nvmlGpuVirtualizationMode(2);
+}
+impl nvmlGpuVirtualizationMode {
+    pub const NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU: nvmlGpuVirtualizationMode =
+        nvmlGpuVirtualizationMode(3);
+}
+impl nvmlGpuVirtualizationMode {
+    pub const NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA: nvmlGpuVirtualizationMode =
+        nvmlGpuVirtualizationMode(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGpuVirtualizationMode(pub ::std::os::raw::c_uint);
+pub use self::nvmlGpuVirtualizationMode as nvmlGpuVirtualizationMode_t;
+impl nvmlHostVgpuMode_enum {
+    pub const NVML_HOST_VGPU_MODE_NON_SRIOV: nvmlHostVgpuMode_enum = nvmlHostVgpuMode_enum(0);
+}
+impl nvmlHostVgpuMode_enum {
+    pub const NVML_HOST_VGPU_MODE_SRIOV: nvmlHostVgpuMode_enum = nvmlHostVgpuMode_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlHostVgpuMode_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlHostVgpuMode_enum as nvmlHostVgpuMode_t;
+impl nvmlVgpuVmIdType {
+    pub const NVML_VGPU_VM_ID_DOMAIN_ID: nvmlVgpuVmIdType = nvmlVgpuVmIdType(0);
+}
+impl nvmlVgpuVmIdType {
+    pub const NVML_VGPU_VM_ID_UUID: nvmlVgpuVmIdType = nvmlVgpuVmIdType(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlVgpuVmIdType(pub ::std::os::raw::c_uint);
+pub use self::nvmlVgpuVmIdType as nvmlVgpuVmIdType_t;
+impl nvmlVgpuGuestInfoState_enum {
+    pub const NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED: nvmlVgpuGuestInfoState_enum =
+        nvmlVgpuGuestInfoState_enum(0);
+}
+impl nvmlVgpuGuestInfoState_enum {
+    pub const NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED: nvmlVgpuGuestInfoState_enum =
+        nvmlVgpuGuestInfoState_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlVgpuGuestInfoState_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlVgpuGuestInfoState_enum as nvmlVgpuGuestInfoState_t;
+impl nvmlGridLicenseFeatureCode_t {
+    pub const NVML_GRID_LICENSE_FEATURE_CODE_VGPU: nvmlGridLicenseFeatureCode_t =
+        nvmlGridLicenseFeatureCode_t(1);
+}
+impl nvmlGridLicenseFeatureCode_t {
+    pub const NVML_GRID_LICENSE_FEATURE_CODE_VWORKSTATION: nvmlGridLicenseFeatureCode_t =
+        nvmlGridLicenseFeatureCode_t(2);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlGridLicenseFeatureCode_t(pub ::std::os::raw::c_uint);
+pub type nvmlVgpuTypeId_t = ::std::os::raw::c_uint;
+pub type nvmlVgpuInstance_t = ::std::os::raw::c_uint;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuInstanceUtilizationSample_st {
+    pub vgpuInstance: nvmlVgpuInstance_t,
+    pub timeStamp: ::std::os::raw::c_ulonglong,
+    pub smUtil: nvmlValue_t,
+    pub memUtil: nvmlValue_t,
+    pub encUtil: nvmlValue_t,
+    pub decUtil: nvmlValue_t,
+}
+pub type nvmlVgpuInstanceUtilizationSample_t = nvmlVgpuInstanceUtilizationSample_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuProcessUtilizationSample_st {
+    pub vgpuInstance: nvmlVgpuInstance_t,
+    pub pid: ::std::os::raw::c_uint,
+    pub processName: [::std::os::raw::c_char; 64usize],
+    pub timeStamp: ::std::os::raw::c_ulonglong,
+    pub smUtil: ::std::os::raw::c_uint,
+    pub memUtil: ::std::os::raw::c_uint,
+    pub encUtil: ::std::os::raw::c_uint,
+    pub decUtil: ::std::os::raw::c_uint,
+}
+pub type nvmlVgpuProcessUtilizationSample_t = nvmlVgpuProcessUtilizationSample_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlProcessUtilizationSample_st {
+    pub pid: ::std::os::raw::c_uint,
+    pub timeStamp: ::std::os::raw::c_ulonglong,
+    pub smUtil: ::std::os::raw::c_uint,
+    pub memUtil: ::std::os::raw::c_uint,
+    pub encUtil: ::std::os::raw::c_uint,
+    pub decUtil: ::std::os::raw::c_uint,
+}
+pub type nvmlProcessUtilizationSample_t = nvmlProcessUtilizationSample_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGridLicensableFeature_st {
+    pub featureCode: nvmlGridLicenseFeatureCode_t,
+    pub featureState: ::std::os::raw::c_uint,
+    pub licenseInfo: [::std::os::raw::c_char; 128usize],
+    pub productName: [::std::os::raw::c_char; 128usize],
+    pub featureEnabled: ::std::os::raw::c_uint,
+}
+pub type nvmlGridLicensableFeature_t = nvmlGridLicensableFeature_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGridLicensableFeatures_st {
+    pub isGridLicenseSupported: ::std::os::raw::c_int,
+    pub licensableFeaturesCount: ::std::os::raw::c_uint,
+    pub gridLicensableFeatures: [nvmlGridLicensableFeature_t; 3usize],
+}
+pub type nvmlGridLicensableFeatures_t = nvmlGridLicensableFeatures_st;
+pub type nvmlDeviceArchitecture_t = ::std::os::raw::c_uint;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlFieldValue_st {
+    pub fieldId: ::std::os::raw::c_uint,
+    pub scopeId: ::std::os::raw::c_uint,
+    pub timestamp: ::std::os::raw::c_longlong,
+    pub latencyUsec: ::std::os::raw::c_longlong,
+    pub valueType: nvmlValueType_t,
+    pub nvmlReturn: nvmlReturn_t,
+    pub value: nvmlValue_t,
+}
+pub type nvmlFieldValue_t = nvmlFieldValue_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlUnit_st {
+    _unused: [u8; 0],
+}
+pub type nvmlUnit_t = *mut nvmlUnit_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlHwbcEntry_st {
+    pub hwbcId: ::std::os::raw::c_uint,
+    pub firmwareVersion: [::std::os::raw::c_char; 32usize],
+}
+pub type nvmlHwbcEntry_t = nvmlHwbcEntry_st;
+impl nvmlFanState_enum {
+    pub const NVML_FAN_NORMAL: nvmlFanState_enum = nvmlFanState_enum(0);
+}
+impl nvmlFanState_enum {
+    pub const NVML_FAN_FAILED: nvmlFanState_enum = nvmlFanState_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlFanState_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlFanState_enum as nvmlFanState_t;
+impl nvmlLedColor_enum {
+    pub const NVML_LED_COLOR_GREEN: nvmlLedColor_enum = nvmlLedColor_enum(0);
+}
+impl nvmlLedColor_enum {
+    pub const NVML_LED_COLOR_AMBER: nvmlLedColor_enum = nvmlLedColor_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlLedColor_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlLedColor_enum as nvmlLedColor_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlLedState_st {
+    pub cause: [::std::os::raw::c_char; 256usize],
+    pub color: nvmlLedColor_t,
+}
+pub type nvmlLedState_t = nvmlLedState_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlUnitInfo_st {
+    pub name: [::std::os::raw::c_char; 96usize],
+    pub id: [::std::os::raw::c_char; 96usize],
+    pub serial: [::std::os::raw::c_char; 96usize],
+    pub firmwareVersion: [::std::os::raw::c_char; 96usize],
+}
+pub type nvmlUnitInfo_t = nvmlUnitInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlPSUInfo_st {
+    pub state: [::std::os::raw::c_char; 256usize],
+    pub current: ::std::os::raw::c_uint,
+    pub voltage: ::std::os::raw::c_uint,
+    pub power: ::std::os::raw::c_uint,
+}
+pub type nvmlPSUInfo_t = nvmlPSUInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlUnitFanInfo_st {
+    pub speed: ::std::os::raw::c_uint,
+    pub state: nvmlFanState_t,
+}
+pub type nvmlUnitFanInfo_t = nvmlUnitFanInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlUnitFanSpeeds_st {
+    pub fans: [nvmlUnitFanInfo_t; 24usize],
+    pub count: ::std::os::raw::c_uint,
+}
+pub type nvmlUnitFanSpeeds_t = nvmlUnitFanSpeeds_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlEventSet_st {
+    _unused: [u8; 0],
+}
+pub type nvmlEventSet_t = *mut nvmlEventSet_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlEventData_st {
+    pub device: nvmlDevice_t,
+    pub eventType: ::std::os::raw::c_ulonglong,
+    pub eventData: ::std::os::raw::c_ulonglong,
+    pub gpuInstanceId: ::std::os::raw::c_uint,
+    pub computeInstanceId: ::std::os::raw::c_uint,
+}
+pub type nvmlEventData_t = nvmlEventData_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlAccountingStats_st {
+    pub gpuUtilization: ::std::os::raw::c_uint,
+    pub memoryUtilization: ::std::os::raw::c_uint,
+    pub maxMemoryUsage: ::std::os::raw::c_ulonglong,
+    pub time: ::std::os::raw::c_ulonglong,
+    pub startTime: ::std::os::raw::c_ulonglong,
+    pub isRunning: ::std::os::raw::c_uint,
+    pub reserved: [::std::os::raw::c_uint; 5usize],
+}
+pub type nvmlAccountingStats_t = nvmlAccountingStats_st;
+impl nvmlEncoderQueryType_enum {
+    pub const NVML_ENCODER_QUERY_H264: nvmlEncoderQueryType_enum = nvmlEncoderQueryType_enum(0);
+}
+impl nvmlEncoderQueryType_enum {
+    pub const NVML_ENCODER_QUERY_HEVC: nvmlEncoderQueryType_enum = nvmlEncoderQueryType_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlEncoderQueryType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlEncoderQueryType_enum as nvmlEncoderType_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlEncoderSessionInfo_st {
+    pub sessionId: ::std::os::raw::c_uint,
+    pub pid: ::std::os::raw::c_uint,
+    pub vgpuInstance: nvmlVgpuInstance_t,
+    pub codecType: nvmlEncoderType_t,
+    pub hResolution: ::std::os::raw::c_uint,
+    pub vResolution: ::std::os::raw::c_uint,
+    pub averageFps: ::std::os::raw::c_uint,
+    pub averageLatency: ::std::os::raw::c_uint,
+}
+pub type nvmlEncoderSessionInfo_t = nvmlEncoderSessionInfo_st;
+impl nvmlFBCSessionType_enum {
+    pub const NVML_FBC_SESSION_TYPE_UNKNOWN: nvmlFBCSessionType_enum = nvmlFBCSessionType_enum(0);
+}
+impl nvmlFBCSessionType_enum {
+    pub const NVML_FBC_SESSION_TYPE_TOSYS: nvmlFBCSessionType_enum = nvmlFBCSessionType_enum(1);
+}
+impl nvmlFBCSessionType_enum {
+    pub const NVML_FBC_SESSION_TYPE_CUDA: nvmlFBCSessionType_enum = nvmlFBCSessionType_enum(2);
+}
+impl nvmlFBCSessionType_enum {
+    pub const NVML_FBC_SESSION_TYPE_VID: nvmlFBCSessionType_enum = nvmlFBCSessionType_enum(3);
+}
+impl nvmlFBCSessionType_enum {
+    pub const NVML_FBC_SESSION_TYPE_HWENC: nvmlFBCSessionType_enum = nvmlFBCSessionType_enum(4);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlFBCSessionType_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlFBCSessionType_enum as nvmlFBCSessionType_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlFBCStats_st {
+    pub sessionsCount: ::std::os::raw::c_uint,
+    pub averageFPS: ::std::os::raw::c_uint,
+    pub averageLatency: ::std::os::raw::c_uint,
+}
+pub type nvmlFBCStats_t = nvmlFBCStats_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlFBCSessionInfo_st {
+    pub sessionId: ::std::os::raw::c_uint,
+    pub pid: ::std::os::raw::c_uint,
+    pub vgpuInstance: nvmlVgpuInstance_t,
+    pub displayOrdinal: ::std::os::raw::c_uint,
+    pub sessionType: nvmlFBCSessionType_t,
+    pub sessionFlags: ::std::os::raw::c_uint,
+    pub hMaxResolution: ::std::os::raw::c_uint,
+    pub vMaxResolution: ::std::os::raw::c_uint,
+    pub hResolution: ::std::os::raw::c_uint,
+    pub vResolution: ::std::os::raw::c_uint,
+    pub averageFPS: ::std::os::raw::c_uint,
+    pub averageLatency: ::std::os::raw::c_uint,
+}
+pub type nvmlFBCSessionInfo_t = nvmlFBCSessionInfo_st;
+impl nvmlDetachGpuState_enum {
+    pub const NVML_DETACH_GPU_KEEP: nvmlDetachGpuState_enum = nvmlDetachGpuState_enum(0);
+}
+impl nvmlDetachGpuState_enum {
+    pub const NVML_DETACH_GPU_REMOVE: nvmlDetachGpuState_enum = nvmlDetachGpuState_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlDetachGpuState_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlDetachGpuState_enum as nvmlDetachGpuState_t;
+impl nvmlPcieLinkState_enum {
+    pub const NVML_PCIE_LINK_KEEP: nvmlPcieLinkState_enum = nvmlPcieLinkState_enum(0);
+}
+impl nvmlPcieLinkState_enum {
+    pub const NVML_PCIE_LINK_SHUT_DOWN: nvmlPcieLinkState_enum = nvmlPcieLinkState_enum(1);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlPcieLinkState_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlPcieLinkState_enum as nvmlPcieLinkState_t;
+
+#[no_mangle]
+pub extern "C" fn nvmlInit_v2() -> nvmlReturn_t {
+    crate::r#impl::init_v2().into()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlInitWithFlags(flags: ::std::os::raw::c_uint) -> nvmlReturn_t {
+    crate::r#impl::init_with_flags().into()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlShutdown() -> nvmlReturn_t {
+    crate::r#impl::shutdown()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlErrorString(result: nvmlReturn_t) -> *const ::std::os::raw::c_char {
+    crate::r#impl::error_string(result)
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetDriverVersion(
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::system_get_driver_version(version, length).into()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetNVMLVersion(
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetCudaDriverVersion(
+    cudaDriverVersion: *mut ::std::os::raw::c_int,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetCudaDriverVersion_v2(
+    cudaDriverVersion: *mut ::std::os::raw::c_int,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetProcessName(
+    pid: ::std::os::raw::c_uint,
+    name: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetCount(unitCount: *mut ::std::os::raw::c_uint) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetHandleByIndex(
+    index: ::std::os::raw::c_uint,
+    unit: *mut nvmlUnit_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetUnitInfo(unit: nvmlUnit_t, info: *mut nvmlUnitInfo_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetLedState(
+    unit: nvmlUnit_t,
+    state: *mut nvmlLedState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetPsuInfo(unit: nvmlUnit_t, psu: *mut nvmlPSUInfo_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetTemperature(
+    unit: nvmlUnit_t,
+    type_: ::std::os::raw::c_uint,
+    temp: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetFanSpeedInfo(
+    unit: nvmlUnit_t,
+    fanSpeeds: *mut nvmlUnitFanSpeeds_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitGetDevices(
+    unit: nvmlUnit_t,
+    deviceCount: *mut ::std::os::raw::c_uint,
+    devices: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetHicVersion(
+    hwbcCount: *mut ::std::os::raw::c_uint,
+    hwbcEntries: *mut nvmlHwbcEntry_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCount_v2(deviceCount: *mut ::std::os::raw::c_uint) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAttributes(
+    device: nvmlDevice_t,
+    attributes: *mut nvmlDeviceAttributes_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetHandleByIndex_v2(
+    index: ::std::os::raw::c_uint,
+    device: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetHandleBySerial(
+    serial: *const ::std::os::raw::c_char,
+    device: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetHandleByUUID(
+    uuid: *const ::std::os::raw::c_char,
+    device: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetHandleByPciBusId_v2(
+    pciBusId: *const ::std::os::raw::c_char,
+    device: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetName(
+    device: nvmlDevice_t,
+    name: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetBrand(
+    device: nvmlDevice_t,
+    type_: *mut nvmlBrandType_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetIndex(
+    device: nvmlDevice_t,
+    index: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSerial(
+    device: nvmlDevice_t,
+    serial: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+pub type nvmlAffinityScope_t = ::std::os::raw::c_uint;
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMemoryAffinity(
+    device: nvmlDevice_t,
+    nodeSetSize: ::std::os::raw::c_uint,
+    nodeSet: *mut ::std::os::raw::c_ulong,
+    scope: nvmlAffinityScope_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCpuAffinityWithinScope(
+    device: nvmlDevice_t,
+    cpuSetSize: ::std::os::raw::c_uint,
+    cpuSet: *mut ::std::os::raw::c_ulong,
+    scope: nvmlAffinityScope_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCpuAffinity(
+    device: nvmlDevice_t,
+    cpuSetSize: ::std::os::raw::c_uint,
+    cpuSet: *mut ::std::os::raw::c_ulong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetCpuAffinity(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceClearCpuAffinity(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTopologyCommonAncestor(
+    device1: nvmlDevice_t,
+    device2: nvmlDevice_t,
+    pathInfo: *mut nvmlGpuTopologyLevel_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTopologyNearestGpus(
+    device: nvmlDevice_t,
+    level: nvmlGpuTopologyLevel_t,
+    count: *mut ::std::os::raw::c_uint,
+    deviceArray: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSystemGetTopologyGpuSet(
+    cpuNumber: ::std::os::raw::c_uint,
+    count: *mut ::std::os::raw::c_uint,
+    deviceArray: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetP2PStatus(
+    device1: nvmlDevice_t,
+    device2: nvmlDevice_t,
+    p2pIndex: nvmlGpuP2PCapsIndex_t,
+    p2pStatus: *mut nvmlGpuP2PStatus_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetUUID(
+    device: nvmlDevice_t,
+    uuid: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetMdevUUID(
+    vgpuInstance: nvmlVgpuInstance_t,
+    mdevUuid: *mut ::std::os::raw::c_char,
+    size: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMinorNumber(
+    device: nvmlDevice_t,
+    minorNumber: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetBoardPartNumber(
+    device: nvmlDevice_t,
+    partNumber: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetInforomVersion(
+    device: nvmlDevice_t,
+    object: nvmlInforomObject_t,
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetInforomImageVersion(
+    device: nvmlDevice_t,
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetInforomConfigurationChecksum(
+    device: nvmlDevice_t,
+    checksum: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceValidateInforom(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDisplayMode(
+    device: nvmlDevice_t,
+    display: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDisplayActive(
+    device: nvmlDevice_t,
+    isActive: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPersistenceMode(
+    device: nvmlDevice_t,
+    mode: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPciInfo_v3(
+    device: nvmlDevice_t,
+    pci: *mut nvmlPciInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMaxPcieLinkGeneration(
+    device: nvmlDevice_t,
+    maxLinkGen: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMaxPcieLinkWidth(
+    device: nvmlDevice_t,
+    maxLinkWidth: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCurrPcieLinkGeneration(
+    device: nvmlDevice_t,
+    currLinkGen: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCurrPcieLinkWidth(
+    device: nvmlDevice_t,
+    currLinkWidth: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPcieThroughput(
+    device: nvmlDevice_t,
+    counter: nvmlPcieUtilCounter_t,
+    value: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPcieReplayCounter(
+    device: nvmlDevice_t,
+    value: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetClockInfo(
+    device: nvmlDevice_t,
+    type_: nvmlClockType_t,
+    clock: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMaxClockInfo(
+    device: nvmlDevice_t,
+    type_: nvmlClockType_t,
+    clock: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetApplicationsClock(
+    device: nvmlDevice_t,
+    clockType: nvmlClockType_t,
+    clockMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDefaultApplicationsClock(
+    device: nvmlDevice_t,
+    clockType: nvmlClockType_t,
+    clockMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceResetApplicationsClocks(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetClock(
+    device: nvmlDevice_t,
+    clockType: nvmlClockType_t,
+    clockId: nvmlClockId_t,
+    clockMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMaxCustomerBoostClock(
+    device: nvmlDevice_t,
+    clockType: nvmlClockType_t,
+    clockMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSupportedMemoryClocks(
+    device: nvmlDevice_t,
+    count: *mut ::std::os::raw::c_uint,
+    clocksMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSupportedGraphicsClocks(
+    device: nvmlDevice_t,
+    memoryClockMHz: ::std::os::raw::c_uint,
+    count: *mut ::std::os::raw::c_uint,
+    clocksMHz: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAutoBoostedClocksEnabled(
+    device: nvmlDevice_t,
+    isEnabled: *mut nvmlEnableState_t,
+    defaultIsEnabled: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetAutoBoostedClocksEnabled(
+    device: nvmlDevice_t,
+    enabled: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetDefaultAutoBoostedClocksEnabled(
+    device: nvmlDevice_t,
+    enabled: nvmlEnableState_t,
+    flags: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetFanSpeed(
+    device: nvmlDevice_t,
+    speed: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetFanSpeed_v2(
+    device: nvmlDevice_t,
+    fan: ::std::os::raw::c_uint,
+    speed: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTemperature(
+    device: nvmlDevice_t,
+    sensorType: nvmlTemperatureSensors_t,
+    temp: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTemperatureThreshold(
+    device: nvmlDevice_t,
+    thresholdType: nvmlTemperatureThresholds_t,
+    temp: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPerformanceState(
+    device: nvmlDevice_t,
+    pState: *mut nvmlPstates_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCurrentClocksThrottleReasons(
+    device: nvmlDevice_t,
+    clocksThrottleReasons: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSupportedClocksThrottleReasons(
+    device: nvmlDevice_t,
+    supportedClocksThrottleReasons: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerState(
+    device: nvmlDevice_t,
+    pState: *mut nvmlPstates_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerManagementMode(
+    device: nvmlDevice_t,
+    mode: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerManagementLimit(
+    device: nvmlDevice_t,
+    limit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerManagementLimitConstraints(
+    device: nvmlDevice_t,
+    minLimit: *mut ::std::os::raw::c_uint,
+    maxLimit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerManagementDefaultLimit(
+    device: nvmlDevice_t,
+    defaultLimit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPowerUsage(
+    device: nvmlDevice_t,
+    power: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTotalEnergyConsumption(
+    device: nvmlDevice_t,
+    energy: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEnforcedPowerLimit(
+    device: nvmlDevice_t,
+    limit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuOperationMode(
+    device: nvmlDevice_t,
+    current: *mut nvmlGpuOperationMode_t,
+    pending: *mut nvmlGpuOperationMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMemoryInfo(
+    device: nvmlDevice_t,
+    memory: *mut nvmlMemory_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetComputeMode(
+    device: nvmlDevice_t,
+    mode: *mut nvmlComputeMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCudaComputeCapability(
+    device: nvmlDevice_t,
+    major: *mut ::std::os::raw::c_int,
+    minor: *mut ::std::os::raw::c_int,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEccMode(
+    device: nvmlDevice_t,
+    current: *mut nvmlEnableState_t,
+    pending: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetBoardId(
+    device: nvmlDevice_t,
+    boardId: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMultiGpuBoard(
+    device: nvmlDevice_t,
+    multiGpuBool: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetTotalEccErrors(
+    device: nvmlDevice_t,
+    errorType: nvmlMemoryErrorType_t,
+    counterType: nvmlEccCounterType_t,
+    eccCounts: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDetailedEccErrors(
+    device: nvmlDevice_t,
+    errorType: nvmlMemoryErrorType_t,
+    counterType: nvmlEccCounterType_t,
+    eccCounts: *mut nvmlEccErrorCounts_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMemoryErrorCounter(
+    device: nvmlDevice_t,
+    errorType: nvmlMemoryErrorType_t,
+    counterType: nvmlEccCounterType_t,
+    locationType: nvmlMemoryLocation_t,
+    count: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetUtilizationRates(
+    device: nvmlDevice_t,
+    utilization: *mut nvmlUtilization_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEncoderUtilization(
+    device: nvmlDevice_t,
+    utilization: *mut ::std::os::raw::c_uint,
+    samplingPeriodUs: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEncoderCapacity(
+    device: nvmlDevice_t,
+    encoderQueryType: nvmlEncoderType_t,
+    encoderCapacity: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEncoderStats(
+    device: nvmlDevice_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    averageFps: *mut ::std::os::raw::c_uint,
+    averageLatency: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetEncoderSessions(
+    device: nvmlDevice_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    sessionInfos: *mut nvmlEncoderSessionInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDecoderUtilization(
+    device: nvmlDevice_t,
+    utilization: *mut ::std::os::raw::c_uint,
+    samplingPeriodUs: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetFBCStats(
+    device: nvmlDevice_t,
+    fbcStats: *mut nvmlFBCStats_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetFBCSessions(
+    device: nvmlDevice_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    sessionInfo: *mut nvmlFBCSessionInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDriverModel(
+    device: nvmlDevice_t,
+    current: *mut nvmlDriverModel_t,
+    pending: *mut nvmlDriverModel_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetVbiosVersion(
+    device: nvmlDevice_t,
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetBridgeChipInfo(
+    device: nvmlDevice_t,
+    bridgeHierarchy: *mut nvmlBridgeChipHierarchy_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetComputeRunningProcesses(
+    device: nvmlDevice_t,
+    infoCount: *mut ::std::os::raw::c_uint,
+    infos: *mut nvmlProcessInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGraphicsRunningProcesses(
+    device: nvmlDevice_t,
+    infoCount: *mut ::std::os::raw::c_uint,
+    infos: *mut nvmlProcessInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceOnSameBoard(
+    device1: nvmlDevice_t,
+    device2: nvmlDevice_t,
+    onSameBoard: *mut ::std::os::raw::c_int,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAPIRestriction(
+    device: nvmlDevice_t,
+    apiType: nvmlRestrictedAPI_t,
+    isRestricted: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSamples(
+    device: nvmlDevice_t,
+    type_: nvmlSamplingType_t,
+    lastSeenTimeStamp: ::std::os::raw::c_ulonglong,
+    sampleValType: *mut nvmlValueType_t,
+    sampleCount: *mut ::std::os::raw::c_uint,
+    samples: *mut nvmlSample_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetBAR1MemoryInfo(
+    device: nvmlDevice_t,
+    bar1Memory: *mut nvmlBAR1Memory_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetViolationStatus(
+    device: nvmlDevice_t,
+    perfPolicyType: nvmlPerfPolicyType_t,
+    violTime: *mut nvmlViolationTime_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAccountingMode(
+    device: nvmlDevice_t,
+    mode: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAccountingStats(
+    device: nvmlDevice_t,
+    pid: ::std::os::raw::c_uint,
+    stats: *mut nvmlAccountingStats_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAccountingPids(
+    device: nvmlDevice_t,
+    count: *mut ::std::os::raw::c_uint,
+    pids: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetAccountingBufferSize(
+    device: nvmlDevice_t,
+    bufferSize: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetRetiredPages(
+    device: nvmlDevice_t,
+    cause: nvmlPageRetirementCause_t,
+    pageCount: *mut ::std::os::raw::c_uint,
+    addresses: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetRetiredPages_v2(
+    device: nvmlDevice_t,
+    cause: nvmlPageRetirementCause_t,
+    pageCount: *mut ::std::os::raw::c_uint,
+    addresses: *mut ::std::os::raw::c_ulonglong,
+    timestamps: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetRetiredPagesPendingStatus(
+    device: nvmlDevice_t,
+    isPending: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetRemappedRows(
+    device: nvmlDevice_t,
+    corrRows: *mut ::std::os::raw::c_uint,
+    uncRows: *mut ::std::os::raw::c_uint,
+    isPending: *mut ::std::os::raw::c_uint,
+    failureOccurred: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetArchitecture(
+    device: nvmlDevice_t,
+    arch: *mut nvmlDeviceArchitecture_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlUnitSetLedState(unit: nvmlUnit_t, color: nvmlLedColor_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetPersistenceMode(
+    device: nvmlDevice_t,
+    mode: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetComputeMode(
+    device: nvmlDevice_t,
+    mode: nvmlComputeMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetEccMode(
+    device: nvmlDevice_t,
+    ecc: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceClearEccErrorCounts(
+    device: nvmlDevice_t,
+    counterType: nvmlEccCounterType_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetDriverModel(
+    device: nvmlDevice_t,
+    driverModel: nvmlDriverModel_t,
+    flags: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetGpuLockedClocks(
+    device: nvmlDevice_t,
+    minGpuClockMHz: ::std::os::raw::c_uint,
+    maxGpuClockMHz: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceResetGpuLockedClocks(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetApplicationsClocks(
+    device: nvmlDevice_t,
+    memClockMHz: ::std::os::raw::c_uint,
+    graphicsClockMHz: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetPowerManagementLimit(
+    device: nvmlDevice_t,
+    limit: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetGpuOperationMode(
+    device: nvmlDevice_t,
+    mode: nvmlGpuOperationMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetAPIRestriction(
+    device: nvmlDevice_t,
+    apiType: nvmlRestrictedAPI_t,
+    isRestricted: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetAccountingMode(
+    device: nvmlDevice_t,
+    mode: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceClearAccountingPids(device: nvmlDevice_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkState(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    isActive: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkVersion(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    version: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkCapability(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    capability: nvmlNvLinkCapability_t,
+    capResult: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkRemotePciInfo_v2(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    pci: *mut nvmlPciInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkErrorCounter(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: nvmlNvLinkErrorCounter_t,
+    counterValue: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceResetNvLinkErrorCounters(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetNvLinkUtilizationControl(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: ::std::os::raw::c_uint,
+    control: *mut nvmlNvLinkUtilizationControl_t,
+    reset: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkUtilizationControl(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: ::std::os::raw::c_uint,
+    control: *mut nvmlNvLinkUtilizationControl_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetNvLinkUtilizationCounter(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: ::std::os::raw::c_uint,
+    rxcounter: *mut ::std::os::raw::c_ulonglong,
+    txcounter: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceFreezeNvLinkUtilizationCounter(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: ::std::os::raw::c_uint,
+    freeze: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceResetNvLinkUtilizationCounter(
+    device: nvmlDevice_t,
+    link: ::std::os::raw::c_uint,
+    counter: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlEventSetCreate(set: *mut nvmlEventSet_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceRegisterEvents(
+    device: nvmlDevice_t,
+    eventTypes: ::std::os::raw::c_ulonglong,
+    set: nvmlEventSet_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSupportedEventTypes(
+    device: nvmlDevice_t,
+    eventTypes: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlEventSetWait_v2(
+    set: nvmlEventSet_t,
+    data: *mut nvmlEventData_t,
+    timeoutms: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlEventSetFree(set: nvmlEventSet_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceModifyDrainState(
+    pciInfo: *mut nvmlPciInfo_t,
+    newState: nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceQueryDrainState(
+    pciInfo: *mut nvmlPciInfo_t,
+    currentState: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceRemoveGpu_v2(
+    pciInfo: *mut nvmlPciInfo_t,
+    gpuState: nvmlDetachGpuState_t,
+    linkState: nvmlPcieLinkState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceDiscoverGpus(pciInfo: *mut nvmlPciInfo_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetFieldValues(
+    device: nvmlDevice_t,
+    valuesCount: ::std::os::raw::c_int,
+    values: *mut nvmlFieldValue_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetVirtualizationMode(
+    device: nvmlDevice_t,
+    pVirtualMode: *mut nvmlGpuVirtualizationMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetHostVgpuMode(
+    device: nvmlDevice_t,
+    pHostVgpuMode: *mut nvmlHostVgpuMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetVirtualizationMode(
+    device: nvmlDevice_t,
+    virtualMode: nvmlGpuVirtualizationMode_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGridLicensableFeatures_v3(
+    device: nvmlDevice_t,
+    pGridLicensableFeatures: *mut nvmlGridLicensableFeatures_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetProcessUtilization(
+    device: nvmlDevice_t,
+    utilization: *mut nvmlProcessUtilizationSample_t,
+    processSamplesCount: *mut ::std::os::raw::c_uint,
+    lastSeenTimeStamp: ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetSupportedVgpus(
+    device: nvmlDevice_t,
+    vgpuCount: *mut ::std::os::raw::c_uint,
+    vgpuTypeIds: *mut nvmlVgpuTypeId_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetCreatableVgpus(
+    device: nvmlDevice_t,
+    vgpuCount: *mut ::std::os::raw::c_uint,
+    vgpuTypeIds: *mut nvmlVgpuTypeId_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetClass(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    vgpuTypeClass: *mut ::std::os::raw::c_char,
+    size: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetName(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    vgpuTypeName: *mut ::std::os::raw::c_char,
+    size: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetDeviceID(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    deviceID: *mut ::std::os::raw::c_ulonglong,
+    subsystemID: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetFramebufferSize(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    fbSize: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetNumDisplayHeads(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    numDisplayHeads: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetResolution(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    displayIndex: ::std::os::raw::c_uint,
+    xdim: *mut ::std::os::raw::c_uint,
+    ydim: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetLicense(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    vgpuTypeLicenseString: *mut ::std::os::raw::c_char,
+    size: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetFrameRateLimit(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    frameRateLimit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetMaxInstances(
+    device: nvmlDevice_t,
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    vgpuInstanceCount: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuTypeGetMaxInstancesPerVm(
+    vgpuTypeId: nvmlVgpuTypeId_t,
+    vgpuInstanceCountPerVm: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetActiveVgpus(
+    device: nvmlDevice_t,
+    vgpuCount: *mut ::std::os::raw::c_uint,
+    vgpuInstances: *mut nvmlVgpuInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetVmID(
+    vgpuInstance: nvmlVgpuInstance_t,
+    vmId: *mut ::std::os::raw::c_char,
+    size: ::std::os::raw::c_uint,
+    vmIdType: *mut nvmlVgpuVmIdType_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetUUID(
+    vgpuInstance: nvmlVgpuInstance_t,
+    uuid: *mut ::std::os::raw::c_char,
+    size: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetVmDriverVersion(
+    vgpuInstance: nvmlVgpuInstance_t,
+    version: *mut ::std::os::raw::c_char,
+    length: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetFbUsage(
+    vgpuInstance: nvmlVgpuInstance_t,
+    fbUsage: *mut ::std::os::raw::c_ulonglong,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetLicenseStatus(
+    vgpuInstance: nvmlVgpuInstance_t,
+    licensed: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetType(
+    vgpuInstance: nvmlVgpuInstance_t,
+    vgpuTypeId: *mut nvmlVgpuTypeId_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetFrameRateLimit(
+    vgpuInstance: nvmlVgpuInstance_t,
+    frameRateLimit: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetEccMode(
+    vgpuInstance: nvmlVgpuInstance_t,
+    eccMode: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetEncoderCapacity(
+    vgpuInstance: nvmlVgpuInstance_t,
+    encoderCapacity: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceSetEncoderCapacity(
+    vgpuInstance: nvmlVgpuInstance_t,
+    encoderCapacity: ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetEncoderStats(
+    vgpuInstance: nvmlVgpuInstance_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    averageFps: *mut ::std::os::raw::c_uint,
+    averageLatency: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetEncoderSessions(
+    vgpuInstance: nvmlVgpuInstance_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    sessionInfo: *mut nvmlEncoderSessionInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetFBCStats(
+    vgpuInstance: nvmlVgpuInstance_t,
+    fbcStats: *mut nvmlFBCStats_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetFBCSessions(
+    vgpuInstance: nvmlVgpuInstance_t,
+    sessionCount: *mut ::std::os::raw::c_uint,
+    sessionInfo: *mut nvmlFBCSessionInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuVersion_st {
+    pub minVersion: ::std::os::raw::c_uint,
+    pub maxVersion: ::std::os::raw::c_uint,
+}
+pub type nvmlVgpuVersion_t = nvmlVgpuVersion_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuMetadata_st {
+    pub version: ::std::os::raw::c_uint,
+    pub revision: ::std::os::raw::c_uint,
+    pub guestInfoState: nvmlVgpuGuestInfoState_t,
+    pub guestDriverVersion: [::std::os::raw::c_char; 80usize],
+    pub hostDriverVersion: [::std::os::raw::c_char; 80usize],
+    pub reserved: [::std::os::raw::c_uint; 6usize],
+    pub vgpuVirtualizationCaps: ::std::os::raw::c_uint,
+    pub guestVgpuVersion: ::std::os::raw::c_uint,
+    pub opaqueDataSize: ::std::os::raw::c_uint,
+    pub opaqueData: [::std::os::raw::c_char; 4usize],
+}
+pub type nvmlVgpuMetadata_t = nvmlVgpuMetadata_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuPgpuMetadata_st {
+    pub version: ::std::os::raw::c_uint,
+    pub revision: ::std::os::raw::c_uint,
+    pub hostDriverVersion: [::std::os::raw::c_char; 80usize],
+    pub pgpuVirtualizationCaps: ::std::os::raw::c_uint,
+    pub reserved: [::std::os::raw::c_uint; 5usize],
+    pub hostSupportedVgpuRange: nvmlVgpuVersion_t,
+    pub opaqueDataSize: ::std::os::raw::c_uint,
+    pub opaqueData: [::std::os::raw::c_char; 4usize],
+}
+pub type nvmlVgpuPgpuMetadata_t = nvmlVgpuPgpuMetadata_st;
+impl nvmlVgpuVmCompatibility_enum {
+    pub const NVML_VGPU_VM_COMPATIBILITY_NONE: nvmlVgpuVmCompatibility_enum =
+        nvmlVgpuVmCompatibility_enum(0);
+}
+impl nvmlVgpuVmCompatibility_enum {
+    pub const NVML_VGPU_VM_COMPATIBILITY_COLD: nvmlVgpuVmCompatibility_enum =
+        nvmlVgpuVmCompatibility_enum(1);
+}
+impl nvmlVgpuVmCompatibility_enum {
+    pub const NVML_VGPU_VM_COMPATIBILITY_HIBERNATE: nvmlVgpuVmCompatibility_enum =
+        nvmlVgpuVmCompatibility_enum(2);
+}
+impl nvmlVgpuVmCompatibility_enum {
+    pub const NVML_VGPU_VM_COMPATIBILITY_SLEEP: nvmlVgpuVmCompatibility_enum =
+        nvmlVgpuVmCompatibility_enum(4);
+}
+impl nvmlVgpuVmCompatibility_enum {
+    pub const NVML_VGPU_VM_COMPATIBILITY_LIVE: nvmlVgpuVmCompatibility_enum =
+        nvmlVgpuVmCompatibility_enum(8);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlVgpuVmCompatibility_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlVgpuVmCompatibility_enum as nvmlVgpuVmCompatibility_t;
+impl nvmlVgpuPgpuCompatibilityLimitCode_enum {
+    pub const NVML_VGPU_COMPATIBILITY_LIMIT_NONE: nvmlVgpuPgpuCompatibilityLimitCode_enum =
+        nvmlVgpuPgpuCompatibilityLimitCode_enum(0);
+}
+impl nvmlVgpuPgpuCompatibilityLimitCode_enum {
+    pub const NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER: nvmlVgpuPgpuCompatibilityLimitCode_enum =
+        nvmlVgpuPgpuCompatibilityLimitCode_enum(1);
+}
+impl nvmlVgpuPgpuCompatibilityLimitCode_enum {
+    pub const NVML_VGPU_COMPATIBILITY_LIMIT_GUEST_DRIVER: nvmlVgpuPgpuCompatibilityLimitCode_enum =
+        nvmlVgpuPgpuCompatibilityLimitCode_enum(2);
+}
+impl nvmlVgpuPgpuCompatibilityLimitCode_enum {
+    pub const NVML_VGPU_COMPATIBILITY_LIMIT_GPU: nvmlVgpuPgpuCompatibilityLimitCode_enum =
+        nvmlVgpuPgpuCompatibilityLimitCode_enum(4);
+}
+impl nvmlVgpuPgpuCompatibilityLimitCode_enum {
+    pub const NVML_VGPU_COMPATIBILITY_LIMIT_OTHER: nvmlVgpuPgpuCompatibilityLimitCode_enum =
+        nvmlVgpuPgpuCompatibilityLimitCode_enum(2147483648);
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct nvmlVgpuPgpuCompatibilityLimitCode_enum(pub ::std::os::raw::c_uint);
+pub use self::nvmlVgpuPgpuCompatibilityLimitCode_enum as nvmlVgpuPgpuCompatibilityLimitCode_t;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlVgpuPgpuCompatibility_st {
+    pub vgpuVmCompatibility: nvmlVgpuVmCompatibility_t,
+    pub compatibilityLimitCode: nvmlVgpuPgpuCompatibilityLimitCode_t,
+}
+pub type nvmlVgpuPgpuCompatibility_t = nvmlVgpuPgpuCompatibility_st;
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetMetadata(
+    vgpuInstance: nvmlVgpuInstance_t,
+    vgpuMetadata: *mut nvmlVgpuMetadata_t,
+    bufferSize: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetVgpuMetadata(
+    device: nvmlDevice_t,
+    pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t,
+    bufferSize: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGetVgpuCompatibility(
+    vgpuMetadata: *mut nvmlVgpuMetadata_t,
+    pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t,
+    compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetPgpuMetadataString(
+    device: nvmlDevice_t,
+    pgpuMetadata: *mut ::std::os::raw::c_char,
+    bufferSize: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGetVgpuVersion(
+    supported: *mut nvmlVgpuVersion_t,
+    current: *mut nvmlVgpuVersion_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlSetVgpuVersion(vgpuVersion: *mut nvmlVgpuVersion_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetVgpuUtilization(
+    device: nvmlDevice_t,
+    lastSeenTimeStamp: ::std::os::raw::c_ulonglong,
+    sampleValType: *mut nvmlValueType_t,
+    vgpuInstanceSamplesCount: *mut ::std::os::raw::c_uint,
+    utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetVgpuProcessUtilization(
+    device: nvmlDevice_t,
+    lastSeenTimeStamp: ::std::os::raw::c_ulonglong,
+    vgpuProcessSamplesCount: *mut ::std::os::raw::c_uint,
+    utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetAccountingMode(
+    vgpuInstance: nvmlVgpuInstance_t,
+    mode: *mut nvmlEnableState_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetAccountingPids(
+    vgpuInstance: nvmlVgpuInstance_t,
+    count: *mut ::std::os::raw::c_uint,
+    pids: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceGetAccountingStats(
+    vgpuInstance: nvmlVgpuInstance_t,
+    pid: ::std::os::raw::c_uint,
+    stats: *mut nvmlAccountingStats_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlVgpuInstanceClearAccountingPids(
+    vgpuInstance: nvmlVgpuInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlBlacklistDeviceInfo_st {
+    pub pciInfo: nvmlPciInfo_t,
+    pub uuid: [::std::os::raw::c_char; 80usize],
+}
+pub type nvmlBlacklistDeviceInfo_t = nvmlBlacklistDeviceInfo_st;
+
+#[no_mangle]
+pub extern "C" fn nvmlGetBlacklistDeviceCount(
+    deviceCount: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGetBlacklistDeviceInfoByIndex(
+    index: ::std::os::raw::c_uint,
+    info: *mut nvmlBlacklistDeviceInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGpuInstancePlacement_st {
+    pub start: ::std::os::raw::c_uint,
+    pub size: ::std::os::raw::c_uint,
+}
+pub type nvmlGpuInstancePlacement_t = nvmlGpuInstancePlacement_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGpuInstanceProfileInfo_st {
+    pub id: ::std::os::raw::c_uint,
+    pub isP2pSupported: ::std::os::raw::c_uint,
+    pub sliceCount: ::std::os::raw::c_uint,
+    pub instanceCount: ::std::os::raw::c_uint,
+    pub multiprocessorCount: ::std::os::raw::c_uint,
+    pub copyEngineCount: ::std::os::raw::c_uint,
+    pub decoderCount: ::std::os::raw::c_uint,
+    pub encoderCount: ::std::os::raw::c_uint,
+    pub jpegCount: ::std::os::raw::c_uint,
+    pub ofaCount: ::std::os::raw::c_uint,
+    pub memorySizeMB: ::std::os::raw::c_ulonglong,
+}
+pub type nvmlGpuInstanceProfileInfo_t = nvmlGpuInstanceProfileInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGpuInstanceInfo_st {
+    pub device: nvmlDevice_t,
+    pub id: ::std::os::raw::c_uint,
+    pub profileId: ::std::os::raw::c_uint,
+    pub placement: nvmlGpuInstancePlacement_t,
+}
+pub type nvmlGpuInstanceInfo_t = nvmlGpuInstanceInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlGpuInstance_st {
+    _unused: [u8; 0],
+}
+pub type nvmlGpuInstance_t = *mut nvmlGpuInstance_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlComputeInstanceProfileInfo_st {
+    pub id: ::std::os::raw::c_uint,
+    pub sliceCount: ::std::os::raw::c_uint,
+    pub instanceCount: ::std::os::raw::c_uint,
+    pub multiprocessorCount: ::std::os::raw::c_uint,
+    pub sharedCopyEngineCount: ::std::os::raw::c_uint,
+    pub sharedDecoderCount: ::std::os::raw::c_uint,
+    pub sharedEncoderCount: ::std::os::raw::c_uint,
+    pub sharedJpegCount: ::std::os::raw::c_uint,
+    pub sharedOfaCount: ::std::os::raw::c_uint,
+}
+pub type nvmlComputeInstanceProfileInfo_t = nvmlComputeInstanceProfileInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlComputeInstanceInfo_st {
+    pub device: nvmlDevice_t,
+    pub gpuInstance: nvmlGpuInstance_t,
+    pub id: ::std::os::raw::c_uint,
+    pub profileId: ::std::os::raw::c_uint,
+}
+pub type nvmlComputeInstanceInfo_t = nvmlComputeInstanceInfo_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nvmlComputeInstance_st {
+    _unused: [u8; 0],
+}
+pub type nvmlComputeInstance_t = *mut nvmlComputeInstance_st;
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceSetMigMode(
+    device: nvmlDevice_t,
+    mode: ::std::os::raw::c_uint,
+    activationStatus: *mut nvmlReturn_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMigMode(
+    device: nvmlDevice_t,
+    currentMode: *mut ::std::os::raw::c_uint,
+    pendingMode: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstanceProfileInfo(
+    device: nvmlDevice_t,
+    profile: ::std::os::raw::c_uint,
+    info: *mut nvmlGpuInstanceProfileInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstancePossiblePlacements(
+    device: nvmlDevice_t,
+    profileId: ::std::os::raw::c_uint,
+    placements: *mut nvmlGpuInstancePlacement_t,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstanceRemainingCapacity(
+    device: nvmlDevice_t,
+    profileId: ::std::os::raw::c_uint,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceCreateGpuInstance(
+    device: nvmlDevice_t,
+    profileId: ::std::os::raw::c_uint,
+    gpuInstance: *mut nvmlGpuInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceDestroy(gpuInstance: nvmlGpuInstance_t) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstances(
+    device: nvmlDevice_t,
+    profileId: ::std::os::raw::c_uint,
+    gpuInstances: *mut nvmlGpuInstance_t,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstanceById(
+    device: nvmlDevice_t,
+    id: ::std::os::raw::c_uint,
+    gpuInstance: *mut nvmlGpuInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceGetInfo(
+    gpuInstance: nvmlGpuInstance_t,
+    info: *mut nvmlGpuInstanceInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceGetComputeInstanceProfileInfo(
+    gpuInstance: nvmlGpuInstance_t,
+    profile: ::std::os::raw::c_uint,
+    engProfile: ::std::os::raw::c_uint,
+    info: *mut nvmlComputeInstanceProfileInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceGetComputeInstanceRemainingCapacity(
+    gpuInstance: nvmlGpuInstance_t,
+    profileId: ::std::os::raw::c_uint,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceCreateComputeInstance(
+    gpuInstance: nvmlGpuInstance_t,
+    profileId: ::std::os::raw::c_uint,
+    computeInstance: *mut nvmlComputeInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlComputeInstanceDestroy(
+    computeInstance: nvmlComputeInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceGetComputeInstances(
+    gpuInstance: nvmlGpuInstance_t,
+    profileId: ::std::os::raw::c_uint,
+    computeInstances: *mut nvmlComputeInstance_t,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlGpuInstanceGetComputeInstanceById(
+    gpuInstance: nvmlGpuInstance_t,
+    id: ::std::os::raw::c_uint,
+    computeInstance: *mut nvmlComputeInstance_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlComputeInstanceGetInfo(
+    computeInstance: nvmlComputeInstance_t,
+    info: *mut nvmlComputeInstanceInfo_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceIsMigDeviceHandle(
+    device: nvmlDevice_t,
+    isMigDevice: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetGpuInstanceId(
+    device: nvmlDevice_t,
+    id: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetComputeInstanceId(
+    device: nvmlDevice_t,
+    id: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMaxMigDeviceCount(
+    device: nvmlDevice_t,
+    count: *mut ::std::os::raw::c_uint,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetMigDeviceHandleByIndex(
+    device: nvmlDevice_t,
+    index: ::std::os::raw::c_uint,
+    migDevice: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}
+
+#[no_mangle]
+pub extern "C" fn nvmlDeviceGetDeviceHandleFromMigDeviceHandle(
+    migDevice: nvmlDevice_t,
+    device: *mut nvmlDevice_t,
+) -> nvmlReturn_t {
+    crate::r#impl::unimplemented()
+}