add INTEL_GPU_DEVICE env var (#1285)

agent/cpu.go

@@ -8,7 +8,6 @@ import (
 )
 
 var lastCpuTimes = make(map[uint16]cpu.TimesStat)
-var lastPerCoreCpuTimes = make(map[uint16][]cpu.TimesStat)
 
 // init initializes the CPU monitoring by storing the initial CPU times
 // for the default 60-second cache interval.
@@ -16,18 +15,6 @@ func init() {
 	if times, err := cpu.Times(false); err == nil {
 		lastCpuTimes[60000] = times[0]
 	}
-	if perCoreTimes, err := cpu.Times(true); err == nil {
-		lastPerCoreCpuTimes[60000] = perCoreTimes
-	}
-}
-
-// CpuMetrics contains detailed CPU usage breakdown
-type CpuMetrics struct {
-	Total  float64
-	User   float64
-	System float64
-	Iowait float64
-	Steal  float64
 }
 
 // getCpuPercent calculates the CPU usage percentage using cached previous measurements.
@@ -47,92 +34,6 @@ func getCpuPercent(cacheTimeMs uint16) (float64, error) {
 	return delta, nil
 }
 
-// getCpuMetrics calculates detailed CPU usage metrics using cached previous measurements.
-// It returns percentages for total, user, system, iowait, and steal time.
-func getCpuMetrics(cacheTimeMs uint16) (CpuMetrics, error) {
-	times, err := cpu.Times(false)
-	if err != nil || len(times) == 0 {
-		return CpuMetrics{}, err
-	}
-	// if cacheTimeMs is not in lastCpuTimes, use 60000 as fallback lastCpuTime
-	if _, ok := lastCpuTimes[cacheTimeMs]; !ok {
-		lastCpuTimes[cacheTimeMs] = lastCpuTimes[60000]
-	}
-
-	t1 := lastCpuTimes[cacheTimeMs]
-	t2 := times[0]
-
-	t1All, t1Busy := getAllBusy(t1)
-	t2All, t2Busy := getAllBusy(t2)
-
-	totalDelta := t2All - t1All
-	if totalDelta <= 0 {
-		return CpuMetrics{}, nil
-	}
-
-	metrics := CpuMetrics{
-		Total:  clampPercent((t2Busy - t1Busy) / totalDelta * 100),
-		User:   clampPercent((t2.User - t1.User) / totalDelta * 100),
-		System: clampPercent((t2.System - t1.System) / totalDelta * 100),
-		Iowait: clampPercent((t2.Iowait - t1.Iowait) / totalDelta * 100),
-		Steal:  clampPercent((t2.Steal - t1.Steal) / totalDelta * 100),
-	}
-
-	lastCpuTimes[cacheTimeMs] = times[0]
-	return metrics, nil
-}
-
-// clampPercent ensures the percentage is between 0 and 100
-func clampPercent(value float64) float64 {
-	return math.Min(100, math.Max(0, value))
-}
-
-// getPerCoreCpuMetrics calculates per-core CPU usage metrics.
-// Returns a map where the key is "cpu0", "cpu1", etc. and the value is an array of [user, system, iowait, steal] percentages.
-func getPerCoreCpuMetrics(cacheTimeMs uint16) (map[string][4]float64, error) {
-	perCoreTimes, err := cpu.Times(true)
-	if err != nil || len(perCoreTimes) == 0 {
-		return nil, err
-	}
-
-	// Initialize cache if needed
-	if _, ok := lastPerCoreCpuTimes[cacheTimeMs]; !ok {
-		lastPerCoreCpuTimes[cacheTimeMs] = lastPerCoreCpuTimes[60000]
-	}
-
-	lastTimes := lastPerCoreCpuTimes[cacheTimeMs]
-	result := make(map[string][4]float64)
-
-	// Calculate metrics for each core
-	for i, currentTime := range perCoreTimes {
-		if i >= len(lastTimes) {
-			break
-		}
-
-		t1 := lastTimes[i]
-		t2 := currentTime
-
-		t1All, _ := getAllBusy(t1)
-		t2All, _ := getAllBusy(t2)
-
-		totalDelta := t2All - t1All
-		if totalDelta <= 0 {
-			continue
-		}
-
-		// Store as [user, system, iowait, steal]
-		result[currentTime.CPU] = [4]float64{
-			clampPercent((t2.User - t1.User) / totalDelta * 100),
-			clampPercent((t2.System - t1.System) / totalDelta * 100),
-			clampPercent((t2.Iowait - t1.Iowait) / totalDelta * 100),
-			clampPercent((t2.Steal - t1.Steal) / totalDelta * 100),
-		}
-	}
-
-	lastPerCoreCpuTimes[cacheTimeMs] = perCoreTimes
-	return result, nil
-}
-
 // calculateBusy calculates the CPU busy percentage between two time points.
 // It computes the ratio of busy time to total time elapsed between t1 and t2,
 // returning a percentage clamped between 0 and 100.

agent/gpu_intel.go

@@ -49,7 +49,12 @@ func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {
 
 // collectIntelStats executes intel_gpu_top in text mode (-l) and parses the output
 func (gm *GPUManager) collectIntelStats() (err error) {
-	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-l")
+	// Build command arguments, optionally selecting a device via -d
+	args := []string{"-s", intelGpuStatsInterval, "-l"}
+	if dev, ok := GetEnv("INTEL_GPU_DEVICE"); ok && dev != "" {
+		args = append(args, "-d", dev)
+	}
+	cmd := exec.Command(intelGpuStatsCmd, args...)
 	// Avoid blocking if intel_gpu_top writes to stderr
 	cmd.Stderr = io.Discard
 	stdout, err := cmd.StdoutPipe()

agent/gpu_test.go

@@ -4,8 +4,10 @@
 package agent
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -1624,3 +1626,42 @@ func TestParseIntelData(t *testing.T) {
 		})
 	}
 }
