深入RUST标准库内核（二 内存）—NonNull/申请及释放

本书github链接：inside-rust-std-library
前面章节参见：
深入RUST标准库内核（序言） - (jianshu.com)
深入RUST标准库内核(一 概述) - (jianshu.com)
深入RUST标准库内核(二 内存）—Layout/原生指针 - (jianshu.com)

NonNull

定义如下：

#[repr(transparent)]
pub struct NonNull {
    pointer: *const T,
}

如前文，因为NonNull是repr(transparent)内存布局模式，所以，NonNull在内存中与*const T完全一致。可以直接转化为* const T。
这种用法是是RUST常用的封装类型的惯用法。因为* const T是没有所有权，借用，生命周期的， 因此不能被RUST编译器做drop操作。而用NonNull封装后，即具备了所有权，借用，生命周期的概念。
另外，NonNull确保指针是非零值。指针为0实际上代表指针异常，在RUST中，应该用Option::None标识。有了NonNull后，即可以用Option>来处理指针为0的情况。

NonNull的相关方法：
NonNull::::cast(self)->NonNull 指针类型转换，程序员应该保证T和U的内存布局相同
NonNull::::new(* mut T)->Option 可以判断* mut T是否为0值，并返回Option>类型,
NonNull::::new_unchecked(* mut T)->Self 封装* mut T，不检查* mut T是否为0，程序员应保证* mu T不为0
NonNull::::from_raw_parts( data_address: NonNull<()>, metadata: ::Metadata) -> NonNull，实际上先调用ptr::from_raw_parts形成* const T的指针，然后再形成NonNull。
NonNull::::to_raw_parts(self) -> (NonNull<()>, ::Metadata) 上面函数的反操作
NonNull::::as_ptr(self)->* mut T 返回原生指针
NonNull::::as_ref<`a>(&self)->&`a T
NonNull::::as_mut<`a>(&mut self)->&`a mut T 从NonNull返回结构引用，此时程序员应保证符合引用安全的规则
NonNull::<[T]>::slice_from_raw_parts(data: NonNull, len: usize) -> Self 将类型指针转化为类型的切片类型指针，实质是ptr::slice_from_raw_parts的一种包装。
NonNull的方法逻辑也都简单，这里不做更深入的分析,以上的方法举例如下：
以下的实例展示了 NonNull在动态内存申请中的使用：

    impl Global {
        fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result, AllocError> {
            match layout.size() {
                0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)),
                // SAFETY: `layout` is non-zero in size,
                size => unsafe {
                    //raw_ptr是 *const u8类型
                    let raw_ptr = if zeroed { alloc_zeroed(layout) } else { alloc(layout) };
                    //NonNull::new处理了raw_ptr为零的情况,返回NonNull,此时内存长度还与T不匹配
                    let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
                    //将NonNull转换为NonNull<[u8]>, NonNull<[u8]>已经是类型T的内存长度。后继可以直接转换为T类型的指针了。
                    Ok(NonNull::slice_from_raw_parts(ptr, size))
                },
            }
        }
        ....
    }

RUST堆内存申请与释放接口

对于堆内存的申请和释放，RUST与其他语言不同，其他语言都是简单而直接的，如 C++/Java的new/delete， C语言的malloc/free等。但RUST的内存申请和释放是复杂和曲折的。
RUST语言库因为要兼容内核与用户空间程序，堆内存的申请和释放给出了能够兼容两者的方案，并额外增加了扩展性。
RUST的内存申请和释放的方案是定义内存申请和释放的GlobalAlloc Trait。编译器自身实现了基于GlobalAlloc的用户态内存管理模块作为默认模块。但也允许开发者实现自定义的内存管理模块，该模块需要实现GlobalAlloc，并做配置,即可使整个库的堆内存申请和释放基于开发者自定义的内存管理模块。自定义内存申请模块通常在内核开发，复杂的框架开发中使用。
堆内存申请和释放的Trait GlobalAlloc定义如下:

pub unsafe trait GlobalAlloc {
    //申请内存，因为Layout中内存大小不为0，所以，alloc不会申请大小为0的内存
    unsafe fn alloc(&self, layout: Layout) -> *mut u8;
    //释放内存
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
    
    //申请后的内存应初始化为0
    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
        let size = layout.size();
        // SAFETY: the safety contract for `alloc` must be upheld by the caller.
        let ptr = unsafe { self.alloc(layout) };
        if !ptr.is_null() {
            // SAFETY: as allocation succeeded, the region from `ptr`
            // of size `size` is guaranteed to be valid for writes.
            unsafe { ptr::write_bytes(ptr, 0, size) };
        }
        ptr
    }

在内核编程或大的框架系统编程中，开发人员通常开发自定义的堆内存管理模块，模块实现GlobalAlloc Trait并添加#[global_allocator]标识。用户态的库，RUST有默认的GlobalAlloc实现。
从代码中可以看到，GlobalAlloc申请返回* mut u8原始指针。此原始指针还要经过Allocator Trait处理之后，才能够被接下来的RUST内存相关模块继续处理。

pub unsafe trait Allocator {
    fn allocate(&self, layout: Layout) -> Result, AllocError>;

    fn allocate_zeroed(&self, layout: Layout) -> Result, AllocError> {
        let ptr = self.allocate(layout)?;
        // SAFETY: `alloc` returns a valid memory block
        // 复杂的类型转换，实际是调用 *const u8::write_bytes(0, layout.size_)
        unsafe { ptr.as_non_null_ptr().as_ptr().write_bytes(0, ptr.len()) }
        Ok(ptr)
    }

    unsafe fn deallocate(&self, ptr: NonNull, layout: Layout);

    ...
}

Global 实现了 Allocator Trait。Rust大部分core库，alloc库数据结构的实现使用Global作为Allocator。

unsafe impl Allocator for Global {
    fn allocate(&self, layout: Layout) -> Result, AllocError> {
        //上文已经给出alloc_impl的说明
        self.alloc_impl(layout, false)
    }

    fn allocate_zeroed(&self, layout: Layout) -> Result, AllocError> {
        self.alloc_impl(layout, true)
    }

    unsafe fn deallocate(&self, ptr: NonNull, layout: Layout) {
        if layout.size() != 0 {
            // SAFETY: `layout` is non-zero in size,
            // other conditions must be upheld by the caller
            unsafe { dealloc(ptr.as_ptr(), layout) }
        }
    }
    ...
    ...
}

pub unsafe fn alloc(layout: Layout) -> *mut u8 {
    unsafe { __rust_alloc(layout.size(), layout.align()) }
}

__rust_alloc实际上会转化为GlobalAlloc::alloc的调用。

Allocator使用GlobalAlloc接口获取内存，然后将GlobalAlloc申请到的* mut u8转换为确定大小的单一指针NonNull<[u8]>， 并处理申请内存可能出现的不成功。NonNull<[u8]>此时内存布局与 T的内存布局已经相同，后继可以转换为真正需要的T的指针并进一步转化为相关类型的引用，从而符合RUST类型系统安全并进行后继的处理。
以上是堆内存的申请和释放。
基于泛型，RUST也巧妙实现了栈内存的申请和释放机制 mem::MaybeUninit