Merge pull request #3 from kpp/benchmarks

Add simple benchmarks

Author: kpp

Cargo.toml

@@ -23,3 +23,20 @@ pin-utils = "=0.1.0-alpha.4"
 [dependencies.futures]
 version = "=0.3.0-alpha.18"
 package = "futures-preview"
+
+[dev-dependencies]
+criterion = "0.2"
+
+[[bench]]
+name = "stream"
+harness = false
+
+[[bench]]
+name = "future"
+harness = false
+
+[profile.bench]
+opt-level = 3
+debug = false
+lto = true
+debug-assertions = false

benches/future.rs

@@ -0,0 +1,70 @@
+#![feature(async_closure)]
+
+#[macro_use]
+extern crate criterion;
+use criterion::{black_box, Benchmark, Criterion};
+
+use futures::executor;
+
+fn bench_ready(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "future::ready",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || black_box(futures::future::ready(42)).await)
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || black_box(futures_async_combinators::future::ready(42)).await)
+            }),
+        );
+    });
+}
+
+fn bench_poll_fn(c: &mut Criterion) {
+    use core::task::{Context, Poll};
+
+    fn ret_42(_cx: &mut Context<'_>) -> Poll<i32> {
+        Poll::Ready(42)
+    }
+
+    executor::block_on(async {
+        c.bench(
+            "future::poll_fn",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || black_box(futures::future::poll_fn(ret_42)).await)
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    black_box(futures_async_combinators::future::poll_fn(ret_42)).await
+                })
+            }),
+        );
+    });
+}
+
+fn bench_map(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "future::map",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || {
+                    use futures::future::*;
+                    let fut = ready(40);
+                    let fut = fut.map(|x| x + 2);
+                    black_box(fut).await
+                })
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    use futures_async_combinators::future::*;
+                    let fut = ready(40);
+                    let fut = map(fut, |x| x + 2);
+                    black_box(fut).await
+                })
+            }),
+        );
+    });
+}
+
+criterion_group!(benches, bench_ready, bench_poll_fn, bench_map);
+criterion_main!(benches);

benches/stream.rs

@@ -0,0 +1,122 @@
+#![feature(async_closure)]
+
+#[macro_use]
+extern crate criterion;
+use criterion::{black_box, Benchmark, Criterion};
+
+use futures::executor;
+
+fn bench_stream_iter(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "stream::iter",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || {
+                    use futures::stream::{iter, StreamExt};
+                    let mut stream = iter(1..=1000);
+                    while let Some(item) = stream.next().await {
+                        black_box(item);
+                    }
+                })
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    use futures::stream::StreamExt;
+                    use futures_async_combinators::stream::iter;
+                    let mut stream = iter(1..=1000);
+                    while let Some(item) = stream.next().await {
+                        black_box(item);
+                    }
+                })
+            }),
+        );
+    });
+}
+
+fn bench_stream_next(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "stream::next",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || {
+                    use futures::stream::{iter, StreamExt};
+                    let mut stream = iter(1..=1000);
+                    while let Some(item) = stream.next().await {
+                        black_box(item);
+                    }
+                })
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    use futures::stream::iter;
+                    use futures_async_combinators::stream::next;
+                    let mut stream = iter(1..=1000);
+                    while let Some(item) = next(&mut stream).await {
+                        black_box(item);
+                    }
+                })
+            }),
+        );
+    });
+}
+
+fn bench_stream_collect(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "stream::collect",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || {
+                    use futures::stream::{iter, StreamExt};
+                    let stream = iter(1..=1000);
+                    let vec: Vec<_> = stream.collect().await;
+                    black_box(vec)
+                })
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    use futures::stream::iter;
+                    use futures_async_combinators::stream::collect;
+                    let stream = iter(1..=1000);
+                    let vec: Vec<_> = collect(stream).await;
+                    black_box(vec)
+                })
+            }),
+        );
+    });
+}
+
+fn bench_stream_map(c: &mut Criterion) {
+    executor::block_on(async {
+        c.bench(
+            "stream::map",
+            Benchmark::new("futures", |b| {
+                b.iter(async move || {
+                    use futures::stream::{iter, StreamExt};
+                    let stream = iter(1..=1000);
+                    let stream = stream.map(|x| x + 42);
+                    let vec: Vec<_> = stream.collect().await;
+                    black_box(vec)
+                })
+            })
+            .with_function("async_combinators", |b| {
+                b.iter(async move || {
+                    use futures::stream::{iter, StreamExt};
+                    use futures_async_combinators::stream::map;
+                    let stream = iter(1..=1000);
+                    let stream = map(stream, |x| x + 42);
+                    let vec: Vec<_> = stream.collect().await;
+                    black_box(vec)
+                })
+            }),
+        );
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_stream_iter,
+    bench_stream_next,
+    bench_stream_collect,
+    bench_stream_map,
+);
+criterion_main!(benches);