cpu_stress/
parallel.rs

1use stress_core::{Intensity, StopSignal};
2
3use crate::branch_chaos;
4use crate::hash_loop;
5use crate::matrix;
6
7#[derive(Debug, Clone, Copy)]
8pub enum CpuWorkload {
9    Hashing,
10    Matrix,
11    BranchChaos,
12    Mixed,
13}
14
15/// One round-robin dispatch across CPU algorithms.
16pub fn dispatch_round(intensity: Intensity, stop: &StopSignal) {
17    static ROUND: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
18    let round = ROUND.fetch_add(1, std::sync::atomic::Ordering::Relaxed) % 4;
19
20    let base_iters = intensity.scale_usize(50_000);
21    let matrix_size = intensity.scale_usize(64).clamp(32, 256);
22
23    match round {
24        0 => {
25            rayon::scope(|s| {
26                for tid in 0..rayon::current_num_threads() {
27                    let iters = base_iters + tid * 10_000;
28                    s.spawn(move |_| {
29                        let _ = hash_loop::hash_iterations(iters);
30                    });
31                }
32            });
33        }
34        1 => {
35            let _ = matrix::matrix_multiply(matrix_size);
36        }
37        2 => {
38            rayon::scope(|s| {
39                for tid in 0..rayon::current_num_threads() {
40                    s.spawn(move |_| {
41                        let _ = branch_chaos::chaotic_branches(base_iters, tid as u64 + 1);
42                    });
43                }
44            });
45        }
46        _ => {
47            if stop.should_stop() {
48                return;
49            }
50            let _ = hash_loop::hash_iterations(base_iters / 2);
51            let _ = matrix::matrix_multiply(matrix_size / 2);
52            let _ = branch_chaos::chaotic_branches(base_iters / 2, 42);
53        }
54    }
55}
56
57pub fn run_workload(kind: CpuWorkload, intensity: Intensity, stop: &StopSignal) {
58    while !stop.should_stop() {
59        dispatch_round_for(kind, intensity);
60    }
61}
62
63fn dispatch_round_for(kind: CpuWorkload, intensity: Intensity) {
64    let base_iters = intensity.scale_usize(80_000);
65    let matrix_size = intensity.scale_usize(96).clamp(32, 320);
66
67    match kind {
68        CpuWorkload::Hashing => {
69            let _ = hash_loop::hash_iterations(base_iters);
70        }
71        CpuWorkload::Matrix => {
72            let _ = matrix::matrix_multiply(matrix_size);
73        }
74        CpuWorkload::BranchChaos => {
75            let _ = branch_chaos::chaotic_branches(base_iters, 7);
76        }
77        CpuWorkload::Mixed => dispatch_round(intensity, &StopSignal::new()),
78    }
79}
cpu_stress/parallel.rs

cpu_stress/
parallel.rs
