object-pool 0.6.0

A thread-safe object pool with automatic return and attach/detach semantics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#[macro_use]
extern crate criterion;

use criterion::Criterion;
use object_pool::{experimental::Pool as ExperimentalPool, Pool};
use std::iter::FromIterator;

static KB: usize = 1024;
static MB: usize = 1024 * KB;
static GB: usize = 1024 * MB;
static SIZES: &[usize] = &[
    4 * KB,
    16 * KB,
    64 * KB,
    128 * KB,
    512 * KB,
    1 * MB,
    16 * MB,
    32 * MB,
    64 * MB,
    128 * MB,
    256 * MB,
    512 * MB,
    1 * GB,
    2 * GB,
    3 * GB,
];

fn basics(c: &mut Criterion) {
    let mut group = c.benchmark_group("pulling_from_pool");
    group.throughput(criterion::Throughput::Elements(1));

    group.bench_function("experimental_pull", |b| {
        let pool = ExperimentalPool::from_iter(&[()]);
        b.iter(|| pool.pull())
    });

    group.bench_function("borrowed", |b| {
        let pool = Pool::new(1, || ());
        b.iter(|| pool.try_pull())
    });

    group.bench_function("owned", |b| {
        let pool = std::sync::Arc::new(Pool::new(1, || ()));
        b.iter(|| pool.try_pull_owned())
    });
    drop(group);

    c.bench_function("detach_from_pool", |b| {
        let pool = Pool::new(1, || ());
        b.iter(|| {
            let item = pool.try_pull().unwrap();
            let (_, vec) = item.detach();
            pool.attach(vec);
        })
    });

    c.bench_function_over_inputs(
        "alloc",
        |b, &&size| b.iter(|| Vec::<u8>::with_capacity(size)),
        SIZES,
    );
}

criterion_group!(benches, basics);
criterion_main!(benches);