Run rustfmt

runtime/executor/benches/perf.rs

@@ -1,22 +1,22 @@
-use executor::prelude::*;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use executor::prelude::*;
 
 fn increment(b: &mut Criterion) {
     let mut sum = 0;
     let executor = Executor::new();
 
-    b.bench_function("Executor::run", |b| b.iter(|| {
-        executor.run(
-            async {
+    b.bench_function("Executor::run", |b| {
+        b.iter(|| {
+            executor.run(async {
                 (0..10_000_000).for_each(|_| {
                     sum += 1;
                 });
-            },
-        );
-    }));
+            });
+        })
+    });
 
     black_box(sum);
 }
 
 criterion_group!(perf, increment);
-criterion_main!(perf);
+criterion_main!(perf);

runtime/executor/benches/spawn.rs

@@ -1,8 +1,8 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use executor::load_balancer;
 use executor::prelude::*;
 use futures_timer::Delay;
 use std::time::Duration;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 #[cfg(feature = "tokio-runtime")]
 mod benches {
@@ -27,7 +27,6 @@ mod benches {
     pub fn spawn_single(b: &mut Criterion) {
         _spawn_single(b);
     }
-
 }
 
 criterion_group!(spawn, benches::spawn_lot, benches::spawn_single);
@@ -36,29 +35,29 @@ criterion_main!(spawn);
 // Benchmark for a 10K burst task spawn
 fn _spawn_lot(b: &mut Criterion) {
     let executor = Executor::new();
-    b.bench_function("spawn_lot", |b| b.iter(|| {
-        let _ = (0..10_000)
-            .map(|_| {
-                executor.spawn(
-                    async {
+    b.bench_function("spawn_lot", |b| {
+        b.iter(|| {
+            let _ = (0..10_000)
+                .map(|_| {
+                    executor.spawn(async {
                         let duration = Duration::from_millis(1);
                         Delay::new(duration).await;
-                    },
-                )
-            })
-            .collect::<Vec<_>>();
-    }));
+                    })
+                })
+                .collect::<Vec<_>>();
+        })
+    });
 }
 
 // Benchmark for a single task spawn
 fn _spawn_single(b: &mut Criterion) {
     let executor = Executor::new();
-    b.bench_function("spawn single", |b| b.iter(|| {
-        executor.spawn(
-            async {
+    b.bench_function("spawn single", |b| {
+        b.iter(|| {
+            executor.spawn(async {
                 let duration = Duration::from_millis(1);
                 Delay::new(duration).await;
-            },
-        );
-    }));
+            });
+        })
+    });
 }

runtime/executor/benches/stats.rs

@@ -1,7 +1,7 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use executor::load_balancer::{core_count, get_cores, stats, SmpStats};
 use executor::placement;
 use std::thread;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 fn stress_stats<S: SmpStats + Sync + Send>(stats: &'static S) {
     let mut handles = Vec::with_capacity(*core_count());
@@ -27,9 +27,11 @@ fn stress_stats<S: SmpStats + Sync + Send>(stats: &'static S) {
 
 // 158,278 ns/iter (+/- 117,103)
 fn lockless_stats_bench(b: &mut Criterion) {
-    b.bench_function("stress_stats", |b| b.iter(|| {
-        stress_stats(stats());
-    }));
+    b.bench_function("stress_stats", |b| {
+        b.iter(|| {
+            stress_stats(stats());
+        })
+    });
 }
 
 fn lockless_stats_bad_load(b: &mut Criterion) {
@@ -45,9 +47,11 @@ fn lockless_stats_bad_load(b: &mut Criterion) {
         }
     }
 
-    b.bench_function("get_sorted_load", |b| b.iter(|| {
-        let _sorted_load = stats.get_sorted_load();
-    }));
+    b.bench_function("get_sorted_load", |b| {
+        b.iter(|| {
+            let _sorted_load = stats.get_sorted_load();
+        })
+    });
 }
 
 fn lockless_stats_good_load(b: &mut Criterion) {
@@ -59,11 +63,17 @@ fn lockless_stats_good_load(b: &mut Criterion) {
         stats.store_load(i, i);
     }
 
-    b.bench_function("get_sorted_load", |b| b.iter(|| {
-        let _sorted_load = stats.get_sorted_load();
-    }));
+    b.bench_function("get_sorted_load", |b| {
+        b.iter(|| {
+            let _sorted_load = stats.get_sorted_load();
+        })
+    });
 }
 
-criterion_group!(stats_bench, lockless_stats_bench, lockless_stats_bad_load,
-    lockless_stats_good_load);
+criterion_group!(
+    stats_bench,
+    lockless_stats_bench,
+    lockless_stats_bad_load,
+    lockless_stats_good_load
+);
 criterion_main!(stats_bench);