Struct VUWorkerPool 

pub struct VUWorkerPool { /* private fields */ }

A pool of dedicated worker threads, each running a current-thread tokio runtime. VU tasks are pinned to their own worker (spawn_vu), so a VU is never co-located with another VU on the same runtime.

Implementations

impl VUWorkerPool

pub const MAX_WORKERS: usize = 10_000

Maximum number of worker threads the pool will ever create. spawn_vu reuses idle slots (slots freed by finished/panicked VUs) before growing, so for any realistic test the pool sizes to PEAK CONCURRENCY and stays far below this cap — strict 1-VU-per-thread isolation is preserved. The cap only bites when a single run is concurrently busy beyond 10 000 VUs; once reached, additional VUs wrap onto existing workers (isolation traded away at extreme VU counts, as documented). The vu_id passed to run_vu is unaffected (naming stays unique) — only the worker slot may be shared. TR-502 proper fix: raised from 4096 to 10000, and with TR-503 shared Runtime (57k vs 843k) 10k VUs is ~570MB + overhead, not 8GB. The thread-per-VU model is retained for now (async Promises are the next step), but the cap no longer blocks k6-scale runs. pids.max still caps in containers.

pub fn new(count: usize) -> Self

Create a new pool with count workers (one per core).

Each worker runs a current-thread tokio runtime on a dedicated OS thread. Panics if count is 0.

pub fn worker_count(&self) -> usize

Return the number of workers in the pool.

pub fn spawn_on<F>(&self, idx: usize, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a future on the worker at idx (must be < worker_count). Returns a JoinHandle that can be awaited from any runtime.

pub fn pids_limit() -> Option<u64>

Read the cgroup pids.max limit if present (Kubernetes pids.max, Docker --pids-limit). Returns None when unlimited or unreadable. Checks both cgroup v1 and v2 paths.

pub fn effective_concurrency(requested: u64) -> u64

Effective concurrency actually achievable — min(requested, MAX_WORKERS, pids.limit). When requested > effective, wrapping or pids-capping reduces throughput to that of effective.

pub fn spawn_vu<F>(&self, vu_id: u32, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a VU on a dedicated worker thread. Reuses an idle slot (a finished VU’s worker) when one exists, grows the pool only when every slot is busy, and wraps onto an existing worker only past MAX_WORKERS. No two LIVE VUs ever share a worker, so a blocking script sleep() still only blocks its own VU — while the pool sizes to PEAK CONCURRENCY instead of the cumulative monotonic id count (P0: ids grew the pool to thousands of threads/runtimes/fds at tiny peak concurrency).

Returns a JoinHandle that can be awaited from any runtime.

pub fn spawn<F>(&self, future: F) -> (usize, JoinHandle<F::Output>)

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a future on the next worker (round-robin distribution). Returns a tuple of (worker_index, JoinHandle).

Trait Implementations

impl Drop for VUWorkerPool

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.