abs_mm 0.1.2

Abstract Memory Management
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

use core::{
    alloc::Layout,
    error,
    fmt,
    ptr::NonNull,
};

pub(crate) type MemAddr = NonNull<[u8]>;

/// A trait used by pool for internal memory alloc and dealloc when Allocator
/// trait is unstable.
///
/// The impl of this trait is usually a wrapper around the function pair of
/// `alloc` and `dealloc`.
///
/// # Safety
///
/// * Memory blocks returned from an allocator must point to valid memory and
///   retain their validity until the instance and all of its clones are
///   dropped,
///
/// * cloning or moving the allocator must not invalidate memory blocks returned
///   from this allocator. A cloned allocator must behave like the same
///   allocator, and
///
/// * any pointer to a memory block which is currently allocated may be passed
///   to any other method of the allocator.
pub unsafe trait TrMalloc {
    type Err: error::Error;

    fn can_support(&self, layout: Layout) -> bool;

    fn allocate(
        &self,
        layout: Layout,
    ) -> Result<MemAddr, Self::Err>;

    /// Deallocate memory pointed by the pointer
    ///
    /// # Safety
    ///
    /// No content yet
    unsafe fn deallocate(
        &self,
        ptr: MemAddr,
        layout: Layout,
    ) -> Result<usize, Self::Err>;
}

/// A dummy allocator that will do nothing but only return error.
#[derive(Debug, Clone, Default)]
pub struct FakeMalloc;

impl FakeMalloc {
    pub fn shared() -> &'static FakeMalloc {
        static FAKE_ALLOC: FakeMalloc = FakeMalloc;
        &FAKE_ALLOC
    }

    /// Will always returns false for any layout
    pub fn can_support(&self, _: Layout) -> bool {
        false
    }

    /// It will always return `Err`
    pub fn allocate(&self, _: Layout) -> Result<MemAddr, FakeMallocError> {
        Result::Err(FakeMallocError)
    }

    /// Do nothing but return `Result::Ok(0)`
    ///
    /// # Safety
    ///
    /// - This is not designed to be called manually.
    pub unsafe fn deallocate(
        &self,
        _: MemAddr,
        _: Layout,
    ) -> Result<usize, FakeMallocError> {
        Result::Ok(0usize)
    }
}

/// No matter `allocate` or `deallocate`, you are doing it all wrong!
#[derive(Debug, Clone, Copy, Default)]
pub struct FakeMallocError;

unsafe impl TrMalloc for FakeMalloc {
    type Err = FakeMallocError;

    #[inline(always)]
    fn can_support(&self, layout: Layout) -> bool {
        FakeMalloc::can_support(self, layout)
    }

    #[inline(always)]
    fn allocate(&self, layout: Layout) -> Result<MemAddr, FakeMallocError> {
        FakeMalloc::allocate(self, layout)
    }

    #[inline(always)]
    unsafe fn deallocate(&self, ptr: MemAddr, layout: Layout) -> Result<usize, FakeMallocError> {
        unsafe { FakeMalloc::deallocate(self, ptr, layout) }
    }
}

impl fmt::Display for FakeMallocError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "FakeMallocError")
    }
}

impl error::Error for FakeMallocError {}

#[cfg(any(test, feature = "core_alloc"))]
pub use crate::core_alloc_::{CoreAlloc, CoreAllocError};