Skip to content

Commit f4db853

Browse files
kppkpp
authored
Merge pull request #22 from kpp/criterion_03
Upgrade to criterion v0.3
2 parents 80ac73f + 746b220 commit f4db853

File tree

4 files changed

+138
-132
lines changed

4 files changed

+138
-132
lines changed

‎.travis.yml

+4-5
Original file line numberDiff line numberDiff line change
@@ -6,15 +6,14 @@ rust:
66
os:
77
- linux
88

9-
script:
10-
- cargo test
11-
129
matrix:
1310
include:
1411
- os: linux
15-
rust: nightly-2019-08-21
12+
script:
13+
- cargo build --examples --tests --benches
14+
- name: coverage
15+
os: linux
1616
sudo: required
17-
name: coverage
1817
addons: # needed for `cargo install cargo-travis`
1918
apt:
2019
packages:

‎Cargo.toml

+1-1
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ version = "=0.3.0-alpha.18"
2525
package = "futures-preview"
2626

2727
[dev-dependencies]
28-
criterion = "0.2"
28+
criterion = "0.3"
2929

3030
[[bench]]
3131
name = "stream"

‎benches/future.rs

+46-40
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,24 @@
11
#![feature(async_closure)]
22

3-
#[macro_use]
4-
extern crate criterion;
5-
use criterion::{black_box, Benchmark, Criterion};
6-
3+
use criterion::*;
74
use futures::executor;
85

