Build on windows + ci enhancements

.travis.yml

@@ -1,28 +1,35 @@
-dist: trusty
-sudo: require
-
-addons:
- apt:
- sources:
- - ubuntu-toolchain-r-test
- packages:
- - gcc-6
- - g++-6
- - cmake
-
 language: rust
 
-cache: cargo
+sudo: required
 
 rust:
  - stable
+ - beta
  - nightly
 
+os:
+ - windows
+ - linux
+ - osx
+
+dist: xenial
+
 matrix:
  allow_failures:
  - rust: nightly
- fast_finish: true
+
+addons:
+ apt:
+ packages:
+ - cmake
+ - gcc
+
+language: rust
+
+cache: cargo
 
 script:
- - cargo test --all
- - cargo test --all --features no_secure
+ - cargo test --verbose --all
+ - cargo test --verbose --all --no-default-features
+ - cargo test --release --verbose --all
+ - cargo test --release --verbose --all --no-default-features

Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "mimalloc"
 version = "0.1.2"
-authors = ["Octavian Oncescu <octavonce@gmail.com>"]
+authors = [
+ "Octavian Oncescu <octavonce@gmail.com>",
+ "Vincent Rouillé <vincent@speedy37.fr>",
+]
 edition = "2018"
 repository = "https://github.com/purpleprotocol/mimalloc_rust"
 keywords = ["mimalloc", "allocator", "encrypted-heap", "performance"]
@@ -10,6 +13,9 @@ description = "Performance and security oriented drop-in allocator"
 license = "MIT"
 readme = "README.md"
 
+[workspace]
+members = ["libmimalloc-sys" ]
+
 [badges]
 travis-ci = { repository = "purpleprotocol/mimalloc_rust" }
 

README.md

@@ -1,20 +1,30 @@
 # Mimalloc Rust
