pi-async-rt 0.3.2

Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
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

#![feature(test)]
extern crate test;

use async_std::sync::Mutex;
use async_std::task;
use std::sync::Arc;
use std::time::Duration;
use test::Bencher;

use crossbeam_channel::bounded;

#[bench]
fn async_std_bench_async_mutex(b: &mut Bencher) {
    b.iter(|| {
        let (s, r) = bounded(1);

        let shared = Arc::new(Mutex::new(0));

        for _ in 0..1 {
            let s0_copy = s.clone();
            let shared0_copy = shared.clone();
            task::spawn(async move {
                for _ in 0..500 {
                    let mut v = shared0_copy.lock_arc().await;
                    if *v >= 999 {
                        *v += 1;
                        s0_copy.send(()).unwrap();
                    } else {
                        *v += 1;
                    }
                }
            });
        }

        for _ in 0..1 {
            let s1_copy = s.clone();
            let shared1_copy = shared.clone();
            task::spawn(async move {
                for _ in 0..500 {
                    let mut v = shared1_copy.lock_arc().await;
                    if *v >= 999 {
                        *v += 1;
                        s1_copy.send(()).unwrap();
                    } else {
                        *v += 1;
                    }
                }
            });
        }

        if let Err(_) = r.recv_timeout(Duration::from_millis(10000)) {
            // println!("!!!!!!recv timeout, len: {:?}", (rt0.len(), rt1.len()));
        }
    });
}