Struct Alignment

Source

pub struct Alignment(/* private fields */);

Expand description

A valid Layout alignment (a power of 2)

Available in named constant forms, which have been #[doc(hidden)] to avoid spam:

Min	Max	Name	Equivalences
`ALIGN_1`	`ALIGN_8192`	Byte(s)	8 bits = 1 octect ≈ 1 byte
`ALIGN_1_B`	`ALIGN_8192_B`	Byte(s)	8 bits = 1 octect ≈ 1 byte
`ALIGN_1_KiB`	`ALIGN_8192_KiB`	Kibibyte(s)	1 KiB = 2¹⁰ bytes = 1024¹ bytes
`ALIGN_1_MiB`	`ALIGN_8192_MiB`	Mebibyte(s)	1 MiB = 2²⁰ bytes = 1024² bytes
`ALIGN_1_GiB`	`ALIGN_8192_GiB`	Gibibyte(s)	1 GiB = 2³⁰ bytes = 1024³ bytes
`ALIGN_1_TiB`	`ALIGN_8192_TiB`	Tebibyte(s)	1 TiB = 2⁴⁰ bytes = 1024⁴ bytes
`ALIGN_1_EiB`	`ALIGN_8192_EiB`	Exbibyte(s)	1 EiB = 2⁵⁰ bytes = 1024⁵ bytes

Implementations§

Source §

impl Alignment

Source

pub const MIN: Alignment = ALIGN_1

Minimum representable alignment (e.g. 1)

Source

pub const MAX: Alignment

Maximum representable alignment

Bits	MAX
16	2¹⁵ B = 32 KiB
32	2³¹ B = 2 GiB
64	2⁶³ B = 8 EiB
128	2¹²⁷ B = ???

Source

pub const fn new(align: usize) -> Option<Self>

Returns None unless align is a valid power of 2 (which also implies nonzero)

Examples found in repository ?

examples/alloc-tester.rs (line 36)

28    pub fn thin(&mut self) -> &mut Self where A : thin::Alloc + thin::Free {
29        let mut thin = AlignmentRange { min: Alignment::MAX, max: Alignment::MAX };
30        for (dst, min_size) in [(&mut thin.min, 1), (&mut thin.max, 4096)] {
31            for _ in 0 .. 100 {
32                let alloc = (self.create)();
33                let addrs = [(); 4096].into_iter().enumerate().map(|(i, _)| alloc.alloc_uninit(i%16+min_size).unwrap()).collect::<Vec<_>>();
34                let addrbits = addrs[..].iter().copied().map(|addr| addr.as_ptr() as usize).reduce(|x,y| x|y).unwrap();
35                addrs.iter().copied().for_each(|addr| unsafe { alloc.free(addr) });
36                let align = Alignment::new(1 << addrbits.trailing_zeros()).unwrap();
37                *dst = align.min(*dst);
38            }
39        }
40        self.thin = Some(thin);
41        self
42    }
43
44    pub fn fat(&mut self) -> &mut Self where A : fat::Alloc + fat::Free {
45        let mut fat = AlignmentRange { min: Alignment::MAX, max: ALIGN_1 };
46
47        for _ in 0 .. 100 {
48            let layout = Layout::new::<u8>(); // 1B
49            let alloc = (self.create)();
50            let addrs = [(); 4096].map(|_| alloc.alloc_uninit(layout).unwrap());
51            let addrbits = addrs[..].iter().copied().map(|addr| addr.as_ptr() as usize).reduce(|x,y| x|y).unwrap();
52            addrs.iter().copied().for_each(|addr| unsafe { alloc.free(addr, layout) });
53            let align = Alignment::new(1 << addrbits.trailing_zeros()).unwrap();
54            fat.min = align.min(fat.min);
55        }
56
57        fat.max = fat.min;
58        let alloc = (self.create)();
59        while let Some(next) = fat.max.as_usize().checked_shl(1) {
60            let Some(align) = Alignment::new(next) else { break };
61            let Ok(layout) = Layout::from_size_align(next, next) else { break };
62            let Ok(addr) = alloc.alloc_uninit(layout) else { break };
63            fat.max = align;
64            unsafe { alloc.free(addr, layout) };
65        }
66
67        self.fat = Some(fat);
68        self
69    }

Source

pub const fn of<T>() -> Self

Returns the Alignment of T.

Source

pub const unsafe fn new_unchecked(align: usize) -> Self

Undefined behavior unless align is a valid power of 2 (which also implies nonzero)

Source

pub const fn as_usize(self) -> usize

Returns the alignment as a usize (the nicheless underlying type)

Examples found in repository ?

examples/alloc-tester.rs (line 59)

44    pub fn fat(&mut self) -> &mut Self where A : fat::Alloc + fat::Free {
45        let mut fat = AlignmentRange { min: Alignment::MAX, max: ALIGN_1 };
46
47        for _ in 0 .. 100 {
48            let layout = Layout::new::<u8>(); // 1B
49            let alloc = (self.create)();
50            let addrs = [(); 4096].map(|_| alloc.alloc_uninit(layout).unwrap());
51            let addrbits = addrs[..].iter().copied().map(|addr| addr.as_ptr() as usize).reduce(|x,y| x|y).unwrap();
52            addrs.iter().copied().for_each(|addr| unsafe { alloc.free(addr, layout) });
53            let align = Alignment::new(1 << addrbits.trailing_zeros()).unwrap();
54            fat.min = align.min(fat.min);
55        }
56
57        fat.max = fat.min;
58        let alloc = (self.create)();
59        while let Some(next) = fat.max.as_usize().checked_shl(1) {
60            let Some(align) = Alignment::new(next) else { break };
61            let Ok(layout) = Layout::from_size_align(next, next) else { break };
62            let Ok(addr) = alloc.alloc_uninit(layout) else { break };
63            fat.max = align;
64            unsafe { alloc.free(addr, layout) };
65        }
66
67        self.fat = Some(fat);
68        self
69    }