Merge branch 'rust-nvml:main' into main

Author: jorgeantonio21

nvml-wrapper-sys/nvml.h

@@ -350,3 +350,34 @@ impl TryFrom<c_uint> for PcieLinkMaxSpeed {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[repr(u32)]
+pub enum FanControlPolicy {
+    TemperatureContinousSw = NVML_FAN_POLICY_TEMPERATURE_CONTINOUS_SW,
+    Manual = NVML_FAN_POLICY_MANUAL,
+}
+
+/// Returned by [`crate::Device::get_fan_control_policy()`].
+///
+/// Policy used for fan control.
+// TODO: technically this is an "enum wrapper" but the type on the C side isn't
+// an enum
+impl FanControlPolicy {
+    pub fn as_c(&self) -> nvmlFanControlPolicy_t {
+        *self as u32
+    }
+}
+
+impl TryFrom<nvmlFanControlPolicy_t> for FanControlPolicy {
+    type Error = NvmlError;
+
+    fn try_from(value: nvmlFanControlPolicy_t) -> Result<Self, Self::Error> {
+        match value {
+            NVML_FAN_POLICY_TEMPERATURE_CONTINOUS_SW => Ok(Self::TemperatureContinousSw),
+            NVML_FAN_POLICY_MANUAL => Ok(Self::TemperatureContinousSw),
+            _ => Err(NvmlError::UnexpectedVariant(value)),
+        }
+    }
+}

nvml-wrapper-sys/src/bindings.rs

@@ -172,7 +172,6 @@ mod test {
         })
     }
 
