cargo fmt --all

Author: cuviper

examples/cpu_monitor.rs

@@ -35,8 +35,9 @@ pub struct Args {
 }
 
 fn main() {
-    let args: &Args =
-        &Docopt::new(USAGE).and_then(|d| d.deserialize()).unwrap_or_else(|e| e.exit());
+    let args: &Args = &Docopt::new(USAGE)
+        .and_then(|d| d.deserialize())
+        .unwrap_or_else(|e| e.exit());
 
     match &args.arg_scenario[..] {
         "tasks_ended" => tasks_ended(args),
@@ -80,7 +81,7 @@ fn task_stall_root(args: &Args) {
 
 fn task_stall_scope(args: &Args) {
     rayon::scope(|scope| {
-                     scope.spawn(move |_| task(args));
-                     scope.spawn(move |_| wait_for_user());
-                 });
+        scope.spawn(move |_| task(args));
+        scope.spawn(move |_| wait_for_user());
+    });
 }

rayon-core/src/compile_fail/mod.rs

@@ -1,4 +1,3 @@
-
 // These modules contain `compile_fail` doc tests.
 mod quicksort_race1;
 mod quicksort_race2;

rayon-core/src/internal/task.rs

@@ -81,4 +81,3 @@ pub trait ToScopeHandle<'scope> {
     /// Convert the receiver into a scope handle.
     fn to_scope_handle(&self) -> Self::ScopeHandle;
 }
-

rayon-core/src/internal/worker.rs

@@ -2,13 +2,13 @@
 //! worker thread. Intended for building abstractions atop the
 //! rayon-core thread pool, rather than direct use by end users.
 
-use std::fmt;
 use latch::LatchProbe;
 use registry;
+use std::fmt;
 
 /// Represents the active worker thread.
 pub struct WorkerThread<'w> {
