Hooked api to allocator ffi

Author: octavonce

Cargo.toml

@@ -8,4 +8,7 @@ edition = "2018"
 libc = "0.2"
 
 [build-dependencies]
-cmake = "0.1"
+cmake = "0.1"
+
+[features]
+no_secure = []

build.rs

@@ -1,5 +1,14 @@
 use cmake::Config;
 
+#[cfg(feature = "no_secure")]
+fn main() {
+    let dst = Config::new("c_src/mimalloc")         
+        .build();
+    println!("cargo:rustc-link-search=native={}", dst.display());
+    //println!("cargo:rustc-link-lib=static=libmimalloc");
+}
+
+#[cfg(not(feature = "no_secure"))]
 fn main() {
     let dst = Config::new("c_src/mimalloc")
         .define("SECURE", "ON")             

src/ffi.rs

@@ -1,7 +1,8 @@
 // Copyright 2019 Octavian Oncescu
+
 use libc::{c_void, size_t};
 
 extern "C" {
-   fn mi_malloc_aligned(size: size_t, alignment: size_t) -> c_void;
-   fn mi_free(p: *const c_void) -> c_void;
+   pub(crate) fn mi_malloc_aligned(size: size_t, alignment: size_t) -> c_void;
+   pub(crate) fn mi_free(p: *const c_void) -> c_void;
 }

src/lib.rs

@@ -1,14 +1,51 @@
 // Copyright 2019 Octavian Oncescu
 
-use std::alloc::{GlobalAlloc, Layout, alloc};
+//! A drop-in global allocator wrapper around the [mimalloc](https://github.com/microsoft/mimalloc) allocator.
+//! Mimalloc is a general purpose, performance oriented allocator built by Microsoft.
+//! 
+//! ## Usage
+//! ```rust
+//! use mimalloc::MiMalloc;
+//!
+//! #[global_allocator]
+//! static GLOBAL: MiMalloc = MiMalloc;
+//! ```
+//! 
+//! ## Usage without secure mode
+//! By default this library builds mimalloc in safe-mode. This means that
+//! heap allocations are encrypted, but this results in a 3% increase in overhead.
+//! 
+//! In `Cargo.toml`:
+//! ```rust
+//! [dependencies]
+//! mimalloc = { version = "*", features = ["no_secure"] }
+//! ```
+
+use std::alloc::{GlobalAlloc, Layout};
 use std::ptr::null_mut;
+use libc::c_void;
 use ffi::*;
 
-pub struct MimAlloc;
+/// Drop-in mimalloc global allocator.
+/// 
+/// ## Usage
+/// ```rust
+/// use mimalloc::MiMalloc;
+///
+/// #[global_allocator]
+/// static GLOBAL: MiMalloc = MiMalloc;
+/// ```
+pub struct MiMalloc;
 
-unsafe impl GlobalAlloc for MimAlloc {
-    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 { null_mut() }
-    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
+unsafe impl GlobalAlloc for MiMalloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 { 
+        mi_malloc_aligned(layout.size(), layout.align());
+        null_mut()
+    }
+    
+    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+        mi_free(ptr as *const c_void);
+    }
 }
 
 mod ffi;