cpu_load 0.1.4

Real-time CPU load monitoring with intelligent core selection / 实时 CPU 负载监控与智能核心选择
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::time::Duration;

use aok::{OK, Void};
use cpu_load::CpuLoad;
use log::info;

#[static_init::constructor(0)]
extern "C" fn _log_init() {
  log_init::init();
}

#[compio::test]
async fn test_iterator() -> Void {
  // 创建 CPU 负载监控器，采样间隔为 100ms
  let cpu_monitor = CpuLoad::init(Duration::from_millis(100));

  // 等待一段时间让后台任务收集数据
  // 需要等待足够长时间让sysinfo库收集到真实的CPU使用率数据
  compio::time::sleep(Duration::from_millis(1000)).await;

  // 获取 CPU 核心数量
  let core_count = cpu_monitor.len();
  info!("检测到 {} 个 CPU 核心", core_count);

  // 测试迭代器基本功能
  let loads: Vec<u8> = cpu_monitor.into_iter().collect();
  assert_eq!(loads.len(), core_count, "迭代器应返回与核心数量相同的元素");

  // 测试迭代器枚举
  for (i, load) in cpu_monitor.into_iter().enumerate() {
    info!("核心 {} 负载: {}%", i, load);
    assert!(load <= 100, "负载值应在 0-100 范围内");
    assert!(i < core_count, "索引应在有效范围内");
  }

  // 测试迭代器大小提示
  let iter = cpu_monitor.into_iter();
  let (lower, upper) = iter.size_hint();
  assert_eq!(lower, core_count, "大小提示下限应等于核心数量");
  assert_eq!(upper, Some(core_count), "大小提示上限应等于核心数量");

  // 测试 ExactSizeIterator
  assert_eq!(iter.len(), core_count, "迭代器长度应等于核心数量");

  // 测试迭代器链式操作
  let avg_load = cpu_monitor.into_iter().map(|x| x as u16).sum::<u16>() as f32 / core_count as f32;
  info!("平均负载: {:.2}%", avg_load);
  assert!(
    (0.0..=100.0).contains(&avg_load),
    "平均负载应在 0-100 范围内"
  );

  // 测试过滤操作
  let high_load_cores: Vec<usize> = cpu_monitor
    .into_iter()
    .enumerate()
    .filter(|(_, load)| *load > 50)
    .map(|(i, _)| i)
    .collect();

  if !high_load_cores.is_empty() {
    info!("高负载核心 (>50%): {:?}", high_load_cores);
  }

  // 测试查找操作
  if let Some(max_load) = cpu_monitor.into_iter().max() {
    info!("最高负载: {}%", max_load);
    assert!(max_load <= 100, "最大负载应在 0-100 范围内");
  }

  if let Some(min_load) = cpu_monitor.into_iter().min() {
    info!("最低负载: {}%", min_load);
    assert!(min_load <= 100, "最小负载应在 0-100 范围内");
  }

  info!("迭代器测试完成");

  // 测试迭代器收集到不同集合类型
  let loads_vec: Vec<u8> = cpu_monitor.into_iter().collect();
  let loads_array = loads_vec.clone().into_iter().collect::<Vec<u8>>();
  info!("收集到的负载数组: {:?}", &loads_array);
  info!("实际收集的负载向量: {:?}", loads_vec);
  OK
}