-    thread: &'w registry::WorkerThread
+    thread: &'w registry::WorkerThread,
 }
 
 impl<'w> WorkerThread<'w> {
@@ -25,8 +25,13 @@ impl<'w> WorkerThread<'w> {
     /// you must ensure that, once the condition `f()` becomes true,
     /// some "rayon event" will also occur to ensure that waiting
     /// threads are awoken.
-    pub unsafe fn wait_until_true<F>(&self, f: F) where F: Fn() -> bool {
-        struct DummyLatch<'a, F: 'a> { f: &'a F }
+    pub unsafe fn wait_until_true<F>(&self, f: F)
+    where
+        F: Fn() -> bool,
+    {
+        struct DummyLatch<'a, F: 'a> {
+            f: &'a F,
+        }
 
         impl<'a, F: Fn() -> bool> LatchProbe for DummyLatch<'a, F> {
             fn probe(&self) -> bool {
@@ -51,17 +56,19 @@ impl<'w> fmt::Debug for WorkerThread<'w> {
 /// is invoked with a reference to the worker-thread the result of
 /// that callback is returned with `Some`. Otherwise, if we are not on
 /// a Rayon worker thread, `None` is immediately returned.
-pub fn if_in_worker_thread<F,R>(if_true: F) -> Option<R>
-    where F: FnOnce(&WorkerThread) -> R,
+pub fn if_in_worker_thread<F, R>(if_true: F) -> Option<R>
+where
+    F: FnOnce(&WorkerThread) -> R,
 {
     let worker_thread = registry::WorkerThread::current();
     if worker_thread.is_null() {
         None
     } else {
         unsafe {
-            let wt = WorkerThread { thread: &*worker_thread };
+            let wt = WorkerThread {
+                thread: &*worker_thread,
+            };
             Some(if_true(&wt))
         }
     }
 }
-

rayon-core/src/job.rs

@@ -41,7 +41,8 @@ impl JobRef {
     /// Unsafe: caller asserts that `data` will remain valid until the
     /// job is executed.
     pub unsafe fn new<T>(data: *const T) -> JobRef
-        where T: Job
+    where
+        T: Job,
     {
         let fn_ptr: unsafe fn(*const T) = <T as Job>::execute;
 
@@ -66,19 +67,21 @@ impl JobRef {
 /// the stack frame is later popped.  The function parameter indicates
 /// `true` if the job was stolen -- executed on a different thread.
 pub struct StackJob<L, F, R>
-    where L: Latch + Sync,
-          F: FnOnce(bool) -> R + Send,
-          R: Send
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
 {
     pub latch: L,
     func: UnsafeCell<Option<F>>,
     result: UnsafeCell<JobResult<R>>,
 }
 
 impl<L, F, R> StackJob<L, F, R>
-    where L: Latch + Sync,
-          F: FnOnce(bool) -> R + Send,
-          R: Send
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
 {
     pub fn new(func: F, latch: L) -> StackJob<L, F, R> {
         StackJob {
@@ -102,9 +105,10 @@ impl<L, F, R> StackJob<L, F, R>
 }
 
 impl<L, F, R> Job for StackJob<L, F, R>
-    where L: Latch + Sync,
-          F: FnOnce(bool) -> R + Send,
-          R: Send
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
 {
     unsafe fn execute(this: *const Self) {
         let this = &*this;
@@ -126,16 +130,20 @@ impl<L, F, R> Job for StackJob<L, F, R>
 ///
 /// (Probably `StackJob` should be refactored in a similar fashion.)
 pub struct HeapJob<BODY>
-    where BODY: FnOnce() + Send
+where
+    BODY: FnOnce() + Send,
 {
     job: UnsafeCell<Option<BODY>>,
 }
 
 impl<BODY> HeapJob<BODY>
-    where BODY: FnOnce() + Send
+where
+    BODY: FnOnce() + Send,
 {
     pub fn new(func: BODY) -> Self {
-        HeapJob { job: UnsafeCell::new(Some(func)) }
+        HeapJob {
+            job: UnsafeCell::new(Some(func)),
+        }
     }
 
     /// Creates a `JobRef` from this job -- note that this hides all
@@ -148,7 +156,8 @@ impl<BODY> HeapJob<BODY>
 }
 
 impl<BODY> Job for HeapJob<BODY>
-    where BODY: FnOnce() + Send
+where
+    BODY: FnOnce() + Send,
 {
     unsafe fn execute(this: *const Self) {
         let this: Box<Self> = mem::transmute(this);

rayon-core/src/join/mod.rs

@@ -1,6 +1,6 @@
+use job::StackJob;
 use latch::{LatchProbe, SpinLatch};
 use log::Event::*;
-use job::StackJob;
 use registry::{self, WorkerThread};
 use std::any::Any;
 use unwind;
@@ -92,10 +92,11 @@ mod test;
 /// panic with the same panic value. If both closures panic, `join()`
 /// will panic with the panic value from the first closure.
 pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
-    where A: FnOnce() -> RA + Send,
-          B: FnOnce() -> RB + Send,
-          RA: Send,
-          RB: Send
+where
+    A: FnOnce() -> RA + Send,
+    B: FnOnce() -> RB + Send,
+    RA: Send,
+    RB: Send,
 {
     join_context(|_| oper_a(), |_| oper_b())
 }
@@ -108,19 +109,24 @@ pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
 /// `join_context` was called from outside the thread pool to begin
 /// with.
 pub fn join_context<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
-    where A: FnOnce(FnContext) -> RA + Send,
-          B: FnOnce(FnContext) -> RB + Send,
-          RA: Send,
-          RB: Send
+where
+    A: FnOnce(FnContext) -> RA + Send,
+    B: FnOnce(FnContext) -> RB + Send,
+    RA: Send,
+    RB: Send,
 {
     registry::in_worker(|worker_thread, injected| unsafe {
-        log!(Join { worker: worker_thread.index() });
+        log!(Join {
+            worker: worker_thread.index()
+        });
 
         // Create virtual wrapper for task b; this all has to be
         // done here so that the stack frame can keep it all live
         // long enough.
-        let job_b = StackJob::new(|migrated| oper_b(FnContext::new(migrated)),
-                                  SpinLatch::new());
+        let job_b = StackJob::new(
+            |migrated| oper_b(FnContext::new(migrated)),
+            SpinLatch::new(),
+        );
         let job_b_ref = job_b.as_job_ref();
         worker_thread.push(job_b_ref);
 
@@ -142,17 +148,23 @@ pub fn join_context<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
                     // Found it! Let's run it.
                     //
                     // Note that this could panic, but it's ok if we unwind here.
-                    log!(PoppedRhs { worker: worker_thread.index() });
+                    log!(PoppedRhs {
+                        worker: worker_thread.index()
+                    });
                     let result_b = job_b.run_inline(injected);
                     return (result_a, result_b);
                 } else {
-                    log!(PoppedJob { worker: worker_thread.index() });
+                    log!(PoppedJob {
+                        worker: worker_thread.index()
+                    });
                     worker_thread.execute(job);
                 }
             } else {
                 // Local deque is empty. Time to steal from other
                 // threads.
-                log!(LostJob { worker: worker_thread.index() });
+                log!(LostJob {
+                    worker: worker_thread.index()
+                });
                 worker_thread.wait_until(&job_b.latch);
                 debug_assert!(job_b.latch.probe());
                 break;
@@ -167,11 +179,11 @@ pub fn join_context<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
 /// B is complete. This is because it may contain references into the
 /// enclosing stack frame(s).
 #[cold] // cold path
-unsafe fn join_recover_from_panic(worker_thread: &WorkerThread,
-                                  job_b_latch: &SpinLatch,
-                                  err: Box<Any + Send>)
-                                  -> !
-{
+unsafe fn join_recover_from_panic(
+    worker_thread: &WorkerThread,
+    job_b_latch: &SpinLatch,
+    err: Box<Any + Send>,
+) -> ! {
     worker_thread.wait_until(job_b_latch);
     unwind::resume_unwinding(err)
 }

rayon-core/src/join/test.rs

@@ -1,10 +1,10 @@
 //! Tests for the join code.
 
-use ThreadPoolBuilder;
 use join::*;
-use rand::{Rng, SeedableRng, XorShiftRng};
 use rand::distributions::Standard;
+use rand::{Rng, SeedableRng, XorShiftRng};
 use unwind;
+use ThreadPoolBuilder;
 
 fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) {
     if v.len() <= 1 {
@@ -96,9 +96,8 @@ fn join_context_both() {
 fn join_context_neither() {
     // If we're already in a 1-thread pool, neither job should be stolen.
     let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
-    let (a_migrated, b_migrated) = pool.install(|| {
-        join_context(|a| a.migrated(), |b| b.migrated())
-    });
+    let (a_migrated, b_migrated) =
+        pool.install(|| join_context(|a| a.migrated(), |b| b.migrated()));
     assert!(!a_migrated);
     assert!(!b_migrated);
 }
@@ -111,8 +110,16 @@ fn join_context_second() {
     let barrier = Barrier::new(2);
     let pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap();
     let (a_migrated, b_migrated) = pool.install(|| {
-        join_context(|a| { barrier.wait(); a.migrated() },
-                     |b| { barrier.wait(); b.migrated() })
+        join_context(
+            |a| {
+                barrier.wait();
+                a.migrated()
+            },
+            |b| {
+                barrier.wait();
+                b.migrated()
+            },
+        )
     });
     assert!(!a_migrated);
     assert!(b_migrated);

rayon-core/src/latch.rs

@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::{Mutex, Condvar};
+use std::sync::{Condvar, Mutex};
 use std::usize;
 
 use sleep::Sleep;
@@ -50,7 +50,9 @@ pub struct SpinLatch {
 impl SpinLatch {
     #[inline]
     pub fn new() -> SpinLatch {
-        SpinLatch { b: AtomicBool::new(false) }
+        SpinLatch {
+            b: AtomicBool::new(false),
+        }
     }
 }
 
@@ -124,7 +126,9 @@ pub struct CountLatch {
 impl CountLatch {
     #[inline]
     pub fn new() -> CountLatch {
-        CountLatch { counter: AtomicUsize::new(1) }
+        CountLatch {
+            counter: AtomicUsize::new(1),
+        }
     }
 
     #[inline]
@@ -150,7 +154,6 @@ impl Latch for CountLatch {
     }
 }
 
-
 /// A tickling latch wraps another latch type, and will also awaken a thread
 /// pool when it is set.  This is useful for jobs injected between thread pools,
 /// so the source pool can continue processing its own work while waiting.