Struct DeferredAcks 

struct DeferredAcks {
    by_poly: HashMap<PolynomialIndex, Vec<(OffchainPublicKey, HalfKeyChallenge, HalfKey)>>,
    total: usize,
    drained: bool,
}

Deferred acknowledgements for one cycle, drained in one shot when its part builders install.

Plain Vecs under one mutex rather than nested caches: a bucket is only ever appended to and then drained whole, so per-entry cache bookkeeping (and its ~200 B overhead per entry) buys nothing. The mutex serialises deferrals within one cycle only, and deferral is O(1) work off the steady-state path.

Fields

by_poly: HashMap<PolynomialIndex, Vec<(OffchainPublicKey, HalfKeyChallenge, HalfKey)>>

total: usize

Running sum of the by_poly lengths, maintained so the per-cycle cap is an O(1) check.

Recomputing it would walk every sub-bucket inside the mutex on every deferral, and there can be one sub-bucket per entry: filling a bucket to MAX_DEFERRED_ACKS_PER_CYCLE would then cost ~33M map-entry visits, on the path every acknowledgement takes during the commitment window. The invariant total == by_poly.values().map(Vec::len).sum() has one increment site and one reset site, both under this mutex.

drained: bool

Set by the one drain this bucket will ever get, in the same critical section as the take.

A bucket is reachable through two routes: the pending_acks key, and an Arc a defer_ack already holds. The drain removes the first but cannot revoke the second, so an append that lands after it would sit in a bucket nothing will ever read again. This flag is how such an append notices — see Deferral::Orphaned.

Trait Implementations

impl Default for DeferredAcks

fn default() -> DeferredAcks

Returns the “default value” for a type.