@camstack/addon-pipeline 1.2.228 → 1.2.231

package/dist/stream-broker/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BOpWY0lf.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-B9KO-igY.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.228",
+  "version": "1.2.231",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",

package/python/inference_pool.py

@@ -279,6 +279,33 @@ _ov_optimal_reqs: int = 0
 # query the device's optimal request count). ≈ measured optimal on Intel
 # CPU/iGPU/NPU (4-5). Threads idle-block on infer, so over-provisioning is cheap.
 OV_DEFAULT_CONCURRENCY: int = 4
+# Floor for the InferRequest / predict-pool size when the device DOES answer.
+# Under PERFORMANCE_HINT=LATENCY an Intel iGPU typically reports 1-2: one
+# execution stream, and the extra requests buy pipelining the LATENCY hint is
+# not asking for. Two rather than one so a second frame can be preprocessed
+# while the first infers, without paying for four.
+OV_MIN_CONCURRENCY: int = 2
+
+
+def _ov_request_count(optimal: int) -> int:
+    """How many InferRequests to create up front.
+
+    ONE function because two call sites must agree: the per-model request pool
+    in `_load_model` and the predict-pool worker count in `_run`. They used to
+    compute it separately with the same expression, and the expression was
+    `max(optimal, OV_DEFAULT_CONCURRENCY)` — a FLOOR of four, not the fallback
+    its own comment described. On this hub that meant every model held four
+    GPU-resident InferRequests forever, per pool, while the device was asking
+    for one or two and `intel_gpu_top` showed the GPU 92% idle. Creating a
+    VAAPI device for an HEVC decode then failed with ENOMEM.
+
+    `optimal <= 0` means the device could not be asked — models load lazily,
+    the property is missing — and UNKNOWN is not SMALL: that case keeps the
+    old default rather than guessing low.
+    """
+    if optimal <= 0:
+        return OV_DEFAULT_CONCURRENCY
+    return max(optimal, OV_MIN_CONCURRENCY)
 # OpenVINO device decision. AUTO is NEVER used: the AUTO plugin runs inference
 # on a CPU "helper" while the GPU JIT-compiles, then hands the model over to the
 # GPU mid-flight. InferRequests created during that window bind to the
@@ -978,17 +1005,18 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         except Exception:
             pass
 
-        # Size N ONCE from the device's optimal infer-request count (fallback to
-        # OV_DEFAULT_CONCURRENCY when the property is missing/zero) so it matches
-        # the predict-pool worker count sized in _run(). Both the sync request-pool
-        # and the async queue below are sized to this same N.
+        # Size N ONCE from the device's optimal infer-request count (falling back
+        # to OV_DEFAULT_CONCURRENCY only when the property is missing/zero) so it
+        # matches the predict-pool worker count sized in _run(). Both the sync
+        # request-pool and the async queue below are sized to this same N, and
+        # both go through `_ov_request_count` so they cannot drift apart.
         import queue as _queue
 
         try:
             _n_req = int(compiled.get_property("OPTIMAL_NUMBER_OF_INFER_REQUESTS"))
         except Exception:
             _n_req = 0
-        _n_req = max(_n_req, OV_DEFAULT_CONCURRENCY)
+        _n_req = _ov_request_count(_n_req)
 
         if _OV_ASYNC_ENABLED:
             # Async pipelining path (CAMSTACK_OV_ASYNC=1). An ov.AsyncInferQueue of
@@ -2386,11 +2414,13 @@ async def _run() -> None:
     # model in _load_model) is actually fed by concurrent predict workers. The
     # addon passes concurrency=1 (it predates the request pool) and models load
     # lazily AFTER this point, so we can't read OPTIMAL_NUMBER_OF_INFER_REQUESTS
