matrice-streaming 0.1.71__tar.gz → 0.1.72__tar.gz

{matrice_streaming-0.1.71 → matrice_streaming-0.1.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.71
+Version: 0.1.72
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_streaming-0.1.71 → matrice_streaming-0.1.72}/matrice_streaming.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.71
+Version: 0.1.72
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_streaming-0.1.71 → matrice_streaming-0.1.72}/src/matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py

@@ -101,7 +101,7 @@ class AsyncCameraWorker:
         # ================================================================
         drop_stale_frames: bool = False,  # Disabled for ML quality
         use_simple_read: bool = True,    # Use cap.read() directly instead of grab/retrieve
-        pin_cpu_affinity: bool = True,   # Pin worker to specific CPU cores
+        pin_cpu_affinity: bool = False,  # Let OS distribute threads (avoids cache contention)
         total_workers: int = 1,          # Total worker count for CPU affinity calculation
         buffer_size: int = 1,            # Minimal buffer for low latency (cv2_bench uses 1)
     ):
@@ -240,8 +240,8 @@ class AsyncCameraWorker:
         # - But TOO many threads causes burst frame arrivals → Redis write queue backup
         # - Cap at 64 threads to balance I/O parallelism vs write contention
         num_cameras = len(camera_configs)
-        # Use 1 thread per camera, capped at 64 to prevent write burst contention
-        num_capture_threads = min(64, max(8, num_cameras))
+        # Use 1 thread per camera, max 64 for reduced contention
+        num_capture_threads = min(64, num_cameras)
         self.capture_executor = ThreadPoolExecutor(max_workers=num_capture_threads)
         self.num_capture_threads = num_capture_threads
 
@@ -1335,7 +1335,7 @@ def run_async_worker(
     # ================================================================
     drop_stale_frames: bool = False,  # Disabled for ML quality
     use_simple_read: bool = True,     # Use cap.read() directly instead of grab/retrieve
-    pin_cpu_affinity: bool = True,
+    pin_cpu_affinity: bool = False,   # Let OS distribute (avoids cache contention)
     total_workers: int = 1,
     buffer_size: int = 1,
     # ================================================================

{matrice_streaming-0.1.71 → matrice_streaming-0.1.72}/src/matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py

@@ -45,7 +45,7 @@ class WorkerManager:
         # ================================================================
         drop_stale_frames: bool = False,   # Use grab()/grab()/retrieve() for latest frame (disabled for ML quality)
         use_simple_read: bool = True,      # Use cap.read() directly instead of grab/retrieve
-        pin_cpu_affinity: bool = True,    # Pin workers to specific CPU cores
+        pin_cpu_affinity: bool = False,   # Let OS distribute (avoids cache contention)
         buffer_size: int = 1,             # VideoCapture buffer size (1 = minimal latency)
         # ================================================================
         # FRAME OPTIMIZER: Control frame similarity detection
@@ -78,17 +78,18 @@ class WorkerManager:
             cpu_count = os.cpu_count() or 4  # Fallback to 4 if can't detect
             num_cameras = len(camera_configs)
 
-            # For systems with 16+ cores OR large camera counts, use camera-based calculation
-            # This applies to Docker containers with limited CPU allocation (e.g., 20 cores)
-            # Too many workers = process overhead; too few = underutilization
-            # Target: ~25 cameras per worker for better read parallelism with video files
-            if cpu_count >= 16 or num_cameras >= 100:
+            # Small deployments: 1 worker per camera for maximum parallelism
+            # Each worker process has its own GIL, enabling true CPU parallelism
+            if num_cameras <= 10:
+                calculated_workers = max(1, num_cameras)
+            # Large deployments: use camera-based calculation
+            elif cpu_count >= 16 or num_cameras >= 100:
                 # Use camera-based calculation for better distribution
                 # 1000 cameras / 25 cameras per worker = 40 workers
                 target_cameras_per_worker = 25
                 calculated_workers = max(4, min(num_cameras // target_cameras_per_worker, 50))
             else:
-                # Standard calculation for smaller systems
+                # Standard calculation for medium systems
                 calculated_workers = max(4, int(cpu_count * cpu_percentage))
 
             # Cap at camera count (no point having more workers than cameras)