Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

fix(dictation): reap abandoned native model workers

rubenluetke10-beep084607383dcb
diff --git a/jarvis/dictation/local_preview.py b/jarvis/dictation/local_preview.py
index 25de9922d7..8d6c314a58 100644
--- a/jarvis/dictation/local_preview.py
+++ b/jarvis/dictation/local_preview.py
@@ -48,6 +48,7 @@ import subprocess
import sys
import threading
import time
+import weakref
from pathlib import Path
from types import SimpleNamespace
from typing import Any
@@ -116,6 +117,40 @@ def _child_python() -> str:
raise RuntimeError(f"no python interpreter beside {exe}")
+def _close_worker_process(proc: subprocess.Popen[bytes]) -> None:
+ """Kill, reap and close pipes. Runs only on a cleanup/caller worker thread."""
+ try:
+ proc.kill()
+ except Exception as exc: # noqa: BLE001 — an already-dead worker is the goal state
+ log.debug("Preview worker kill skipped: %s", exc)
+ try:
+ wait = getattr(proc, "wait", None)
+ if callable(wait):
+ wait(timeout=3.0)
+ except Exception as exc: # noqa: BLE001 — never wait forever on teardown
+ log.warning("Preview worker did not exit after kill: %s", exc)
+ return
+ for stream in (proc.stdin, proc.stdout):
+ if stream is not None:
+ try:
+ stream.close()
+ except Exception as exc: # noqa: BLE001 — already-closed pipe is harmless
+ log.debug("Preview worker pipe close skipped: %s", exc)
+
+
+def _release_abandoned_worker(proc: subprocess.Popen[bytes]) -> None:
+ """Do not let garbage collection block the voice/UI loop on pipe teardown."""
+ try:
+ threading.Thread(
+ target=_close_worker_process,
+ args=(proc,),
+ name="dictation-worker-reap",
+ daemon=True,
+ ).start()
+ except RuntimeError:
+ log.exception("Could not schedule abandoned dictation worker cleanup")
+
+
class _WorkerModel:
"""faster-whisper-shaped proxy whose decodes run in the preview worker.
@@ -130,6 +165,15 @@ class _WorkerModel:
self._proc = proc
self.device = device
self.compute = compute
+ # Provider switches discard the owner without necessarily calling close.
+ # Popen can retain a live child in its global _active list, including
+ # its open stdin pipe: neither GC nor the child's EOF loop then frees
+ # the native model. Retain only the process here, never a bound method
+ # of self. Active transcribe calls keep self alive until they finish.
+ self._cleanup = weakref.finalize(self, _release_abandoned_worker, proc)
+ # No new threads during interpreter shutdown. Parent pipe closure is
+ # the worker's existing EOF/exit path at process shutdown.
+ self._cleanup.atexit = False # type: ignore[misc] # Writable property despite finalize's slots.
def transcribe(
self,
@@ -175,23 +219,8 @@ class _WorkerModel:
def close(self) -> None:
"""Kill and reap the worker. Blocking: callers must keep this off-loop."""
- try:
- self._proc.kill()
- except Exception as exc: # noqa: BLE001 — an already-dead worker is the goal state
- log.debug("Preview worker kill skipped: %s", exc)
- try:
- wait = getattr(self._proc, "wait", None)
- if callable(wait):
- wait(timeout=3.0)
- except Exception as exc: # noqa: BLE001 — never wait forever on teardown
- log.warning("Preview worker did not exit after kill: %s", exc)
- return
- for stream in (self._proc.stdin, self._proc.stdout):
- if stream is not None:
- try:
- stream.close()
- except Exception as exc: # noqa: BLE001 — already-closed pipe is harmless
- log.debug("Preview worker pipe close skipped: %s", exc)
+ if self._cleanup.detach() is not None:
+ _close_worker_process(self._proc)
def _spawn_worker_model(model_name: str, *, compute: str | None = None) -> _WorkerModel | None:
diff --git a/tests/unit/dictation/test_worker_ownership.py b/tests/unit/dictation/test_worker_ownership.py
new file mode 100644
index 0000000000..8dba1ab5e1
--- /dev/null
+++ b/tests/unit/dictation/test_worker_ownership.py
@@ -0,0 +1,123 @@
+"""An abandoned native worker must not outlive its last usable owner."""
+
+from __future__ import annotations
+
+import gc
+import io
+import subprocess
+import sys
+import threading
+import weakref
+
+import pytest
+
+from jarvis.core.process_utils import NO_WINDOW_CREATIONFLAGS
+from jarvis.dictation.local_final import LocalFinalSTT
+from jarvis.dictation.local_preview import LocalPreviewTranscriber, _WorkerModel
+
+
+class Process:
+ def __init__(self) -> None:
+ self.stdin = io.BytesIO()
+ self.stdout = io.BytesIO()
+ self.kills = 0
+ self.reaped = threading.Event()
+
+ def kill(self) -> None:
+ self.kills += 1
+
+ def wait(self, timeout: float) -> int:
+ self.reaped.set()
+ return 0
+
+
[email protected]("kind", ["preview", "final"])
+def test_replacing_an_owner_reaps_its_abandoned_worker(kind: str) -> None:
+ proc = Process()
+ worker = _WorkerModel(proc, "cpu", "int8")
+ if kind == "preview":
+ owner = LocalPreviewTranscriber(prefer_worker=True)
+ owner._model = worker
+ else:
+ owner = LocalFinalSTT()
+ owner._worker = worker
+ reference = weakref.ref(worker)
+ del worker, owner
+ gc.collect()
+ assert reference() is None
+ assert proc.reaped.wait(2), "the owner disappeared but its worker was never reaped"
+ assert proc.kills == 1
+
+
+def test_a_retained_worker_is_not_reaped_until_the_last_caller_releases_it() -> None:
+ proc = Process()
+ owner = LocalFinalSTT()
+ owner._worker = _WorkerModel(proc, "cpu", "int8")
+ active_call = owner._worker
+ del owner
+ gc.collect()
+ assert proc.kills == 0
+ del active_call
+ gc.collect()
+ assert proc.reaped.wait(2)
+
+
+def test_explicit_close_and_later_collection_reap_only_once() -> None:
+ proc = Process()
+ worker = _WorkerModel(proc, "cpu", "int8")
+ worker.close()
+ worker.close()
+ del worker
+ gc.collect()
+ assert proc.kills == 1
+ assert proc.stdin.closed and proc.stdout.closed
+
+
+def test_collection_never_waits_for_a_slow_worker_on_the_collecting_thread() -> None:
+ release = threading.Event()
+ started = threading.Event()
+
+ class SlowProcess(Process):
+ def wait(self, timeout: float) -> int:
+ started.set()
+ assert release.wait(timeout)
+ return super().wait(timeout)
+
+ proc = SlowProcess()
+ worker = _WorkerModel(proc, "cpu", "int8")
+ try:
+ del worker
+ gc.collect()
+ assert started.wait(1)
+ assert not proc.reaped.is_set()
+ finally:
+ release.set()
+ assert proc.reaped.wait(2)
+
+
+def test_twenty_real_worker_replacements_leave_no_child_processes() -> None:
+ """Exercise real process ownership without importing any inference engine."""
+ processes: list[subprocess.Popen[bytes]] = []
+ try:
+ for _ in range(20):
+ proc = subprocess.Popen(
+ [sys.executable, "-X", "utf8", "-c", "import sys; sys.stdin.buffer.read()"],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.DEVNULL,
+ creationflags=NO_WINDOW_CREATIONFLAGS,
+ )
+ processes.append(proc)
+ worker = _WorkerModel(proc, "cpu", "int8")
+ del worker
+ gc.collect()
+ proc.wait(timeout=5)
+ assert all(proc.poll() is not None for proc in processes)
+ finally:
+ for proc in processes:
+ if proc.poll() is None:
+ proc.kill()
+ proc.wait(timeout=5)
+ for stream in (proc.stdin, proc.stdout):
+ if stream is not None:
+ stream.close()