612 lines
35 KiB
Go
612 lines
35 KiB
Go
package stress
|
||
|
||
import (
|
||
"fmt"
|
||
"strings"
|
||
)
|
||
|
||
// ============================
|
||
// 性能/温度基准（让用户对结果有感性认知）
|
||
// ============================
|
||
//
|
||
// 评级说明（与"超过正常"程度绑定，4 档）：
|
||
// - 远低于正常 red #dc2626
|
||
// - 达到正常 green #16a34a
|
||
// - 超过正常 blue #3b82f6
|
||
// - 远超过正常 purple #7c3aed
|
||
//
|
||
// 评分方向：
|
||
// - higher_better: 数值越大越好（CPU/内存跑分、IOPS、吞吐）
|
||
// - lower_better : 数值越小越好（温度）
|
||
//
|
||
// 阈值（Cutoffs）：3 个分界点将数值划分为 4 档。
|
||
// - higher_better: <c0 远低于, c0~c1 正常, c1~c2 超过, ≥c2 远超过
|
||
// - lower_better : >c0 远低于（危险）, c1~c0 正常, c2~c1 超过, ≤c2 远超过（优秀）
|
||
//
|
||
// 阈值仅作参考，应根据实际硬件代际持续校准；下文取自常见消费级/主流企业级硬件中位水平。
|
||
|
||
// Level 评级
|
||
type Level string
|
||
|
||
const (
|
||
LevelPoor Level = "poor" // 远低于正常
|
||
LevelNormal Level = "normal" // 达到正常
|
||
LevelGood Level = "good" // 超过正常
|
||
LevelExcellent Level = "excellent" // 远超过正常
|
||
)
|
||
|
||
// LevelDisplay 评级显示元数据
|
||
type LevelDisplay struct {
|
||
Text string // 远低于正常 / 达到正常 / 超过正常 / 远超过正常
|
||
Color string // 颜色（与报告 CSS 协调）
|
||
Order int // 0/1/2/3 用于排序与综合评级
|
||
}
|
||
|
||
var levelDisplay = map[Level]LevelDisplay{
|
||
LevelPoor: {Text: "远低于正常", Color: "#dc2626", Order: 0},
|
||
LevelNormal: {Text: "达到正常", Color: "#16a34a", Order: 1},
|
||
LevelGood: {Text: "超过正常", Color: "#3b82f6", Order: 2},
|
||
LevelExcellent: {Text: "远超过正常", Color: "#7c3aed", Order: 3},
|
||
}
|
||
|
||
// LevelMeta 取评级显示信息，未知时返回 normal
|
||
func LevelMeta(l Level) LevelDisplay {
|
||
if d, ok := levelDisplay[l]; ok {
|
||
return d
|
||
}
|
||
return LevelDisplay{Text: string(l), Color: "#64748b", Order: 1}
|
||
}
|
||
|
||
// Direction 评分方向
|
||
type Direction string
|
||
|
||
const (
|
||
DirHigherBetter Direction = "higher" // 越高越好
|
||
DirLowerBetter Direction = "lower" // 越低越好
|
||
)
|
||
|
||
// MetricBench 单个指标的基准配置
|
||
type MetricBench struct {
|
||
Key string // 指标键：score / max_temp / iops_total / bw_total
|
||
Label string // 显示名
|
||
Unit string // 单位
|
||
Direction Direction // 评分方向
|
||
Cutoffs [3]float64
|
||
Note string // 备注（用于展示）
|
||
}
|
||
|
||
// ============================
|
||
// 各指标基准（消费/主流企业级硬件参考）
|
||
// ============================
|
||
|
||
// CPU 跑分：stress-ng bogo ops/s，4 线程参考（线程越多分越高）
|
||
var benchCPU = MetricBench{
|
||
Key: "score", Label: "CPU 跑分", Unit: "ops/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{8000, 20000, 40000},
|
||
Note: "stress-ng bogo ops/s（4 线程参考；线程数越多分越高）",
|
||
}
|
||
|
||
// 内存跑分
|
||
var benchMemory = MetricBench{
|
||
Key: "score", Label: "内存跑分", Unit: "ops/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{5000, 15000, 30000},
|
||
Note: "stress-ng bogo ops/s",
|
||
}
|
||
|
||
// 综合工况：CPU+内存 综合
|
||
var benchFull = MetricBench{
|
||
Key: "score", Label: "综合跑分", Unit: "ops/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{6000, 18000, 35000},
|
||
Note: "CPU+内存综合 ops/s",
|
||
}
|
||
|
||
// 内存精压：MB/s（DDR4 一般 20-50 GB/s，受通道数和频率影响）
|
||
var benchMemNative = MetricBench{
|
||
Key: "score", Label: "内存带宽", Unit: "MB/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{3000, 8000, 15000},
|
||
Note: "内存读写带宽",
|
||
}
|
||
|
||
// 磁盘 4K 随机读写 IOPS
|
||
var benchDiskIOPS = MetricBench{
|
||
Key: "iops_total", Label: "磁盘 IOPS", Unit: "ops/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{1000, 10000, 50000},
|
||
Note: "4K 随机读写：<1k≈HDD, 1k-10k≈低端 SSD, 10k-50k≈SATA/NVMe 入门, >50k≈NVMe 中高端",
|
||
}
|
||
|
||
// 磁盘读写总带宽
|
||
var benchDiskBW = MetricBench{
|
||
Key: "bw_total", Label: "磁盘吞吐", Unit: "MB/s",
|
||
Direction: DirHigherBetter,
|
||
Cutoffs: [3]float64{100, 500, 2000},
|
||
Note: "读写总带宽：<100≈HDD, 100-500≈低端 SSD, 500-2000≈SATA/NVMe 入门, >2000≈NVMe Gen3+",
|
||
}
|
||
|
||
// 最高温度（°C，越低越好）
|
||
var benchTemp = MetricBench{
|
||
Key: "max_temp", Label: "最高温度", Unit: "°C",
|
||
Direction: DirLowerBetter,
|
||
Cutoffs: [3]float64{90, 75, 60}, // 阈值由高到低：poor/normal, normal/good, good/excellent
|
||
Note: "<60°C 优秀, 60-75°C 正常, 75-90°C 偏高, >90°C 危险",
|
||
}
|
||
|
||
// ============================
|
||
// 硬件基准库（按 CPU 型号匹配）
|
||
// ============================
|
||
//
|
||
// 设计目的：不同代/不同档位的硬件不能用同一套阈值比较。
|
||
// 例如 i3 与 i7 跑分差距数倍；J4125 与 N100 也不能直接比较。
|
||
//
|
||
// 使用方式：
|
||
// - MatchHardware(cpuModel) 依据 CPU 型号子串匹配（大小写不敏感）
|
||
// - 匹配成功 → 使用该硬件的专属阈值评估
|
||
// - 未匹配 → 所有指标强制返回 LevelNormal（"达到正常"），不判定好坏
|
||
// - 库中字段为 nil → 退到默认基准
|
||
//
|
||
// 维护说明：库按"匹配顺序"查找，越靠前越优先。新增型号请在最匹配的
|
||
// 位置追加（i5-12xxx 必须在 i5 之前），否则会被更宽泛的规则先匹配。
|
||
|
||
// HardwareBench 一类硬件的基准
|
||
type HardwareBench struct {
|
||
// Match CPU 型号匹配子串（大小写不敏感），如 "i7-12"、"N100"、"Ryzen 5"
|
||
Match string
|
||
// Note 硬件说明，会显示在报告备注里
|
||
Note string
|
||
// CPU/Memory/Full/MemBand 各类跑分基准；nil 表示使用默认基准
|
||
CPU *MetricBench
|
||
Memory *MetricBench
|
||
Full *MetricBench
|
||
MemBand *MetricBench
|
||
}
|
||
|
||
// hardwareLibrary 硬件基准库（按匹配顺序查找，越靠前越优先）
|
||
// 数值参考：stress-ng bogo ops/s @ 默认线程数；内存带宽为 stream/memcpy 估算
|
||
// 维护提醒：每代 CPU 阈值约为上一代的 1.15~1.30 倍，跨代需重新校准
|
||
var hardwareLibrary = []HardwareBench{
|
||
// ============ Intel 飞牛常用低功耗 ============
|
||
{
|
||
Match: "N100", Note: "Intel N100 (Alder Lake-N, 4C/4T, 6W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 22000, 38000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 12000, 22000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 18000, 30000}, Note: "CPU+内存综合"},
|
||
MemBand: &MetricBench{Key: "score", Label: "内存带宽", Unit: "MB/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 8000, 15000}, Note: "单通道 DDR5 带宽上限"},
|
||
},
|
||
{
|
||
Match: "N305", Note: "Intel N305 (Alder Lake-N, 8C/8T, 15W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 40000, 65000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 18000, 35000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{15000, 30000, 50000}, Note: "CPU+内存综合"},
|
||
MemBand: &MetricBench{Key: "score", Label: "内存带宽", Unit: "MB/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 10000, 18000}, Note: "DDR5 双通道带宽"},
|
||
},
|
||
{
|
||
Match: "N95", Note: "Intel N95 (Alder Lake-N, 4C/4T, 15W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 20000, 35000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 11000, 20000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 16000, 28000}, Note: "CPU+内存综合"},
|
||
MemBand: &MetricBench{Key: "score", Label: "内存带宽", Unit: "MB/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 7000, 13000}, Note: "单通道 DDR4/DDR5 带宽"},
|
||
},
|
||
{
|
||
Match: "N5105", Note: "Intel Celeron N5105 (Jasper Lake, 4C/4T, 10W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{7000, 14000, 25000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 9000, 16000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 12000, 22000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "N5095", Note: "Intel Celeron N5095 (Jasper Lake, 4C/4T, 15W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{6000, 12000, 22000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 8000, 15000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 10000, 19000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "J4125", Note: "Intel Celeron J4125 (Gemini Lake, 4C/4T, 10W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 10000, 18000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 6000, 12000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 8000, 15000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "J4105", Note: "Intel Celeron J4105 (Gemini Lake, 4C/4T, 10W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4500, 9000, 16000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 6000, 11000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 7500, 14000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "J3455", Note: "Intel Celeron J3455 (Apollo Lake, 4C/4T, 10W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3500, 7500, 13000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{2500, 5000, 9500}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 6500, 12000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "J1900", Note: "Intel Celeron J1900 (Bay Trail, 4C/4T, 10W)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{2500, 5500, 10000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{2000, 4000, 7000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{2000, 4500, 8500}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Celeron", Note: "Intel Celeron (其他型号)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 12000, 22000}, Note: "Celeron 系列通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 7000, 14000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 10000, 18000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Atom", Note: "Intel Atom",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{2000, 5000, 9000}, Note: "Atom 系列通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{1500, 3500, 6500}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{1800, 4500, 8000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ Intel Core i9（按代匹配） ============
|
||
{
|
||
Match: "i9-13", Note: "13代 i9 (Raptor Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{50000, 100000, 160000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 50000, 90000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{30000, 70000, 120000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i9-12", Note: "12代 i9 (Alder Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{40000, 85000, 140000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 45000, 80000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{28000, 60000, 100000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i9-11", Note: "11代 i9 (Rocket Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{35000, 75000, 125000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{15000, 38000, 70000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{25000, 55000, 95000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i9-10", Note: "10代 i9 (Comet Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{30000, 65000, 110000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 35000, 65000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 48000, 85000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i9-", Note: "Intel Core i9 (其他代)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{25000, 55000, 95000}, Note: "i9 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{12000, 30000, 60000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 45000, 80000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ Intel Core i7（按代匹配） ============
|
||
{
|
||
Match: "i7-13", Note: "13代 i7 (Raptor Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{40000, 85000, 140000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 45000, 80000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{28000, 60000, 100000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-12", Note: "12代 i7 (Alder Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{32000, 70000, 115000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{16000, 40000, 70000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{24000, 52000, 90000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-11", Note: "11代 i7 (Rocket Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{28000, 60000, 100000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 35000, 60000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 48000, 80000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-10", Note: "10代 i7 (Comet Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{25000, 55000, 90000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{12000, 30000, 55000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 42000, 72000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-8", Note: "8/9代 i7 (Coffee Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 45000, 75000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 25000, 45000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{16000, 35000, 60000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-7", Note: "7代 i7 (Kaby Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{16000, 35000, 60000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 20000, 38000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{12000, 28000, 48000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i7-", Note: "Intel Core i7 (其他代)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 40000, 70000}, Note: "i7 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{9000, 22000, 42000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 32000, 55000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ Intel Core i5（按代匹配） ============
|
||
{
|
||
Match: "i5-13", Note: "13代 i5 (Raptor Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{30000, 65000, 105000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 35000, 60000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 48000, 80000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i5-12", Note: "12代 i5 (Alder Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{25000, 55000, 90000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{12000, 30000, 55000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 40000, 70000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i5-11", Note: "11代 i5 (Rocket Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 48000, 80000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{11000, 27000, 48000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{16000, 35000, 60000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i5-10", Note: "10代 i5 (Comet Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 42000, 70000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 25000, 45000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 32000, 55000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i5-8", Note: "8/9代 i5 (Coffee Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{15000, 32000, 55000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 18000, 35000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 24000, 42000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i5-", Note: "Intel Core i5 (其他代)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 30000, 50000}, Note: "i5 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{7000, 17000, 32000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 22000, 40000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ Intel Core i3（按代匹配） ============
|
||
{
|
||
Match: "i3-13", Note: "13代 i3 (Raptor Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 42000, 70000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 24000, 45000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{15000, 32000, 55000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i3-12", Note: "12代 i3 (Alder Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 38000, 62000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{9000, 22000, 40000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{13000, 28000, 50000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i3-10", Note: "10代 i3 (Comet Lake)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 30000, 50000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{7000, 17000, 32000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 22000, 40000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "i3-", Note: "Intel Core i3 (其他代)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 22000, 38000}, Note: "i3 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5500, 13000, 25000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 18000, 32000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ Intel Xeon ============
|
||
{
|
||
Match: "Xeon", Note: "Intel Xeon",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{30000, 70000, 120000}, Note: "Xeon 通用参考（按核心数浮动大）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{15000, 35000, 70000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 50000, 90000}, Note: "CPU+内存综合"},
|
||
},
|
||
|
||
// ============ AMD Ryzen（按系列） ============
|
||
{
|
||
Match: "Ryzen 9", Note: "AMD Ryzen 9",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{40000, 85000, 145000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{18000, 45000, 85000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{30000, 65000, 110000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Ryzen 7", Note: "AMD Ryzen 7",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{28000, 60000, 100000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{13000, 32000, 60000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{20000, 45000, 78000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Ryzen 5", Note: "AMD Ryzen 5",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{22000, 48000, 80000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{11000, 26000, 48000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{16000, 36000, 62000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Ryzen 3", Note: "AMD Ryzen 3",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{14000, 30000, 50000}, Note: "stress-ng bogo ops/s（4 线程）"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{7000, 17000, 32000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{10000, 22000, 40000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "Athlon", Note: "AMD Athlon",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{5000, 11000, 20000}, Note: "Athlon 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{3000, 7000, 13000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 9000, 17000}, Note: "CPU+内存综合"},
|
||
},
|
||
{
|
||
Match: "AMD", Note: "AMD 处理器 (其他型号)",
|
||
CPU: &MetricBench{Key: "score", Label: "CPU 跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{8000, 18000, 32000}, Note: "AMD 通用参考"},
|
||
Memory: &MetricBench{Key: "score", Label: "内存跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{4000, 10000, 18000}, Note: "stress-ng bogo ops/s"},
|
||
Full: &MetricBench{Key: "score", Label: "综合跑分", Unit: "ops/s", Direction: DirHigherBetter, Cutoffs: [3]float64{6000, 14000, 25000}, Note: "CPU+内存综合"},
|
||
},
|
||
}
|
||
|
||
// MatchHardware 根据 CPU 型号匹配硬件基准（大小写不敏感，子串匹配）
|
||
// 返回 nil 表示未在库中（调用方应将所有指标视为"达到正常"，不做好坏判定）
|
||
func MatchHardware(cpuModel string) *HardwareBench {
|
||
if cpuModel == "" {
|
||
return nil
|
||
}
|
||
lower := strings.ToLower(cpuModel)
|
||
for i := range hardwareLibrary {
|
||
if strings.Contains(lower, strings.ToLower(hardwareLibrary[i].Match)) {
|
||
return &hardwareLibrary[i]
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ============================
|
||
// 评估函数
|
||
// ============================
|
||
|
||
// EvalBench 根据基准评估单个数值
|
||
func EvalBench(b MetricBench, value float64) Level {
|
||
c := b.Cutoffs
|
||
switch b.Direction {
|
||
case DirHigherBetter:
|
||
switch {
|
||
case value < c[0]:
|
||
return LevelPoor
|
||
case value < c[1]:
|
||
return LevelNormal
|
||
case value < c[2]:
|
||
return LevelGood
|
||
default:
|
||
return LevelExcellent
|
||
}
|
||
case DirLowerBetter:
|
||
switch {
|
||
case value > c[0]:
|
||
return LevelPoor
|
||
case value > c[1]:
|
||
return LevelNormal
|
||
case value > c[2]:
|
||
return LevelGood
|
||
default:
|
||
return LevelExcellent
|
||
}
|
||
}
|
||
return LevelNormal
|
||
}
|
||
|
||
// ReferenceText 生成"参考范围"展示文本
|
||
func (b MetricBench) ReferenceText() string {
|
||
c := b.Cutoffs
|
||
if b.Direction == DirHigherBetter {
|
||
return fmt.Sprintf(
|
||
"参考: <%.0f%s 远低于 · %.0f-%.0f%s 正常 · %.0f-%.0f%s 良好 · ≥%.0f%s 卓越",
|
||
c[0], b.Unit, c[0], c[1], b.Unit, c[1], c[2], b.Unit, c[2], b.Unit,
|
||
)
|
||
}
|
||
return fmt.Sprintf(
|
||
"参考: >%.0f%s 危险 · %.0f-%.0f%s 偏高 · %.0f-%.0f%s 正常 · ≤%.0f%s 优秀",
|
||
c[0], b.Unit, c[1], c[0], b.Unit, c[2], c[1], b.Unit, c[2], b.Unit,
|
||
)
|
||
}
|
||
|
||
// BenchItem 一次基准评估的展示单元（序列化到报告）
|
||
type BenchItem struct {
|
||
Key string `json:"key"`
|
||
Label string `json:"label"`
|
||
Value string `json:"value"` // 格式化后的值，如 "72.0 °C"
|
||
ValueNum float64 `json:"value_num"` // 原始数值
|
||
Unit string `json:"unit"`
|
||
Level Level `json:"level"`
|
||
LevelText string `json:"level_text"`
|
||
LevelColor string `json:"level_color"`
|
||
Reference string `json:"reference"`
|
||
Note string `json:"note"`
|
||
}
|
||
|
||
// OverallLevel 取多个评级中"最差"（最差用于提示风险）
|
||
func OverallLevel(items []BenchItem) Level {
|
||
if len(items) == 0 {
|
||
return ""
|
||
}
|
||
worst := LevelExcellent
|
||
for _, it := range items {
|
||
if LevelMeta(it.Level).Order < LevelMeta(worst).Order {
|
||
worst = it.Level
|
||
}
|
||
}
|
||
return worst
|
||
}
|
||
|
||
// EvaluateResult 对一个 Result 评估所有可用指标的基准
|
||
// 返回的列表按"重要性"排序：跑分 → 温度 → IOPS → 吞吐
|
||
// cpuModel: 设备 CPU 型号（来自 sysInfo["cpu"]）；空串或不在库中时，所有指标项
|
||
// 强制返回 LevelNormal（"达到正常"），不做好坏判定，避免误报
|
||
func EvaluateResult(r Result, cpuModel string) []BenchItem {
|
||
hb := MatchHardware(cpuModel)
|
||
inLibrary := hb != nil
|
||
|
||
var items []BenchItem
|
||
|
||
makeItem := func(b MetricBench, v float64) BenchItem {
|
||
// 未在库中 → 强制 normal；已匹配 → 按专属阈值评估
|
||
lvl := LevelNormal
|
||
if inLibrary {
|
||
lvl = EvalBench(b, v)
|
||
}
|
||
d := LevelMeta(lvl)
|
||
return BenchItem{
|
||
Key: b.Key,
|
||
Label: b.Label,
|
||
Value: fmt.Sprintf("%.1f %s", v, b.Unit),
|
||
ValueNum: v,
|
||
Unit: b.Unit,
|
||
Level: lvl,
|
||
LevelText: d.Text,
|
||
LevelColor: d.Color,
|
||
Reference: b.ReferenceText(),
|
||
Note: b.Note,
|
||
}
|
||
}
|
||
|
||
// pickBench 选基准：库中有专属 → 专属；库中无该字段或未在库 → 默认
|
||
pickBench := func(field *MetricBench, defaultBench MetricBench) MetricBench {
|
||
if hb != nil && field != nil {
|
||
return *field
|
||
}
|
||
return defaultBench
|
||
}
|
||
|
||
// 1) 跑分（按测试类型选基准）
|
||
if r.Score > 0 {
|
||
var b MetricBench
|
||
switch r.Type {
|
||
case TestCPU:
|
||
if hb != nil {
|
||
b = pickBench(hb.CPU, benchCPU)
|
||
} else {
|
||
b = benchCPU
|
||
}
|
||
case TestMemory:
|
||
if hb != nil {
|
||
b = pickBench(hb.Memory, benchMemory)
|
||
} else {
|
||
b = benchMemory
|
||
}
|
||
case TestFull:
|
||
if hb != nil {
|
||
b = pickBench(hb.Full, benchFull)
|
||
} else {
|
||
b = benchFull
|
||
}
|
||
case TestMemNative:
|
||
if hb != nil {
|
||
b = pickBench(hb.MemBand, benchMemNative)
|
||
} else {
|
||
b = benchMemNative
|
||
}
|
||
}
|
||
if b.Key != "" {
|
||
items = append(items, makeItem(b, r.Score))
|
||
}
|
||
}
|
||
|
||
// 2) 温度（max_temp 存在即评估）
|
||
// 温度阈值为通用参考（60/75/90°C），未在库中同样会按通用阈值评估并强制 normal
|
||
if t, ok := r.Metrics["max_temp"]; ok && t > 0 {
|
||
items = append(items, makeItem(benchTemp, t))
|
||
}
|
||
|
||
// 3) 磁盘 IOPS（通用参考，与 CPU 无关）
|
||
if t, ok := r.Metrics["iops_total"]; ok && t > 0 {
|
||
items = append(items, makeItem(benchDiskIOPS, t))
|
||
}
|
||
|
||
// 4) 磁盘吞吐（通用参考，与 CPU 无关）
|
||
if t, ok := r.Metrics["bw_total"]; ok && t > 0 {
|
||
items = append(items, makeItem(benchDiskBW, t))
|
||
}
|
||
|
||
return items
|
||
}
|