+
+func TestIntelCollectorDeviceEnv(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("PATH", dir)
+
+	// Prepare a file to capture args
+	argsFile := filepath.Join(dir, "args.txt")
+
+	// Create a fake intel_gpu_top that records its arguments and prints minimal valid output
+	scriptPath := filepath.Join(dir, "intel_gpu_top")
+	script := fmt.Sprintf(`#!/bin/sh
+echo "$@" > %s
+echo "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS             VCS"
+echo " req  act       /s   %%   gpu   pkg     rd     wr       %%  se  wa       %%  se  wa"
+echo "226  223      338  58  2.00  2.69   1820    965   0.00    0   0    0.00   0   0"
+echo "189  187      412  67  1.80  2.45   1950    823   8.50    2   1    15.00   1   0"
+`, argsFile)
+	if err := os.WriteFile(scriptPath, []byte(script), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	// Set device selector via prefixed env var
+	t.Setenv("BESZEL_AGENT_INTEL_GPU_DEVICE", "sriov")
+
+	gm := &GPUManager{GpuDataMap: make(map[string]*system.GPUData)}
+	if err := gm.collectIntelStats(); err != nil {
+		t.Fatalf("collectIntelStats error: %v", err)
+	}
+
+	// Verify that -d sriov was passed
+	data, err := os.ReadFile(argsFile)
+	if err != nil {
+		t.Fatalf("failed reading args file: %v", err)
+	}
+	argsStr := strings.TrimSpace(string(data))
+	require.Contains(t, argsStr, "-d sriov")
+	require.Contains(t, argsStr, "-s ")
+	require.Contains(t, argsStr, "-l")
+}

agent/system.go

@@ -83,21 +83,12 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		systemStats.Battery[1] = batteryState
 	}
 
-	// cpu metrics
-	cpuMetrics, err := getCpuMetrics(cacheTimeMs)
+	// cpu percent
+	cpuPercent, err := getCpuPercent(cacheTimeMs)
 	if err == nil {
-		systemStats.Cpu = twoDecimals(cpuMetrics.Total)
-		systemStats.CpuUser = twoDecimals(cpuMetrics.User)
-		systemStats.CpuSystem = twoDecimals(cpuMetrics.System)
-		systemStats.CpuIowait = twoDecimals(cpuMetrics.Iowait)
-		systemStats.CpuSteal = twoDecimals(cpuMetrics.Steal)
+		systemStats.Cpu = twoDecimals(cpuPercent)
 	} else {
-		slog.Error("Error getting cpu metrics", "err", err)
-	}
-
-	// per-core cpu metrics
-	if perCoreCpuMetrics, err := getPerCoreCpuMetrics(cacheTimeMs); err == nil && len(perCoreCpuMetrics) > 0 {
-		systemStats.CpuCores = perCoreCpuMetrics
+		slog.Error("Error getting cpu percent", "err", err)
 	}
 
 	// load average

internal/entities/system/system.go

