[nicolas-grekas]

Stacked on #2617 and #2635: review the commits on top of them.

Tasks for background workers, the task half of #2319. A worker declares the namespaces it receives, and a sender names the namespace:

worker {
	file images.php
	background
	num 4
	tasks image.resize image.thumbnail
}

// anywhere
$task = new FrankenPHP\SentTaskHandle('image.resize', ['file' => 'photo.jpg']);
while (null !== $update = $task->read()) {
}

// the background worker, in its tick() loop
while ($task = $handle->receive()) {
    $task->update(['progress' => 50]);
    $task->complete(resize($task->getNamespace(), $task->getPayload()));
}

1. Constructing a SentTaskHandle waits for a thread to pick the task up and throws on timeout, so a busy worker pushes back instead of queueing without bounds.
2. A pool shares one queue for all its namespaces, and each task wakes one parked thread through its WorkerHandle, so the loop of feat: background workers and FrankenPHP\WorkerHandle #2617 doesn't change.
3. Both task handles are Io\Poll\Handle with a getStream(), like the worker's. abandon(), or dropping the handle, gives up on the task, which the worker learns from update() returning false; a worker letting go of a task without complete() makes the sender's next read() throw.
4. Each side waits on its own descriptor, eventfd on Linux, kqueue on macOS, a socket pair on Windows, pooled between tasks: 8 senders on 8 threads went from 2k to 32k tasks/s along the way.

The metrics follow: frankenphp_busy_workers and frankenphp_worker_queue_depth count tasks, plus frankenphp_worker_task_count{outcome} and frankenphp_worker_task_time for a Metrics implementation that also implements TaskMetrics.

Left out compared to #2319: a queue ahead of pickup, and cancelling a task before it.

[nicolas-grekas]

Pushed 23d3094 after benchmarking the task path in the Docker builder image (harness kept out of the PR). Three changes: a send wakes one parked thread instead of every thread of the pool; the sender waits for the pickup in the kernel, on the task's socket, instead of in a Go select (waking a thread parked inside a cgo callback costs the scheduler a P hand-off); and the queue mutex is no longer held across a syscall nor taken twice per wake-up. One thread: 549 to 285µs per task. A pool of 8: 1745 to 320µs. 8 senders on 8 threads: 2k to 32k tasks/s. Absolute numbers are that VM's, the ratios are the point.