WorkerLocal and Parallel Iterators in Rust

holds worker-locals values for each thread in a thread pool. You can only access the worker local value through the `Deref` `impl` on the thread pool it was constructed on. It panics otherwise. `WorkerLocal` is used to implement the `Arena` allocator in the parallel environment, which is critical in parallel queries. Its implementation is located in the [`rustc_data_structures::sync::worker_local`] module. However, in the non-parallel compiler, it is implemented as `(OneThread<T>)`, whose `T` can be accessed directly through `Deref::deref`. ## Parallel iterator The parallel iterators provided by the [`rayon`] crate are easy ways to implement parallelism. In the current implementation of the parallel compiler we use a custom [fork][rustc-rayon] of `rayon` to run tasks in parallel. Some iterator functions are implemented to run loops in parallel when `parallel-compiler` is true. | Function(Omit `Send` and `Sync`) | Introduction | Owning Module | | ------------------------------------------------------------ | ------------------------------------------------------------ | -------------------------- | | **par_iter**<T: IntoParallelIterator>(t: T) -> T::Iter | generate a parallel iterator | rustc_data_structure::sync | | **par_for_each_in**<T: IntoParallelIterator>(t: T, for_each: impl Fn(T::Item)) | generate a parallel iterator and run `for_each` on each element | rustc_data_structure::sync | | **Map::par_body_owners**(self, f: impl Fn(LocalDefId)) | run `f` on all hir owners in the crate | rustc_middle::hir::map | | **Map::par_for_each_module**(self, f: impl Fn(LocalDefId)) | run `f` on all modules and sub modules in the crate | rustc_middle::hir::map | | **ModuleItems::par_items**(&self, f: impl Fn(ItemId)) | run `f` on all items in the module | rustc_middle::hir | | **ModuleItems::par_trait_items**(&self, f: impl Fn(TraitItemId)) | run `f` on all trait items in the module | rustc_middle::hir | | **ModuleItems::par_impl_items**(&self, f: impl Fn(ImplItemId)) | run `f` on all impl items in the module | rustc_middle::hir | | **ModuleItems::par_foreign_items**(&self, f: impl Fn(ForeignItemId)) | run `f` on all foreign items in the module | rustc_middle::hir | There are a lot of loops in the compiler which can possibly be parallelized using these functions. As of  August 2022, scenarios where the parallel iterator function has been used are as follows: | caller | scenario | callee | | ------------------------------------------------------- | ------------------------------------------------------------ | ------------------------ | | rustc_metadata::rmeta::encoder::prefetch_mir | Prefetch queries which will be needed later by metadata encoding | par_iter | | rustc_monomorphize::collector::collect_crate_mono_items | Collect monomorphized items reachable from non-generic items | par_for_each_in | | rustc_interface::passes::analysis | Check the validity of the match statements | Map::par_body_owners |

This section explains the `WorkerLocal` data structure, which holds worker-local values for each thread in a thread pool and is crucial for implementing the `Arena` allocator in parallel queries. It also describes parallel iterators provided by the `rayon` crate, used for parallelism. Several iterator functions are implemented to run loops in parallel when `parallel-compiler` is enabled. The table lists several function callsites for these parallel functions, as well as descriptions of what they do.