-    #[cfg(feature = "test-local")]
     #[test]
     fn wait() {
         use crate::error::NvmlError;

nvml-wrapper/src/device.rs

@@ -290,21 +290,30 @@ impl From<nvmlEccErrorCounts_t> for EccErrorCounts {
 pub struct MemoryInfo {
     /// Unallocated FB memory.
     pub free: u64,
+
+    /// Reserved FB memory.
+    pub reserved: u64,
+
     /// Total installed FB memory.
     pub total: u64,
     /// Allocated FB memory.
     ///
     /// Note that the driver/GPU always sets aside a small amount of memory for
     /// bookkeeping.
     pub used: u64,
+
+    /// Struct version, must be set according to API specification before calling the API.
+    pub version: u32,
 }
 
-impl From<nvmlMemory_t> for MemoryInfo {
-    fn from(struct_: nvmlMemory_t) -> Self {
+impl From<nvmlMemory_v2_t> for MemoryInfo {
+    fn from(struct_: nvmlMemory_v2_t) -> Self {
         Self {
             free: struct_.free,
+            reserved: struct_.reserved,
             total: struct_.total,
             used: struct_.used,
+            version: struct_.version,
         }
     }
 }
@@ -656,6 +665,68 @@ impl TryFrom<nvmlFBCSessionInfo_t> for FbcSessionInfo {
     }
 }
 
+/// Hardware level attributes from a GPU device
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct DeviceAttributes {
+    /// Streaming MultiProcessor Count
+    pub multiprocessor_count: u32,
+    /// Shared Copy Engine Count
+    pub shared_copy_engine_count: u32,
+    /// Shared Decoder Count
+    pub shared_decoder_count: u32,
+    /// Shared Encoder Count
+    pub shared_encoder_count: u32,
+    /// Shared JPEG Count
+    pub shared_jpeg_count: u32,
+    /// Shared OFA Count
+    pub shared_ofa_count: u32,
+    /// GPU instance slice Count
+    pub gpu_instance_slice_count: u32,
+    /// Compute Instance slice count
+    pub compute_instance_slice_count: u32,
+    /// Device memory size in MB
+    pub memory_size_mb: u64,
+}
+
+impl From<nvmlDeviceAttributes_t> for DeviceAttributes {
+    fn from(struct_: nvmlDeviceAttributes_t) -> Self {
+        Self {
+            multiprocessor_count: struct_.multiprocessorCount,
+            shared_copy_engine_count: struct_.sharedCopyEngineCount,
+            shared_decoder_count: struct_.sharedDecoderCount,
+            shared_encoder_count: struct_.sharedEncoderCount,
+            shared_jpeg_count: struct_.sharedJpegCount,
+            shared_ofa_count: struct_.sharedOfaCount,
+            gpu_instance_slice_count: struct_.gpuInstanceSliceCount,
+            compute_instance_slice_count: struct_.computeInstanceSliceCount,
+            memory_size_mb: struct_.memorySizeMB,
+        }
+    }
+}
+
+/// Fan speed info
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct FanSpeedInfo {
+    /// The API version number
+    pub version: u32,
+    /// The fan index
+    pub fan: u32,
+    /// OUT: the fan speed in RPM.
+    pub speed: u32,
+}
+
+impl From<nvmlFanSpeedInfo_t> for FanSpeedInfo {
+    fn from(struct_: nvmlFanSpeedInfo_t) -> Self {
+        Self {
+            version: struct_.version,
+            fan: struct_.fan,
+            speed: struct_.speed,
+        }
+    }
+}
+
 #[cfg(test)]
 #[allow(unused_variables, unused_imports)]
 mod tests {

nvml-wrapper/src/enums/device.rs

@@ -4,6 +4,40 @@ use crate::enum_wrappers::device::OperationMode;
 #[cfg(feature = "serde")]
 use serde_derive::{Deserialize, Serialize};
 
+/// Returned from `Device.confidential_compute_gpu_attestation_report_bytes()`
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ConfidentialComputeGpuAttestationReport {
+    /// The size of the attestation report.
+    pub attestation_report_size: u32,
+    /// The attestation report, of size
+    /// `ffi::bindings::NVML_CC_GPU_ATTESTATION_REPORT_SIZE` == 8192 bytes.
+    pub attestation_report: Vec<u8>,
+    /// Whether the CEC attestation report is present.
+    pub is_cec_attestation_report_present: bool,
+    /// The size of the CEC attestation report.
+    pub cec_attestation_report_size: u32,
+    /// The CEC attestation report, of size
+    /// `ffi::bindings::NVML_CC_GPU_CEC_ATTESTATION_REPORT_SIZE` == 4096 bytes.
+    pub cec_attestation_report: Vec<u8>,
+}
+
+/// Returned from `Device.confidential_compute_gpu_certificate()`
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ConfidentialComputeGpuCertificate {
+    /// The size of the certificate chain.
+    pub cert_chain_size: u32,
+    /// The size of the attestation certificate chain.
+    pub attestation_cert_chain_size: u32,
+    /// The certificate chain, of size
+    /// `ffi::bindings::NVML_GPU_CERT_CHAIN_SIZE` == 4096 bytes.
+    pub cert_chain: Vec<u8>,
+    /// The attestation certificate chain, of size
+    /// `ffi::bindings::NVML_GPU_ATTESTATION_CERT_CHAIN_SIZE` == 5120 bytes.
+    pub attestation_cert_chain: Vec<u8>,
+}
+
 /// Returned from `Device.auto_boosted_clocks_enabled()`
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

nvml-wrapper/src/event.rs

@@ -104,6 +104,7 @@ impl ShouldPrint for BusType {}
 impl ShouldPrint for PowerSource {}
 impl ShouldPrint for DeviceArchitecture {}
 impl ShouldPrint for PcieLinkMaxSpeed {}
+impl ShouldPrint for DeviceAttributes {}
 
 #[cfg(target_os = "windows")]
 impl ShouldPrint for DriverModelState {}
@@ -126,9 +127,9 @@ where
     T: Fn() -> Result<R, NvmlError>,
     R: ShouldPrint,
 {
-    single(|| test());
+    single(&test);
 
-    multi(reps, || test());
+    multi(reps, test);
 }
 
 pub fn test_with_device<T, R>(reps: usize, nvml: &Nvml, test: T)