-    # here — default to OV_DEFAULT_CONCURRENCY (≈ the measured optimal of 4-5
-    # on Intel CPU/iGPU/NPU). If startup-loaded models report a higher optimal,
-    # use that. The per-model InferRequest pool is sized to the same target.
+    # here — `_ov_request_count(0)` then answers OV_DEFAULT_CONCURRENCY, because
+    # a device that could not be asked is UNKNOWN and not small. A startup-loaded
+    # model that DID answer sizes it to what the device actually wants. The
+    # per-model InferRequest pool goes through the same function, so the two
+    # cannot drift apart.
     if runtime == "openvino":
-        target = max(_ov_optimal_reqs, OV_DEFAULT_CONCURRENCY)
+        target = _ov_request_count(_ov_optimal_reqs)
         if target > concurrency:
             sys.stderr.write(
                 f"OpenVINO LATENCY: predict concurrency {concurrency} -> {target}\n"

package/python/test_inference_pool_ov_requests.py

@@ -0,0 +1,79 @@
+"""Unit tests for `_ov_request_count` — how many InferRequests a model holds.
+
+The failure this guards: the sizing used to be `max(optimal, 4)`, a FLOOR of
+four rather than the fallback the comment beside it described. Every loaded
+model then held four GPU-resident InferRequests for ever, per pool, while an
+Intel iGPU under PERFORMANCE_HINT=LATENCY was asking for one or two and the GPU
+sat 92% idle. Creating a VAAPI device for an HEVC decode failed with ENOMEM
+because of it.
+
+Pure-python: stubs numpy / PIL / postprocessors so the module imports without
+the ML runtime installed.
+
+Run: python3 -m unittest test_inference_pool_ov_requests -v
+"""
+from __future__ import annotations
+
+import sys
+import types
+import unittest
+
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
+    _np = types.ModuleType("numpy")
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
+    _pil = types.ModuleType("PIL")
+    _pil_image = types.ModuleType("PIL.Image")
+    _pil.Image = _pil_image
+    sys.modules["PIL"] = _pil
+    sys.modules["PIL.Image"] = _pil_image
+
+if "postprocessors" not in sys.modules:
+    _pp = types.ModuleType("postprocessors")
+    _pp.POSTPROCESSORS = {}
+    sys.modules["postprocessors"] = _pp
+
+from inference_pool import (  # noqa: E402
+    OV_DEFAULT_CONCURRENCY,
+    OV_MIN_CONCURRENCY,
+    _ov_request_count,
+)
+
+
+class OvRequestCountTest(unittest.TestCase):
+    def test_honours_what_the_device_asked_for(self):
+        # The whole point: a device that says 2 gets 2, not 4.
+        self.assertEqual(_ov_request_count(2), 2)
+        self.assertEqual(_ov_request_count(5), 5)
+        self.assertEqual(_ov_request_count(8), 8)
+
+    def test_a_device_asking_for_one_still_gets_the_floor(self):
+        # One request means a frame cannot be prepared while another infers.
+        # Two is the floor; it is not four.
+        self.assertEqual(_ov_request_count(1), OV_MIN_CONCURRENCY)
+        self.assertEqual(OV_MIN_CONCURRENCY, 2)
+
+    def test_UNKNOWN_is_not_small_and_keeps_the_old_default(self):
+        # Models load lazily, so at dispatcher-sizing time the device has not
+        # been asked at all. Absent is not zero (D393): that case keeps the
+        # measured default rather than guessing low and starving the pool.
+        self.assertEqual(_ov_request_count(0), OV_DEFAULT_CONCURRENCY)
+        self.assertEqual(_ov_request_count(-1), OV_DEFAULT_CONCURRENCY)
+        self.assertEqual(OV_DEFAULT_CONCURRENCY, 4)
+
+    def test_is_never_a_floor_of_the_default(self):
+        # The defect, stated as a test: the old expression was
+        # `max(optimal, OV_DEFAULT_CONCURRENCY)`, so a device asking for 2 got
+        # 4. If this ever goes back to a floor, this fails.
+        self.assertLess(_ov_request_count(2), OV_DEFAULT_CONCURRENCY)
+
+
+if __name__ == "__main__":
+    unittest.main()