Method promote_cold

src/thread_pool.rs:1261–1328

(&self, current_tick: u64)

    pub(crate) membership: Membership,
    /// A sequence of jobs waiting to be executed. Newer jobs are executed
    /// before older ones, allowing efficient depth-first execution. During
    /// promotion, the oldest job is shared. Populated by `join()`.
    ///
    /// Jobs in this queue take precedence over those in the fifo queue.
    lifo_queue: JobQueue,
    /// A sequence of jobs waiting to be executed. Older jobs are executed
    /// before newer ones, providing reliably low latency. During promotion,
    /// this queue is partitioned into chunks and the chunks are shared.
    /// Populated by `spawn()`.
    ///
    /// Jobs in this queue are executed only when the lifo queue is empty.
    pub(crate) fifo_queue: JobQueue,
    /// A sequence of `!Sendf` jobs waitging to be executed. Older jobs are
    /// executed before newer ones.
    ///
    /// This queue does not participate in promotion. This is a `SeqQueue` so
    /// that a `Future` that is `!Send` and has been spawned onto this thread
    /// can be woken on another thread (the other thread then sends this thread
    /// a job that polls the future).
    pub(crate) nonsend_fifo_queue: Arc<SegQueue<JobRef>>,
    /// A local psudorandom number-generator. Used to spread out
    /// worker-to-worker operations evenly across the pool.
    rng: XorShift64Star,
    /// The CPU tick when work was last promoted from local to shared. This has
    /// no absolute relation to time.
    last_promote_tick: Cell<u64>,
    /// Set to true when executing a job that came from a different thread.
    migrated: Cell<bool>,
    // Make non-send. A `Worker` represents the local state of a particular
    // thread, so must be `!Send` and `!Sync`. It is already `!Sync` because of
    // `Cell`.
    _phantom: PhantomData<*const ()>,
}

use core::ops::Deref;

impl Deref for Worker {
    type Target = Membership;

    fn deref(&self) -> &Membership {
        &self.membership
    }
}

/// Describes the outcome of a call to [`Worker::yield_now`] or
/// [`Worker::yield_local`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Yield {
    /// Indicates that a job was executed.
    Executed,
    /// Indicates that no job was executed. After receiving this, do not `yield`
    /// again until you have a reasonable expectation that new work will have
    /// been shared.
    Idle,
}

impl Worker {
    /// Calls the provided closure on the thread's worker instance, if it has