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
// Copyright 2019 Octavian Oncescu use core::ffi::c_void; #[cfg(feature = "extended")] mod extended; #[cfg(feature = "extended")] pub use extended::*; extern "C" { /// Allocate zero-initialized `size` bytes. /// /// Returns a pointer to newly allocated zero-initialized memory, or null if /// out of memory. pub fn mi_zalloc(size: usize) -> *mut c_void; /// Allocate `size` bytes. /// /// Returns pointer to the allocated memory or null if out of memory. /// Returns a unique pointer if called with `size` 0. pub fn mi_malloc(size: usize) -> *mut c_void; /// Re-allocate memory to `newsize` bytes. /// /// Return pointer to the allocated memory or null if out of memory. If null /// is returned, the pointer `p` is not freed. Otherwise the original /// pointer is either freed or returned as the reallocated result (in case /// it fits in-place with the new size). /// /// If `p` is null, it behaves as [`mi_malloc`]. If `newsize` is larger than /// the original `size` allocated for `p`, the bytes after `size` are /// uninitialized. pub fn mi_realloc(p: *mut c_void, newsize: usize) -> *mut c_void; /// Allocate `size` bytes aligned by `alignment`, initialized to zero. /// /// Return pointer to the allocated memory or null if out of memory. /// /// Returns a unique pointer if called with `size` 0. pub fn mi_zalloc_aligned(size: usize, alignment: usize) -> *mut c_void; /// Allocate `size` bytes aligned by `alignment`. /// /// Return pointer to the allocated memory or null if out of memory. /// /// Returns a unique pointer if called with `size` 0. pub fn mi_malloc_aligned(size: usize, alignment: usize) -> *mut c_void; /// Re-allocate memory to `newsize` bytes, aligned by `alignment`. /// /// Return pointer to the allocated memory or null if out of memory. If null /// is returned, the pointer `p` is not freed. Otherwise the original /// pointer is either freed or returned as the reallocated result (in case /// it fits in-place with the new size). /// /// If `p` is null, it behaves as [`mi_malloc_aligned`]. If `newsize` is /// larger than the original `size` allocated for `p`, the bytes after /// `size` are uninitialized. pub fn mi_realloc_aligned(p: *mut c_void, newsize: usize, alignment: usize) -> *mut c_void; /// Free previously allocated memory. /// /// The pointer `p` must have been allocated before (or be null). pub fn mi_free(p: *mut c_void); /// Return the available bytes in a memory block. /// /// The returned size can be used to call `mi_expand` successfully. pub fn mi_usable_size(p: *const c_void) -> usize; } #[cfg(test)] mod tests { use super::*; #[test] fn it_frees_memory_malloc() { let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8; unsafe { mi_free(ptr as *mut c_void) }; } #[test] fn it_frees_memory_zalloc() { let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8; unsafe { mi_free(ptr as *mut c_void) }; } #[test] fn it_frees_memory_realloc() { let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8; let ptr = unsafe { mi_realloc_aligned(ptr as *mut c_void, 8, 8) } as *mut u8; unsafe { mi_free(ptr as *mut c_void) }; } #[test] fn it_calculates_usable_size() { let ptr = unsafe { mi_malloc(32) } as *mut u8; let usable_size = unsafe { mi_usable_size(ptr as *mut c_void) }; assert!( usable_size >= 32, "usable_size should at least equal to the allocated size" ); } }