add libc api feature (#198)

Author: wpbrown

.gitignore

@@ -1,3 +1,7 @@
 target
 Cargo.lock
 .idea
+
+# vscode dirs
+.vscode/
+.vs/

Cargo.toml

@@ -33,3 +33,4 @@ lto = ["snmalloc-sys/lto"]
 notls = ["snmalloc-sys/notls"]
 stats = ["snmalloc-sys/stats"]
 usewait-on-address = ["snmalloc-sys/usewait-on-address"]
+libc-api = ["snmalloc-sys/libc-api"]

README.md

@@ -39,6 +39,7 @@ are listed at
 - `lto`: Links with InterProceduralOptimization/LinkTimeOptimization
 - `notls`: Enables to be loaded dynamically, thus disable tls.
 - `stats`: Enables allocation statistics.
+- `libc-api`: Enables libc API backed by snmalloc.
 
 **To get the crates compiled, you need to choose either `1mib` or `16mib` to determine the chunk configuration**
 

snmalloc-sys/Cargo.toml

@@ -32,3 +32,4 @@ lto = []
 notls = []
 stats = []
 usewait-on-address = []
+libc-api = []

snmalloc-sys/build.rs

@@ -60,6 +60,7 @@ struct BuildFeatures {
     stats: bool,
     android_lld: bool,
     local_dynamic_tls: bool,
+    libc_api: bool,
 }
 
 impl BuildConfig {
@@ -277,6 +278,7 @@ impl BuildFeatures {
             stats: cfg!(feature = "stats"),
             android_lld: cfg!(feature = "android-lld"),
             local_dynamic_tls: cfg!(feature = "local_dynamic_tls"),
+            libc_api: cfg!(feature = "libc-api"),
         }
     }
 }
@@ -378,7 +380,8 @@ fn configure_platform(config: &mut BuildConfig) {
         .define("SNMALLOC_QEMU_WORKAROUND", if config.features.qemu { "ON" } else { "OFF" })
         .define("SNMALLOC_ENABLE_DYNAMIC_LOADING", if config.features.notls { "ON" } else { "OFF" })
         .define("SNMALLOC_USE_WAIT_ON_ADDRESS", if config.features.wait_on_address { "1" } else { "0" })
-        .define("USE_SNMALLOC_STATS", if config.features.stats { "ON" } else { "OFF" });
+        .define("USE_SNMALLOC_STATS", if config.features.stats { "ON" } else { "OFF" })
+        .define("SNMALLOC_RUST_LIBC_API", if config.features.libc_api { "ON" } else { "OFF" });
 
     // Android configuration
     if config.target.contains("android") {

snmalloc-sys/snmalloc

@@ -39,15 +39,21 @@ extern "C" {
         new_size: usize,
     ) -> *mut c_void;
 
+    /// Return the available bytes in a memory block.
+    pub fn sn_rust_usable_size(p: *const c_void) -> usize;
+}
+
+#[cfg(feature = "libc-api")]
+extern "C" {
     /// Allocate `count` items of `size` length each.
     /// Returns `null` if `count * size` overflows or on out-of-memory.
     /// All items are initialized to zero.
-    pub fn calloc(count: usize, size: usize) -> *mut c_void;
+    pub fn sn_calloc(count: usize, 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 malloc(size: usize) -> *mut c_void;
+    pub fn sn_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
@@ -57,18 +63,19 @@ extern "C" {
     /// If `p` is null, it behaves as [`sn_malloc`]. If `newsize` is larger than
     /// the original `size` allocated for `p`, the bytes after `size` are
     /// uninitialized.
-    pub fn realloc(p: *mut c_void, newsize: usize) -> *mut c_void;
+    pub fn sn_realloc(p: *mut c_void, newsize: usize) -> *mut c_void;
 
     /// Free previously allocated memory.
     /// The pointer `p` must have been allocated before (or be null).
-    pub fn free(p: *mut c_void);
+    pub fn sn_free(p: *mut c_void);
 
     /// Return the available bytes in a memory block.
-    pub fn sn_rust_usable_size(p: *const c_void) -> usize;
+    pub fn sn_malloc_usable_size(p: *const c_void) -> usize;
+    
 }
 
 #[cfg(test)]
-mod tests {
+mod rust_tests {
     use super::*;
 
     #[test]
@@ -90,19 +97,6 @@ mod tests {
         unsafe { sn_rust_dealloc(ptr as *mut c_void, 8, 8) };
     }
 
-    #[test]
-    fn it_frees_memory_sn_malloc() {
-        let ptr = unsafe { malloc(8) } as *mut u8;
-        unsafe { free(ptr as *mut c_void) };
-    }
-
-    #[test]
-    fn it_frees_memory_sn_realloc() {
-        let ptr = unsafe { malloc(8) } as *mut u8;
-        let ptr = unsafe { realloc(ptr as *mut c_void, 8) } as *mut u8;
-        unsafe { free(ptr as *mut c_void) };
-    }
-
     #[test]
     fn it_reallocs_correctly() {
         let mut ptr = unsafe { sn_rust_alloc(8, 8) } as *mut u8;
@@ -126,3 +120,32 @@ mod tests {
         unsafe { sn_rust_dealloc(ptr as *mut c_void, 32, 8) };
     }
 }
+
+#[cfg(all(test, feature = "libc-api"))]
+mod libc_tests {
+    use super::*;
+
+    #[test]
+    fn it_frees_memory_sn_malloc() {
+        let ptr = unsafe { sn_malloc(8) } as *mut u8;
+        unsafe { sn_free(ptr as *mut c_void) };
+    }
+
+    #[test]
+    fn it_frees_memory_sn_realloc() {
+        let ptr = unsafe { sn_malloc(8) } as *mut u8;
+        let ptr = unsafe { sn_realloc(ptr as *mut c_void, 8) } as *mut u8;
+        unsafe { sn_free(ptr as *mut c_void) };
+    }
+    
+    #[test]
+    fn it_calculates_malloc_usable_size() {
+        let ptr = unsafe { sn_malloc(32) } as *mut u8;
+        let usable_size = unsafe { sn_malloc_usable_size(ptr as *mut c_void) };
+        assert!(
+            usable_size >= 32,
+            "usable_size should at least equal to the allocated size"
+        );
+        unsafe { sn_free(ptr as *mut c_void) };
+    }
+}