@camstack/addon-post-analysis 1.2.269 → 1.2.271

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-D42gEB0t.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-Bs8m-J-O.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.269",
+  "version": "1.2.271",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",

package/python/raw_tensor_inference.py

@@ -19,6 +19,7 @@ to stderr (stdout is the binary framing channel only).
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 import numpy as np
@@ -31,6 +32,7 @@ from tensor_frames import (
     read_frame,
     write_frame,
 )
+from session_threads import resolve_session_threads
 
 
 def numpy_dtype_for(onnx_type: str):
@@ -46,10 +48,23 @@ def numpy_dtype_for(onnx_type: str):
 def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument("model")
+    # A CEILING, not a tuning. This engine serves arbitrary vision models, so
+    # unlike the text encoder it keeps some parallelism — but onnxruntime's
+    # default is the HOST's core count, held for the life of the process, and
+    # that is a fact about the machine rather than about the work. Nobody has
+    # measured the right number here because this path runs on no node of the
+    # current cluster; an operator who measures raises it with --threads.
+    ap.add_argument("--threads", type=int, default=4)
     args = ap.parse_args()
 
     print(f"raw_tensor_inference: loading model {args.model}", file=sys.stderr)
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
+    intra, inter = resolve_session_threads(args.threads, os.cpu_count())
+    sess_options = ort.SessionOptions()
+    sess_options.intra_op_num_threads = intra
+    sess_options.inter_op_num_threads = inter
+    sess = ort.InferenceSession(
+        args.model, sess_options=sess_options, providers=["CPUExecutionProvider"]
+    )
     inp = sess.get_inputs()[0]
     input_name = inp.name
     input_dtype = numpy_dtype_for(inp.type)

package/python/session_threads.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""The thread ceiling for an embedding engine's onnxruntime session.
+
+Deliberately free of third-party imports so the decision can be tested without
+onnxruntime or numpy installed — see `test_session_threads.py` for why that
+matters and what this prevents.
+"""
+from __future__ import annotations
+
+
+def resolve_session_threads(
+    requested: int, cpu_count: int | None
+) -> tuple[int, int]:
+    """(intra_op_num_threads, inter_op_num_threads) for an engine session.
+
+    `requested` is a CEILING the caller states, not a tuning: it exists so the
+    permanent thread cost of a long-lived engine stops scaling with whatever
+    host it lands on. The machine's own core count caps it in turn, because
+    asking for more op threads than there are cores only buys coordination.
+
+    An unknown core count (`os.cpu_count()` answers None when it cannot tell)
+    means "no cap available", NOT "no cores": the request stands. Folding an
+    unreadable measurement into zero is the mistake D393 names.
+
+    inter-op is always 1. Both engines serve exactly one request at a time by
+    construction — read a framed request, infer, write a framed response — so
+    there is never a second branch of the graph in flight for inter-op
+    parallelism to run.
+    """
+    ceiling = max(1, requested)
+    if cpu_count is not None and cpu_count > 0:
+        ceiling = min(ceiling, cpu_count)
+    return ceiling, 1

package/python/test_session_threads.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""How many threads an embedding engine's onnxruntime session may hold.
+
+Both embedding subprocesses — `raw_tensor_inference.py` and
+`text_encoder_inference.py` — build an `ort.InferenceSession` with no
+`SessionOptions`, so onnxruntime takes `intra_op_num_threads` = the HOST's core
+count. These are not one-shot scripts: each writes a READY frame and then sits
+in a `while True` serving requests, so those threads are held for the life of
+the process. On this cluster's hub that is 20 threads per engine, and it grows
+with the machine — a fact about the host, not about the work.
+
+The sibling `yamnet_audio.py` already learned this the expensive way
+(~1000% CPU across a handful of audio streams) and caps to one op thread with a
+`--threads` override. This is the same rule, made testable: the caller states a
+ceiling, the machine's core count caps it, and the result is never zero.
+
+Kept free of numpy and onnxruntime on purpose — neither installs on the
+operator's Mac, and a decision worth testing should not need a GPU runtime to
+be checked.
+"""
+from __future__ import annotations
+
+import unittest
+
+from session_threads import resolve_session_threads
+
+
+class TestResolveSessionThreads(unittest.TestCase):
+    def test_a_request_larger_than_the_machine_is_capped_by_the_machine(self) -> None:
+        intra, _ = resolve_session_threads(8, cpu_count=4)
+        self.assertEqual(intra, 4)
+
+    def test_a_smaller_request_is_honoured_on_a_big_host(self) -> None:
+        # The whole point: a 20-core hub must not hand 20 permanent threads to
+        # an engine that asked for 4.
+        intra, _ = resolve_session_threads(4, cpu_count=20)
+        self.assertEqual(intra, 4)
+
+    def test_it_never_resolves_to_zero_or_fewer_threads(self) -> None:
+        for requested in (0, -3):
+            with self.subTest(requested=requested):
+                intra, inter = resolve_session_threads(requested, cpu_count=20)
+                self.assertEqual(intra, 1)
+                self.assertGreaterEqual(inter, 1)
+
+    def test_an_unknown_core_count_does_not_silently_become_no_threads(self) -> None:
+        # os.cpu_count() returns None when it cannot tell. Folding that into 0
+        # would hand onnxruntime an invalid session; the request stands instead.
+        for unknown in (None, 0):
+            with self.subTest(cpu_count=unknown):
+                intra, _ = resolve_session_threads(4, cpu_count=unknown)
+                self.assertEqual(intra, 4)
+
+    def test_inter_op_is_always_one(self) -> None:
+        # These engines serve ONE request at a time by construction (a framed
+        # read, an inference, a framed write). There is never a second graph
+        # branch in flight for inter-op parallelism to run.
+        for cpu in (1, 4, 20, 64):
+            with self.subTest(cpu_count=cpu):
+                _, inter = resolve_session_threads(4, cpu_count=cpu)
+                self.assertEqual(inter, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/text_encoder_inference.py

@@ -20,6 +20,7 @@ Diagnostics go to stderr (stdout is the binary framing channel only).
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 import numpy as np
@@ -27,6 +28,7 @@ import onnxruntime as ort
 from tokenizers import Tokenizer
 
 from tensor_frames import READY_FRAME, encode_tensor, read_frame, write_frame
+from session_threads import resolve_session_threads
 
 # CLIP fixed context length — token ids are truncated/padded to exactly this.
 CONTEXT_LENGTH = 77
@@ -44,6 +46,12 @@ def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument("model")
     ap.add_argument("tokenizer")
+    # A CLIP text encoder is one pass over a fixed 77-token window. There is
+    # nothing here worth splitting across threads, and onnxruntime's default is
+    # the HOST's core count held for the life of this process — 20 on this
+    # cluster's hub. `yamnet_audio.py` measured what that costs (~1000% CPU on
+    # a handful of streams) and landed on the same default.
+    ap.add_argument("--threads", type=int, default=1)
     args = ap.parse_args()
 
     print(
@@ -51,7 +59,13 @@ def main() -> None:
         f"tokenizer {args.tokenizer}",
         file=sys.stderr,
     )
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
+    intra, inter = resolve_session_threads(args.threads, os.cpu_count())
+    sess_options = ort.SessionOptions()
+    sess_options.intra_op_num_threads = intra
+    sess_options.inter_op_num_threads = inter
+    sess = ort.InferenceSession(
+        args.model, sess_options=sess_options, providers=["CPUExecutionProvider"]
+    )
     input_name = sess.get_inputs()[0].name
     output_name = sess.get_outputs()[0].name
     tokenizer = build_tokenizer(args.tokenizer)