atap 0.1.0

Threadsafe futureless async runtime for macOS
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

//! # Idle CPU Usage
//! What the runtime costs while it has nothing to do but wait

mod common;

use atap::{Runtime, sleep::Sleep};
use common::cpu_time;
use std::{
    thread,
    time::{Duration, Instant},
};

/// A runtime with every task parked in a long sleep uses
/// almost no cpu
#[test]
fn idle_cpu_usage() {
    let _ = Runtime::init();

    let tasks = 20;
    let waiting = Duration::from_secs(5);

    println!(
        "pid {} idling {} tasks for {:?}",
        std::process::id(),
        tasks,
        waiting,
    );

    // Given a moment to get everything parked, so the threads
    // starting up aren't charged to the idling
    let handles: Vec<_> = (0..tasks)
        .map(|_| Runtime::task(Sleep::sleep(waiting)).spawn())
        .collect();

    thread::sleep(Duration::from_millis(200));

    let before = cpu_time();
    let started = Instant::now();

    let mut shortest = Duration::MAX;
    let mut longest = Duration::ZERO;

    for handle in handles {
        let slept = handle
            .join()
            .expect("every idling task finishes, rather than failing instantly");

        shortest = shortest.min(slept);
        longest = longest.max(slept);
    }

    let window = started.elapsed();
    let burnt = cpu_time() - before;

    // Against one core, since a single spinning thread is the
    // thing worth catching
    let share = burnt.as_secs_f64() / window.as_secs_f64() * 100.0;

    println!(
        "{} tasks asked for {:?} and slept {:?} to {:?}, \
         burning {:?} of cpu over a {:?} window, {:.3}% of one core",
        tasks, waiting, shortest, longest, burnt, window, share,
    );

    // No sleep came back early
    assert!(
        shortest >= waiting,
        "a sleep asked for {:?} came back after {:?}, which is early",
        waiting,
        shortest,
    );

    // A thread spinning out the whole wait would be 100% of a core
    assert!(
        share < 5.0,
        "idling {} tasks over a {:?} window burnt {:?} of cpu, {:.3}% of a core, \
         so something was awake that should have been parked",
        tasks,
        window,
        burnt,
        share,
    );
}