Miscellaneous Fixes (#23709)

frigate/test/test_config.py

@@ -397,6 +397,43 @@ class TestConfig(unittest.TestCase):
         assert "dog" in frigate_config.cameras["back"].objects.filters
         assert frigate_config.cameras["back"].objects.filters["dog"].threshold == 0.7
 
+    def test_unsupported_tracked_object_pruned_from_track_and_filters(self):
+        # "unicorn" is not in the model labelmap, so it must be removed from the
+        # tracked objects AND from the object filters, otherwise a stale filter
+        # entry lingers in the parsed config.
+        config = {
+            "mqtt": {"host": "mqtt"},
+            "cameras": {
+                "back": {
+                    "ffmpeg": {
+                        "inputs": [
+                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
+                        ]
+                    },
+                    "detect": {
+                        "height": 1080,
+                        "width": 1920,
+                        "fps": 5,
+                    },
+                    "objects": {
+                        "track": ["person", "unicorn"],
+                        "filters": {
+                            "person": {"threshold": 0.7},
+                            "unicorn": {"threshold": 0.7},
+                        },
+                    },
+                }
+            },
+        }
+
+        frigate_config = FrigateConfig(**config)
+        objects = frigate_config.cameras["back"].objects
+        assert "unicorn" not in objects.track
+        assert "unicorn" not in objects.filters
+        # supported entries are left untouched
+        assert "person" in objects.track
+        assert "person" in objects.filters
+
     def test_global_object_mask(self):
         config = {
             "mqtt": {"host": "mqtt"},

frigate/test/test_gpu_stats.py

@@ -40,18 +40,18 @@ class TestGpuStats(unittest.TestCase):
                 "driver": "i915",
                 "pid": "100",
                 "engines": {
-                    "render": (1_000_000_000, 0),
-                    "video": (5_000_000_000, 0),
-                    "video-enhance": (200_000_000, 0),
-                    "compute": (0, 0),
+                    "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),
-                    "compute": (2_000_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_000_000_000, 0, 1),
                 },
             },
         }
@@ -60,18 +60,18 @@ class TestGpuStats(unittest.TestCase):
                 "driver": "i915",
                 "pid": "100",
                 "engines": {
-                    "render": (1_200_000_000, 0),
-                    "video": (5_500_000_000, 0),
-                    "video-enhance": (300_000_000, 0),
-                    "compute": (0, 0),
+                    "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),
-                    "compute": (2_100_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_100_000_000, 0, 1),
                 },
             },
         }
@@ -92,6 +92,64 @@ class TestGpuStats(unittest.TestCase):
             },
         }
 
+    @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")
+    def test_intel_gpu_stats_xe_capacity(
+        self, 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%.
+        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.util.services._read_intel_drm_fdinfo")
     def test_intel_gpu_stats_no_clients(self, read_fdinfo):
         read_fdinfo.return_value = {}