sembr src/parallel-rustc.md

Author: tshepang

src/parallel-rustc.md

@@ -11,7 +11,8 @@ Tracking issue: <https://github.com/rust-lang/rust/issues/113349>
 As of <!-- date-check --> November 2024, most of the rust compiler is now
 parallelized.
 
-- The codegen part is executed concurrently by default. You can use the `-C
+- The codegen part is executed concurrently by default.
+  You can use the `-C
   codegen-units=n` option to control the number of concurrent tasks.
 - The parts after HIR lowering to codegen such as type checking, borrowing
   checking, and mir optimization are parallelized in the nightly version.
@@ -31,17 +32,19 @@ The following sections are kept for now but are quite outdated.
 ## Code generation
 
 During monomorphization the compiler splits up all the code to
-be generated into smaller chunks called _codegen units_. These are then generated by
-independent instances of LLVM running in parallel. At the end, the linker
-is run to combine all the codegen units together into one binary. This process
-occurs in the [`rustc_codegen_ssa::base`] module.
+be generated into smaller chunks called _codegen units_.
+These are then generated by independent instances of LLVM running in parallel.
+At the end, the linker
+is run to combine all the codegen units together into one binary.
+This process occurs in the [`rustc_codegen_ssa::base`] module.
 
 [`rustc_codegen_ssa::base`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/index.html
 
 ## Data structures
 
 The underlying thread-safe data-structures used in the parallel compiler
-can be found in the [`rustc_data_structures::sync`] module. These data structures 
+can be found in the [`rustc_data_structures::sync`] module.
+These data structures
 are implemented differently depending on whether `parallel-compiler` is true.
 
 | data structure                   | parallel                                            | non-parallel |
@@ -68,14 +71,18 @@ are implemented differently depending on whether `parallel-compiler` is true.
 
 ### WorkerLocal
 
-[`WorkerLocal`] is a special data structure implemented for parallel compilers. It
-holds worker-locals values for each thread in a thread pool. You can only
+[`WorkerLocal`] is a special data structure implemented for parallel compilers.
+It 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. 
+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,
+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`.
 
@@ -85,7 +92,8 @@ 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
+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 
@@ -142,15 +150,17 @@ When a query `foo` is evaluated, the cache table for `foo` is locked.
   start evaluating.
 - If there *is* another query invocation for the same key in progress, we
   release the lock, and just block the thread until the other invocation has
-  computed the result we are waiting for. **Cycle error detection** in the parallel 
-  compiler requires more complex logic than in single-threaded mode. When 
+  computed the result we are waiting for.
+  **Cycle error detection** in the parallel
+  compiler requires more complex logic than in single-threaded mode.
+  When
   worker threads in parallel queries stop making progress due to interdependence, 
   the compiler uses an extra thread *(named deadlock handler)* to detect, remove and 
   report the cycle error.
 
 The parallel query feature still has implementation to do, most of which is
-related to the previous `Data Structures` and `Parallel Iterators`. See [this
-open feature tracking issue][tracking].
+related to the previous `Data Structures` and `Parallel Iterators`.
+See [this open feature tracking issue][tracking].
 
 ## Rustdoc