Struct miri::concurrency::thread::ThreadManager

pub struct ThreadManager<'mir, 'tcx> {
    active_thread: ThreadId,
    threads: IndexVec<ThreadId, Thread<'mir, 'tcx>>,
    pub(crate) sync: SynchronizationState<'mir, 'tcx>,
    thread_local_alloc_ids: RefCell<FxHashMap<(DefId, ThreadId), Pointer<Provenance>>>,
    yield_active_thread: bool,
    timeout_callbacks: FxHashMap<ThreadId, TimeoutCallbackInfo<'mir, 'tcx>>,
}

A set of threads.

Fields

active_thread: ThreadId

Identifier of the currently active thread.

threads: IndexVec<ThreadId, Thread<'mir, 'tcx>>

Threads used in the program.

Note that this vector also contains terminated threads.

sync: SynchronizationState<'mir, 'tcx>

This field is pub(crate) because the synchronization primitives (crate::sync) need a way to access it.

thread_local_alloc_ids: RefCell<FxHashMap<(DefId, ThreadId), Pointer<Provenance>>>

A mapping from a thread-local static to an allocation id of a thread specific allocation.

yield_active_thread: bool

A flag that indicates that we should change the active thread.

timeout_callbacks: FxHashMap<ThreadId, TimeoutCallbackInfo<'mir, 'tcx>>

Callbacks that are called once the specified time passes.

Implementations

impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx>

pub(crate) fn init(
    ecx: &mut MiriInterpCx<'mir, 'tcx>,
    on_main_stack_empty: StackEmptyCallback<'mir, 'tcx>
)

fn get_thread_local_alloc_id(&self, def_id: DefId) -> Option<Pointer<Provenance>>

Check if we have an allocation for the given thread local static for the active thread.

fn set_thread_local_alloc(&self, def_id: DefId, ptr: Pointer<Provenance>)

Set the pointer for the allocation of the given thread local static for the active thread.

Panics if a thread local is initialized twice for the same thread.

pub fn active_thread_stack(
    &self
) -> &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>]

Borrow the stack of the active thread.

fn active_thread_stack_mut(
    &mut self
) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>>

Mutably borrow the stack of the active thread.

pub fn all_stacks(
    &self
) -> impl Iterator<Item = &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>]>

fn create_thread(
    &mut self,
    on_stack_empty: StackEmptyCallback<'mir, 'tcx>
) -> ThreadId

Create a new thread and returns its id.

fn set_active_thread_id(&mut self, id: ThreadId) -> ThreadId

Set an active thread and return the id of the thread that was active before.

pub fn get_active_thread_id(&self) -> ThreadId

Get the id of the currently active thread.

pub fn get_total_thread_count(&self) -> usize

Get the total number of threads that were ever spawn by this program.

pub fn get_live_thread_count(&self) -> usize

Get the total of threads that are currently live, i.e., not yet terminated. (They might be blocked.)

fn has_terminated(&self, thread_id: ThreadId) -> bool

Has the given thread terminated?

fn have_all_terminated(&self) -> bool

Have all threads terminated?

fn enable_thread(&mut self, thread_id: ThreadId)

Enable the thread for execution. The thread must be terminated.

pub fn active_thread_mut(&mut self) -> &mut Thread<'mir, 'tcx>

Get a mutable borrow of the currently active thread.

pub fn active_thread_ref(&self) -> &Thread<'mir, 'tcx>

Get a shared borrow of the currently active thread.

fn detach_thread(
    &mut self,
    id: ThreadId,
    allow_terminated_joined: bool
) -> InterpResult<'tcx>

Mark the thread as detached, which means that no other thread will try to join it and the thread is responsible for cleaning up.

allow_terminated_joined allows detaching joined threads that have already terminated. This matches Windows’s behavior for CloseHandle.

See https://docs.microsoft.com/en-us/windows/win32/procthread/thread-handles-and-identifiers:

The handle is valid until closed, even after the thread it represents has been terminated.

fn join_thread(
    &mut self,
    joined_thread_id: ThreadId,
    data_race: Option<&mut GlobalState>
) -> InterpResult<'tcx>

Mark that the active thread tries to join the thread with joined_thread_id.

fn join_thread_exclusive(
    &mut self,
    joined_thread_id: ThreadId,
    data_race: Option<&mut GlobalState>
) -> InterpResult<'tcx>

Mark that the active thread tries to exclusively join the thread with joined_thread_id. If the thread is already joined by another thread, it will throw UB

pub fn set_thread_name(&mut self, thread: ThreadId, new_thread_name: Vec<u8>)

Set the name of the given thread.

pub fn get_thread_name(&self, thread: ThreadId) -> &[u8]

Get the name of the given thread.

fn block_thread(&mut self, thread: ThreadId)

Put the thread into the blocked state.

fn unblock_thread(&mut self, thread: ThreadId)

Put the blocked thread into the enabled state.

fn yield_active_thread(&mut self)

Change the active thread to some enabled thread.

fn register_timeout_callback(
    &mut self,
    thread: ThreadId,
    call_time: Time,
    callback: Box<dyn MachineCallback<'mir, 'tcx> + 'tcx>
)

Register the given callback to be called once the call_time passes.

The callback will be called with thread being the active thread, and the callback may not change the active thread.

fn unregister_timeout_callback_if_exists(&mut self, thread: ThreadId)

Unregister the callback for the thread.

fn get_ready_callback(
    &mut self,
    clock: &Clock
) -> Option<(ThreadId, Box<dyn MachineCallback<'mir, 'tcx> + 'tcx>)>

Get a callback that is ready to be called.

fn thread_terminated(
    &mut self,
    data_race: Option<&mut GlobalState>
) -> Vec<Pointer<Provenance>>

Wakes up threads joining on the active one and deallocates thread-local statics. The AllocId that can now be freed are returned.

fn schedule(&mut self, clock: &Clock) -> InterpResult<'tcx, SchedulingAction>

Decide which action to take next and on which thread.

The currently implemented scheduling policy is the one that is commonly used in stateless model checkers such as Loom: run the active thread as long as we can and switch only when we have to (the active thread was blocked, terminated, or has explicitly asked to be preempted).

Trait Implementations

impl<'mir, 'tcx> Debug for ThreadManager<'mir, 'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'mir, 'tcx> Default for ThreadManager<'mir, 'tcx>

fn default() -> Self

Returns the “default value” for a type.

impl VisitTags for ThreadManager<'_, '_>

fn visit_tags(&self, visit: &mut dyn FnMut(BorTag))

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