feat(bench): for futures adapter

Author: Berrysoft

Cargo.toml

@@ -76,12 +76,12 @@ required-features = ["tokio"]
 
 [[bench]]
 name = "net"
-required-features = ["tokio"]
+required-features = ["tokio", "futures"]
 harness = false
 
 [[bench]]
 name = "fs"
-required-features = ["tokio"]
+required-features = ["tokio", "futures"]
 harness = false
 
 [profile.bench]

benches/compat/mod.rs

@@ -1,4 +1,4 @@
-use compio_compat::{RuntimeCompat, TokioAdapter};
+use compio_compat::{FuturesAdapter, RuntimeCompat, TokioAdapter};
 use criterion::async_executor::AsyncExecutor;
 
 pub struct CompioInTokio {
@@ -30,3 +30,27 @@ impl AsyncExecutor for &CompioInTokio {
         self.truntime.block_on(self.cruntime.execute(future))
     }
 }
+
+pub struct CompioInFutures {
+    runtime: RuntimeCompat<FuturesAdapter>,
+}
+
+impl Default for CompioInFutures {
+    fn default() -> Self {
+        let runtime =
+            RuntimeCompat::<FuturesAdapter>::new(compio::runtime::Runtime::new().unwrap()).unwrap();
+        Self { runtime }
+    }
+}
+
+impl AsyncExecutor for CompioInFutures {
+    fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
+        (&self).block_on(future)
+    }
+}
+
+impl AsyncExecutor for &CompioInFutures {
+    fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
+        futures_executor::block_on(self.runtime.execute(future))
+    }
+}

benches/fs.rs

@@ -66,6 +66,12 @@ fn read_compio_in_tokio(b: &mut Bencher, (path, offsets): &(&Path, &[u64])) {
         .iter_custom(|iter| read_compio_impl(iter, path, offsets))
 }
 
+fn read_compio_in_futures(b: &mut Bencher, (path, offsets): &(&Path, &[u64])) {
+    let runtime = CompioInFutures::default();
+    b.to_async(&runtime)
+        .iter_custom(|iter| read_compio_impl(iter, path, offsets))
+}
+
 fn read_all_tokio(b: &mut Bencher, (path, len): &(&Path, u64)) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_all()
@@ -116,6 +122,12 @@ fn read_all_compio_in_tokio(b: &mut Bencher, (path, len): &(&Path, u64)) {
         .iter_custom(|iter| read_all_compio_impl(iter, path, *len))
 }
 
+fn read_all_compio_in_futures(b: &mut Bencher, (path, len): &(&Path, u64)) {
+    let runtime = CompioInFutures::default();
+    b.to_async(&runtime)
+        .iter_custom(|iter| read_all_compio_impl(iter, path, *len))
+}
+
 fn read(c: &mut Criterion) {
     let mut rng = rng();
 
@@ -143,6 +155,11 @@ fn read(c: &mut Criterion) {
         &(&path, &offsets),
         read_compio_in_tokio,
     );
+    group.bench_with_input::<_, _, (&Path, &[u64])>(
+        "compio-in-futures",
+        &(&path, &offsets),
+        read_compio_in_futures,
+    );
 
     group.finish();
 
@@ -158,6 +175,12 @@ fn read(c: &mut Criterion) {
         &(&path, TOTAL_SIZE),
         read_all_compio_in_tokio,
     );
+    group.bench_with_input::<_, _, (&Path, u64)>(
+        "compio-in-futures",
+        &(&path, TOTAL_SIZE),
+        read_all_compio_in_futures,
+    );
+
     group.finish();
 }
 
