Add GPU_FOREIGN_UTIL_PCT: game detection via per-process GPU 3D-engine usage
Reads the same PDH counters as Task Manager (\GPU Engine(*)\Utilization Percentage, locale-independent via PdhAddEnglishCounterW), which cover graphics work under WDDM — games are caught without an exe list and the offender is named. Windows-only; a missing or failing counter disables the path with one log line. dwm (the desktop compositor) joins the default ignore list.
This commit is contained in:
mram
+84
-30
@@ -1,8 +1,10 @@
|
||||
// Package game detects processes outside gpu-turnstile's control that hold
|
||||
// the GPU — typically a game — so the proxy can block new GPU work and free
|
||||
// VRAM while they run. Two detection paths: an explicit process watch list
|
||||
// (GAME_PROCS) and a foreign-VRAM threshold via nvidia-smi
|
||||
// (GPU_FOREIGN_VRAM_MB) that catches anything not on the ignore list.
|
||||
// VRAM while they run. Three detection paths: an explicit process watch
|
||||
// list (GAME_PROCS), a foreign-VRAM threshold via nvidia-smi
|
||||
// (GPU_FOREIGN_VRAM_MB), and a per-process GPU 3D-engine utilization
|
||||
// threshold via Windows PDH counters (GPU_FOREIGN_UTIL_PCT). The latter two
|
||||
// catch anything not on the ignore list without naming individual games.
|
||||
package game
|
||||
|
||||
import (
|
||||
@@ -11,6 +13,7 @@ import (
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"os/exec"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
@@ -28,28 +31,33 @@ type computeApp struct {
|
||||
}
|
||||
|
||||
// Detector checks whether a foreign process holds the GPU. The zero value
|
||||
// (no watch list, no threshold) never detects anything; main only starts the
|
||||
// poll loop when at least one path is configured.
|
||||
// (no watch list, no thresholds) never detects anything; main only starts
|
||||
// the poll loop when at least one path is configured.
|
||||
type Detector struct {
|
||||
procs map[string]bool // normalized names from GAME_PROCS
|
||||
vramMB int // foreign VRAM threshold; 0 = disabled
|
||||
utilPct int // foreign 3D-engine utilization threshold; 0 = disabled
|
||||
ignore map[string]bool // normalized names never counted as foreign
|
||||
log *slog.Logger
|
||||
noNvidia bool // nvidia-smi was not found; VRAM path disabled for good
|
||||
noNvidia bool // nvidia-smi was not found; VRAM path disabled for good
|
||||
sampler *gpuEngineSampler // open PDH query, opened lazily on first Check
|
||||
noPDH bool // engine counters unavailable; util path disabled for good
|
||||
}
|
||||
|
||||
// New builds a Detector from the configured watch list, VRAM threshold in
|
||||
// MiB (0 disables the nvidia-smi path) and ignore list. Names are matched
|
||||
// case-insensitively, with or without a trailing ".exe".
|
||||
func New(procs []string, vramMB int, ignore []string, log *slog.Logger) *Detector {
|
||||
// MiB, 3D-engine utilization threshold in percent (both 0 = disabled) and
|
||||
// ignore list. Names are matched case-insensitively, with or without a
|
||||
// trailing ".exe".
|
||||
func New(procs []string, vramMB, utilPct int, ignore []string, log *slog.Logger) *Detector {
|
||||
if log == nil {
|
||||
log = slog.Default()
|
||||
}
|
||||
return &Detector{
|
||||
procs: nameSet(procs),
|
||||
vramMB: vramMB,
|
||||
ignore: nameSet(ignore),
|
||||
log: log,
|
||||
procs: nameSet(procs),
|
||||
vramMB: vramMB,
|
||||
utilPct: utilPct,
|
||||
ignore: nameSet(ignore),
|
||||
log: log,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -73,34 +81,63 @@ func nameSet(names []string) map[string]bool {
|
||||
// description of each (empty when the GPU is free for gpu-turnstile's
|
||||
// consumers). A failing nvidia-smi call is returned as an error only when
|
||||
// the process list found nothing; a missing nvidia-smi binary disables the
|
||||
// VRAM path permanently (logged once).
|
||||
// VRAM path permanently (logged once), as do missing engine counters.
|
||||
func (d *Detector) Check(ctx context.Context) ([]string, error) {
|
||||
ps, psErr := processes()
|
||||
if d.vramMB <= 0 || d.noNvidia {
|
||||
return d.detect(ps, nil), psErr
|
||||
utils := d.engineUtil()
|
||||
var apps []computeApp
|
||||
if d.vramMB > 0 && !d.noNvidia {
|
||||
var err error
|
||||
apps, err = queryComputeApps(ctx)
|
||||
if errors.Is(err, exec.ErrNotFound) {
|
||||
d.noNvidia = true
|
||||
d.log.Warn("GPU_FOREIGN_VRAM_MB is set but nvidia-smi was not found; VRAM detection disabled")
|
||||
} else if err != nil {
|
||||
return d.detect(ps, nil, utils), err
|
||||
}
|
||||
}
|
||||
apps, err := queryComputeApps(ctx)
|
||||
if errors.Is(err, exec.ErrNotFound) {
|
||||
d.noNvidia = true
|
||||
d.log.Warn("GPU_FOREIGN_VRAM_MB is set but nvidia-smi was not found; VRAM detection disabled")
|
||||
return d.detect(ps, nil), nil
|
||||
}
|
||||
if err != nil {
|
||||
return d.detect(ps, nil), err
|
||||
}
|
||||
return d.detect(ps, apps), nil
|
||||
return d.detect(ps, apps, utils), psErr
|
||||
}
|
||||
|
||||
// detect is the pure core of Check: given the process table and (optionally)
|
||||
// the nvidia-smi compute-apps list, it returns the foreign holders.
|
||||
func (d *Detector) detect(ps []Process, apps []computeApp) []string {
|
||||
// engineUtil samples per-process 3D-engine utilization via PDH. The first
|
||||
// call only primes the rate counters and returns nil. A failing open or
|
||||
// sample disables the path permanently (logged once).
|
||||
func (d *Detector) engineUtil() map[int]float64 {
|
||||
if d.utilPct <= 0 || d.noPDH {
|
||||
return nil
|
||||
}
|
||||
if d.sampler == nil {
|
||||
s, err := openGPUEngineSampler()
|
||||
if err != nil {
|
||||
d.noPDH = true
|
||||
d.log.Warn("GPU_FOREIGN_UTIL_PCT is set but per-process GPU counters are unavailable; engine detection disabled", "err", err)
|
||||
return nil
|
||||
}
|
||||
d.sampler = s
|
||||
}
|
||||
utils, err := d.sampler.sample()
|
||||
if err != nil {
|
||||
if errors.Is(err, errNotPrimed) {
|
||||
return nil
|
||||
}
|
||||
d.noPDH = true
|
||||
d.log.Warn("per-process GPU counters failed; engine detection disabled", "err", err)
|
||||
return nil
|
||||
}
|
||||
return utils
|
||||
}
|
||||
|
||||
// detect is the pure core of Check: given the process table and
|
||||
// (optionally) the nvidia-smi compute-apps list and the PDH engine
|
||||
// utilization, it returns the foreign holders.
|
||||
func (d *Detector) detect(ps []Process, apps []computeApp, utils map[int]float64) []string {
|
||||
var holders []string
|
||||
for _, p := range ps {
|
||||
if d.procs[normName(p.Name)] {
|
||||
holders = append(holders, fmt.Sprintf("%s (pid %d)", p.Name, p.PID))
|
||||
}
|
||||
}
|
||||
if d.vramMB > 0 && apps != nil {
|
||||
if (d.vramMB > 0 && apps != nil) || (d.utilPct > 0 && utils != nil) {
|
||||
names := make(map[int]string, len(ps))
|
||||
for _, p := range ps {
|
||||
names[p.PID] = p.Name
|
||||
@@ -115,6 +152,23 @@ func (d *Detector) detect(ps []Process, apps []computeApp) []string {
|
||||
}
|
||||
holders = append(holders, fmt.Sprintf("%s (pid %d) using %d MiB VRAM", name, a.PID, a.UsedMB))
|
||||
}
|
||||
// Sorted for stable output (map iteration order is random).
|
||||
pids := make([]int, 0, len(utils))
|
||||
for pid := range utils {
|
||||
pids = append(pids, pid)
|
||||
}
|
||||
slices.Sort(pids)
|
||||
for _, pid := range pids {
|
||||
util := utils[pid]
|
||||
name := names[pid]
|
||||
if d.ignore[normName(name)] || util < float64(d.utilPct) {
|
||||
continue
|
||||
}
|
||||
if name == "" {
|
||||
name = "unknown process"
|
||||
}
|
||||
holders = append(holders, fmt.Sprintf("%s (pid %d) using %.0f%% GPU", name, pid, util))
|
||||
}
|
||||
}
|
||||
return holders
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user