async-map 0.2.3

A rarely-locking, shared map for Rust.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use async_map::AsyncFactory;
use criterion::BenchmarkId;
use criterion::Criterion;
use criterion::{criterion_group, criterion_main};
use tokio::runtime::Builder;

use async_map::lockingmap::LockingMap;
use async_map::non_locking_map::NonLockingMap;
use async_map::AsyncMap;
use async_map::VersionedMap;
use std::sync::Arc;

// This is a struct that tells Criterion.rs to use the "futures" crate's current-thread executor
#[cfg(feature = "async_tokio")]
use criterion::async_executor::AsyncExecutor;

// Here we have an async function to benchmark
async fn do_something<M: AsyncMap<Key = String, Value = String> + 'static>(
    size: usize,
    keys: Arc<Vec<Vec<(String, String)>>>,
    factory: fn() -> M,
) {
    let map: M = factory();

    let mut handles = Vec::new();

    for thread in 0..size {
        let map = map.clone();
        let keys = keys.clone();

        handles.push(tokio::task::spawn(async move {
            for step in 0..1000 {
                let step_pair: &(String, String) = &(keys[(step / 100) % 10][(step + thread) % 10]);

                let future = map.get(
                    &step_pair.0,
                    Box::new(move |key: &String| format!("Valu: {}", key))
                        as Box<dyn AsyncFactory<String, String>>,
                );

                let value = future.await;

                assert_eq!(*step_pair.1, value);
            }
        }));
    }

    for handle in handles {
        if let Err(_) = handle.await {
            todo!()
        }
    }
}

fn from_elem(c: &mut Criterion) {
    let size: usize = 1024;

    let keys = vec![
        "one".to_owned(),
        "two".to_owned(),
        "three".to_owned(),
        "four".to_owned(),
        "five".to_owned(),
        "six".to_owned(),
        "seven".to_owned(),
        "eight".to_owned(),
        "nine".to_owned(),
        "ten".to_owned(),
    ];

    let mut keys_vec: Vec<Vec<(String, String)>> = Vec::new();

    for i in 0..10 {
        keys_vec.push(
            keys.iter()
                .map(|text| text.clone() + &i.to_string())
                .map(|key| {
                    let value = format!("Valu: {}", key);
                    (key, value)
                })
                .collect(),
        );
    }

    let keys = Arc::new(keys_vec);
    let keys_ref = &keys;
    c.bench_with_input(BenchmarkId::new("versioned", size), &size, move |b, &s| {
        let runtime = Builder::new_multi_thread()
            .worker_threads(3)
            .thread_name("benchmark")
            .thread_stack_size(3 * 1024 * 1024)
            .build()
            .unwrap();
        // Insert a call to `to_async` to convert the bencher to async mode.
        // The timing loops are the same as with the normal bencher.
        b.to_async(runtime)
            .iter(|| do_something(s, keys_ref.clone(), VersionedMap::new));
    });

    c.bench_with_input(BenchmarkId::new("locking", size), &size, move |b, &s| {
        let runtime = Builder::new_multi_thread()
            .worker_threads(3)
            .thread_name("benchmark")
            .thread_stack_size(3 * 1024 * 1024)
            .build()
            .unwrap();
        // Insert a call to `to_async` to convert the bencher to async mode.
        // The timing loops are the same as with the normal bencher.
        b.to_async(runtime)
            .iter(|| do_something(s, keys_ref.clone(), LockingMap::new));
    });

    c.bench_with_input(
        BenchmarkId::new("non-locking", size),
        &size,
        move |b, &s| {
            let runtime = Builder::new_multi_thread()
                .worker_threads(3)
                .thread_name("benchmark")
                .thread_stack_size(3 * 1024 * 1024)
                .build()
                .unwrap();
            // Insert a call to `to_async` to convert the bencher to async mode.
            // The timing loops are the same as with the normal bencher.
            b.to_async(runtime)
                .iter(|| do_something(s, keys_ref.clone(), NonLockingMap::new));
        },
    );
}

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