Module rustc_data_structures::sync

source ·
Expand description

This module defines various operations and types that are implemented in one way for the serial compiler, and another way the parallel compiler.

§Operations

The parallel versions of operations use Rayon to execute code in parallel, while the serial versions degenerate straightforwardly to serial execution. The operations include join, parallel, par_iter, and par_for_each.

§Types

The parallel versions of types provide various kinds of synchronization, while the serial compiler versions do not.

The following table shows how the types are implemented internally. Except where noted otherwise, the type in column one is defined as a newtype around the type from column two or three.

TypeSerial versionParallel version
Lrc<T>rc::Rc<T>sync::Arc<T>
Weak<T>rc::Weak<T>sync::Weak<T>
LRef<'a, T> 1&'a mut T&'a T
AtomicBoolCell<bool>atomic::AtomicBool
AtomicU32Cell<u32>atomic::AtomicU32
AtomicU64Cell<u64>atomic::AtomicU64
AtomicUsizeCell<usize>atomic::AtomicUsize
Lock<T>RefCell<T>RefCell<T> or
parking_lot::Mutex<T>
RwLock<T>RefCell<T>parking_lot::RwLock<T>
MTLock<T> 2TLock<T>
MTLockRef<'a, T> 1&'a mut MTLock<T>&'a MTLock<T>
ParallelIteratorIteratorrayon::iter::ParallelIterator

2 MTLock is similar to Lock, but the serial version avoids the cost of a RefCell. This is appropriate when interior mutability is not required.

1 MTRef, MTLockRef are type aliases.


  1.  
  2.  

Re-exports§

  • pub use lock::Lock;
  • pub use lock::LockGuard;
  • pub use lock::Mode;
  • pub use std::cell::Ref as ReadGuard;
  • pub use std::cell::Ref as MappedReadGuard;
  • pub use std::cell::RefMut as WriteGuard;
  • pub use std::cell::RefMut as MappedWriteGuard;
  • pub use std::cell::RefMut as MappedLockGuard;
  • pub use crate::marker::*;

Modules§

  • freeze 🔒
  • lock 🔒
    This module implements a lock which only uses synchronization if might_be_dyn_thread_safe is true. It implements DynSend and DynSync instead of the typical Send and Sync traits.
  • mode 🔒
  • parallel 🔒
    This module defines parallel operations that are implemented in one way for the serial compiler, and another way the parallel compiler.
  • vec 🔒

Structs§

  • A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference Counted’.
  • A cell which can be written to only once.
  • Weak is a version of Rc that holds a non-owning reference to the managed allocation. The allocation is accessed by calling upgrade on the Weak pointer, which returns an Option<Rc<T>>.
  • This is a single threaded variant of AtomicU64, AtomicUsize, etc. It has explicit ordering arguments and is only intended for use with the native atomic types. You should use this type through the AtomicU64, AtomicUsize, etc, type aliases as it’s not intended to be used separately.
  • A type which allows mutation using a lock until the value is frozen and can be accessed lock-free.
  • A guard holding shared access to a FreezeLock which is in a locked state or frozen.
  • A guard holding mutable access to a FreezeLock which is in a locked state or frozen.
  • Represents a list of threads which can access worker locals.
  • Holds worker local values for each possible thread in a registry. You can only access the worker local value through the Deref impl on the registry associated with the thread it was created on. It will panic otherwise.

Traits§

Functions§

Type Aliases§