gpu_telemetry 0.1.0

High-level GPU telemetry background logger
Documentation
use std::{marker::PhantomData, sync::{Arc, atomic::{AtomicBool, Ordering}}, thread::{JoinHandle, spawn}, time::Duration};

use crate::{errors::{Error, ErrorKind}, monitor::telemetry::Telemetry, sys::GpuTelemetry};

pub mod telemetry;

pub struct GpuMonitor<B: GpuTelemetry = crate::DefaultQuery> {
    stop: Arc<AtomicBool>,
    handle: JoinHandle<Result<Telemetry, Error>>,
    _backend: PhantomData<B>,
}

impl<B: GpuTelemetry> GpuMonitor<B> {
    pub fn start(interval: Duration) -> Result<Self, Error> {
        if interval.is_zero() {
            return Err(Error {
                msg: "cannot track telemetry at interval of zero",
                kind: ErrorKind::InvalidInterval,
            })
        }

        let stop = Arc::new(AtomicBool::new(false));
        let stop_thread = Arc::clone(&stop);

        let handle = spawn(move || {
            let backend = B::new(0)?;

            let mut telemetry = Telemetry {
                samples: Vec::new(),
            };

            while !stop_thread.load(Ordering::Relaxed) {
                let sample = backend.query()?;

                telemetry.samples.push(sample);

                backend.wait_at_most(interval)?;
            }

            Ok(telemetry)
        });

        Ok(Self {
            stop,
            handle,
            _backend: PhantomData,
        })
    }

    pub fn stop(self) -> Result<Telemetry, Error> {
        self.stop.store(true, Ordering::Relaxed);
        self.handle.join().map_err(|_| Error {
            msg: "could not join telemetry background process",
            kind: ErrorKind::SyncError,
        })?
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[cfg(any(target_os = "windows", target_os = "linux"))]
    fn gpu_monitor_default() {
        let monitor: GpuMonitor = GpuMonitor::start(Duration::from_millis(50)).unwrap();
        std::thread::sleep(Duration::from_secs(3));
        let _ = monitor.stop().unwrap();
    }

    #[test]
    #[cfg(target_os = "windows")]
    fn gpu_monitor_dx() {
        let monitor = GpuMonitor::<crate::sys::DxGpuQuery>::start(Duration::from_millis(50)).unwrap();
        std::thread::sleep(Duration::from_secs(3));
        let _ = monitor.stop().unwrap();
    }

    #[test]
    #[cfg(any(target_os = "windows", target_os = "linux"))]
    fn gpu_monitor_vulkan() {
        let monitor = GpuMonitor::<crate::sys::VulkanGpuQuery>::start(Duration::from_millis(50)).unwrap();
        std::thread::sleep(Duration::from_secs(3));
        let _ = monitor.stop().unwrap();
    }
}