conquer-util 0.3.0

utilities for concurrent and lock-free programming
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

//! Transparent thin wrapper types for artificially increasing the alignment of
//! the wrapped type.

use core::borrow::{Borrow, BorrowMut};
use core::convert::{AsMut, AsRef};

macro_rules! impl_align {
    ($(struct align($align:expr) $wrapper:ident; $comment:expr)*) => {
        $(
            #[doc = $comment]
            #[derive(Copy, Clone, Debug, Default, Hash, Eq, Ord, PartialEq, PartialOrd)]
            #[repr(align($align))]
            pub struct $wrapper<T> {
                /// The aligned inner value.
                pub aligned: T,
            }

            impl<T> $wrapper<T> {
                /// Creates a new aligned value.
                #[inline]
                pub const fn new(aligned: T) -> Self {
                    Self { aligned }
                }

                /// Returns a shared reference to the aligned value.
                #[inline]
                pub const fn get(&self) -> &T {
                    &self.aligned
                }

                /// Returns a mutable reference to the aligned value.
                #[inline]
                pub fn get_mut(&mut self) -> &mut T {
                    &mut self.aligned
                }
            }

            impl<T> AsRef<T> for $wrapper<T> {
                #[inline]
                fn as_ref(&self) -> &T {
                    &self.aligned
                }
            }

            impl<T> AsMut<T> for $wrapper<T> {
                #[inline]
                fn as_mut(&mut self) -> &mut T {
                    &mut self.aligned
                }
            }

            impl<T> Borrow<T> for $wrapper<T> {
                #[inline]
                fn borrow(&self) -> &T {
                    &self.aligned
                }
            }

            impl<T> BorrowMut<T> for $wrapper<T> {
                #[inline]
                fn borrow_mut(&mut self) -> &mut T {
                    &mut self.aligned
                }
            }
        )*
    };
}

impl_align! {
    struct align(2)          Aligned2;    "A thin wrapper type with an alignment of at least 2B."
    struct align(4)          Aligned4;    "A thin wrapper type with an alignment of at least 4B."
    struct align(8)          Aligned8;    "A thin wrapper type with an alignment of at least 8B."
    struct align(16)         Aligned16;   "A thin wrapper type with an alignment of at least 16B."
    struct align(32)         Aligned32;   "A thin wrapper type with an alignment of at least 32B."
    struct align(64)         Aligned64;   "A thin wrapper type with an alignment of at least 64B."
    struct align(128)        Aligned128;  "A thin wrapper type with an alignment of at least 128B."
    struct align(256)        Aligned256;  "A thin wrapper type with an alignment of at least 256B."
    struct align(512)        Aligned512;  "A thin wrapper type with an alignment of at least 512B."
    struct align(1024)       Aligned1024; "A thin wrapper type with an alignment of at least 1kB."
    struct align(2048)       Aligned2048; "A thin wrapper type with an alignment of at least 2kB."
    struct align(4096)       Aligned4096; "A thin wrapper type with an alignment of at least 4kB."
    struct align(0x2000)     Aligned8k;   "A thin wrapper type with an alignment of at least 8kB."
    struct align(0x4000)     Aligned16k;  "A thin wrapper type with an alignment of at least 16kB."
    struct align(0x8000)     Aligned32k;  "A thin wrapper type with an alignment of at least 32kB."
    struct align(0x10000)    Aligned64k;  "A thin wrapper type with an alignment of at least 64kB."
    struct align(0x20000)    Aligned128k; "A thin wrapper type with an alignment of at least 128kB."
    struct align(0x40000)    Aligned256k; "A thin wrapper type with an alignment of at least 256kB."
    struct align(0x80000)    Aligned512k; "A thin wrapper type with an alignment of at least 512kB."
    struct align(0x100000)   Aligned1M;   "A thin wrapper type with an alignment of at least 1MB."
    struct align(0x200000)   Aligned2M;   "A thin wrapper type with an alignment of at least 2MB."
    struct align(0x400000)   Aligned4M;   "A thin wrapper type with an alignment of at least 4MB."
    struct align(0x800000)   Aligned8M;   "A thin wrapper type with an alignment of at least 8MB."
    struct align(0x1000000)  Aligned16M;  "A thin wrapper type with an alignment of at least 16MB."
    struct align(0x2000000)  Aligned32M;  "A thin wrapper type with an alignment of at least 32MB."
    struct align(0x4000000)  Aligned64M;  "A thin wrapper type with an alignment of at least 64MB."
    struct align(0x8000000)  Aligned128M; "A thin wrapper type with an alignment of at least 128MB."
    struct align(0x10000000) Aligned256M; "A thin wrapper type with an alignment of at least 256MB."
    struct align(0x20000000) Aligned512M; "A thin wrapper type with an alignment of at least 512MB."
}

#[cfg(test)]
mod tests {
    use core::mem;

    use super::*;

    #[test]
    fn alignments() {
        assert_eq!(mem::align_of::<Aligned8<u8>>(), 8);
        assert_eq!(mem::align_of::<Aligned16<u8>>(), 16);
        assert_eq!(mem::align_of::<Aligned32<u8>>(), 32);
        assert_eq!(mem::align_of::<Aligned64<u8>>(), 64);
        assert_eq!(mem::align_of::<Aligned128<u8>>(), 128);
        assert_eq!(mem::align_of::<Aligned256<u8>>(), 256);
        assert_eq!(mem::align_of::<Aligned512<u8>>(), 512);
        assert_eq!(mem::align_of::<Aligned1024<u8>>(), 1024);
        assert_eq!(mem::align_of::<Aligned2048<u8>>(), 2048);
        assert_eq!(mem::align_of::<Aligned4096<u8>>(), 4096);
    }

    #[test]
    fn construct_and_deref() {
        let value = Aligned8::new(255u8);
        assert_eq!(value.aligned, 255);

        let value = Aligned64::new(1u8);
        assert_eq!(value.aligned, 1);
    }
}