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();
}
}