+
 [![Build Status](https://travis-ci.org/purpleprotocol/mimalloc_rust.svg?branch=master)](https://travis-ci.org/purpleprotocol/mimalloc_rust) [![Latest Version]][crates.io] [![Documentation]][docs.rs]
 
 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;
 ```
 
+## Requirements
+
+[CMake](https://cmake.org/) and a __C__ compiler are required for building 
+[mimalloc](https://github.com/microsoft/mimalloc) with cargo.
+
 ## Usage without secure mode
-By default this library builds mimalloc in secure mode. This means that
-heap allocations are encrypted, but this results in a 3% increase in overhead.
+
+By default this library builds mimalloc in secure mode. This add guard pages, 
+randomized allocation, encrypted free lists, etc. The performance penalty should 
+only be around 3% according to [mimalloc](https://github.com/microsoft/mimalloc)
+own benchmarks.
 
 To disable secure mode, in `Cargo.toml`:
 ```rust
@@ -25,4 +35,4 @@ mimalloc = { version = "*", default-features = false }
 [crates.io]: https://crates.io/crates/mimalloc
 [Latest Version]: https://img.shields.io/crates/v/mimalloc.svg
 [Documentation]: https://docs.rs/mimalloc/badge.svg
-[docs.rs]: https://docs.rs/mimalloc
+[docs.rs]: https://docs.rs/mimalloc

libmimalloc-sys/build.rs

@@ -1,32 +1,45 @@
 use cmake::Config;
 
-#[cfg(not(feature = "secure"))]
 fn main() {
- let mut dst = Config::new("c_src/mimalloc") 
- .build();
+ let mut cfg = &mut Config::new("c_src/mimalloc");
 
- dst.push("build");
+ cfg = cfg.define("MI_OVERRIDE", "OFF");
 
- println!("cargo:rustc-link-search=native={}", dst.display());
- if cfg!(debug_assertions) {
- println!("cargo:rustc-link-lib=static=mimalloc-debug");
- } else {
- println!("cargo:rustc-link-lib=static=mimalloc");
+ if cfg!(feature = "secure") {
+ cfg = cfg.define("MI_SECURE", "OFF");
  }
-}
 
-#[cfg(feature = "secure")]
-fn main() {
- let mut dst = Config::new("c_src/mimalloc")
- .define("SECURE", "ON") 
- .build();
+ if cfg!(all(windows, target_env = "msvc")) {
+ // cc::get_compiler have /nologo /MD default flags that are cmake::Config
+ // defaults to. Those flags prevents mimalloc from building on windows
+ // extracted from default cmake configuration on windows
+ if cfg!(debug_assertions) {
+ // CMAKE_C_FLAGS + CMAKE_C_FLAGS_DEBUG
+ cfg = cfg.cflag("/DWIN32 /D_WINDOWS /W3 /MDd /Zi /Ob0 /Od /RTC1");
+ } else {
+ // CMAKE_C_FLAGS + CMAKE_C_FLAGS_RELEASE
+ cfg = cfg.cflag("/DWIN32 /D_WINDOWS /W3 /MD /O2 /Ob2 /DNDEBUG");
+ }
+ }
 
- dst.push("build");
-
- println!("cargo:rustc-link-search=native={}", dst.display());
- if cfg!(debug_assertions) {
- println!("cargo:rustc-link-lib=static=mimalloc-debug");
+ let (out_dir, out_name) = if cfg!(all(windows, target_env = "msvc")) {
+ if cfg!(debug_assertions) {
+ ("./build/Debug", "mimalloc-static-debug")
+ } else {
+ ("./build/Release", "mimalloc-static")
+ }
  } else {
- println!("cargo:rustc-link-lib=static=mimalloc-secure");
- }
-}
+ if cfg!(debug_assertions) {
+ ("./build", "mimalloc-debug")
+ } else {
+ ("./build", "mimalloc")
+ }
+ };
+
+ // Build mimalloc-static
+ let mut dst = cfg.build_target("mimalloc-static").build();
+ dst.push(out_dir);
+
+ println!("cargo:rustc-link-search=native={}", dst.display());
+ println!("cargo:rustc-link-lib={}", out_name);
+}

libmimalloc-sys/src/lib.rs

@@ -3,35 +3,35 @@
 use libc::{c_void, size_t};
 
 extern "C" {
- pub fn mi_zalloc(size: size_t) -> *const c_void;
- pub fn mi_malloc(size: size_t) -> *const c_void;
- pub fn mi_realloc(p: *const c_void, size: size_t) -> *const c_void;
- pub fn mi_zalloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
- pub fn mi_malloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
- pub fn mi_realloc_aligned(p: *const c_void, size: size_t, alignment: size_t) -> *const c_void;
- pub fn mi_free(p: *const c_void) -> c_void;
+  pub fn mi_zalloc(size: size_t) -> *const c_void;
+  pub fn mi_malloc(size: size_t) -> *const c_void;
+  pub fn mi_realloc(p: *const c_void, size: size_t) -> *const c_void;
+  pub fn mi_zalloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
+  pub fn mi_malloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
+  pub fn mi_realloc_aligned(p: *const c_void, size: size_t, alignment: size_t) -> *const c_void;
+  pub fn mi_free(p: *const c_void) -> c_void;
 }
 
 #[cfg(test)]
 mod tests {
- use super::*;
+  use super::*;
 
- #[test]
- fn it_frees_memory_malloc() {
- let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
- unsafe { mi_free(ptr as *const c_void) };
- }
+  #[test]
+  fn it_frees_memory_malloc() {
+  let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
+  unsafe { mi_free(ptr as *const c_void) };
+  }
 
- #[test]
- fn it_frees_memory_zalloc() {
- let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8;
- unsafe { mi_free(ptr as *const c_void) };
- }
+  #[test]
+  fn it_frees_memory_zalloc() {
+  let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8;
+  unsafe { mi_free(ptr as *const 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 *const c_void, 8, 8) } as *mut u8;
- unsafe { mi_free(ptr as *const 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 *const c_void, 8, 8) } as *mut u8;
+  unsafe { mi_free(ptr as *const c_void) };
+  }
+}

src/lib.rs

@@ -4,19 +4,19 @@
 
 //! 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,ignore
 //! use mimalloc::MiMalloc;
 //!
 //! #[global_allocator]
 //! static GLOBAL: MiMalloc = MiMalloc;
 //! ```
-//! 
+//!
 //! ## Usage without secure mode
 //! By default this library builds mimalloc in secure mode. This means that
 //! heap allocations are encrypted, but this results in a 3% increase in overhead.
-//! 
+//!
 //! To disable secure mode, in `Cargo.toml`:
 //! ```rust,ignore
 //! [dependencies]
@@ -26,9 +26,8 @@
 extern crate libmimalloc_sys as ffi;
 
 use core::alloc::{GlobalAlloc, Layout};
-use core::ptr;
-use libc::c_void;
 use ffi::*;
+use libc::c_void;
 
 // Copied from https://github.com/rust-lang/rust/blob/master/src/libstd/sys_common/alloc.rs
 #[cfg(all(any(
@@ -52,7 +51,7 @@ const MIN_ALIGN: usize = 8;
 const MIN_ALIGN: usize = 16;
 
 /// Drop-in mimalloc global allocator.
-/// 
+///
 /// ## Usage
 /// ```rust,ignore
 /// use mimalloc::MiMalloc;
@@ -68,10 +67,9 @@ unsafe impl GlobalAlloc for MiMalloc {
  if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
  mi_malloc(layout.size()) as *mut u8
  } else {
- #[cfg(target_os = "macos")]
- {
+ if cfg!(target_os = "macos") {
  if layout.align() > (1 << 31) {
- return ptr::null_mut()
+ return core::ptr::null_mut();
  }
  }
 
@@ -84,17 +82,16 @@ unsafe impl GlobalAlloc for MiMalloc {
  if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
  mi_zalloc(layout.size()) as *mut u8
  } else {
- #[cfg(target_os = "macos")]
- {
+ if cfg!(target_os = "macos") {
  if layout.align() > (1 << 31) {
- return ptr::null_mut()
+ return core::ptr::null_mut();
  }
  }
 
  mi_zalloc_aligned(layout.size(), layout.align()) as *mut u8
  }
  }
- 
+
  #[inline]
  unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
  mi_free(ptr as *const c_void);
@@ -147,4 +144,4 @@ mod tests {
  alloc.dealloc(ptr, layout);
  }
  }
-}
+}