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
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

//! Pessimize implementations for core::cell

use crate::{
    assume_accessed, assume_accessed_imut, consume, hide, pessimize_cast, BorrowPessimize,
    Pessimize,
};
use core::cell::{Cell, UnsafeCell};

// TODO: Once specialization is available, provide a default implementation for
//       all Cell<T> that goes through as_ptr().
//
// Can't use PessimizeCast/BorrowPessimize because need to propagate changes
// back in `assume_accessed_imut`
unsafe impl<T: Copy + Pessimize> Pessimize for Cell<T> {
    #[inline]
    fn hide(self) -> Self {
        Cell::new(hide(self.into_inner()))
    }

    #[inline]
    fn assume_read(&self) {
        consume::<T>(self.get())
    }

    #[inline]
    fn assume_accessed(&mut self) {
        assume_accessed::<T>(self.get_mut())
    }

    #[inline]
    fn assume_accessed_imut(&self) {
        let inner = self.get();
        assume_accessed_imut::<T>(&inner);
        self.set(inner);
    }
}

pessimize_cast!(
    allow(missing_docs)
    {
        T : (
            |T: (Pessimize)| UnsafeCell<T> : (
                Self::into_inner,
                Self::new
            )
        )
    }
);
//
impl<T: Pessimize> BorrowPessimize for UnsafeCell<T> {
    type BorrowedPessimize = *mut T;

    #[inline]
    fn with_pessimize(&self, f: impl FnOnce(&Self::BorrowedPessimize)) {
        // Can't safely get an &T out of an &UnsafeCell<T>, must use by-ptr barrier
        f(&self.get());
    }

    #[inline]
    fn assume_accessed_impl(&mut self) {
        assume_accessed::<T>(self.get_mut())
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;
    use crate::{
        pessimize_newtypes,
        tests::{assert_unoptimized, test_unoptimized_value_type, test_value_type},
    };

    pub fn test_unoptimized_cell<T: Clone + PartialEq, CellT: Pessimize>(
        mut cell: CellT,
        mut get_mut: impl FnMut(&mut CellT) -> &mut T,
    ) {
        let old_value = get_mut(&mut cell).clone();
        assert_unoptimized(cell, |mut cell| {
            assume_accessed_imut::<&CellT>(&&cell);
            consume(*get_mut(&mut cell) == old_value);
            cell
        });
    }

    #[test]
    fn cell() {
        test_value_type(Cell::new(isize::MIN), Cell::new(isize::MAX));
    }

    #[test]
    #[ignore]
    fn cell_optim() {
        test_unoptimized_value_type::<Cell<isize>>();
        test_unoptimized_cell(Cell::new(0isize), Cell::get_mut);
    }

    #[derive(Debug, Default)]
    struct TestableUnsafeCell(UnsafeCell<isize>);
    //
    impl TestableUnsafeCell {
        fn new(i: isize) -> Self {
            Self(UnsafeCell::new(i))
        }
    }
    //
    impl Clone for TestableUnsafeCell {
        fn clone(&self) -> Self {
            Self::new(unsafe { *self.0.get() })
        }
    }
    //
    impl PartialEq for TestableUnsafeCell {
        fn eq(&self, other: &Self) -> bool {
            unsafe { *self.0.get() == *other.0.get() }
        }
    }
    //
    pessimize_newtypes!( allow(missing_docs) { TestableUnsafeCell{ UnsafeCell<isize> } } );
    //
    #[test]
    fn unsafe_cell() {
        test_value_type(
            TestableUnsafeCell::new(isize::MIN),
            TestableUnsafeCell::new(isize::MAX),
        );
    }
    //
    #[test]
    #[ignore]
    fn unsafe_cell_optim() {
        test_unoptimized_value_type::<TestableUnsafeCell>();
        test_unoptimized_cell(UnsafeCell::new(0isize), UnsafeCell::get_mut);
    }
}