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
#![no_std] //! `snmalloc-rs` provides a wrapper for [`microsoft/snmalloc`](https://github.com/microsoft/snmalloc) to make it usable as a global allocator for rust. //! snmalloc is a research allocator. Its key design features are: //! - Memory that is freed by the same thread that allocated it does not require any synchronising operations. //! - Freeing memory in a different thread to initially allocated it, does not take any locks and instead uses a novel message passing scheme to return the memory to the original allocator, where it is recycled. //! - The allocator uses large ranges of pages to reduce the amount of meta-data required. //! //! The benchmark is available at the [paper](https://github.com/microsoft/snmalloc/blob/master/snmalloc.pdf) of `snmalloc` //! There are three features defined in this crate: //! - `debug`: Enable the `Debug` mode in `snmalloc`. //! - `1mib`: Use the `1mib` chunk configuration. //! - `cache-friendly`: Make the allocator more cache friendly (setting `CACHE_FRIENDLY_OFFSET` to `64` in building the library). //! //! The whole library supports `no_std`. //! //! To use `snmalloc-rs` add it as a dependency: //! ```toml //! # Cargo.toml //! [dependencies] //! snmalloc-rs = "0.1.0" //! ``` //! //! To set `SnMalloc` as the global allocator add this to your project: //! ```rust //! #[global_allocator] //! static ALLOC: snmalloc_rs::SnMalloc = snmalloc_rs::SnMalloc; //! ``` extern crate snmalloc_sys as ffi; use core::alloc::{GlobalAlloc, Layout}; pub struct SnMalloc; unsafe impl GlobalAlloc for SnMalloc { /// Allocate the memory with the given alignment and size. /// On success, it returns a pointer pointing to the required memory address. /// On failure, it returns a null pointer. /// The client must assure the following things: /// - `alignment` is greater than zero /// - Other constrains are the same as the rust standard library. /// The program may be forced to abort if the constrains are not full-filled. #[inline(always)] unsafe fn alloc(&self, layout: Layout) -> *mut u8 { ffi::rust_alloc(layout.align(), layout.size()) as _ } /// De-allocate the memory at the given address with the given alignment and size. /// The client must assure the following things: /// - the memory is acquired using the same allocator and the pointer points to the start position. /// - Other constrains are the same as the rust standard library. /// The program may be forced to abort if the constrains are not full-filled. #[inline(always)] unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { ffi::rust_dealloc(ptr as _, layout.align(), layout.size()); } /// Re-allocate the memory at the given address with the given alignment and size. /// On success, it returns a pointer pointing to the required memory address. /// The memory content within the `new_size` will remains the same as previous. /// On failure, it returns a null pointer. In this situation, the previous memory is not returned to the allocator. /// The client must assure the following things: /// - the memory is acquired using the same allocator and the pointer points to the start position /// - `alignment` fulfills all the requirements as `rust_alloc` /// - Other constrains are the same as the rust standard library. /// The program may be forced to abort if the constrains are not full-filled. #[inline(always)] unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { ffi::rust_realloc(ptr as _, layout.align(), layout.size(), new_size) as _ } } #[cfg(test)] mod tests { use super::*; #[test] fn it_frees_allocated_memory() { unsafe { let layout = Layout::from_size_align(8, 8).unwrap(); let alloc = SnMalloc; let ptr = alloc.alloc(layout.clone()); alloc.dealloc(ptr, layout); } } #[test] fn it_frees_zero_allocated_memory() { unsafe { let layout = Layout::from_size_align(8, 8).unwrap(); let alloc = SnMalloc; let ptr = alloc.alloc_zeroed(layout.clone()); alloc.dealloc(ptr, layout); } } #[test] fn it_frees_reallocated_memory() { unsafe { let layout = Layout::from_size_align(8, 8).unwrap(); let alloc = SnMalloc; let ptr = alloc.alloc(layout.clone()); let ptr = alloc.realloc(ptr, layout.clone(), 16); alloc.dealloc(ptr, layout); } } }