refactor(benchmark): split execute.py into execute/profiling/accuracy/pipeline

AGENTS.md

@@ -178,7 +178,10 @@ src/inference_endpoint/
 │   ├── benchmark/
 │   │   ├── __init__.py
 │   │   ├── cli.py             # benchmark_app: offline, online, from-config subcommands
-│   │   └── execute.py         # Phased execution: setup/run_threaded/finalize + BenchmarkContext; run_benchmark runs the main benchmark (cli._run dispatches run_audit when audit: is set)
+│   │   ├── execute.py         # Phased orchestration: setup_benchmark/run_benchmark_async/finalize_benchmark + BenchmarkContext; run_benchmark runs the main benchmark (cli._run dispatches run_audit when audit: is set)
+│   │   ├── profiling.py       # Profiler-trigger protocol (vLLM /start_profile,/stop_profile) + ProfileController (URL derivation + start/stop/payload lifecycle)
+│   │   ├── accuracy.py        # AccuracyConfiguration + per-dataset scoring (_score_accuracy, OSL/response-count rollups, write_accuracy_results)
+│   │   └── pipeline.py        # MetricsPipeline: async context manager for the ZMQ + metrics-aggregator/event-logger subprocess lifecycle (__aenter__/__aexit__/start/drain_and_build_report) + snapshot→Report
 │   ├── audit.py               # run_audit() — compliance audit orchestrator (phases → verify → result)
 │   ├── probe.py               # ProbeConfig + execute_probe()
 │   ├── info.py                # execute_info()

src/inference_endpoint/async_utils/services/launcher.py

@@ -145,6 +145,35 @@ async def launch(
             # re-raise the exception.
             raise
 
+    def terminate_all(self, timeout: float = 5.0) -> None:
+        """Terminate all managed subprocesses: SIGTERM then escalate to SIGKILL.
+
+        Sends SIGTERM first so subprocesses can flush final state (e.g. the
+        metrics aggregator writes ``INTERRUPTED`` ``final_snapshot.json`` in its
+        SIGTERM handler). After ``timeout`` seconds any process that has not
+        exited is killed unconditionally with SIGKILL.
+        """
+        for proc in self._procs:
+            if proc.poll() is None:
+                try:
+                    proc.terminate()
+                except OSError as e:  # noqa: BLE001 — proc already exited between poll and terminate
+                    logger.debug("terminate pid=%d: %s", proc.pid, e)
+        deadline = time.monotonic() + timeout
+        for proc in self._procs:
+            remaining = max(0.0, deadline - time.monotonic())
+            try:
+                proc.wait(timeout=remaining)
+            except subprocess.TimeoutExpired:
+                try:
+                    proc.kill()
+                    proc.wait(timeout=5)
+                except (OSError, subprocess.TimeoutExpired) as e:  # noqa: BLE001
+                    # OSError: proc already exited between kill and wait.
+                    # TimeoutExpired: proc is stuck in kernel D-state; log and
+                    # continue so remaining processes in _procs are still handled.
+                    logger.warning("Could not kill pid=%d: %s", proc.pid, e)
+
     def kill_all(self) -> None:
         """Kill all managed subprocesses."""
         for proc in self._procs: