rexl 0.0.4

Common Library 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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::time::Instant;

type FnBox = Box<dyn Fn() + 'static>;

pub struct Timeit {
    /// multi metering
    count:    u32,
    /// assert skip < count
    /// such as count=100, skip=10, then discard head 10 & tail 10 before merge
    skip:     u32,
    /// repeat times, one action avg time is `the result or run()` / repeat
    /// such as one action cost 1ms, if repeat=12 then total cost almost equal 12ms
    repeat:   u32,
    /// use parallel io to execute
    parallel: bool,
    ///v
    actions:  Vec<FnBox>,
}

impl Timeit {
    pub fn new() -> Self {
        Timeit {
            count:    1,
            skip:     0,
            repeat:   1,
            parallel: false,
            actions:  vec![],
        }
    }

    pub fn count(&mut self, count: u32) -> &mut Self {
        self.count = count;
        self
    }

    pub fn skip(&mut self, skip: u32) -> &mut Self {
        self.skip = skip;
        self
    }

    pub fn repeat(&mut self, repeat: u32) -> &mut Self {
        self.repeat = repeat;
        self
    }

    pub fn parallel(&mut self, parallel: bool) -> &mut Self {
        self.parallel = parallel;
        self
    }

    pub fn add_action<F: Fn() + 'static>(&mut self, action: F) -> &mut Self {
        self.actions.push(Box::new(action));
        self
    }

    pub fn add_unary_action<T: 'static>(
        &mut self, supplier: fn() -> T, action: fn(T),
    ) -> &mut Self {
        self.actions.push(Box::new(move || action(supplier())));
        self
    }

    pub fn run(&self) -> Vec<u64> {
        let mut tss: Vec<Vec<u64>>;

        // parallel
        if self.parallel {
            tss = self.run_parallel();
        }
        // serially
        else {
            tss = self.run_serially();
        }

        // stat
        self.stat(&mut tss)
    }

    pub fn run_serially(&self) -> Vec<Vec<u64>> {
        let size = self.actions.len();
        let count = self.count as usize;
        let repeat = self.repeat;

        let mut tss = Vec::with_capacity(size);
        for i in 0..size {
            let mut ts = Vec::with_capacity(count);
            let action = &self.actions[i];

            for _ in 0..count {
                let mut t = 0u64;
                for _ in 0..repeat {
                    let now = Instant::now();
                    action();
                    t += now.elapsed().as_nanos() as u64;
                }
                ts.push(t);
            }
            tss.push(ts);
        }
        tss
    }

    pub fn run_parallel(&self) -> Vec<Vec<u64>> {
        unimplemented!()
    }

    fn stat(&self, tss: &mut Vec<Vec<u64>>) -> Vec<u64> {
        let size = tss.len();
        let count = self.count as usize;
        let skip = self.skip as usize;

        let mut stat = vec![0u64; size];
        for i in 0..size {
            tss[i].sort();
            let mut avg = 0u64;
            let mut c = 0;
            for j in 0..count {
                // if skip = 10, then
                // skip 0, 1, ..., 9 or len-10, ..., len - 1
                if j < skip || j >= count - skip {
                    continue
                }
                c += 1;
                avg += tss[i][j];
            }
            stat[i] = avg / c;
        }
        stat
    }

    pub fn run_and_format(
        &self, unit: &'static str, unit_base: f64, delimiter: &'static str,
    ) -> String {
        let ts: Vec<String> = self
            .run()
            .iter()
            .map(|it| format!("{:?}{}", *it as f64 / unit_base, unit))
            .collect();
        ts.join(delimiter)
    }

    pub fn run_and_format_sec(&self, delimiter: &'static str) -> String {
        self.run_and_format("s", 1000_000_000.0, delimiter)
    }

    pub fn run_and_format_ms(&self, delimiter: &'static str) -> String {
        self.run_and_format("ms", 1000_000.0, delimiter)
    }

    pub fn run_and_format_us(&self, delimiter: &'static str) -> String {
        self.run_and_format("us", 1000.0, delimiter)
    }
}