pessimize 3.0.2

More efficient Rust compiler optimization barriers
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

//! Implementations of Pessimize for std::process

use crate::{assume_accessed, pessimize_cast, pessimize_copy, BorrowPessimize};
use std::{
    os::unix::process::ExitStatusExt,
    process::{ExitStatus, Output},
};

pessimize_copy!(
    doc(cfg(all(any(feature = "std", test), unix)))
    {
        i32 : (
            ExitStatus : (Self::into_raw, Self::from_raw)
        )
    }
);

pessimize_cast!(
    doc(cfg(all(any(feature = "std", test), unix)))
    {
        (ExitStatus, Vec<u8>, Vec<u8>) : (
            Output : (
                |Self { status, stdout, stderr }| (status, stdout, stderr),
                |(status, stdout, stderr)| Self { status, stdout, stderr }
            )
        )
    }
);
//
#[cfg_attr(feature = "nightly", doc(cfg(all(any(feature = "std", test), unix))))]
impl BorrowPessimize for Output {
    type BorrowedPessimize = (ExitStatus, *const u8, usize, usize, *const u8, usize, usize);

    #[inline]
    fn with_pessimize(&self, f: impl FnOnce(&Self::BorrowedPessimize)) {
        f(&(
            self.status,
            self.stdout.as_ptr(),
            self.stdout.len(),
            self.stdout.capacity(),
            self.stderr.as_ptr(),
            self.stderr.len(),
            self.stderr.capacity(),
        ))
    }

    #[inline]
    fn assume_accessed_impl(&mut self) {
        assume_accessed(&mut self.status);
        assume_accessed(&mut self.stdout);
        assume_accessed(&mut self.stderr);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::tests::{test_unoptimized_value, test_value};

    #[test]
    fn exit_status() {
        test_value(ExitStatus::from_raw(i32::MIN));
        test_value(ExitStatus::from_raw(0));
        test_value(ExitStatus::from_raw(i32::MAX));
    }

    #[test]
    #[ignore]
    fn exit_status_optim() {
        test_unoptimized_value(ExitStatus::from_raw(0));
    }

    #[test]
    fn output() {
        test_value(Output {
            status: ExitStatus::from_raw(i32::MIN),
            stdout: vec![1],
            stderr: vec![2],
        });
        test_value(Output {
            status: ExitStatus::from_raw(0),
            stdout: vec![12],
            stderr: vec![34],
        });
        test_value(Output {
            status: ExitStatus::from_raw(i32::MAX),
            stdout: vec![],
            stderr: vec![u8::MAX],
        });
    }

    #[test]
    #[ignore]
    fn output_optim() {
        test_unoptimized_value(Output {
            status: ExitStatus::from_raw(0),
            stdout: vec![],
            stderr: vec![],
        });
    }
}