Struct rayon_core::registry::WorkerThread

pub(crate) struct WorkerThread {
    worker: Worker<JobRef>,
    stealer: Stealer<JobRef>,
    fifo: JobFifo,
    index: usize,
    rng: XorShift64Star,
    registry: Arc<Registry>,
}

//////////////////////////////////////////////////////////////////////// WorkerThread identifiers

Fields

worker: Worker<JobRef>

the “worker” half of our local deque

stealer: Stealer<JobRef>

the “stealer” half of the worker’s broadcast deque

fifo: JobFifo

local queue used for spawn_fifo indirection

index: usize

rng: XorShift64Star

A weak random number generator.

registry: Arc<Registry>

Implementations

impl WorkerThread

pub(crate) fn current() -> *const WorkerThread

Gets the WorkerThread index for the current thread; returns NULL if this is not a worker thread. This pointer is valid anywhere on the current thread.

unsafe fn set_current(thread: *const WorkerThread)

Sets self as the worker thread index for the current thread. This is done during worker thread startup.

pub(crate) fn registry(&self) -> &Arc<Registry>

Returns the registry that owns this worker thread.

pub(crate) fn index(&self) -> usize

Our index amongst the worker threads (ranges from 0..self.num_threads()).

pub(crate) unsafe fn push(&self, job: JobRef)

pub(crate) unsafe fn push_fifo(&self, job: JobRef)

pub(crate) fn local_deque_is_empty(&self) -> bool

pub(crate) fn take_local_job(&self) -> Option<JobRef>

Attempts to obtain a “local” job – typically this means popping from the top of the stack, though if we are configured for breadth-first execution, it would mean dequeuing from the bottom.

fn has_injected_job(&self) -> bool

pub(crate) unsafe fn wait_until<L: AsCoreLatch + ?Sized>(&self, latch: &L)

Wait until the latch is set. Try to keep busy by popping and stealing tasks as necessary.

unsafe fn wait_until_cold(&self, latch: &CoreLatch)

unsafe fn wait_until_out_of_work(&self)

fn find_work(&self) -> Option<JobRef>

pub(crate) fn yield_now(&self) -> Yield

pub(crate) fn yield_local(&self) -> Yield

pub(crate) unsafe fn execute(&self, job: JobRef)

fn steal(&self) -> Option<JobRef>

Try to steal a single job and return it.

This should only be done as a last resort, when there is no local work to do.

Trait Implementations

impl Drop for WorkerThread

fn drop(&mut self)

Executes the destructor for this type.

impl From<ThreadBuilder> for WorkerThread

fn from(thread: ThreadBuilder) -> Self

Converts to this type from the input type.