RedBear-OS/local/recipes/system/redbear-power/source/src/bench.rs

//! Lightweight CPU stress benchmark for thermal response testing.
//!
//! Spawns one thread per core that runs a prime-sieve-style loop until
//! the user presses 'B' to stop, or the duration expires. The benchmark
//! is intentionally simple (no FFT, no AES-NI, no AVX) so it works on
//! the lowest-common-denominator hardware and exercises enough load to
//! observe thermal headroom behavior.
//!
//! Pattern matches cpu-x `core/benchmarks.cpp:primes_bench` but in Rust.
//! All work is done on the spawned threads; the main thread just
//! collects the running total via `AtomicU64`.

use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};

pub struct Bench {
    pub running: bool,
    pub started_at: Option<Instant>,
    pub duration: Duration,
    pub primes_found: Arc<AtomicU64>,
    pub cancel: Arc<AtomicBool>,
    pub threads: Vec<JoinHandle<()>>,
    pub last_score: u64,
    pub last_duration_s: u32,
}

impl Default for Bench {
    fn default() -> Self {
        Self {
            running: false,
            started_at: None,
            duration: Duration::from_secs(30),
            primes_found: Arc::new(AtomicU64::new(0)),
            cancel: Arc::new(AtomicBool::new(false)),
            threads: Vec::new(),
            last_score: 0,
            last_duration_s: 0,
        }
    }
}

impl Bench {
    pub fn start(&mut self, num_cores: usize, duration_s: u32) {
        if self.running {
            return;
        }
        self.duration = Duration::from_secs(duration_s as u64);
        self.primes_found.store(0, Ordering::Relaxed);
        self.cancel.store(false, Ordering::Relaxed);
        self.started_at = Some(Instant::now());
        self.running = true;

        let primes = Arc::clone(&self.primes_found);
        let cancel = Arc::clone(&self.cancel);
        let duration = self.duration;
        let cores = num_cores.max(1);
        for _ in 0..cores {
            let primes = Arc::clone(&primes);
            let cancel = Arc::clone(&cancel);
            self.threads.push(thread::spawn(move || {
                let start = Instant::now();
                let mut n: u64 = 1;
                while !cancel.load(Ordering::Relaxed) && start.elapsed() < duration {
                    n += 1;
                    let mut is_prime = n >= 2;
                    let mut i: u64 = 2;
                    while i * i <= n && is_prime {
                        if n % i == 0 {
                            is_prime = false;
                        }
                        i += 1;
                    }
                    if is_prime {
                        primes.fetch_add(1, Ordering::Relaxed);
                    }
                }
            }));
        }
    }

    pub fn stop(&mut self) {
        if !self.running {
            return;
        }
        self.cancel.store(true, Ordering::Relaxed);
        let elapsed = self.started_at.map(|s| s.elapsed()).unwrap_or_default();
        self.last_duration_s = elapsed.as_secs() as u32;
        self.last_score = self.primes_found.load(Ordering::Relaxed);
        for h in self.threads.drain(..) {
            let _ = h.join();
        }
        self.running = false;
        self.started_at = None;
    }

    pub fn progress(&self) -> Option<(u32, u64)> {
        if !self.running {
            return None;
        }
        let elapsed = self.started_at?.elapsed().as_secs() as u32;
        Some((elapsed, self.primes_found.load(Ordering::Relaxed)))
    }

    pub fn status_line(&self, num_cores: usize) -> String {
        if let Some((elapsed, primes)) = self.progress() {
            format!(
                "Bench: prime sieve ({}s elapsed, {} primes, {} threads)",
                elapsed,
                primes,
                num_cores.max(1)
            )
        } else if self.last_score > 0 {
            format!(
                "Bench: last run = {} primes in {}s",
                self.last_score, self.last_duration_s
            )
        } else {
            "Bench: idle (press 'b' to start)".to_string()
        }
    }
}