mirror of
https://github.com/blakeblackshear/frigate.git
synced 2026-09-26 03:58:58 +03:00
Nicolas Mowen
27a40a507b
* Implement hardware detection and UI management * Cleanup Frigate+ detection * Don't count model as changed * Fixes for audio map error * Add descriptions * Enforce that all model must exist * Fix hardware picking * Docs fixes * WebUI cleanup * Cleanup handling of scenes * UI refinement * Cleanup recommended UI * test fixews
388 lines
15 KiB
Python
388 lines
15 KiB
Python
import unittest
|
|
from io import StringIO
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from frigate.util.services import (
|
|
get_amd_gpu_stats,
|
|
get_intel_gpu_stats,
|
|
get_openvino_npu_stats,
|
|
)
|
|
|
|
|
|
class TestGpuStats(unittest.TestCase):
|
|
def setUp(self):
|
|
self.amd_results = "Unknown Radeon card. <= R500 won't work, new cards might.\nDumping to -, line limit 1.\n1664070990.607556: bus 10, gpu 4.17%, ee 0.00%, vgt 0.00%, ta 0.00%, tc 0.00%, sx 0.00%, sh 0.00%, spi 0.83%, smx 0.00%, cr 0.00%, sc 0.00%, pa 0.00%, db 0.00%, cb 0.00%, vram 60.37% 294.04mb, gtt 0.33% 52.21mb, mclk 100.00% 1.800ghz, sclk 26.65% 0.533ghz\n"
|
|
|
|
@patch("subprocess.run")
|
|
def test_amd_gpu_stats(self, sp):
|
|
process = MagicMock()
|
|
process.returncode = 0
|
|
process.stdout = self.amd_results
|
|
sp.return_value = process
|
|
amd_stats = get_amd_gpu_stats()
|
|
assert amd_stats == {"gpu": "4.17%", "mem": "60.37%"}
|
|
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services.time.time", side_effect=[0.0, 1.0])
|
|
@patch(
|
|
"frigate.util.services.os.readlink",
|
|
return_value="/sys/bus/pci/drivers/intel_vpu",
|
|
)
|
|
@patch(
|
|
"frigate.util.services.glob.glob",
|
|
return_value=["/sys/class/accel/accel0"],
|
|
)
|
|
@patch(
|
|
"builtins.open",
|
|
side_effect=[StringIO("1000"), StringIO("1250")],
|
|
)
|
|
def test_openvino_npu_stats_discovers_accel0(
|
|
self, open_file, glob, readlink, time, sleep
|
|
):
|
|
assert get_openvino_npu_stats() == {"npu": "25.0", "mem": "-%"}
|
|
|
|
open_file.assert_any_call(
|
|
"/sys/class/accel/accel0/device/power/runtime_active_time"
|
|
)
|
|
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services.time.time", side_effect=[0.0, 1.0])
|
|
@patch(
|
|
"frigate.util.services.os.readlink",
|
|
side_effect=[
|
|
"/sys/bus/pci/drivers/other",
|
|
"/sys/bus/pci/drivers/intel_vpu",
|
|
],
|
|
)
|
|
@patch(
|
|
"frigate.util.services.glob.glob",
|
|
return_value=[
|
|
"/sys/class/accel/accel0",
|
|
"/sys/class/accel/accel1",
|
|
],
|
|
)
|
|
@patch(
|
|
"builtins.open",
|
|
side_effect=[StringIO("1000"), StringIO("1250")],
|
|
)
|
|
def test_openvino_npu_stats_skips_non_intel_accelerator(
|
|
self, open_file, glob, readlink, time, sleep
|
|
):
|
|
assert get_openvino_npu_stats() == {"npu": "25.0", "mem": "-%"}
|
|
|
|
open_file.assert_any_call(
|
|
"/sys/class/accel/accel1/device/power/runtime_active_time"
|
|
)
|
|
|
|
@patch(
|
|
"frigate.util.services.os.readlink",
|
|
return_value="/sys/bus/pci/drivers/other",
|
|
)
|
|
@patch(
|
|
"frigate.util.services.glob.glob",
|
|
return_value=["/sys/class/accel/accel0"],
|
|
)
|
|
@patch("builtins.open")
|
|
def test_openvino_npu_stats_no_intel_accelerator(self, open_file, glob, readlink):
|
|
assert get_openvino_npu_stats() is None
|
|
open_file.assert_not_called()
|
|
|
|
@patch(
|
|
"frigate.util.services.os.readlink",
|
|
return_value="/sys/bus/pci/drivers/intel_vpu",
|
|
)
|
|
@patch(
|
|
"frigate.util.services.glob.glob",
|
|
return_value=["/sys/class/accel/accel0"],
|
|
)
|
|
@patch("builtins.open", side_effect=FileNotFoundError)
|
|
def test_openvino_npu_stats_runtime_counter_unavailable(
|
|
self, open_file, glob, readlink
|
|
):
|
|
assert get_openvino_npu_stats() is None
|
|
open_file.assert_called_once_with(
|
|
"/sys/class/accel/accel0/device/power/runtime_active_time"
|
|
)
|
|
|
|
@patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services.time.monotonic")
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_fdinfo(
|
|
self, drm_devices, read_fdinfo, monotonic, sleep, get_names
|
|
):
|
|
# 1 second of wall clock between snapshots
|
|
drm_devices.return_value = {"0000:00:02.0": "i915"}
|
|
monotonic.side_effect = [0.0, 1.0]
|
|
get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
|
|
|
|
# Two i915 clients on the same iGPU. Engine values are cumulative ns.
|
|
# Deltas over the 1s window:
|
|
# client A (pid 100): render +200_000_000 (20%), video +500_000_000 (50%),
|
|
# video-enhance +100_000_000 (10%)
|
|
# client B (pid 200): compute +100_000_000 (10%)
|
|
# Engine totals → render 20, video 50, video-enhance 10, compute 10
|
|
# → compute = render + compute = 30
|
|
# → dec = video + video-enhance = 60
|
|
# → gpu = compute + dec = 90
|
|
snapshot_a = {
|
|
("0000:00:02.0", "1", "100"): {
|
|
"driver": "i915",
|
|
"pid": "100",
|
|
"engines": {
|
|
"render": (1_000_000_000, 0, 1),
|
|
"video": (5_000_000_000, 0, 1),
|
|
"video-enhance": (200_000_000, 0, 1),
|
|
"compute": (0, 0, 1),
|
|
},
|
|
},
|
|
("0000:00:02.0", "2", "200"): {
|
|
"driver": "i915",
|
|
"pid": "200",
|
|
"engines": {
|
|
"render": (0, 0, 1),
|
|
"compute": (2_000_000_000, 0, 1),
|
|
},
|
|
},
|
|
}
|
|
snapshot_b = {
|
|
("0000:00:02.0", "1", "100"): {
|
|
"driver": "i915",
|
|
"pid": "100",
|
|
"engines": {
|
|
"render": (1_200_000_000, 0, 1),
|
|
"video": (5_500_000_000, 0, 1),
|
|
"video-enhance": (300_000_000, 0, 1),
|
|
"compute": (0, 0, 1),
|
|
},
|
|
},
|
|
("0000:00:02.0", "2", "200"): {
|
|
"driver": "i915",
|
|
"pid": "200",
|
|
"engines": {
|
|
"render": (0, 0, 1),
|
|
"compute": (2_100_000_000, 0, 1),
|
|
},
|
|
},
|
|
}
|
|
read_fdinfo.side_effect = [snapshot_a, snapshot_b]
|
|
|
|
intel_stats = get_intel_gpu_stats(None)
|
|
|
|
sleep.assert_called_once()
|
|
assert intel_stats == {
|
|
"0000:00:02.0": {
|
|
"name": "Intel Graphics",
|
|
"vendor": "intel",
|
|
"gpu": "90.0%",
|
|
"mem": "-%",
|
|
"compute": "30.0%",
|
|
"dec": "60.0%",
|
|
"clients": {"100": "80.0%", "200": "10.0%"},
|
|
},
|
|
}
|
|
|
|
@patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services.time.monotonic")
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_xe_capacity(
|
|
self, drm_devices, read_fdinfo, monotonic, sleep, get_names
|
|
):
|
|
# Xe engines report cumulative cycles paired with total cycles, plus a
|
|
# per-class capacity. drm-cycles-* is summed across every instance of a
|
|
# class, so on Battlemage (capacity 2 for vcs/vecs) busy/total must be
|
|
# divided by capacity to land in 0-100%.
|
|
drm_devices.return_value = {"0000:03:00.0": "xe"}
|
|
monotonic.side_effect = [0.0, 1.0]
|
|
get_names.return_value = {"0000:03:00.0": "Intel Arc"}
|
|
|
|
# Deltas over the window (busy, total): render 200/1000 cap 1 = 20%,
|
|
# video 800/1000 cap 2 = 40%, video-enhance 400/1000 cap 2 = 20%,
|
|
# compute 100/1000 cap 1 = 10%. Without the capacity divisor video/
|
|
# video-enhance would read 80%/40% and dec would clamp at 100%.
|
|
snapshot_a = {
|
|
("0000:03:00.0", "1", "300"): {
|
|
"driver": "xe",
|
|
"pid": "300",
|
|
"engines": {
|
|
"render": (0, 0, 1),
|
|
"video": (0, 0, 2),
|
|
"video-enhance": (0, 0, 2),
|
|
"compute": (0, 0, 1),
|
|
},
|
|
},
|
|
}
|
|
snapshot_b = {
|
|
("0000:03:00.0", "1", "300"): {
|
|
"driver": "xe",
|
|
"pid": "300",
|
|
"engines": {
|
|
"render": (200, 1000, 1),
|
|
"video": (800, 1000, 2),
|
|
"video-enhance": (400, 1000, 2),
|
|
"compute": (100, 1000, 1),
|
|
},
|
|
},
|
|
}
|
|
read_fdinfo.side_effect = [snapshot_a, snapshot_b]
|
|
|
|
intel_stats = get_intel_gpu_stats(None)
|
|
|
|
assert intel_stats == {
|
|
"0000:03:00.0": {
|
|
"name": "Intel Arc",
|
|
"vendor": "intel",
|
|
"gpu": "90.0%",
|
|
"mem": "-%",
|
|
"compute": "30.0%",
|
|
"dec": "60.0%",
|
|
"clients": {"300": "90.0%"},
|
|
},
|
|
}
|
|
|
|
@patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_no_clients_reports_idle(
|
|
self, drm_devices, read_fdinfo, sleep, get_names
|
|
):
|
|
# The device exists but nothing holds it open, e.g. while camera
|
|
# processes are restarting. This is an idle state, not an error:
|
|
# returning None here would latch the hwaccel error cooldown and
|
|
# blank GPU stats for an hour over a momentary gap.
|
|
drm_devices.return_value = {"0000:00:02.0": "i915"}
|
|
read_fdinfo.return_value = {}
|
|
get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
|
|
|
|
assert get_intel_gpu_stats(None) == {
|
|
"0000:00:02.0": {
|
|
"name": "Intel Graphics",
|
|
"vendor": "intel",
|
|
"gpu": "0.0%",
|
|
"mem": "-%",
|
|
"compute": "0.0%",
|
|
"dec": "0.0%",
|
|
},
|
|
}
|
|
# Idle short-circuits before spending the sample window
|
|
sleep.assert_not_called()
|
|
read_fdinfo.assert_called_once()
|
|
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_clients_without_engine_counters(
|
|
self, drm_devices, read_fdinfo, sleep
|
|
):
|
|
# i915 publishes drm-driver/drm-pdev/drm-client-id but no drm-engine-*
|
|
# lines while GuC submission is active on kernels older than 6.5, so
|
|
# clients are found with nothing to sample. Reporting idle here would
|
|
# be a lie, and sampling a second time cannot help.
|
|
drm_devices.return_value = {"0000:00:02.0": "i915"}
|
|
read_fdinfo.return_value = {
|
|
("0000:00:02.0", "48", "1109"): {
|
|
"driver": "i915",
|
|
"pid": "1109",
|
|
"engines": {},
|
|
},
|
|
("0000:00:02.0", "51", "1258"): {
|
|
"driver": "i915",
|
|
"pid": "1258",
|
|
"engines": {},
|
|
},
|
|
}
|
|
|
|
assert get_intel_gpu_stats(None) is None
|
|
sleep.assert_not_called()
|
|
read_fdinfo.assert_called_once()
|
|
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_no_intel_device(self, drm_devices, read_fdinfo):
|
|
# Only a non-Intel GPU is visible in sysfs; /proc is never scanned
|
|
drm_devices.return_value = {"0000:01:00.0": "nvidia"}
|
|
|
|
assert get_intel_gpu_stats(None) is None
|
|
read_fdinfo.assert_not_called()
|
|
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
@patch("frigate.util.services._resolve_intel_gpu_pdev")
|
|
def test_intel_gpu_stats_unresolvable_device_hint(
|
|
self, resolve_pdev, drm_devices, read_fdinfo
|
|
):
|
|
# A configured intel_gpu_device that cannot be resolved is a config
|
|
# error, not a reason to silently fall back to reporting all GPUs
|
|
resolve_pdev.return_value = None
|
|
|
|
assert get_intel_gpu_stats("/dev/dri/renderD999") is None
|
|
drm_devices.assert_not_called()
|
|
read_fdinfo.assert_not_called()
|
|
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
@patch("frigate.util.services._resolve_intel_gpu_pdev")
|
|
def test_intel_gpu_stats_hint_resolves_to_non_intel_gpu(
|
|
self, resolve_pdev, drm_devices, read_fdinfo
|
|
):
|
|
# card numbering can reorder across reboots on multi-GPU hosts, so a
|
|
# configured hint may point at another vendor's card; call it out
|
|
# instead of reporting nothing
|
|
resolve_pdev.return_value = "0000:01:00.0"
|
|
drm_devices.return_value = {
|
|
"0000:00:02.0": "i915",
|
|
"0000:01:00.0": "nvidia",
|
|
}
|
|
|
|
assert get_intel_gpu_stats("/dev/dri/card0") is None
|
|
read_fdinfo.assert_not_called()
|
|
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_unreadable_proc(self, drm_devices, read_fdinfo):
|
|
# A scan failure (None) is a different condition than a scan that
|
|
# finds no clients ({}) and must not report idle
|
|
drm_devices.return_value = {"0000:00:02.0": "i915"}
|
|
read_fdinfo.return_value = None
|
|
|
|
assert get_intel_gpu_stats(None) is None
|
|
|
|
@patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
|
|
@patch("frigate.util.services.time.sleep")
|
|
@patch("frigate.util.services.time.monotonic")
|
|
@patch("frigate.util.services._read_intel_drm_fdinfo")
|
|
@patch("frigate.util.services.enumerate_drm_devices")
|
|
def test_intel_gpu_stats_clients_lost_between_samples(
|
|
self, drm_devices, read_fdinfo, monotonic, sleep, get_names
|
|
):
|
|
# Clients disappearing during the sample window is transient process
|
|
# churn, so report idle rather than latching an error
|
|
drm_devices.return_value = {"0000:00:02.0": "i915"}
|
|
monotonic.side_effect = [0.0, 1.0]
|
|
get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
|
|
read_fdinfo.side_effect = [
|
|
{
|
|
("0000:00:02.0", "1", "100"): {
|
|
"driver": "i915",
|
|
"pid": "100",
|
|
"engines": {"video": (5_000_000_000, 0, 1)},
|
|
},
|
|
},
|
|
{},
|
|
]
|
|
|
|
assert get_intel_gpu_stats(None) == {
|
|
"0000:00:02.0": {
|
|
"name": "Intel Graphics",
|
|
"vendor": "intel",
|
|
"gpu": "0.0%",
|
|
"mem": "-%",
|
|
"compute": "0.0%",
|
|
"dec": "0.0%",
|
|
},
|
|
}
|