96
fn bench_ready(c: &mut Criterion) {
107
executor::block_on(async {
11-
c.bench(
12-
"future::ready",
13-
Benchmark::new("futures", |b| {
14-
b.iter(async move || black_box(futures::future::ready(42)).await)
8+
let mut group = c.benchmark_group("future::ready");
9+
10+
group.bench_function("futures", |b| {
11+
b.iter(async move || {
12+
black_box(futures::future::ready(42)).await
13+
})
14+
});
15+
group.bench_function("async_combinators", |b| {
16+
b.iter(async move || {
17+
black_box(futures_async_combinators::future::ready(42)).await
1518
})
16-
.with_function("async_combinators", |b| {
17-
b.iter(async move || black_box(futures_async_combinators::future::ready(42)).await)
18-
}),
19-
);
19+
});
20+
21+
group.finish();
2022
});
2123
}
2224

@@ -28,41 +30,45 @@ fn bench_poll_fn(c: &mut Criterion) {
2830
}
2931

3032
executor::block_on(async {
31-
c.bench(
32-
"future::poll_fn",
33-
Benchmark::new("futures", |b| {
34-
b.iter(async move || black_box(futures::future::poll_fn(ret_42)).await)
33+
let mut group = c.benchmark_group("future::poll_fn");
34+
35+
group.bench_function("futures", |b| {
36+
b.iter(async move || {
37+
black_box(futures::future::poll_fn(ret_42)).await
3538
})
36-
.with_function("async_combinators", |b| {
37-
b.iter(async move || {
38-
black_box(futures_async_combinators::future::poll_fn(ret_42)).await
39-
})
40-
}),
41-
);
39+
});
40+
group.bench_function("async_combinators", |b| {
41+
b.iter(async move || {
42+
black_box(futures_async_combinators::future::poll_fn(ret_42)).await
43+
})
44+
});
45+
46+
group.finish();
4247
});
4348
}
4449

4550
fn bench_map(c: &mut Criterion) {
4651
executor::block_on(async {
47-
c.bench(
48-
"future::map",
49-
Benchmark::new("futures", |b| {
50-
b.iter(async move || {
51-
use futures::future::*;
52-
let fut = ready(40);
53-
let fut = fut.map(|x| x + 2);
54-
black_box(fut).await
55-
})
52+
let mut group = c.benchmark_group("future::map");
53+
54+
group.bench_function("futures", |b| {
55+
b.iter(async move || {
56+
use futures::future::*;
57+
let fut = ready(40);
58+
let fut = fut.map(|x| x + 2);
59+
black_box(fut).await
5660
})
57-
.with_function("async_combinators", |b| {
58-
b.iter(async move || {
59-
use futures_async_combinators::future::*;
60-
let fut = ready(40);
61-
let fut = map(fut, |x| x + 2);
62-
black_box(fut).await
63-
})
64-
}),
65-
);
61+
});
62+
group.bench_function("async_combinators", |b| {
63+
b.iter(async move || {
64+
use futures_async_combinators::future::*;
65+
let fut = ready(40);
66+
let fut = map(fut, |x| x + 2);
67+
black_box(fut).await
68+
})
69+
});
70+
71+
group.finish();
6672
});
6773
}
6874

‎benches/stream.rs

+87-86
Original file line numberDiff line numberDiff line change
@@ -1,114 +1,115 @@
11
#![feature(async_closure)]
22

3-
#[macro_use]
4-
extern crate criterion;
5-
use criterion::{black_box, Benchmark, Criterion};
6-
3+
use criterion::*;
74
use futures::executor;
85

96
fn bench_stream_iter(c: &mut Criterion) {
107
executor::block_on(async {
11-
c.bench(
12-
"stream::iter",
13-
Benchmark::new("futures", |b| {
14-
b.iter(async move || {
15-
use futures::stream::{iter, StreamExt};
16-
let mut stream = iter(1..=1000);
17-
while let Some(item) = stream.next().await {
18-
black_box(item);
19-
}
20-
})
8+
let mut group = c.benchmark_group("stream::iter");
9+
10+
group.bench_function("futures", |b| {
11+
b.iter(async move || {
12+
use futures::stream::{iter, StreamExt};
13+
let mut stream = iter(1..=1000);
14+
while let Some(item) = stream.next().await {
15+
black_box(item);
16+
}
2117
})
22-
.with_function("async_combinators", |b| {
23-
b.iter(async move || {
24-
use futures::stream::StreamExt;
25-
use futures_async_combinators::stream::iter;
26-
let mut stream = iter(1..=1000);
27-
while let Some(item) = stream.next().await {
28-
black_box(item);
29-
}
30-
})
31-
}),
32-
);
18+
});
19+
group.bench_function("async_combinators", |b| {
20+
b.iter(async move || {
21+
use futures::stream::StreamExt;
22+
use futures_async_combinators::stream::iter;
23+
let mut stream = iter(1..=1000);
24+
while let Some(item) = stream.next().await {
25+
black_box(item);
26+
}
27+
})
28+
});
29+
30+
group.finish();
3331
});
3432
}
3533

3634
fn bench_stream_next(c: &mut Criterion) {
3735
executor::block_on(async {
38-
c.bench(
39-
"stream::next",
40-
Benchmark::new("futures", |b| {
41-
b.iter(async move || {
42-
use futures::stream::{iter, StreamExt};
43-
let mut stream = iter(1..=1000);
44-
while let Some(item) = stream.next().await {
45-
black_box(item);
46-
}
47-
})
36+
let mut group = c.benchmark_group("stream::next");
37+
38+
group.bench_function("futures", |b| {
39+
b.iter(async move || {
40+
use futures::stream::{iter, StreamExt};
41+
let mut stream = iter(1..=1000);
42+
while let Some(item) = stream.next().await {
43+
black_box(item);
44+
}
45+
})
46+
});
47+
group.bench_function("async_combinators", |b| {
48+
b.iter(async move || {
49+
use futures::stream::iter;
50+
use futures_async_combinators::stream::next;
51+
let mut stream = iter(1..=1000);
52+
while let Some(item) = next(&mut stream).await {
53+
black_box(item);
54+
}
4855
})
49-
.with_function("async_combinators", |b| {
50-
b.iter(async move || {
51-
use futures::stream::iter;
52-
use futures_async_combinators::stream::next;
53-
let mut stream = iter(1..=1000);
54-
while let Some(item) = next(&mut stream).await {
55-
black_box(item);
56-
}
57-
})
58-
}),
59-
);
56+
});
57+
58+
group.finish();
6059
});
6160
}
6261

6362
fn bench_stream_collect(c: &mut Criterion) {
6463
executor::block_on(async {
65-
c.bench(
66-
"stream::collect",
67-
Benchmark::new("futures", |b| {
68-
b.iter(async move || {
69-
use futures::stream::{iter, StreamExt};
70-
let stream = iter(1..=1000);
71-
let vec: Vec<_> = stream.collect().await;
72-
black_box(vec)
73-
})
64+
let mut group = c.benchmark_group("stream::collect");
65+
66+
group.bench_function("futures", |b| {
67+
b.iter(async move || {
68+
use futures::stream::{iter, StreamExt};
69+
let stream = iter(1..=1000);
70+
let vec: Vec<_> = stream.collect().await;
71+
black_box(vec)
72+
})
73+
});
74+
group.bench_function("async_combinators", |b| {
75+
b.iter(async move || {
76+
use futures::stream::iter;
77+
use futures_async_combinators::stream::collect;
78+
let stream = iter(1..=1000);
79+
let vec: Vec<_> = collect(stream).await;
80+
black_box(vec)
7481
})
75-
.with_function("async_combinators", |b| {
76-
b.iter(async move || {
77-
use futures::stream::iter;
78-
use futures_async_combinators::stream::collect;
79-
let stream = iter(1..=1000);
80-
let vec: Vec<_> = collect(stream).await;
81-
black_box(vec)
82-
})
83-
}),
84-
);
82+
});
83+
84+
group.finish();
8585
});
8686
}
8787

8888
fn bench_stream_map(c: &mut Criterion) {
8989
executor::block_on(async {
90-
c.bench(
91-
"stream::map",
92-
Benchmark::new("futures", |b| {
93-
b.iter(async move || {
94-
use futures::stream::{iter, StreamExt};
95-
let stream = iter(1..=1000);
96-
let stream = stream.map(|x| x + 42);
97-
let vec: Vec<_> = stream.collect().await;
98-
black_box(vec)
99-
})
90+
let mut group = c.benchmark_group("stream::map");
91+
92+
group.bench_function("futures", |b| {
93+
b.iter(async move || {
94+
use futures::stream::{iter, StreamExt};
95+
let stream = iter(1..=1000);
96+
let stream = stream.map(|x| x + 42);
97+
let vec: Vec<_> = stream.collect().await;
98+
black_box(vec)
99+
})
100+
});
101+
group.bench_function("async_combinators", |b| {
102+
b.iter(async move || {
103+
use futures::stream::{iter, StreamExt};
104+
use futures_async_combinators::stream::map;
105+
let stream = iter(1..=1000);
106+
let stream = map(stream, |x| x + 42);
107+
let vec: Vec<_> = stream.collect().await;
108+
black_box(vec)
100109
})
101-
.with_function("async_combinators", |b| {
102-
b.iter(async move || {
103-
use futures::stream::{iter, StreamExt};
104-
use futures_async_combinators::stream::map;
105-
let stream = iter(1..=1000);
106-
let stream = map(stream, |x| x + 42);
107-
let vec: Vec<_> = stream.collect().await;
108-
black_box(vec)
109-
})
110-
}),
111-
);
110+
});
111+
112+
group.finish();
112113
});
113114
}
114115

0 commit comments

Comments
 (0)