@@ -11,12 +11,7 @@ import (
 type Stats struct {
 	Cpu            float64             `json:"cpu" cbor:"0,keyasint"`
 	MaxCpu         float64             `json:"cpum,omitempty" cbor:"1,keyasint,omitempty"`
-	CpuUser        float64                `json:"cpuu,omitempty" cbor:"33,keyasint,omitempty"`
-	CpuSystem      float64                `json:"cpus,omitempty" cbor:"34,keyasint,omitempty"`
-	CpuIowait      float64                `json:"cpui,omitempty" cbor:"35,keyasint,omitempty"`
-	CpuSteal       float64                `json:"cpust,omitempty" cbor:"36,keyasint,omitempty"`
-	CpuCores       map[string][4]float64  `json:"cpuc,omitempty" cbor:"37,keyasint,omitempty"` // [user, system, iowait, steal] per core
-	Mem            float64                `json:"m" cbor:"2,keyasint"`
+	Mem            float64             `json:"m" cbor:"2,keyasint"`
 	MemUsed        float64             `json:"mu" cbor:"3,keyasint"`
 	MemPct         float64             `json:"mp" cbor:"4,keyasint"`
 	MemBuffCache   float64             `json:"mb" cbor:"5,keyasint"`

internal/site/src/components/charts/hooks.ts

@@ -118,28 +118,6 @@ export function useNetworkInterfaces(interfaces: SystemStats["ni"]) {
 				dataKey: ({ stats }: SystemStatsRecord) => stats?.ni?.[key]?.[index],
 				color: `hsl(${220 + (((sortedKeys.indexOf(key) * 360) / sortedKeys.length) % 360)}, 70%, 50%)`,
 
-				opacity: 0.3,
-			}))
-		},
-	}
-}
-
-// Assures consistent colors for CPU cores
-export function useCpuCores(cores: SystemStats["cpuc"]) {
-	const keys = Object.keys(cores ?? {})
-	// Sort cores by name (cpu0, cpu1, cpu2, etc.)
-	const sortedKeys = keys.sort((a, b) => {
-		const numA = Number.parseInt(a.replace("cpu", ""))
-		const numB = Number.parseInt(b.replace("cpu", ""))
-		return numA - numB
-	})
-	return {
-		length: sortedKeys.length,
-		data: (index = 0) => {
-			return sortedKeys.map((key) => ({
-				label: key,
-				dataKey: ({ stats }: SystemStatsRecord) => stats?.cpuc?.[key]?.[index],
-				color: `hsl(${(((sortedKeys.indexOf(key) * 360) / sortedKeys.length) % 360)}, 70%, 50%)`,
 				opacity: 0.3,
 			}))
 		},

internal/site/src/components/routes/system.tsx

@@ -73,7 +73,6 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from ".
 import { Separator } from "../ui/separator"
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../ui/tooltip"
 import NetworkSheet from "./system/network-sheet"
-import CpuCoresSheet from "./system/cpu-cores-sheet"
 import LineChartDefault from "../charts/line-chart"
 
 
@@ -586,49 +585,18 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 						grid={grid}
 						title={t`CPU Usage`}
 						description={t`Average system-wide CPU utilization`}
-						cornerEl={
-							<>
-								{maxValSelect}
-								<CpuCoresSheet chartData={chartData} dataEmpty={dataEmpty} grid={grid} maxValues={maxValues} />
-							</>
-						}
-						legend={true}
+						cornerEl={maxValSelect}
 					>
 						<AreaChartDefault
 							chartData={chartData}
 							maxToggled={maxValues}
-							legend={true}
 							dataPoints={[
 								{
-									label: t`Total`,
+									label: t`CPU Usage`,
 									dataKey: ({ stats }) => (showMax ? stats?.cpum : stats?.cpu),
 									color: 1,
 									opacity: 0.4,
 								},
-								{
-									label: t`User`,
-									dataKey: ({ stats }) => stats?.cpuu,
-									color: 2,
-									opacity: 0.3,
-								},
-								{
-									label: t`System`,
-									dataKey: ({ stats }) => stats?.cpus,
-									color: 3,
-									opacity: 0.3,
-								},
-								{
-									label: t`IOWait`,
-									dataKey: ({ stats }) => stats?.cpui,
-									color: 4,
-									opacity: 0.3,
-								},
-								{
-									label: t`Steal`,
-									dataKey: ({ stats }) => stats?.cpust,
-									color: 5,
-									opacity: 0.3,
-								},
 							]}
 							tickFormatter={(val) => `${toFixedFloat(val, 2)}%`}
 							contentFormatter={({ value }) => `${decimalString(value)}%`}

internal/site/src/components/routes/system/cpu-cores-sheet.tsx

@@ -1,119 +0,0 @@
-import { t } from "@lingui/core/macro"
-import { MoreHorizontalIcon } from "lucide-react"
-import { memo, useRef, useState } from "react"
-import AreaChartDefault from "@/components/charts/area-chart"
-import ChartTimeSelect from "@/components/charts/chart-time-select"
-import { Button } from "@/components/ui/button"
-import { Sheet, SheetContent, SheetTrigger } from "@/components/ui/sheet"
-import { DialogTitle } from "@/components/ui/dialog"
-import { decimalString, toFixedFloat } from "@/lib/utils"
-import type { ChartData, SystemStatsRecord } from "@/types"
-import { ChartCard } from "../system"
-
-export default memo(function CpuCoresSheet({
-	chartData,
-	dataEmpty,
-	grid,
-	maxValues,
-}: {
-	chartData: ChartData
-	dataEmpty: boolean
-	grid: boolean
-	maxValues: boolean
-}) {
-	const [cpuCoresOpen, setCpuCoresOpen] = useState(false)
-	const hasOpened = useRef(false)
-
-	if (cpuCoresOpen && !hasOpened.current) {
-		hasOpened.current = true
-	}
-
-	// Get list of CPU cores from the latest stats
-	const cpuCoresData = chartData.systemStats.at(-1)?.stats?.cpuc ?? {}
-	const coreNames = Object.keys(cpuCoresData).sort((a, b) => {
-		const numA = Number.parseInt(a.replace("cpu", ""))
-		const numB = Number.parseInt(b.replace("cpu", ""))
-		return numA - numB
-	})
-
-	if (coreNames.length === 0) {
-		return null
-	}
-
-	return (
-		<Sheet open={cpuCoresOpen} onOpenChange={setCpuCoresOpen}>
-			<DialogTitle className="sr-only">{t`Per-core CPU usage`}</DialogTitle>
-			<SheetTrigger asChild>
-				<Button
-					title={t`View per-core CPU`}
-					variant="outline"
-					size="icon"
-					className="shrink-0 max-sm:absolute max-sm:top-3 max-sm:end-3"
-				>
-					<MoreHorizontalIcon />
-				</Button>
-			</SheetTrigger>
-			{hasOpened.current && (
-				<SheetContent aria-describedby={undefined} className="overflow-auto w-200 !max-w-full p-4 sm:p-6">
-					<ChartTimeSelect className="w-[calc(100%-2em)]" agentVersion={chartData.agentVersion} />
-					{coreNames.map((coreName) => (
-						<ChartCard
-							key={coreName}
-							empty={dataEmpty}
-							grid={grid}
-							title={coreName.toUpperCase()}
-							description={t`CPU usage breakdown for ${coreName}`}
-							legend={true}
-							className="min-h-auto"
-						>
-							<AreaChartDefault
-								chartData={chartData}
-								maxToggled={maxValues}
-								legend={true}
-								dataPoints={[
-									{
-										label: t`Total`,
-										dataKey: ({ stats }: SystemStatsRecord) => {
-											const core = stats?.cpuc?.[coreName]
-											if (!core) return undefined
-											// Sum all metrics: user + system + iowait + steal
-											return core[0] + core[1] + core[2] + core[3]
-										},
-										color: 1,
-										opacity: 0.4,
-									},
-									{
-										label: t`User`,
-										dataKey: ({ stats }: SystemStatsRecord) => stats?.cpuc?.[coreName]?.[0],
-										color: 2,
-										opacity: 0.3,
-									},
-									{
-										label: t`System`,
-										dataKey: ({ stats }: SystemStatsRecord) => stats?.cpuc?.[coreName]?.[1],
-										color: 3,
-										opacity: 0.3,
-									},
-									{
-										label: t`IOWait`,
-										dataKey: ({ stats }: SystemStatsRecord) => stats?.cpuc?.[coreName]?.[2],
-										color: 4,
-										opacity: 0.3,
-									},
-									{
-										label: t`Steal`,
-										dataKey: ({ stats }: SystemStatsRecord) => stats?.cpuc?.[coreName]?.[3],
-										color: 5,
-										opacity: 0.3,
-									},
-								]}
-								tickFormatter={(val) => `${toFixedFloat(val, 2)}%`}
-								contentFormatter={({ value }) => `${decimalString(value)}%`}
-							/>
-						</ChartCard>
-					))}
-				</SheetContent>
-			)}
-		</Sheet>
-	)
-})

internal/site/src/types.d.ts

@@ -84,16 +84,6 @@ export interface SystemStats {
 	cpu: number
 	/** peak cpu */
 	cpum?: number
-	/** cpu user percent */
-	cpuu?: number
-	/** cpu system percent */
-	cpus?: number
-	/** cpu iowait percent */
-	cpui?: number
-	/** cpu steal percent */
-	cpust?: number
-	/** per-core cpu metrics [user, system, iowait, steal] */
-	cpuc?: Record<string, [number, number, number, number]>
 	// TODO: remove these in future release in favor of la
 	/** load average 1 minute */
 	l1?: number

supplemental/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.15.4
+
+- Add `INTEL_GPU_DEVICE` environment variable to select Intel GPU device. (#1285)
+
 ## 0.15.3
 
 - Improve parsing of edge case S.M.A.R.T. power on times. (#1347)