Method worker_task

benchmarks/dirty_benchmark.py:320–352

Worker that makes sequential requests on a persistent connection.

(num_requests: int)

        remainder = total_requests % concurrency

        def worker_task(num_requests: int) -> None:
            """Worker that makes sequential requests on a persistent connection."""
            worker_latencies = []
            worker_errors = []

            try:
                client = DirtyClient(self.socket_path, timeout=timeout)
                client.connect()

                for _ in range(num_requests):
                    try:
                        start = time.perf_counter()
                        client.execute(BENCHMARK_APP, action, *args, **kwargs)
                        elapsed = (time.perf_counter() - start) * 1000
                        worker_latencies.append(elapsed)
                    except Exception as e:
                        worker_errors.append(str(e))
                        # Reconnect on error
                        try:
                            client.close()
                            client = DirtyClient(self.socket_path, timeout=timeout)
                            client.connect()
                        except Exception:
                            pass

                client.close()
            except Exception as e:
                worker_errors.append(f"Connection error: {e}")

            # Add results to shared lists
            with lock:
                latencies.extend(worker_latencies)
                errors.extend(worker_errors)

        # Run concurrent workers
        with ThreadPoolExecutor(max_workers=concurrency) as executor: