mirror of
https://github.com/noctalia-dev/noctalia-shell.git
synced 2026-05-11 17:08:27 +08:00
Lemmy
1507 lines
51 KiB
QML
1507 lines
51 KiB
QML
pragma Singleton
|
|
import Qt.labs.folderlistmodel
|
|
|
|
import QtQuick
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import qs.Commons
|
|
import qs.Services.UI
|
|
|
|
Singleton {
|
|
id: root
|
|
|
|
// Component registration - only poll when something needs system stat data
|
|
function registerComponent(componentId) {
|
|
root._registered[componentId] = true;
|
|
root._registered = Object.assign({}, root._registered);
|
|
Logger.d("SystemStat", "Component registered:", componentId, "- total:", root._registeredCount);
|
|
}
|
|
|
|
function unregisterComponent(componentId) {
|
|
delete root._registered[componentId];
|
|
root._registered = Object.assign({}, root._registered);
|
|
Logger.d("SystemStat", "Component unregistered:", componentId, "- total:", root._registeredCount);
|
|
}
|
|
|
|
property var _registered: ({})
|
|
readonly property int _registeredCount: Object.keys(_registered).length
|
|
readonly property bool _lockScreenActive: PanelService.lockScreen?.active ?? false
|
|
readonly property bool shouldRun: _registeredCount > 0 && !_lockScreenActive
|
|
|
|
// Polling intervals (hardcoded to sensible values per stat type)
|
|
readonly property int cpuUsageIntervalMs: 1000
|
|
readonly property int cpuFreqIntervalMs: 3000
|
|
readonly property int memIntervalMs: 5000
|
|
readonly property int networkIntervalMs: 3000
|
|
readonly property int loadAvgIntervalMs: 10000
|
|
readonly property int diskIntervalMs: 30000
|
|
readonly property int gpuIntervalMs: 5000
|
|
|
|
// Public values
|
|
property real cpuUsage: 0
|
|
property list<real> coresUsage: []
|
|
property real cpuTemp: 0
|
|
property string cpuFreq: "0.0GHz"
|
|
property real cpuFreqRatio: 0
|
|
property real cpuGlobalMaxFreq: 3.5
|
|
property real gpuTemp: 0
|
|
property bool gpuAvailable: false
|
|
property string gpuType: "" // "amd", "intel", "nvidia"
|
|
property real memGb: 0
|
|
property real memPercent: 0
|
|
property real memTotalGb: 0
|
|
property real swapGb: 0
|
|
property real swapPercent: 0
|
|
property real swapTotalGb: 0
|
|
property var diskPercents: ({})
|
|
property var diskAvailPercents: ({}) // available disk space in percent
|
|
property var diskUsedGb: ({}) // Used space in GB per mount point
|
|
property var diskAvailableGb: ({}) // available space in GB per mount point
|
|
property var diskSizeGb: ({}) // Total size in GB per mount point
|
|
property real rxSpeed: 0
|
|
property real txSpeed: 0
|
|
property real zfsArcSizeKb: 0 // ZFS ARC cache size in KB
|
|
property real zfsArcCminKb: 0 // ZFS ARC minimum (non-reclaimable) size in KB
|
|
property real loadAvg1: 0
|
|
property real loadAvg5: 0
|
|
property real loadAvg15: 0
|
|
property int nproc: 0 // Number of cpu cores
|
|
|
|
// History arrays (2 minutes of data, length computed from polling interval)
|
|
// Pre-filled with zeros so the graph scrolls smoothly from the start
|
|
readonly property int historyDurationMs: (1 * 60 * 1000) // 1 minute
|
|
|
|
// Computed history lengths based on polling intervals
|
|
readonly property int cpuHistoryLength: Math.ceil(historyDurationMs / cpuUsageIntervalMs)
|
|
readonly property int gpuHistoryLength: Math.ceil(historyDurationMs / gpuIntervalMs)
|
|
readonly property int memHistoryLength: Math.ceil(historyDurationMs / memIntervalMs)
|
|
readonly property int diskHistoryLength: Math.max(10, Math.ceil(historyDurationMs / diskIntervalMs))
|
|
readonly property int networkHistoryLength: Math.ceil(historyDurationMs / networkIntervalMs)
|
|
|
|
property var cpuHistory: new Array(cpuHistoryLength).fill(0)
|
|
property var cpuTempHistory: new Array(cpuHistoryLength).fill(40) // Reasonable default temp
|
|
property var gpuTempHistory: new Array(gpuHistoryLength).fill(40) // Reasonable default temp
|
|
property var memHistory: new Array(memHistoryLength).fill(0)
|
|
property var diskHistories: ({}) // Keyed by mount path, initialized on first update
|
|
property var rxSpeedHistory: new Array(networkHistoryLength).fill(0)
|
|
property var txSpeedHistory: new Array(networkHistoryLength).fill(0)
|
|
|
|
// Historical min/max tracking (since shell started) for consistent graph scaling
|
|
// Temperature defaults create a valid 30-80°C range that expands as real data comes in
|
|
property real cpuTempHistoryMin: 30
|
|
property real cpuTempHistoryMax: 80
|
|
property real gpuTempHistoryMin: 30
|
|
property real gpuTempHistoryMax: 80
|
|
// Network uses autoscaling from current history window
|
|
// Disk is always 0-100%
|
|
|
|
// History management - called from update functions, not change handlers
|
|
// (change handlers don't fire when value stays the same)
|
|
function pushCpuHistory() {
|
|
let h = cpuHistory.slice();
|
|
h.push(cpuUsage);
|
|
if (h.length > cpuHistoryLength)
|
|
h.shift();
|
|
cpuHistory = h;
|
|
}
|
|
|
|
function pushCpuTempHistory() {
|
|
if (cpuTemp > 0) {
|
|
if (cpuTemp < cpuTempHistoryMin)
|
|
cpuTempHistoryMin = cpuTemp;
|
|
if (cpuTemp > cpuTempHistoryMax)
|
|
cpuTempHistoryMax = cpuTemp;
|
|
}
|
|
let h = cpuTempHistory.slice();
|
|
h.push(cpuTemp);
|
|
if (h.length > cpuHistoryLength)
|
|
h.shift();
|
|
cpuTempHistory = h;
|
|
}
|
|
|
|
function pushGpuHistory() {
|
|
if (gpuTemp > 0) {
|
|
if (gpuTemp < gpuTempHistoryMin)
|
|
gpuTempHistoryMin = gpuTemp;
|
|
if (gpuTemp > gpuTempHistoryMax)
|
|
gpuTempHistoryMax = gpuTemp;
|
|
}
|
|
let h = gpuTempHistory.slice();
|
|
h.push(gpuTemp);
|
|
if (h.length > gpuHistoryLength)
|
|
h.shift();
|
|
gpuTempHistory = h;
|
|
}
|
|
|
|
function pushMemHistory() {
|
|
let h = memHistory.slice();
|
|
h.push(memPercent);
|
|
if (h.length > memHistoryLength)
|
|
h.shift();
|
|
memHistory = h;
|
|
}
|
|
|
|
function pushDiskHistory() {
|
|
let newHistories = {};
|
|
for (let path in diskPercents) {
|
|
// Pre-fill with zeros if this is a new path
|
|
let h = diskHistories[path] ? diskHistories[path].slice() : new Array(diskHistoryLength).fill(0);
|
|
h.push(diskPercents[path]);
|
|
if (h.length > diskHistoryLength)
|
|
h.shift();
|
|
newHistories[path] = h;
|
|
}
|
|
diskHistories = newHistories;
|
|
}
|
|
|
|
function pushNetworkHistory() {
|
|
let rxH = rxSpeedHistory.slice();
|
|
rxH.push(rxSpeed);
|
|
if (rxH.length > networkHistoryLength)
|
|
rxH.shift();
|
|
rxSpeedHistory = rxH;
|
|
|
|
let txH = txSpeedHistory.slice();
|
|
txH.push(txSpeed);
|
|
if (txH.length > networkHistoryLength)
|
|
txH.shift();
|
|
txSpeedHistory = txH;
|
|
}
|
|
|
|
// Network max speed tracking (autoscales from current history window)
|
|
// Minimum floor of 1 MB/s so graph doesn't fluctuate at low speeds
|
|
readonly property real rxMaxSpeed: {
|
|
const max = Math.max(...rxSpeedHistory);
|
|
return Math.max(max, 1000000); // 1 MB/s floor
|
|
}
|
|
readonly property real txMaxSpeed: {
|
|
const max = Math.max(...txSpeedHistory);
|
|
return Math.max(max, 512000); // 512 KB/s floor
|
|
}
|
|
|
|
// Ready-to-use ratios based on current maximums (0..1 range)
|
|
readonly property real rxRatio: rxMaxSpeed > 0 ? Math.min(1, rxSpeed / rxMaxSpeed) : 0
|
|
readonly property real txRatio: txMaxSpeed > 0 ? Math.min(1, txSpeed / txMaxSpeed) : 0
|
|
|
|
// Color resolution (respects useCustomColors setting)
|
|
readonly property color warningColor: Settings.data.systemMonitor.useCustomColors ? (Settings.data.systemMonitor.warningColor || Color.mTertiary) : Color.mTertiary
|
|
readonly property color criticalColor: Settings.data.systemMonitor.useCustomColors ? (Settings.data.systemMonitor.criticalColor || Color.mError) : Color.mError
|
|
|
|
// Threshold values from settings
|
|
readonly property int cpuWarningThreshold: Settings.data.systemMonitor.cpuWarningThreshold
|
|
readonly property int cpuCriticalThreshold: Settings.data.systemMonitor.cpuCriticalThreshold
|
|
readonly property int tempWarningThreshold: Settings.data.systemMonitor.tempWarningThreshold
|
|
readonly property int tempCriticalThreshold: Settings.data.systemMonitor.tempCriticalThreshold
|
|
readonly property int gpuWarningThreshold: Settings.data.systemMonitor.gpuWarningThreshold
|
|
readonly property int gpuCriticalThreshold: Settings.data.systemMonitor.gpuCriticalThreshold
|
|
readonly property int memWarningThreshold: Settings.data.systemMonitor.memWarningThreshold
|
|
readonly property int memCriticalThreshold: Settings.data.systemMonitor.memCriticalThreshold
|
|
readonly property int swapWarningThreshold: Settings.data.systemMonitor.swapWarningThreshold
|
|
readonly property int swapCriticalThreshold: Settings.data.systemMonitor.swapCriticalThreshold
|
|
readonly property int diskWarningThreshold: Settings.data.systemMonitor.diskWarningThreshold
|
|
readonly property int diskCriticalThreshold: Settings.data.systemMonitor.diskCriticalThreshold
|
|
readonly property int diskAvailWarningThreshold: Settings.data.systemMonitor.diskAvailWarningThreshold
|
|
readonly property int diskAvailCriticalThreshold: Settings.data.systemMonitor.diskAvailCriticalThreshold
|
|
|
|
// Computed warning/critical states (uses >= inclusive comparison)
|
|
readonly property bool cpuWarning: cpuUsage >= cpuWarningThreshold
|
|
readonly property bool cpuCritical: cpuUsage >= cpuCriticalThreshold
|
|
readonly property bool tempWarning: cpuTemp >= tempWarningThreshold
|
|
readonly property bool tempCritical: cpuTemp >= tempCriticalThreshold
|
|
readonly property bool gpuWarning: gpuAvailable && gpuTemp >= gpuWarningThreshold
|
|
readonly property bool gpuCritical: gpuAvailable && gpuTemp >= gpuCriticalThreshold
|
|
readonly property bool memWarning: memPercent >= memWarningThreshold
|
|
readonly property bool memCritical: memPercent >= memCriticalThreshold
|
|
readonly property bool swapWarning: swapPercent >= swapWarningThreshold
|
|
readonly property bool swapCritical: swapPercent >= swapCriticalThreshold
|
|
|
|
// Helper functions for disk (disk path is dynamic)
|
|
function isDiskWarning(diskPath, available = false) {
|
|
return available ? (diskAvailPercents[diskPath] || 0) <= diskAvailWarningThreshold : (diskPercents[diskPath] || 0) >= diskWarningThreshold;
|
|
}
|
|
|
|
function isDiskCritical(diskPath, available = false) {
|
|
return available ? (diskAvailPercents[diskPath] || 0) <= diskAvailCriticalThreshold : (diskPercents[diskPath] || 0) >= diskCriticalThreshold;
|
|
}
|
|
|
|
// Ready-to-use stat colors (for gauges, panels, icons)
|
|
readonly property color cpuColor: cpuCritical ? criticalColor : (cpuWarning ? warningColor : Color.mPrimary)
|
|
readonly property color tempColor: tempCritical ? criticalColor : (tempWarning ? warningColor : Color.mPrimary)
|
|
readonly property color gpuColor: gpuCritical ? criticalColor : (gpuWarning ? warningColor : Color.mPrimary)
|
|
readonly property color memColor: memCritical ? criticalColor : (memWarning ? warningColor : Color.mPrimary)
|
|
readonly property color swapColor: swapCritical ? criticalColor : (swapWarning ? warningColor : Color.mPrimary)
|
|
|
|
function getCoreUsageColor(usage) {
|
|
if (usage >= cpuCriticalThreshold)
|
|
return criticalColor;
|
|
if (usage >= cpuWarningThreshold)
|
|
return warningColor;
|
|
return Color.mPrimary;
|
|
}
|
|
|
|
function getDiskColor(diskPath, available = false) {
|
|
return isDiskCritical(diskPath, available) ? criticalColor : (isDiskWarning(diskPath, available) ? warningColor : Color.mPrimary);
|
|
}
|
|
|
|
// Internal state for CPU calculation
|
|
property var prevCpuStats: null
|
|
property var prevCpuCoresStats: null
|
|
|
|
// Internal state for network speed calculation
|
|
// Previous Bytes need to be stored as 'real' as they represent the total of bytes transfered
|
|
// since the computer started, so their value will easily overlfow a 32bit int.
|
|
property real prevRxBytes: 0
|
|
property real prevTxBytes: 0
|
|
property real prevTime: 0
|
|
|
|
// Cpu temperature is the most complex
|
|
readonly property var supportedTempCpuSensorNames: ["coretemp", "k10temp", "zenpower"]
|
|
property string cpuTempSensorName: ""
|
|
property string cpuTempHwmonPath: ""
|
|
// For Intel coretemp averaging of all cores/sensors
|
|
property var intelTempValues: []
|
|
property int intelTempFilesChecked: 0
|
|
property int intelTempMaxFiles: 20 // Will test up to temp20_input
|
|
|
|
// Thermal zone fallback (for ARM SoCs with SCMI sensors, etc.)
|
|
property var cpuThermalZonePaths: [] // All matching CPU zones for averaging
|
|
property string gpuThermalZonePath: ""
|
|
|
|
// GPU temperature detection
|
|
// On dual-GPU systems, we prioritize discrete GPUs over integrated GPUs
|
|
// Priority: NVIDIA (opt-in) > AMD dGPU > Intel Arc > AMD iGPU
|
|
// Note: NVIDIA requires opt-in because nvidia-smi wakes the dGPU on laptops, draining battery
|
|
readonly property var supportedTempGpuSensorNames: ["amdgpu", "xe"]
|
|
property string gpuTempHwmonPath: ""
|
|
property var foundGpuSensors: [] // [{hwmonPath, type, hasDedicatedVram}]
|
|
property int gpuVramCheckIndex: 0
|
|
|
|
// --------------------------------------------
|
|
Component.onCompleted: {
|
|
Logger.i("SystemStat", "Service started (polling deferred until a consumer registers).");
|
|
|
|
// Kickoff the cpu name detection for temperature (one-time probes, not polling)
|
|
cpuTempNameReader.checkNext();
|
|
|
|
// Kickoff the gpu sensor detection for temperature (one-time probes, not polling)
|
|
gpuTempNameReader.checkNext();
|
|
|
|
// Get nproc on startup (one-time)
|
|
nprocProcess.running = true;
|
|
}
|
|
|
|
onShouldRunChanged: {
|
|
if (shouldRun) {
|
|
// Reset differential state so first readings after resume are clean
|
|
root.prevCpuStats = null;
|
|
root.prevCpuCoresStats = null;
|
|
root.prevTime = 0;
|
|
|
|
// Trigger initial reads
|
|
zfsArcStatsFile.reload();
|
|
loadAvgFile.reload();
|
|
|
|
// Start persistent disk shell
|
|
if (!dfShell.running) {
|
|
dfShell.running = true;
|
|
}
|
|
} else {
|
|
// Stop persistent disk shell
|
|
if (dfShell.running) {
|
|
dfShell.running = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Re-run GPU detection when dGPU opt-in setting changes
|
|
Connections {
|
|
target: Settings.data.systemMonitor
|
|
function onEnableDgpuMonitoringChanged() {
|
|
Logger.i("SystemStat", "dGPU monitoring opt-in setting changed, re-detecting GPUs");
|
|
restartGpuDetection();
|
|
}
|
|
}
|
|
|
|
// Reset differential state after suspend so the first reading is treated as fresh
|
|
Connections {
|
|
target: Time
|
|
function onResumed() {
|
|
Logger.i("SystemStat", "System resumed - resetting differential state");
|
|
root.prevCpuStats = null;
|
|
root.prevCpuCoresStats = null;
|
|
root.prevTime = 0;
|
|
}
|
|
}
|
|
|
|
function restartGpuDetection() {
|
|
// Reset GPU state
|
|
root.gpuAvailable = false;
|
|
root.gpuType = "";
|
|
root.gpuTempHwmonPath = "";
|
|
root.gpuTemp = 0;
|
|
root.foundGpuSensors = [];
|
|
root.gpuVramCheckIndex = 0;
|
|
|
|
// Restart GPU detection
|
|
gpuTempNameReader.currentIndex = 0;
|
|
gpuTempNameReader.checkNext();
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// Timer for CPU usage and temperature
|
|
Timer {
|
|
id: cpuTimer
|
|
interval: root.cpuUsageIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: {
|
|
cpuStatFile.reload();
|
|
updateCpuTemperature();
|
|
}
|
|
}
|
|
|
|
// Timer for CPU frequency (slower — /proc/cpuinfo is large and freq changes infrequently)
|
|
Timer {
|
|
id: cpuFreqTimer
|
|
interval: root.cpuFreqIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: cpuInfoFile.reload()
|
|
}
|
|
|
|
// Timer for load average
|
|
Timer {
|
|
id: loadAvgTimer
|
|
interval: root.loadAvgIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: loadAvgFile.reload()
|
|
}
|
|
|
|
// Timer for memory stats
|
|
Timer {
|
|
id: memoryTimer
|
|
interval: root.memIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: {
|
|
memInfoFile.reload();
|
|
zfsArcStatsFile.reload();
|
|
}
|
|
}
|
|
|
|
// Timer for disk usage
|
|
Timer {
|
|
id: diskTimer
|
|
interval: root.diskIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: {
|
|
if (dfShell.running) {
|
|
dfShell.write("df --output=target,pcent,used,size,avail --block-size=1 -x efivarfs 2>/dev/null; echo '@@DF_END@@'\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Timer for network speeds
|
|
Timer {
|
|
id: networkTimer
|
|
interval: root.networkIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun
|
|
triggeredOnStart: true
|
|
onTriggered: netDevFile.reload()
|
|
}
|
|
|
|
// Timer for GPU temperature
|
|
Timer {
|
|
id: gpuTempTimer
|
|
interval: root.gpuIntervalMs
|
|
repeat: true
|
|
running: root.shouldRun && root.gpuAvailable
|
|
triggeredOnStart: true
|
|
onTriggered: updateGpuTemperature()
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// FileView components for reading system files
|
|
FileView {
|
|
id: memInfoFile
|
|
path: "/proc/meminfo"
|
|
onLoaded: parseMemoryInfo(text())
|
|
}
|
|
|
|
FileView {
|
|
id: cpuStatFile
|
|
path: "/proc/stat"
|
|
onLoaded: calculateCpuUsage(text())
|
|
}
|
|
|
|
FileView {
|
|
id: netDevFile
|
|
path: "/proc/net/dev"
|
|
onLoaded: calculateNetworkSpeed(text())
|
|
}
|
|
|
|
FileView {
|
|
id: loadAvgFile
|
|
path: "/proc/loadavg"
|
|
onLoaded: parseLoadAverage(text())
|
|
}
|
|
|
|
// ZFS ARC stats file (only exists on ZFS systems)
|
|
FileView {
|
|
id: zfsArcStatsFile
|
|
path: "/proc/spl/kstat/zfs/arcstats"
|
|
printErrors: false
|
|
onLoaded: parseZfsArcStats(text())
|
|
onLoadFailed: {
|
|
// File doesn't exist (non-ZFS system), set ARC values to 0
|
|
root.zfsArcSizeKb = 0;
|
|
root.zfsArcCminKb = 0;
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// Persistent shell for disk usage queries (avoids fork+exec of large Quickshell process every poll)
|
|
// Uses 'df' aka 'disk free'
|
|
// "-x efivarfs" skips efivarfs mountpoints, for which the `statfs` syscall may cause system-wide stuttering
|
|
// --block-size=1 gives us bytes for precise GB calculation
|
|
// Timer writes commands to stdin; SplitParser reads output delimited by @@DF_END@@
|
|
Process {
|
|
id: dfShell
|
|
command: ["sh"]
|
|
stdinEnabled: true
|
|
running: false
|
|
|
|
onRunningChanged: {
|
|
if (!running && root.shouldRun) {
|
|
// Restart if it died unexpectedly while we still need it
|
|
Logger.w("SystemStat", "Disk shell exited unexpectedly, restarting");
|
|
Qt.callLater(() => {
|
|
dfShell.running = true;
|
|
});
|
|
}
|
|
}
|
|
|
|
stdout: SplitParser {
|
|
splitMarker: "@@DF_END@@"
|
|
onRead: data => {
|
|
const lines = data.trim().split('\n');
|
|
const newPercents = {};
|
|
const newAvailPercents = {};
|
|
const newUsedGb = {};
|
|
const newSizeGb = {};
|
|
const newAvailableGb = {};
|
|
const bytesPerGb = 1000 * 1000 * 1000;
|
|
// Start from line 1 (skip header)
|
|
for (var i = 1; i < lines.length; i++) {
|
|
const parts = lines[i].trim().split(/\s+/);
|
|
if (parts.length >= 5) {
|
|
const target = parts[0];
|
|
const percent = parseInt(parts[1].replace(/[^0-9]/g, '')) || 0;
|
|
const usedBytes = parseFloat(parts[2]) || 0;
|
|
const sizeBytes = parseFloat(parts[3]) || 0;
|
|
const availBytes = parseFloat(parts[4]) || 0;
|
|
const availPercent = sizeBytes > 0 ? (availBytes / sizeBytes) * 100 : 0;
|
|
newPercents[target] = percent;
|
|
newAvailPercents[target] = Math.round(availPercent);
|
|
newUsedGb[target] = usedBytes / bytesPerGb;
|
|
newSizeGb[target] = sizeBytes / bytesPerGb;
|
|
newAvailableGb[target] = availBytes / bytesPerGb;
|
|
}
|
|
}
|
|
root.diskPercents = newPercents;
|
|
root.diskAvailPercents = newAvailPercents;
|
|
root.diskUsedGb = newUsedGb;
|
|
root.diskSizeGb = newSizeGb;
|
|
root.diskAvailableGb = newAvailableGb;
|
|
root.pushDiskHistory();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Process to get number of processors
|
|
Process {
|
|
id: nprocProcess
|
|
command: ["nproc"]
|
|
running: false
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
root.nproc = parseInt(text.trim());
|
|
}
|
|
}
|
|
}
|
|
|
|
// FileView to get avg cpu frequency (replaces subprocess spawn of `cat /proc/cpuinfo`)
|
|
FileView {
|
|
id: cpuInfoFile
|
|
path: "/proc/cpuinfo"
|
|
onLoaded: {
|
|
let txt = text();
|
|
let matches = txt.match(/cpu MHz\s+:\s+([0-9.]+)/g);
|
|
if (matches && matches.length > 0) {
|
|
let totalFreq = 0.0;
|
|
for (let i = 0; i < matches.length; i++) {
|
|
totalFreq += parseFloat(matches[i].split(":")[1]);
|
|
}
|
|
let avgFreq = (totalFreq / matches.length) / 1000.0;
|
|
root.cpuFreq = avgFreq.toFixed(1) + "GHz";
|
|
cpuMaxFreqFile.reload();
|
|
if (avgFreq > root.cpuGlobalMaxFreq)
|
|
root.cpuGlobalMaxFreq = avgFreq;
|
|
if (root.cpuGlobalMaxFreq > 0) {
|
|
root.cpuFreqRatio = Math.min(1.0, avgFreq / root.cpuGlobalMaxFreq);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// FileView to get maximum CPU frequency limit (replaces subprocess spawn)
|
|
// Reads cpu0's scaling_max_freq as representative value
|
|
FileView {
|
|
id: cpuMaxFreqFile
|
|
path: "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq"
|
|
printErrors: false
|
|
onLoaded: {
|
|
let maxKHz = parseInt(text().trim());
|
|
if (!isNaN(maxKHz) && maxKHz > 0) {
|
|
let newMaxFreq = maxKHz / 1000000.0;
|
|
if (Math.abs(root.cpuGlobalMaxFreq - newMaxFreq) > 0.01) {
|
|
root.cpuGlobalMaxFreq = newMaxFreq;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// --------------------------------------------
|
|
// CPU Temperature
|
|
// It's more complex.
|
|
// ----
|
|
// #1 - Find a common cpu sensor name ie: "coretemp", "k10temp", "zenpower"
|
|
FileView {
|
|
id: cpuTempNameReader
|
|
property int currentIndex: 0
|
|
printErrors: false
|
|
|
|
function checkNext() {
|
|
if (currentIndex >= 16) {
|
|
// No hwmon sensor found, try thermal_zone fallback (ARM SoCs, SCMI, etc.)
|
|
thermalZoneScanner.startScan();
|
|
return;
|
|
}
|
|
|
|
//Logger.i("SystemStat", "---- Probing: hwmon", currentIndex)
|
|
cpuTempNameReader.path = `/sys/class/hwmon/hwmon${currentIndex}/name`;
|
|
cpuTempNameReader.reload();
|
|
}
|
|
|
|
onLoaded: {
|
|
const name = text().trim();
|
|
if (root.supportedTempCpuSensorNames.includes(name)) {
|
|
root.cpuTempSensorName = name;
|
|
root.cpuTempHwmonPath = `/sys/class/hwmon/hwmon${currentIndex}`;
|
|
Logger.i("SystemStat", `Found ${root.cpuTempSensorName} CPU thermal sensor at ${root.cpuTempHwmonPath}`);
|
|
} else {
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
// Qt.callLater is mandatory
|
|
checkNext();
|
|
});
|
|
}
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
// Qt.callLater is mandatory
|
|
checkNext();
|
|
});
|
|
}
|
|
}
|
|
|
|
// ----
|
|
// #2 - Read sensor value
|
|
FileView {
|
|
id: cpuTempReader
|
|
printErrors: false
|
|
|
|
onLoaded: {
|
|
const data = text().trim();
|
|
if (root.cpuTempSensorName === "coretemp") {
|
|
// For Intel, collect all temperature values
|
|
const temp = parseInt(data) / 1000.0;
|
|
//console.log(temp, cpuTempReader.path)
|
|
root.intelTempValues.push(temp);
|
|
Qt.callLater(() => {
|
|
// Qt.callLater is mandatory
|
|
checkNextIntelTemp();
|
|
});
|
|
} else {
|
|
// For AMD sensors (k10temp and zenpower), directly set the temperature
|
|
root.cpuTemp = Math.round(parseInt(data) / 1000.0);
|
|
root.pushCpuTempHistory();
|
|
}
|
|
}
|
|
onLoadFailed: function (error) {
|
|
Qt.callLater(() => {
|
|
// Qt.callLater is mandatory
|
|
checkNextIntelTemp();
|
|
});
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// Thermal zone fallback for CPU and GPU temperature
|
|
// Used on ARM SoCs (e.g., SCMI sensors) where hwmon doesn't expose
|
|
// coretemp/k10temp/zenpower. Scans /sys/class/thermal/thermal_zoneN/type
|
|
// for CPU and GPU zone names, then reads temp from all matching zones.
|
|
//
|
|
// CPU: reads all cpu-*-thermal zones and reports the hottest core.
|
|
// GPU: prefers gpu-avg-thermal (firmware average), falls back to max of gpu[0-9]-thermal.
|
|
|
|
FileView {
|
|
id: thermalZoneScanner
|
|
property int currentIndex: 0
|
|
property var cpuZones: []
|
|
property var gpuZones: []
|
|
property string gpuAvgZonePath: ""
|
|
printErrors: false
|
|
|
|
function startScan() {
|
|
currentIndex = 0;
|
|
cpuZones = [];
|
|
gpuZones = [];
|
|
gpuAvgZonePath = "";
|
|
checkNext();
|
|
}
|
|
|
|
function checkNext() {
|
|
if (currentIndex >= 20) {
|
|
finishScan();
|
|
return;
|
|
}
|
|
thermalZoneScanner.path = `/sys/class/thermal/thermal_zone${currentIndex}/type`;
|
|
thermalZoneScanner.reload();
|
|
}
|
|
|
|
onLoaded: {
|
|
const name = text().trim();
|
|
const zonePath = `/sys/class/thermal/thermal_zone${currentIndex}`;
|
|
if (name.startsWith("cpu") && name.endsWith("thermal")) {
|
|
cpuZones.push({
|
|
"type": name,
|
|
"path": zonePath + "/temp"
|
|
});
|
|
} else if (name === "gpu-avg-thermal") {
|
|
gpuAvgZonePath = zonePath + "/temp";
|
|
} else if (/^gpu[0-9]+-?thermal$/.test(name)) {
|
|
gpuZones.push({
|
|
"type": name,
|
|
"path": zonePath + "/temp"
|
|
});
|
|
}
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
checkNext();
|
|
});
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
checkNext();
|
|
});
|
|
}
|
|
|
|
function finishScan() {
|
|
// CPU thermal zones
|
|
if (cpuZones.length > 0) {
|
|
root.cpuTempSensorName = "thermal_zone";
|
|
root.cpuThermalZonePaths = cpuZones.map(z => z.path);
|
|
const types = cpuZones.map(z => z.type).join(", ");
|
|
Logger.i("SystemStat", `Found ${cpuZones.length} CPU thermal zone(s): ${types}`);
|
|
} else if (root.cpuTempHwmonPath === "") {
|
|
Logger.w("SystemStat", "No supported temperature sensor found");
|
|
}
|
|
|
|
// GPU thermal zones
|
|
if (gpuAvgZonePath !== "") {
|
|
root.gpuThermalZonePath = gpuAvgZonePath;
|
|
root.gpuAvailable = true;
|
|
root.gpuType = "thermal_zone";
|
|
Logger.i("SystemStat", `Found GPU thermal zone: gpu-avg-thermal`);
|
|
} else if (gpuZones.length > 0) {
|
|
root.gpuThermalZonePaths = gpuZones.map(z => z.path);
|
|
root.gpuThermalZonePath = gpuZones[0].path; // fallback single path
|
|
root.gpuAvailable = true;
|
|
root.gpuType = "thermal_zone";
|
|
const types = gpuZones.map(z => z.type).join(", ");
|
|
Logger.i("SystemStat", `Found ${gpuZones.length} GPU thermal zone(s): ${types} (using max)`);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Thermal zone reader for CPU: reads all zones, reports max (hottest core)
|
|
FileView {
|
|
id: cpuThermalZoneReader
|
|
property int currentZoneIndex: 0
|
|
property var collectedTemps: []
|
|
printErrors: false
|
|
|
|
onLoaded: {
|
|
const temp = parseInt(text().trim()) / 1000.0;
|
|
if (!isNaN(temp) && temp > 0)
|
|
collectedTemps.push(temp);
|
|
currentZoneIndex++;
|
|
Qt.callLater(() => {
|
|
readNextCpuThermalZone();
|
|
});
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
currentZoneIndex++;
|
|
Qt.callLater(() => {
|
|
readNextCpuThermalZone();
|
|
});
|
|
}
|
|
}
|
|
|
|
function readNextCpuThermalZone() {
|
|
if (cpuThermalZoneReader.currentZoneIndex >= root.cpuThermalZonePaths.length) {
|
|
if (cpuThermalZoneReader.collectedTemps.length > 0) {
|
|
root.cpuTemp = Math.round(Math.max(...cpuThermalZoneReader.collectedTemps));
|
|
} else {
|
|
root.cpuTemp = 0;
|
|
}
|
|
root.pushCpuTempHistory();
|
|
return;
|
|
}
|
|
cpuThermalZoneReader.path = root.cpuThermalZonePaths[cpuThermalZoneReader.currentZoneIndex];
|
|
cpuThermalZoneReader.reload();
|
|
}
|
|
|
|
// Thermal zone reader for GPU: reads single zone (gpu-avg-thermal) or max of gpu[N] zones
|
|
FileView {
|
|
id: gpuThermalZoneReader
|
|
property int currentZoneIndex: 0
|
|
property var collectedTemps: []
|
|
printErrors: false
|
|
|
|
onLoaded: {
|
|
const temp = parseInt(text().trim()) / 1000.0;
|
|
if (!isNaN(temp) && temp > 0)
|
|
collectedTemps.push(temp);
|
|
|
|
// If we have multiple GPU zones (no gpu-avg), iterate and take max
|
|
if (root.gpuThermalZonePaths && root.gpuThermalZonePaths.length > 0) {
|
|
currentZoneIndex++;
|
|
if (currentZoneIndex < root.gpuThermalZonePaths.length) {
|
|
Qt.callLater(() => {
|
|
readNextGpuThermalZone();
|
|
});
|
|
return;
|
|
}
|
|
// All zones read, take max
|
|
root.gpuTemp = Math.round(Math.max(...collectedTemps));
|
|
} else {
|
|
// Single gpu-avg-thermal zone
|
|
root.gpuTemp = Math.round(temp);
|
|
}
|
|
root.pushGpuHistory();
|
|
}
|
|
}
|
|
|
|
function readNextGpuThermalZone() {
|
|
gpuThermalZoneReader.path = root.gpuThermalZonePaths[gpuThermalZoneReader.currentZoneIndex];
|
|
gpuThermalZoneReader.reload();
|
|
}
|
|
|
|
// Property to store multiple GPU thermal zone paths (when no gpu-avg is available)
|
|
property var gpuThermalZonePaths: []
|
|
|
|
// --------------------------------------------
|
|
// --------------------------------------------
|
|
// GPU Temperature
|
|
// On dual-GPU systems (e.g., Intel iGPU + NVIDIA dGPU, or AMD APU + AMD dGPU),
|
|
// we scan all hwmon entries, then select the best GPU based on priority.
|
|
// ----
|
|
// #1 - Scan all hwmon entries to find GPU sensors
|
|
FileView {
|
|
id: gpuTempNameReader
|
|
property int currentIndex: 0
|
|
printErrors: false
|
|
|
|
function checkNext() {
|
|
if (currentIndex >= 16) {
|
|
// Finished scanning all hwmon entries
|
|
// Only check nvidia-smi if user has explicitly enabled dGPU monitoring (opt-in)
|
|
// because nvidia-smi wakes up the dGPU on laptops, draining battery
|
|
if (Settings.data.systemMonitor.enableDgpuMonitoring) {
|
|
Logger.d("SystemStat", `Found ${root.foundGpuSensors.length} sysfs GPU sensor(s), checking nvidia-smi (dGPU opt-in enabled)`);
|
|
nvidiaSmiCheck.running = true;
|
|
} else {
|
|
Logger.d("SystemStat", `Found ${root.foundGpuSensors.length} sysfs GPU sensor(s), skipping nvidia-smi (dGPU opt-in disabled)`);
|
|
root.gpuVramCheckIndex = 0;
|
|
checkNextGpuVram();
|
|
}
|
|
return;
|
|
}
|
|
|
|
gpuTempNameReader.path = `/sys/class/hwmon/hwmon${currentIndex}/name`;
|
|
gpuTempNameReader.reload();
|
|
}
|
|
|
|
onLoaded: {
|
|
const name = text().trim();
|
|
if (root.supportedTempGpuSensorNames.includes(name)) {
|
|
// Collect this GPU sensor, don't stop - continue scanning for more
|
|
const hwmonPath = `/sys/class/hwmon/hwmon${currentIndex}`;
|
|
const gpuType = name === "amdgpu" ? "amd" : "intel";
|
|
root.foundGpuSensors.push({
|
|
"hwmonPath": hwmonPath,
|
|
"type": gpuType,
|
|
"hasDedicatedVram": false // Will be checked later for AMD
|
|
});
|
|
Logger.d("SystemStat", `Found ${name} GPU sensor at ${hwmonPath}`);
|
|
}
|
|
// Continue scanning regardless of whether we found a match
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
checkNext();
|
|
});
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
currentIndex++;
|
|
Qt.callLater(() => {
|
|
checkNext();
|
|
});
|
|
}
|
|
}
|
|
|
|
// ----
|
|
// #2 - Read GPU sensor value (AMD/Intel via sysfs)
|
|
FileView {
|
|
id: gpuTempReader
|
|
printErrors: false
|
|
|
|
onLoaded: {
|
|
const data = text().trim();
|
|
root.gpuTemp = Math.round(parseInt(data) / 1000.0);
|
|
root.pushGpuHistory();
|
|
}
|
|
}
|
|
|
|
// ----
|
|
// #3 - Check if nvidia-smi is available (for NVIDIA GPUs)
|
|
Process {
|
|
id: nvidiaSmiCheck
|
|
command: ["sh", "-c", "command -v nvidia-smi"]
|
|
running: false
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (text.trim().length > 0) {
|
|
// Add NVIDIA as a GPU option (always discrete, highest priority)
|
|
root.foundGpuSensors.push({
|
|
"hwmonPath": "",
|
|
"type": "nvidia",
|
|
"hasDedicatedVram": true // NVIDIA is always discrete
|
|
});
|
|
Logger.d("SystemStat", "Found NVIDIA GPU (nvidia-smi available)");
|
|
}
|
|
// After NVIDIA check, check VRAM for AMD GPUs to distinguish dGPU from iGPU
|
|
root.gpuVramCheckIndex = 0;
|
|
checkNextGpuVram();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----
|
|
// #4 - Check VRAM for AMD GPUs to distinguish dGPU from iGPU
|
|
// dGPUs have dedicated VRAM, iGPUs don't (use system RAM)
|
|
FileView {
|
|
id: gpuVramChecker
|
|
printErrors: false
|
|
|
|
onLoaded: {
|
|
// File exists and has content = dGPU with dedicated VRAM
|
|
const vramSize = parseInt(text().trim());
|
|
if (vramSize > 0) {
|
|
root.foundGpuSensors[root.gpuVramCheckIndex].hasDedicatedVram = true;
|
|
Logger.d("SystemStat", `GPU at ${root.foundGpuSensors[root.gpuVramCheckIndex].hwmonPath} has dedicated VRAM (dGPU)`);
|
|
}
|
|
root.gpuVramCheckIndex++;
|
|
Qt.callLater(() => {
|
|
checkNextGpuVram();
|
|
});
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
// File doesn't exist = iGPU (no dedicated VRAM)
|
|
// hasDedicatedVram is already false by default
|
|
root.gpuVramCheckIndex++;
|
|
Qt.callLater(() => {
|
|
checkNextGpuVram();
|
|
});
|
|
}
|
|
}
|
|
|
|
// ----
|
|
// #4 - Read GPU temperature via nvidia-smi (NVIDIA only)
|
|
Process {
|
|
id: nvidiaTempProcess
|
|
command: ["nvidia-smi", "--query-gpu=temperature.gpu", "--format=csv,noheader,nounits"]
|
|
running: false
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
const temp = parseInt(text.trim());
|
|
if (!isNaN(temp)) {
|
|
root.gpuTemp = temp;
|
|
root.pushGpuHistory();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// -------------------------------------------------------
|
|
// Parse ZFS ARC stats from /proc/spl/kstat/zfs/arcstats
|
|
function parseZfsArcStats(text) {
|
|
if (!text)
|
|
return;
|
|
const lines = text.split('\n');
|
|
|
|
// The file format is: name type data
|
|
// We need to find the lines with "size" and "c_min" and extract the values (third column)
|
|
let foundSize = false;
|
|
let foundCmin = false;
|
|
|
|
for (const line of lines) {
|
|
const parts = line.trim().split(/\s+/);
|
|
if (parts.length >= 3) {
|
|
if (parts[0] === 'size') {
|
|
// The value is in bytes, convert to KB
|
|
const arcSizeBytes = parseInt(parts[2]) || 0;
|
|
root.zfsArcSizeKb = Math.floor(arcSizeBytes / 1024);
|
|
foundSize = true;
|
|
} else if (parts[0] === 'c_min') {
|
|
// The value is in bytes, convert to KB
|
|
const arcCminBytes = parseInt(parts[2]) || 0;
|
|
root.zfsArcCminKb = Math.floor(arcCminBytes / 1024);
|
|
foundCmin = true;
|
|
}
|
|
|
|
// If we found both, we can return early
|
|
if (foundSize && foundCmin) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If fields not found, set to 0
|
|
if (!foundSize) {
|
|
root.zfsArcSizeKb = 0;
|
|
}
|
|
if (!foundCmin) {
|
|
root.zfsArcCminKb = 0;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Parse load average from /proc/loadavg
|
|
function parseLoadAverage(text) {
|
|
if (!text)
|
|
return;
|
|
const parts = text.trim().split(/\s+/);
|
|
if (parts.length >= 3) {
|
|
root.loadAvg1 = parseFloat(parts[0]);
|
|
root.loadAvg5 = parseFloat(parts[1]);
|
|
root.loadAvg15 = parseFloat(parts[2]);
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Parse memory info from /proc/meminfo
|
|
function parseMemoryInfo(text) {
|
|
if (!text)
|
|
return;
|
|
const lines = text.split('\n');
|
|
let memTotal = 0;
|
|
let memAvailable = 0;
|
|
let swapTotal = 0;
|
|
let swapFree = 0;
|
|
|
|
for (const line of lines) {
|
|
if (line.startsWith('MemTotal:')) {
|
|
memTotal = parseInt(line.split(/\s+/)[1]) || 0;
|
|
} else if (line.startsWith('MemAvailable:')) {
|
|
memAvailable = parseInt(line.split(/\s+/)[1]) || 0;
|
|
} else if (line.startsWith('SwapTotal:')) {
|
|
swapTotal = parseInt(line.split(/\s+/)[1]) || 0;
|
|
} else if (line.startsWith('SwapFree:')) {
|
|
swapFree = parseInt(line.split(/\s+/)[1]) || 0;
|
|
}
|
|
}
|
|
|
|
if (memTotal > 0) {
|
|
// Calculate usage, adjusting for ZFS ARC cache if present
|
|
let usageKb = memTotal - memAvailable;
|
|
if (root.zfsArcSizeKb > 0) {
|
|
usageKb = Math.max(0, usageKb - root.zfsArcSizeKb + root.zfsArcCminKb);
|
|
}
|
|
root.memGb = (usageKb / 1048576).toFixed(1); // 1024*1024 = 1048576
|
|
root.memPercent = Math.round((usageKb / memTotal) * 100);
|
|
root.memTotalGb = (memTotal / 1048576).toFixed(1);
|
|
root.pushMemHistory();
|
|
}
|
|
|
|
// Swap usage
|
|
root.swapTotalGb = (swapTotal / 1048576).toFixed(1);
|
|
if (swapTotal > 0) {
|
|
const swapUsedKb = swapTotal - swapFree;
|
|
root.swapGb = (swapUsedKb / 1048576).toFixed(1);
|
|
root.swapPercent = Math.round((swapUsedKb / swapTotal) * 100);
|
|
} else {
|
|
root.swapGb = 0;
|
|
root.swapPercent = 0;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Calculate CPU usage from /proc/stat
|
|
|
|
function calculateLineUsage(line) {
|
|
const parts = line.split(/\s+/);
|
|
const stats = {
|
|
"user": parseInt(parts[1]) || 0,
|
|
"nice": parseInt(parts[2]) || 0,
|
|
"system": parseInt(parts[3]) || 0,
|
|
"idle": parseInt(parts[4]) || 0,
|
|
"iowait": parseInt(parts[5]) || 0,
|
|
"irq": parseInt(parts[6]) || 0,
|
|
"softirq": parseInt(parts[7]) || 0,
|
|
"steal": parseInt(parts[8]) || 0,
|
|
"guest": parseInt(parts[9]) || 0,
|
|
"guestNice": parseInt(parts[10]) || 0
|
|
};
|
|
return stats;
|
|
}
|
|
|
|
function computeUsage(prev, curr) {
|
|
if (!prev || !curr)
|
|
return -1;
|
|
const currTotalIdle = curr.idle + curr.iowait;
|
|
const currTotal = Object.values(curr).reduce((sum, val) => sum + val, 0);
|
|
const prevTotalIdle = prev.idle + prev.iowait;
|
|
const prevTotal = Object.values(prev).reduce((sum, val) => sum + val, 0);
|
|
|
|
const diffTotal = currTotal - prevTotal;
|
|
const diffIdle = currTotalIdle - prevTotalIdle;
|
|
if (diffTotal > 0) {
|
|
return (((diffTotal - diffIdle) / diffTotal) * 100).toFixed(1);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function calculateCpuUsage(text) {
|
|
if (!text)
|
|
return;
|
|
const lines = text.split('\n');
|
|
const cpuLine = lines[0];
|
|
|
|
// First line is total CPU
|
|
if (!cpuLine.startsWith('cpu '))
|
|
return;
|
|
|
|
const currCpuStats = calculateLineUsage(cpuLine);
|
|
const usage = computeUsage(root.prevCpuStats, currCpuStats);
|
|
|
|
if (usage >= 0) {
|
|
root.cpuUsage = usage;
|
|
root.pushCpuHistory();
|
|
}
|
|
root.prevCpuStats = currCpuStats;
|
|
|
|
// Find the number of CPU cores
|
|
let nbCores = 0;
|
|
for (let i = 1; i < lines.length; i++) {
|
|
if (!lines[i].startsWith('cpu'))
|
|
break;
|
|
nbCores++;
|
|
}
|
|
|
|
// Fallback if we did not find any cores
|
|
if (nbCores === 0)
|
|
return;
|
|
|
|
// If we found more cores than before, we reset our stats
|
|
if (root.coresUsage.length < nbCores)
|
|
root.coresUsage = new Array(nbCores).fill(0);
|
|
|
|
let coresStats = [];
|
|
let newCoresUsage = root.coresUsage.slice();
|
|
for (let i = 0; i < nbCores; i++) {
|
|
const coreCpuLine = lines[i + 1];
|
|
const currCoreStats = calculateLineUsage(coreCpuLine);
|
|
const coreUsage = computeUsage(root.prevCpuCoresStats?.[i], currCoreStats);
|
|
if (coreUsage >= 0) {
|
|
newCoresUsage[i] = coreUsage;
|
|
}
|
|
coresStats.push(currCoreStats);
|
|
}
|
|
root.coresUsage = newCoresUsage;
|
|
root.prevCpuCoresStats = coresStats;
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Check whether a network interface is virtual/tunnel/bridge.
|
|
// Only physical interfaces (eth*, en*, wl*, ww*) are kept so
|
|
// that traffic routed through VPNs, Docker bridges, etc. is
|
|
// not double-counted.
|
|
readonly property var _virtualPrefixes: ["lo", "docker", "veth", "br-", "virbr", "vnet", "tun", "tap", "wg", "tailscale", "nordlynx", "proton", "mullvad", "flannel", "cni", "cali", "vxlan", "genev", "gre", "sit", "ip6tnl", "dummy", "ifb", "nlmon", "bond"]
|
|
|
|
function isVirtualInterface(name) {
|
|
for (let i = 0; i < _virtualPrefixes.length; ++i) {
|
|
if (name.startsWith(_virtualPrefixes[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Calculate RX and TX speed from /proc/net/dev
|
|
// Sums speeds of all physical interfaces
|
|
function calculateNetworkSpeed(text) {
|
|
if (!text) {
|
|
return;
|
|
}
|
|
|
|
const currentTime = Date.now() / 1000;
|
|
const lines = text.split('\n');
|
|
|
|
let totalRx = 0;
|
|
let totalTx = 0;
|
|
|
|
for (var i = 2; i < lines.length; i++) {
|
|
const line = lines[i].trim();
|
|
if (!line) {
|
|
continue;
|
|
}
|
|
|
|
const colonIndex = line.indexOf(':');
|
|
if (colonIndex === -1) {
|
|
continue;
|
|
}
|
|
|
|
const iface = line.substring(0, colonIndex).trim();
|
|
if (isVirtualInterface(iface)) {
|
|
continue;
|
|
}
|
|
|
|
const statsLine = line.substring(colonIndex + 1).trim();
|
|
const stats = statsLine.split(/\s+/);
|
|
|
|
const rxBytes = parseInt(stats[0], 10) || 0;
|
|
const txBytes = parseInt(stats[8], 10) || 0;
|
|
|
|
totalRx += rxBytes;
|
|
totalTx += txBytes;
|
|
}
|
|
|
|
// Compute only if we have a previous run to compare to.
|
|
if (root.prevTime > 0) {
|
|
const timeDiff = currentTime - root.prevTime;
|
|
|
|
// Avoid division by zero if time hasn't passed.
|
|
if (timeDiff > 0) {
|
|
let rxDiff = totalRx - root.prevRxBytes;
|
|
let txDiff = totalTx - root.prevTxBytes;
|
|
|
|
// Handle counter resets (e.g., WiFi reconnect), which would cause a negative value.
|
|
if (rxDiff < 0) {
|
|
rxDiff = 0;
|
|
}
|
|
if (txDiff < 0) {
|
|
txDiff = 0;
|
|
}
|
|
|
|
root.rxSpeed = Math.round(rxDiff / timeDiff); // Speed in Bytes/s
|
|
root.txSpeed = Math.round(txDiff / timeDiff);
|
|
}
|
|
}
|
|
|
|
root.prevRxBytes = totalRx;
|
|
root.prevTxBytes = totalTx;
|
|
root.prevTime = currentTime;
|
|
|
|
// Update network history after speeds are computed
|
|
root.pushNetworkHistory();
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Helper function to format network speeds
|
|
function formatSpeed(bytesPerSecond) {
|
|
const units = ["KB", "MB", "GB"];
|
|
let value = bytesPerSecond / 1000;
|
|
let unitIndex = 0;
|
|
|
|
while (value >= 1000 && unitIndex < units.length - 1) {
|
|
value /= 1000;
|
|
unitIndex++;
|
|
}
|
|
|
|
const unit = units[unitIndex];
|
|
const shortUnit = unit[0];
|
|
const numStr = value < 10 ? value.toFixed(1) : Math.round(value).toString();
|
|
|
|
return (numStr + unit).length > 5 ? numStr + shortUnit : numStr + unit;
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Compact speed formatter for vertical bar display
|
|
function formatCompactSpeed(bytesPerSecond) {
|
|
if (!bytesPerSecond || bytesPerSecond <= 0)
|
|
return "0";
|
|
const units = ["", "K", "M", "G"];
|
|
let value = bytesPerSecond;
|
|
let unitIndex = 0;
|
|
while (value >= 1000 && unitIndex < units.length - 1) {
|
|
value = value / 1000.0;
|
|
unitIndex++;
|
|
}
|
|
// Promote at ~100 of current unit (e.g., 100k -> ~0.1M shown as 0.1M or 0M if rounded)
|
|
if (unitIndex < units.length - 1 && value >= 100) {
|
|
value = value / 1000.0;
|
|
unitIndex++;
|
|
}
|
|
const display = Math.round(value).toString();
|
|
return display + units[unitIndex];
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Smart formatter for memory values (GB) - max 4 chars
|
|
// Uses decimal for < 10GB, integer otherwise
|
|
function formatGigabytes(memGb) {
|
|
const value = parseFloat(memGb);
|
|
if (isNaN(value))
|
|
return "0G";
|
|
|
|
if (value < 10)
|
|
return value.toFixed(1) + "G"; // "0.0G" to "9.9G"
|
|
return Math.round(value) + "G"; // "10G" to "999G"
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Formatting gigabytes with optional padding
|
|
function formatGigabytesDisplay(memGb, maxGb = null) {
|
|
const value = formatGigabytes(memGb === null ? 0 : memGb);
|
|
if (maxGb !== null) {
|
|
const padding = Math.max(4, formatGigabytes(maxGb).length);
|
|
return value.padStart(padding, " ");
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Formatting percentage with optional padding
|
|
function formatPercentageDisplay(value, padding = false) {
|
|
return `${Math.round(value === null ? 0 : value)}%`.padStart(padding ? 4 : 0, " ");
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Formatting disk usage
|
|
function formatDiskDisplay(diskPath, {
|
|
percent = false,
|
|
available = false,
|
|
padding = false
|
|
} = {}) {
|
|
if (percent) {
|
|
const raw = available ? root.diskAvailPercents[diskPath] : root.diskPercents[diskPath];
|
|
return formatPercentageDisplay(raw, padding);
|
|
} else {
|
|
const rawGb = available ? root.diskAvailableGb[diskPath] : root.diskUsedGb[diskPath];
|
|
const maxGb = padding ? root.diskSizeGb[diskPath] : null;
|
|
return formatGigabytesDisplay(rawGb, maxGb);
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Formatting ram usage
|
|
function formatRamDisplay({
|
|
swap = false,
|
|
percent = false,
|
|
padding = false
|
|
} = {}) {
|
|
if (percent) {
|
|
const raw = swap ? swapPercent : memPercent;
|
|
return formatPercentageDisplay(raw, padding);
|
|
} else {
|
|
const rawGb = swap ? swapGb : memGb;
|
|
const maxGb = padding ? (swap ? swapTotalGb : memTotalGb) : null;
|
|
return formatGigabytesDisplay(rawGb, maxGb);
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Function to start fetching and computing the cpu temperature
|
|
function updateCpuTemperature() {
|
|
// For AMD sensors (k10temp and zenpower), only use Tctl sensor
|
|
// temp1_input corresponds to Tctl (Temperature Control) on these sensors
|
|
if (root.cpuTempSensorName === "k10temp" || root.cpuTempSensorName === "zenpower") {
|
|
cpuTempReader.path = `${root.cpuTempHwmonPath}/temp1_input`;
|
|
cpuTempReader.reload();
|
|
} // For Intel coretemp, start averaging all available sensors/cores
|
|
else if (root.cpuTempSensorName === "coretemp") {
|
|
root.intelTempValues = [];
|
|
root.intelTempFilesChecked = 0;
|
|
checkNextIntelTemp();
|
|
} // For thermal_zone fallback (ARM SoCs, SCMI, etc.), read all CPU zones and take max
|
|
else if (root.cpuTempSensorName === "thermal_zone") {
|
|
cpuThermalZoneReader.currentZoneIndex = 0;
|
|
cpuThermalZoneReader.collectedTemps = [];
|
|
readNextCpuThermalZone();
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Function to check next Intel temperature sensor
|
|
function checkNextIntelTemp() {
|
|
if (root.intelTempFilesChecked >= root.intelTempMaxFiles) {
|
|
// Calculate average of all found temperatures
|
|
if (root.intelTempValues.length > 0) {
|
|
let sum = 0;
|
|
for (var i = 0; i < root.intelTempValues.length; i++) {
|
|
sum += root.intelTempValues[i];
|
|
}
|
|
root.cpuTemp = Math.round(sum / root.intelTempValues.length);
|
|
root.pushCpuTempHistory();
|
|
//Logger.i("SystemStat", `Averaged ${root.intelTempValues.length} CPU thermal sensors: ${root.cpuTemp}°C`)
|
|
} else {
|
|
Logger.w("SystemStat", "No temperature sensors found for coretemp");
|
|
root.cpuTemp = 0;
|
|
root.pushCpuTempHistory();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Check next temperature file
|
|
root.intelTempFilesChecked++;
|
|
cpuTempReader.path = `${root.cpuTempHwmonPath}/temp${root.intelTempFilesChecked}_input`;
|
|
cpuTempReader.reload();
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Function to check VRAM for each AMD GPU to determine if it's a dGPU
|
|
function checkNextGpuVram() {
|
|
// Skip non-AMD GPUs (NVIDIA and Intel Arc are always discrete)
|
|
while (root.gpuVramCheckIndex < root.foundGpuSensors.length) {
|
|
const gpu = root.foundGpuSensors[root.gpuVramCheckIndex];
|
|
if (gpu.type === "amd") {
|
|
// Check for dedicated VRAM at hwmonPath/device/mem_info_vram_total
|
|
gpuVramChecker.path = `${gpu.hwmonPath}/device/mem_info_vram_total`;
|
|
gpuVramChecker.reload();
|
|
return;
|
|
}
|
|
// Skip non-AMD GPUs
|
|
root.gpuVramCheckIndex++;
|
|
}
|
|
|
|
// All VRAM checks complete, now select the best GPU
|
|
selectBestGpu();
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Function to select the best GPU based on priority
|
|
// Priority (when dGPU monitoring enabled): NVIDIA > AMD dGPU > Intel Arc > AMD iGPU
|
|
// Priority (when dGPU monitoring disabled): AMD iGPU only (discrete GPUs skipped to preserve D3cold)
|
|
function selectBestGpu() {
|
|
const dgpuEnabled = Settings.data.systemMonitor.enableDgpuMonitoring;
|
|
|
|
if (root.foundGpuSensors.length === 0) {
|
|
// No hwmon GPU sensors found, try thermal_zone fallback
|
|
if (dgpuEnabled && root.gpuThermalZonePath === "" && root.gpuThermalZonePaths.length === 0) {
|
|
// Thermal zone scanner hasn't found GPU zones yet; start a scan
|
|
thermalZoneScanner.startScan();
|
|
}
|
|
return;
|
|
}
|
|
|
|
let best = null;
|
|
|
|
for (var i = 0; i < root.foundGpuSensors.length; i++) {
|
|
const gpu = root.foundGpuSensors[i];
|
|
|
|
// NVIDIA is always highest priority (always discrete) - skip if dGPU monitoring disabled
|
|
if (gpu.type === "nvidia") {
|
|
if (dgpuEnabled) {
|
|
best = gpu;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// AMD dGPU is second priority - skip if dGPU monitoring disabled (preserves D3cold power state)
|
|
if (gpu.type === "amd" && gpu.hasDedicatedVram) {
|
|
if (dgpuEnabled) {
|
|
best = gpu;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Intel Arc is third priority (always discrete) - skip if dGPU monitoring disabled
|
|
if (gpu.type === "intel" && !best) {
|
|
if (dgpuEnabled) {
|
|
best = gpu;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// AMD iGPU is lowest priority (fallback) - always allowed (no D3cold issue)
|
|
if (gpu.type === "amd" && !gpu.hasDedicatedVram && !best) {
|
|
best = gpu;
|
|
}
|
|
}
|
|
|
|
if (best) {
|
|
root.gpuTempHwmonPath = best.hwmonPath;
|
|
root.gpuType = best.type;
|
|
root.gpuAvailable = true;
|
|
|
|
const gpuDesc = best.type === "nvidia" ? "NVIDIA" : (best.type === "intel" ? "Intel Arc" : (best.hasDedicatedVram ? "AMD dGPU" : "AMD iGPU"));
|
|
Logger.i("SystemStat", `Selected ${gpuDesc} for temperature monitoring at ${best.hwmonPath || "nvidia-smi"}`);
|
|
} else if (!dgpuEnabled) {
|
|
Logger.d("SystemStat", "No iGPU found and dGPU monitoring is disabled");
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// Function to update GPU temperature
|
|
function updateGpuTemperature() {
|
|
if (root.gpuType === "nvidia") {
|
|
nvidiaTempProcess.running = true;
|
|
} else if (root.gpuType === "amd" || root.gpuType === "intel") {
|
|
gpuTempReader.path = `${root.gpuTempHwmonPath}/temp1_input`;
|
|
gpuTempReader.reload();
|
|
} else if (root.gpuType === "thermal_zone") {
|
|
if (root.gpuThermalZonePaths && root.gpuThermalZonePaths.length > 0) {
|
|
// Multiple GPU zones (no gpu-avg), read all and take max
|
|
gpuThermalZoneReader.currentZoneIndex = 0;
|
|
gpuThermalZoneReader.collectedTemps = [];
|
|
readNextGpuThermalZone();
|
|
} else {
|
|
// Single gpu-avg-thermal zone
|
|
gpuThermalZoneReader.path = root.gpuThermalZonePath;
|
|
gpuThermalZoneReader.reload();
|
|
}
|
|
}
|
|
}
|
|
}
|