aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Cargo.toml3
-rw-r--r--level_zero/src/ze.rs12
-rw-r--r--zluda_ml/Cargo.toml12
-rw-r--r--zluda_ml/README3
-rw-r--r--zluda_ml/src/impl.rs138
-rw-r--r--zluda_ml/src/lib.rs3
-rw-r--r--zluda_ml/src/nvml.rs3166
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()
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 16:58:31 +0000