Method activate

src/thread_pool.rs:953–1045

(self, f: F)

        let member_data = self.get_member_data();
        loop {
            // This is only used to select candidate seats; any seat may in fact
            // be claimed by a concurrent call to `try_enroll` or
            // `try_enroll_many`.
            let claimed_bitmask = self.claimed_bitmask.load(Ordering::Relaxed);
            if claimed_bitmask == u32::MAX {
                return Vec::new();
            }

            // Build a mask of up to `n` free seats by walking the complement.
            let mut enrolled_bitmask = 0;
            let mut available_bitmask = !claimed_bitmask;
            for _ in 0..n {
                if available_bitmask == 0 {
                    break;
                }
                // Isolate the lowest available bit and add it to the enrollment
                // bits
                enrolled_bitmask |=
                    available_bitmask & available_bitmask.wrapping_neg();
                // Remove that bit from the available bits
                available_bitmask &= available_bitmask - 1;
            }

            // This RMW tries to atomically claim the selected seats all at
            // once. Doing this in a single step keeps the batch claim atomic
            // with respect to other concurrent `try_enroll_many` calls, and can
            // prevent livelocks.
            //
            // We use `Acquire` ordering on success to synchronize with the
            // `Release` RMW any previous owner would make during resignation.
            // If the CAS fails we lost a race and retry; since we claimed
            // nothing, the failure ordering can be `Relaxed`.
            if self
                .claimed_bitmask
                .compare_exchange(
                    claimed_bitmask,
                    claimed_bitmask | enrolled_bitmask,
                    Ordering::Acquire,
                    Ordering::Relaxed,
                )
                .is_ok()
            {
                return (0..32)
                    .filter(|&i| enrolled_bitmask & (1 << i) != 0)
                    .map(|seat_number| Membership {
                        thread_pool: self,
                        member_index: seat_number as usize,
                        member_data,
                    })
                    .collect();
            }
        }
    }

    /// Blocks workers from resigning from the pool.
    ///
    /// Each call to this function must be paired with exactly one following
    /// call to `unfreeze_membership`.