Struct WorkerThread

pub(crate) struct WorkerThread {
    worker: Worker<JobRef>,
    stealer: Stealer<JobRef>,
    fifo: JobFifo,
    pub(crate) index: usize,
    rng: XorShift64Star,
    pub(crate) 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.

pub(crate) 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.

pub(crate) unsafe fn wait_for_jobs<L: AsCoreLatch + ?Sized, const BROADCAST_JOBS: bool>( &self, latch: &L, all_jobs_started: impl FnMut() -> bool, is_job: impl FnMut(&JobRef) -> bool, execute_job: impl FnMut(JobRef), )

Wait until the latch is set. Executes local jobs if is_job is true for them and all_jobs_started still returns false.

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

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

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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 384 bytes