Fix CI

Author: Stjepan Glavina

async-mutex/Cargo.toml

@@ -16,9 +16,11 @@ readme = "../README.md"
 event-listener = "2.0.0"
 
 [dev-dependencies]
+async-executor = "1.3.0"
 async-io = "1.1.2"
-async-std = "1.6.2"
 futures = "0.3.5"
 futures-intrusive = "0.3.1"
 futures-lite = "1.0.0"
+num_cpus = "1.13.0"
+once_cell = "1.4.1"
 tokio = { version = "0.2.21", features = ["sync", "parking_lot"] }

async-mutex/benches/async-mutex.rs

@@ -3,24 +3,34 @@
 extern crate test;
 
 use std::sync::Arc;
+use std::thread;
 
+use async_executor::Executor;
 use async_mutex::Mutex;
-use async_std::task;
+use futures_lite::future;
+use once_cell::sync::Lazy;
 use test::Bencher;
 
+static EX: Lazy<Executor> = Lazy::new(|| {
+    for _ in 0..num_cpus::get() {
+        thread::spawn(|| future::block_on(EX.run(future::pending::<()>())));
+    }
+    Executor::new()
+});
+
 #[bench]
 fn create(b: &mut Bencher) {
     b.iter(|| Mutex::new(()));
 }
 
 #[bench]
 fn contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(10, 1000)));
+    b.iter(|| future::block_on(run(10, 1000)));
 }
 
 #[bench]
 fn no_contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(1, 10000)));
+    b.iter(|| future::block_on(run(1, 10000)));
 }
 
 async fn run(task: usize, iter: usize) {
@@ -29,7 +39,7 @@ async fn run(task: usize, iter: usize) {
 
     for _ in 0..task {
         let m = m.clone();
-        tasks.push(task::spawn(async move {
+        tasks.push(EX.spawn(async move {
             for _ in 0..iter {
                 let _ = m.lock().await;
             }

async-mutex/benches/async-std.rs

@@ -3,24 +3,34 @@
 extern crate test;
 
 use std::sync::Arc;
+use std::thread;
 
-use async_std::task;
+use async_executor::Executor;
 use futures_intrusive::sync::Mutex;
+use futures_lite::future;
+use once_cell::sync::Lazy;
 use test::Bencher;
 
+static EX: Lazy<Executor> = Lazy::new(|| {
+    for _ in 0..num_cpus::get() {
+        thread::spawn(|| future::block_on(EX.run(future::pending::<()>())));
+    }
+    Executor::new()
+});
+
 #[bench]
 fn create(b: &mut Bencher) {
     b.iter(|| Mutex::new((), true));
 }
 
 #[bench]
 fn contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(10, 1000)));
+    b.iter(|| future::block_on(run(10, 1000)));
 }
 
 #[bench]
 fn no_contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(1, 10000)));
+    b.iter(|| future::block_on(run(1, 10000)));
 }
 
 async fn run(task: usize, iter: usize) {
@@ -29,7 +39,7 @@ async fn run(task: usize, iter: usize) {
 
     for _ in 0..task {
         let m = m.clone();
-        tasks.push(task::spawn(async move {
+        tasks.push(EX.spawn(async move {
             for _ in 0..iter {
                 let _ = m.lock().await;
             }

async-mutex/benches/futures-intrusive.rs

@@ -3,24 +3,34 @@
 extern crate test;
 
 use std::sync::Arc;
+use std::thread;
 
-use async_std::task;
+use async_executor::Executor;
 use futures::lock::Mutex;
+use futures_lite::future;
+use once_cell::sync::Lazy;
 use test::Bencher;
 
+static EX: Lazy<Executor> = Lazy::new(|| {
+    for _ in 0..num_cpus::get() {
+        thread::spawn(|| future::block_on(EX.run(future::pending::<()>())));
+    }
+    Executor::new()
+});
+
 #[bench]
 fn create(b: &mut Bencher) {
     b.iter(|| Mutex::new(()));
 }
 
 #[bench]
 fn contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(10, 1000)));
+    b.iter(|| future::block_on(run(10, 1000)));
 }
 
 #[bench]
 fn no_contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(1, 10000)));
+    b.iter(|| future::block_on(run(1, 10000)));
 }
 
 async fn run(task: usize, iter: usize) {
@@ -29,7 +39,7 @@ async fn run(task: usize, iter: usize) {
 
     for _ in 0..task {
         let m = m.clone();
-        tasks.push(task::spawn(async move {
+        tasks.push(EX.spawn(async move {
             for _ in 0..iter {
                 let _ = m.lock().await;
             }

async-mutex/benches/futures.rs

@@ -3,24 +3,34 @@
 extern crate test;
 
 use std::sync::Arc;
+use std::thread;
 
-use async_std::task;
+use async_executor::Executor;
+use futures_lite::future;
+use once_cell::sync::Lazy;
 use test::Bencher;
 use tokio::sync::Mutex;
 
+static EX: Lazy<Executor> = Lazy::new(|| {
+    for _ in 0..num_cpus::get() {
+        thread::spawn(|| future::block_on(EX.run(future::pending::<()>())));
+    }
+    Executor::new()
+});
+
 #[bench]
 fn create(b: &mut Bencher) {
     b.iter(|| Mutex::new(()));
 }
 
 #[bench]
 fn contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(10, 1000)));
+    b.iter(|| future::block_on(run(10, 1000)));
 }
 
 #[bench]
 fn no_contention(b: &mut Bencher) {
-    b.iter(|| task::block_on(run(1, 10000)));
+    b.iter(|| future::block_on(run(1, 10000)));
 }
 
 async fn run(task: usize, iter: usize) {
@@ -29,7 +39,7 @@ async fn run(task: usize, iter: usize) {
 
     for _ in 0..task {
         let m = m.clone();
-        tasks.push(task::spawn(async move {
+        tasks.push(EX.spawn(async move {
             for _ in 0..iter {
                 let _ = m.lock().await;
             }