Struct ScopeBase

struct ScopeBase<'scope> {
    registry: Arc<Registry>,
    panic: AtomicPtr<Box<dyn Any + Send + 'static>>,
    job_completed_latch: CountLatch,
    pending_jobs: Mutex<HashSet<JobRefId>>,
    worker: Option<usize>,
    marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>,
    tlv: Tlv,
}

Fields

registry: Arc<Registry>

thread registry where scope() was executed or where in_place_scope() should spawn jobs.

panic: AtomicPtr<Box<dyn Any + Send + 'static>>

if some job panicked, the error is stored here; it will be propagated to the one who created the scope

job_completed_latch: CountLatch

latch to track job counts

pending_jobs: Mutex<HashSet<JobRefId>>

Jobs that have been spawned, but not yet started.

worker: Option<usize>

The worker which will wait on scope completion, if any.

marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>

You can think of a scope as containing a list of closures to execute, all of which outlive 'scope. They’re not actually required to be Sync, but it’s still safe to let the Scope implement Sync because the closures are only moved across threads to be executed.

tlv: Tlv

The TLV at the scope’s creation. Used to set the TLV for spawned jobs.

Implementations

impl<'scope> ScopeBase<'scope>

fn new(owner: Option<&WorkerThread>, registry: Option<&Arc<Registry>>) -> Self

Creates the base of a new scope for the given registry

fn heap_job_ref<FUNC>(&self, job: Box<HeapJob<FUNC>>) -> JobRef

where FUNC: FnOnce(JobRefId) + Send + 'scope,

fn inject_broadcast<FUNC>(&self, job: Arc<ArcJob<FUNC>>)

where FUNC: Fn(JobRefId) + Send + Sync + 'scope,

fn complete<FUNC, R>(&self, owner: Option<&WorkerThread>, func: FUNC) -> R

where FUNC: FnOnce() -> R,

Executes func as a job, either aborting or executing as appropriate.

unsafe fn execute_job<FUNC>(this: *const Self, func: FUNC)

where FUNC: FnOnce(),

Executes func as a job, either aborting or executing as appropriate.

unsafe fn execute_job_closure<FUNC, R>( this: *const Self, func: FUNC, ) -> Option<R>

where FUNC: FnOnce() -> R,

Executes func as a job in scope. Adjusts the “job completed” counters and also catches any panic and stores it into scope.

fn job_panicked(&self, err: Box<dyn Any + Send + 'static>)

fn maybe_propagate_panic(&self)

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: 128 bytes