criterion/
format.rs

1use Throughput;
2
3pub fn change(pct: f64, signed: bool) -> String {
4    if signed {
5        format!("{:>+6}%", signed_short(pct * 1e2))
6    } else {
7        format!("{:>6}%", short(pct * 1e2))
8    }
9}
10
11fn short(n: f64) -> String {
12    if n < 10.0 {
13        format!("{:.4}", n)
14    } else if n < 100.0 {
15        format!("{:.3}", n)
16    } else if n < 1000.0 {
17        format!("{:.2}", n)
18    } else if n < 10000.0 {
19        format!("{:.1}", n)
20    } else {
21        format!("{:.0}", n)
22    }
23}
24
25fn signed_short(n: f64) -> String {
26    let n_abs = n.abs();
27
28    if n_abs < 10.0 {
29        format!("{:+.4}", n)
30    } else if n_abs < 100.0 {
31        format!("{:+.3}", n)
32    } else if n_abs < 1000.0 {
33        format!("{:+.2}", n)
34    } else if n_abs < 10000.0 {
35        format!("{:+.1}", n)
36    } else {
37        format!("{:+.0}", n)
38    }
39}
40
41pub fn time(ns: f64) -> String {
42    if ns < 1.0 {
43        format!("{:>6} ps", short(ns * 1e3))
44    } else if ns < 10f64.powi(3) {
45        format!("{:>6} ns", short(ns))
46    } else if ns < 10f64.powi(6) {
47        format!("{:>6} us", short(ns / 1e3))
48    } else if ns < 10f64.powi(9) {
49        format!("{:>6} ms", short(ns / 1e6))
50    } else {
51        format!("{:>6} s", short(ns / 1e9))
52    }
53}
54
55pub fn throughput(throughput: &Throughput, ns: f64) -> String {
56    match *throughput {
57        Throughput::Bytes(bytes) => bytes_per_second(f64::from(bytes) * (1e9 / ns)),
58        Throughput::Elements(elems) => elements_per_second(f64::from(elems) * (1e9 / ns)),
59    }
60}
61
62pub fn bytes_per_second(bytes_per_second: f64) -> String {
63    if bytes_per_second < 1024.0 {
64        format!("{:>6}   B/s", short(bytes_per_second))
65    } else if bytes_per_second < 1024.0 * 1024.0 {
66        format!("{:>6} KiB/s", short(bytes_per_second / 1024.0))
67    } else if bytes_per_second < 1024.0 * 1024.0 * 1024.0 {
68        format!("{:>6} MiB/s", short(bytes_per_second / (1024.0 * 1024.0)))
69    } else {
70        format!(
71            "{:>6} GiB/s",
72            short(bytes_per_second / (1024.0 * 1024.0 * 1024.0))
73        )
74    }
75}
76
77pub fn elements_per_second(elements_per_second: f64) -> String {
78    if elements_per_second < 1000.0 {
79        format!("{:>6}  elem/s", short(elements_per_second))
80    } else if elements_per_second < 1000.0 * 1000.0 {
81        format!("{:>6} Kelem/s", short(elements_per_second / 1000.0))
82    } else if elements_per_second < 1000.0 * 1000.0 * 1000.0 {
83        format!(
84            "{:>6} Melem/s",
85            short(elements_per_second / (1000.0 * 1000.0))
86        )
87    } else {
88        format!(
89            "{:>6} Gelem/s",
90            short(elements_per_second / (1000.0 * 1000.0 * 1000.0))
91        )
92    }
93}
94
95pub fn iter_count(iterations: u64) -> String {
96    if iterations < 10_000 {
97        format!("{} iterations", iterations)
98    } else if iterations < 1_000_000 {
99        format!("{:.0}k iterations", (iterations as f64) / 1000.0)
100    } else if iterations < 10_000_000 {
101        format!("{:.1}M iterations", (iterations as f64) / (1000.0 * 1000.0))
102    } else if iterations < 1_000_000_000 {
103        format!("{:.0}M iterations", (iterations as f64) / (1000.0 * 1000.0))
104    } else if iterations < 10_000_000_000 {
105        format!(
106            "{:.1}B iterations",
107            (iterations as f64) / (1000.0 * 1000.0 * 1000.0)
108        )
109    } else {
110        format!(
111            "{:.0}B iterations",
112            (iterations as f64) / (1000.0 * 1000.0 * 1000.0)
113        )
114    }
115}
116
117#[cfg(test)]
118mod test {
119    use super::*;
120
121    #[test]
122    fn short_max_len() {
123        let mut float = 1.0;
124        while float < 999999.9 {
125            let string = short(float);
126            println!("{}", string);
127            assert!(string.len() <= 6);
128            float *= 2.0;
129        }
130    }
131
132    #[test]
133    fn signed_short_max_len() {
134        let mut float = -1.0;
135        while float > -999999.9 {
136            let string = signed_short(float);
137            println!("{}", string);
138            assert!(string.len() <= 7);
139            float *= 2.0;
140        }
141    }
142}