Struct DispatchReservation 

pub struct DispatchReservation { /* private fields */ }

One capacity slot on one worker, held from selection until it is dropped.

Returned by ConnectedWorkerRegistry::select_and_reserve. Dropping it releases the slot and wakes the selection waits, exactly as a completion does — so a dispatch that dies anywhere between choosing its worker and handing the count to the heartbeat tracker gives the slot back without that path having to know a slot existed. That is the whole point: the release is owed by the type, not by every error arm.

Handing the slot over: Self::commit, and why it exists now

This type used to forbid a commit/forget escape, on the reasoning that the tracker’s own increment would carry the slot afterwards and the two would merely overlap “for the width of one call”. That was measured and it was wrong in a way that mattered.

The overlap is two separate acquisitions of the registry lock — the tracker increments under one, this type’s Drop decrements under another — and between them the worker’s in_flight reads ONE HIGHER than the number of dispatches it is actually holding. A concurrent leg that lands in that window asks ConnectedWorkerRegistry::reserve_worker, is told held >= advertised, and is refused a slot the worker demonstrably has. Observed directly: in_flight = 5 on a worker advertising 4, on a fan sized exactly to its pool — which is the normal shape, so the margin is zero and one collision is enough.

So the handover is now a single act with no intermediate state: Self::commit disarms this reservation and the tracker skips its own increment, because the slot this reservation already holds IS the slot the tracked dispatch holds. The count goes 1 → 1 rather than 1 → 2 → 1, and never passes through a value that is not true.

The original worry — a missed handoff silently under-counting a busy worker forever — is answered by making the transfer the ONLY way to commit: the tracker takes the reservation by value, so it either commits it or drops it, and a dropped reservation still releases.

Implementations

impl DispatchReservation

pub fn worker_id(&self) -> WorkerId

The worker whose slot this reservation holds.

Trait Implementations

impl Debug for DispatchReservation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for DispatchReservation

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.