@@ -219,6 +242,13 @@ fn write_compio_in_tokio(b: &mut Bencher, (path, offsets, content): &(&Path, &[u
         .iter_custom(|iter| write_compio_impl(iter, path, offsets, content.clone()))
 }
 
+fn write_compio_in_futures(b: &mut Bencher, (path, offsets, content): &(&Path, &[u64], &[u8])) {
+    let runtime = CompioInFutures::default();
+    let content = content.to_vec();
+    b.to_async(&runtime)
+        .iter_custom(|iter| write_compio_impl(iter, path, offsets, content.clone()))
+}
+
 fn write_all_tokio(b: &mut Bencher, (path, content): &(&Path, &[u8])) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_all()
@@ -282,6 +312,13 @@ fn write_all_compio_in_tokio(b: &mut Bencher, (path, content): &(&Path, &[u8]))
         .iter_custom(|iter| write_all_compio_impl(iter, path, content.clone()))
 }
 
+fn write_all_compio_in_futures(b: &mut Bencher, (path, content): &(&Path, &[u8])) {
+    let runtime = CompioInFutures::default();
+    let content = content.to_vec();
+    b.to_async(&runtime)
+        .iter_custom(|iter| write_all_compio_impl(iter, path, content.clone()))
+}
+
 fn write(c: &mut Criterion) {
     const WRITE_FILE_SIZE: u64 = 16;
 
@@ -329,6 +366,12 @@ fn write(c: &mut Criterion) {
         &(&path, &offsets, &single_content),
         write_compio_in_tokio,
     );
+    group.bench_with_input::<_, _, (&Path, &[u64], &[u8])>(
+        "compio-in-futures",
+        &(&path, &offsets, &single_content),
+        write_compio_in_futures,
+    );
+
     group.finish();
 
     let mut group = c.benchmark_group("write-all");
@@ -341,6 +384,11 @@ fn write(c: &mut Criterion) {
         &(&path, &content),
         write_all_compio_in_tokio,
     );
+    group.bench_with_input::<_, _, (&Path, &[u8])>(
+        "compio-in-futures",
+        &(&path, &content),
+        write_all_compio_in_futures,
+    );
 
     group.finish()
 }

benches/net.rs

@@ -121,12 +121,18 @@ fn echo_compio_tcp(b: &mut Bencher, content: Vec<u8>) {
         .iter_custom(|iter| echo_compio_tcp_impl(iter, content.clone()))
 }
 
-fn echo_tokio_compio_tcp(b: &mut Bencher, content: Vec<u8>) {
+fn echo_compio_in_tokio_tcp(b: &mut Bencher, content: Vec<u8>) {
     let runtime = CompioInTokio::default();
     b.to_async(&runtime)
         .iter_custom(|iter| echo_compio_tcp_impl(iter, content.clone()))
 }
 
+fn echo_compio_in_futures_tcp(b: &mut Bencher, content: Vec<u8>) {
+    let runtime = CompioInFutures::default();
+    b.to_async(&runtime)
+        .iter_custom(|iter| echo_compio_tcp_impl(iter, content.clone()))
+}
+
 #[cfg(unix)]
 fn echo_tokio_unix(b: &mut Bencher, content: &[u8]) {
     use tokio::net::{UnixListener, UnixStream};
@@ -191,6 +197,12 @@ fn echo_compio_in_tokio_unix(b: &mut Bencher, content: Vec<u8>) {
         .iter_custom(|iter| echo_compio_unix_impl(iter, content.clone()))
 }
 
+fn echo_compio_in_futures_unix(b: &mut Bencher, content: Vec<u8>) {
+    let runtime = CompioInFutures::default();
+    b.to_async(&runtime)
+        .iter_custom(|iter| echo_compio_unix_impl(iter, content.clone()))
+}
+
 fn echo(c: &mut Criterion) {
     let mut rng = rng();
 
@@ -203,7 +215,10 @@ fn echo(c: &mut Criterion) {
     group.bench_function("tokio-tcp", |b| echo_tokio_tcp(b, &content));
     group.bench_function("compio-tcp", |b| echo_compio_tcp(b, content.clone()));
     group.bench_function("compio-in-tokio-tcp", |b| {
-        echo_tokio_compio_tcp(b, content.clone())
+        echo_compio_in_tokio_tcp(b, content.clone())
+    });
+    group.bench_function("compio-in-futures-tcp", |b| {
+        echo_compio_in_futures_tcp(b, content.clone())
     });
 
     #[cfg(unix)]
@@ -212,6 +227,9 @@ fn echo(c: &mut Criterion) {
     group.bench_function("compio-in-tokio-unix", |b| {
         echo_compio_in_tokio_unix(b, content.clone())
     });
+    group.bench_function("compio-in-futures-unix", |b| {
+        echo_compio_in_futures_unix(b, content.clone())
+    });
 
     group.finish();
 }