Fix format and tidy for code moved from rayon

Author: celinval

compiler/rustc_thread_pool/src/broadcast/mod.rs

@@ -1,10 +1,11 @@
-use crate::job::{ArcJob, StackJob};
-use crate::latch::{CountLatch, LatchRef};
-use crate::registry::{Registry, WorkerThread};
 use std::fmt;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+use crate::job::{ArcJob, StackJob};
+use crate::latch::{CountLatch, LatchRef};
+use crate::registry::{Registry, WorkerThread};
+
 mod test;
 
 /// Executes `op` within every thread in the current threadpool. If this is
@@ -53,10 +54,7 @@ impl<'a> BroadcastContext<'a> {
     pub(super) fn with<R>(f: impl FnOnce(BroadcastContext<'_>) -> R) -> R {
         let worker_thread = WorkerThread::current();
         assert!(!worker_thread.is_null());
-        f(BroadcastContext {
-            worker: unsafe { &*worker_thread },
-            _marker: PhantomData,
-        })
+        f(BroadcastContext { worker: unsafe { &*worker_thread }, _marker: PhantomData })
     }
 
     /// Our index amongst the broadcast threads (ranges from `0..self.num_threads()`).
@@ -108,9 +106,8 @@ where
     let current_thread = WorkerThread::current().as_ref();
     let tlv = crate::tlv::get();
     let latch = CountLatch::with_count(n_threads, current_thread);
-    let jobs: Vec<_> = (0..n_threads)
-        .map(|_| StackJob::new(tlv, &f, LatchRef::new(&latch)))
-        .collect();
+    let jobs: Vec<_> =
+        (0..n_threads).map(|_| StackJob::new(tlv, &f, LatchRef::new(&latch))).collect();
     let job_refs = jobs.iter().map(|job| job.as_job_ref());
 
     registry.inject_broadcast(job_refs);

compiler/rustc_thread_pool/src/broadcast/test.rs renamed to compiler/rustc_thread_pool/src/broadcast/tests.rs

@@ -1,11 +1,12 @@
 #![cfg(test)]
 
-use crate::ThreadPoolBuilder;
+use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc::channel;
-use std::sync::Arc;
 use std::{thread, time};
 
+use crate::ThreadPoolBuilder;
+
 #[test]
 fn broadcast_global() {
     let v = crate::broadcast(|ctx| ctx.index());

compiler/rustc_thread_pool/src/job.rs

@@ -1,13 +1,14 @@
-use crate::latch::Latch;
-use crate::tlv;
-use crate::tlv::Tlv;
-use crate::unwind;
-use crossbeam_deque::{Injector, Steal};
 use std::any::Any;
 use std::cell::UnsafeCell;
 use std::mem;
 use std::sync::Arc;
 
+use crossbeam_deque::{Injector, Steal};
+
+use crate::latch::Latch;
+use crate::tlv::Tlv;
+use crate::{tlv, unwind};
+
 pub(super) enum JobResult<T> {
     None,
     Ok(T),
@@ -29,7 +30,7 @@ pub(super) trait Job {
 /// Effectively a Job trait object. Each JobRef **must** be executed
 /// exactly once, or else data may leak.
 ///
-/// Internally, we store the job's data in a `*const ()` pointer.  The
+/// Internally, we store the job's data in a `*const ()` pointer. The
 /// true type is something like `*const StackJob<...>`, but we hide
 /// it. We also carry the "execute fn" from the `Job` trait.
 pub(super) struct JobRef {
@@ -48,10 +49,7 @@ impl JobRef {
         T: Job,
     {
         // erase types:
-        JobRef {
-            pointer: data as *const (),
-            execute_fn: <T as Job>::execute,
-        }
+        JobRef { pointer: data as *const (), execute_fn: <T as Job>::execute }
     }
 
     /// Returns an opaque handle that can be saved and compared,
@@ -69,7 +67,7 @@ impl JobRef {
 
 /// A job that will be owned by a stack slot. This means that when it
 /// executes it need not free any heap data, the cleanup occurs when
-/// the stack frame is later popped.  The function parameter indicates
+/// the stack frame is later popped. The function parameter indicates
 /// `true` if the job was stolen -- executed on a different thread.
 pub(super) struct StackJob<L, F, R>
 where
@@ -248,13 +246,11 @@ pub(super) struct JobFifo {
 
 impl JobFifo {
     pub(super) fn new() -> Self {
-        JobFifo {
-            inner: Injector::new(),
-        }
+        JobFifo { inner: Injector::new() }
     }
 
     pub(super) unsafe fn push(&self, job_ref: JobRef) -> JobRef {
-        // A little indirection ensures that spawns are always prioritized in FIFO order.  The
+        // A little indirection ensures that spawns are always prioritized in FIFO order. The
         // jobs in a thread's deque may be popped from the back (LIFO) or stolen from the front
         // (FIFO), but either way they will end up popping from the front of this queue.
         self.inner.push(job_ref);

compiler/rustc_thread_pool/src/join/mod.rs

@@ -1,11 +1,10 @@
+use std::any::Any;
+
 use crate::job::StackJob;
 use crate::latch::SpinLatch;
 use crate::registry::{self, WorkerThread};
 use crate::tlv::{self, Tlv};
-use crate::unwind;
-use std::any::Any;
-
-use crate::FnContext;
+use crate::{FnContext, unwind};
 
 #[cfg(test)]
 mod test;
@@ -22,7 +21,7 @@ mod test;
 /// it.
 ///
 /// When `join` is called from outside the thread pool, the calling
-/// thread will block while the closures execute in the pool.  When
+/// thread will block while the closures execute in the pool. When
 /// `join` is called within the pool, the calling thread still actively
 /// participates in the thread pool. It will begin by executing closure
 /// A (on the current thread). While it is doing that, it will advertise
@@ -80,13 +79,13 @@ mod test;
 /// CPU-bound tasks that do not perform I/O or other blocking
 /// operations. If you do perform I/O, and that I/O should block
 /// (e.g., waiting for a network request), the overall performance may
-/// be poor.  Moreover, if you cause one closure to be blocked waiting
+/// be poor. Moreover, if you cause one closure to be blocked waiting
 /// on another (for example, using a channel), that could lead to a
 /// deadlock.
 ///
 /// # Panics
 ///
-/// No matter what happens, both closures will always be executed.  If
+/// No matter what happens, both closures will always be executed. If
 /// a single closure panics, whether it be the first or second
 /// closure, that panic will be propagated and hence `join()` will
 /// panic with the same panic value. If both closures panic, `join()`
@@ -109,7 +108,7 @@ where
 /// Identical to `join`, except that the closures have a parameter
 /// that provides context for the way the closure has been called,
 /// especially indicating whether they're executing on a different
-/// thread than where `join_context` was called.  This will occur if
+/// thread than where `join_context` was called. This will occur if
 /// the second job is stolen by a different thread, or if
 /// `join_context` was called from outside the thread pool to begin
 /// with.
@@ -148,7 +147,7 @@ where
         };
 
         // Now that task A has finished, try to pop job B from the
-        // local stack.  It may already have been popped by job A; it
+        // local stack. It may already have been popped by job A; it
         // may also have been stolen. There may also be some tasks
         // pushed on top of it in the stack, and we will have to pop
         // those off to get to it.

compiler/rustc_thread_pool/src/join/test.rs renamed to compiler/rustc_thread_pool/src/join/tests.rs

@@ -1,11 +1,12 @@
 //! Tests for the join code.
 
-use super::*;
-use crate::ThreadPoolBuilder;
 use rand::distr::StandardUniform;
 use rand::{Rng, SeedableRng};
 use rand_xorshift::XorShiftRng;
 
+use super::*;
+use crate::ThreadPoolBuilder;
+
 fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) {
     if v.len() <= 1 {
         return;

compiler/rustc_thread_pool/src/latch.rs

@@ -28,7 +28,7 @@ use crate::registry::{Registry, WorkerThread};
 /// - Once `probe()` returns true, all memory effects from the `set()`
 ///   are visible (in other words, the set should synchronize-with
 ///   the probe).
-/// - Once `set()` occurs, the next `probe()` *will* observe it.  This
+/// - Once `set()` occurs, the next `probe()` *will* observe it. This
 ///   typically requires a seq-cst ordering. See [the "tickle-then-get-sleepy" scenario in the sleep
 ///   README](/src/sleep/README.md#tickle-then-get-sleepy) for details.
 pub(super) trait Latch {
@@ -78,29 +78,23 @@ pub(super) struct CoreLatch {
 impl CoreLatch {
     #[inline]
     fn new() -> Self {
-        Self {
-            state: AtomicUsize::new(0),
-        }
+        Self { state: AtomicUsize::new(0) }
     }
 
     /// Invoked by owning thread as it prepares to sleep. Returns true
     /// if the owning thread may proceed to fall asleep, false if the
     /// latch was set in the meantime.
     #[inline]
     pub(super) fn get_sleepy(&self) -> bool {
-        self.state
-            .compare_exchange(UNSET, SLEEPY, Ordering::SeqCst, Ordering::Relaxed)
-            .is_ok()
+        self.state.compare_exchange(UNSET, SLEEPY, Ordering::SeqCst, Ordering::Relaxed).is_ok()
     }
 
     /// Invoked by owning thread as it falls asleep sleep. Returns
     /// true if the owning thread should block, or false if the latch
     /// was set in the meantime.
     #[inline]
     pub(super) fn fall_asleep(&self) -> bool {
-        self.state
-            .compare_exchange(SLEEPY, SLEEPING, Ordering::SeqCst, Ordering::Relaxed)
-            .is_ok()
+        self.state.compare_exchange(SLEEPY, SLEEPING, Ordering::SeqCst, Ordering::Relaxed).is_ok()
     }
 
     /// Invoked by owning thread as it falls asleep sleep. Returns
@@ -110,8 +104,7 @@ impl CoreLatch {
     pub(super) fn wake_up(&self) {
         if !self.probe() {
             let _ =
-                self.state
-                    .compare_exchange(SLEEPING, UNSET, Ordering::SeqCst, Ordering::Relaxed);
+                self.state.compare_exchange(SLEEPING, UNSET, Ordering::SeqCst, Ordering::Relaxed);
         }
     }
 
@@ -166,15 +159,12 @@ impl<'r> SpinLatch<'r> {
         }
     }
 
-    /// Creates a new spin latch for cross-threadpool blocking.  Notably, we
+    /// Creates a new spin latch for cross-threadpool blocking. Notably, we
     /// need to make sure the registry is kept alive after setting, so we can
     /// safely call the notification.
     #[inline]
     pub(super) fn cross(thread: &'r WorkerThread) -> SpinLatch<'r> {
-        SpinLatch {
-            cross: true,
-            ..SpinLatch::new(thread)
-        }
+        SpinLatch { cross: true, ..SpinLatch::new(thread) }
     }
 
     #[inline]
@@ -235,10 +225,7 @@ pub(super) struct LockLatch {
 impl LockLatch {
     #[inline]
     pub(super) fn new() -> LockLatch {
-        LockLatch {
-            m: Mutex::new(false),
-            v: Condvar::new(),
-        }
+        LockLatch { m: Mutex::new(false), v: Condvar::new() }
     }
 
     /// Block until latch is set, then resets this lock latch so it can be reused again.
@@ -288,9 +275,7 @@ pub(super) struct OnceLatch {
 impl OnceLatch {
     #[inline]
     pub(super) fn new() -> OnceLatch {
-        Self {
-            core_latch: CoreLatch::new(),
-        }
+        Self { core_latch: CoreLatch::new() }
     }
 
     /// Set the latch, then tickle the specific worker thread,
@@ -372,9 +357,7 @@ impl CountLatch {
                     registry: Arc::clone(owner.registry()),
                     worker_index: owner.index(),
                 },
-                None => CountLatchKind::Blocking {
-                    latch: LockLatch::new(),
-                },
+                None => CountLatchKind::Blocking { latch: LockLatch::new() },
             },
         }
     }
@@ -387,11 +370,7 @@ impl CountLatch {
 
     pub(super) fn wait(&self, owner: Option<&WorkerThread>) {
         match &self.kind {
-            CountLatchKind::Stealing {
-                latch,
-                registry,
-                worker_index,
-            } => unsafe {
+            CountLatchKind::Stealing { latch, registry, worker_index } => unsafe {
                 let owner = owner.expect("owner thread");
                 debug_assert_eq!(registry.id(), owner.registry().id());
                 debug_assert_eq!(*worker_index, owner.index());
@@ -409,11 +388,7 @@ impl Latch for CountLatch {
             // NOTE: Once we call `set` on the internal `latch`,
             // the target may proceed and invalidate `this`!
             match (*this).kind {
-                CountLatchKind::Stealing {
-                    ref latch,
-                    ref registry,
-                    worker_index,
-                } => {
+                CountLatchKind::Stealing { ref latch, ref registry, worker_index } => {
                     let registry = Arc::clone(registry);
                     if CoreLatch::set(latch) {
                         registry.notify_worker_latch_is_set(worker_index);
@@ -433,10 +408,7 @@ pub(super) struct LatchRef<'a, L> {
 
 impl<L> LatchRef<'_, L> {
     pub(super) fn new(inner: &L) -> LatchRef<'_, L> {
-        LatchRef {
-            inner,
-            marker: PhantomData,
-        }
+        LatchRef { inner, marker: PhantomData }
     }
 }