Allow specification of cc as a feature

Author: Ryan Clanton

.github/workflows/rust.yml

@@ -31,6 +31,8 @@ jobs:
       run: cargo test --all
     - name: Run tests 1mib
       run: cargo test --all --features 1mib
+    - name: Run tests 1mib build_cc
+      run: cargo test --all --features build_cc
     - name: Run tests debug
       run: cargo test --all --features debug
     - name: Run tests cache-friendly

.travis.yml

@@ -95,6 +95,7 @@ cache:
 script:
   - cargo test --all
   - cargo test --all --features 1mib
+  - cargo test --all --features build_cc
   - cargo test --all --features debug
   - cargo test --all --features cache-friendly
 

Cargo.toml

@@ -16,10 +16,11 @@ readme = "README.md"
 members = ["snmalloc-sys" ]
 
 [dependencies]
-snmalloc-sys = {version = "0.2.25", path = "snmalloc-sys"}
+snmalloc-sys = {version = "0.2.25", path = "snmalloc-sys",default-features = false }
 
 [features]
 default = ["1mib"]
+build_cc = ["snmalloc-sys/build_cc","1mib"]
 1mib = ["snmalloc-sys/1mib"]
 16mib = ["snmalloc-sys/16mib"]
 qemu = ["snmalloc-sys/qemu"]

snmalloc-sys/Cargo.toml

@@ -13,14 +13,17 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [build-dependencies]
-cc = {version = "1.0.67"}
+cc = {version = "1.0",optional=true}
+cmake = {version = "0.1",optional=true}
+
 
 [dependencies.libc]
 version = "0.2"
 default-features = false
 
 [features]
-default = ["1mib"]
+default = ["1mib","cmake"]
+build_cc = ["cc"]
 1mib = []
 16mib = []
 qemu = []

snmalloc-sys/build.rs

@@ -1,8 +1,11 @@
+#[cfg(feature = "build_cc")]
 fn main() {
     let mut build = cc::Build::new();
     build.include("snmalloc/src");
     build.file("snmalloc/src/override/rust.cc".to_string());
     build.flag_if_supported("/O2");
+    build.flag_if_supported("/Zi");
+    build.flag_if_supported("/nologo");
     build.flag_if_supported("/W4");
     build.flag_if_supported("/WX");
     build.flag_if_supported("/wd4127");
@@ -12,24 +15,32 @@ fn main() {
     build.flag_if_supported("/DNDEBUG");
     build.flag_if_supported("/EHsc");
     build.flag_if_supported("/std:c++17");
+    build.flag_if_supported("/Gd");
+    build.flag_if_supported("/TP");
+    build.flag_if_supported("/Gm-");
+    build.flag_if_supported("/GS");
+    build.flag_if_supported("/fp:precise");
+    build.flag_if_supported("/Zc:wchar_t");
+    build.flag_if_supported("/Zc:forScope");
+    build.flag_if_supported("/Zc:inline");
     build.flag_if_supported("-O3");
     build.flag_if_supported("-Wc++17-extensions");
     build.flag_if_supported("-std=c++1z");
     build.flag_if_supported("-std=gnu++1z");
     build.flag_if_supported("-mcx16");
-	build.flag_if_supported("-fno-exceptions");
-	build.flag_if_supported("-fno-rtti");
-	build.flag_if_supported("-g");
-	build.flag_if_supported("-fomit-frame-pointer");
+    build.flag_if_supported("-fno-exceptions");
+    build.flag_if_supported("-fno-rtti");
+    build.flag_if_supported("-g");
+    build.flag_if_supported("-fomit-frame-pointer");
+    build.flag_if_supported("-fpermissive");
     build.cpp(true);
     build.debug(false);
 
     let triple = std::env::var("TARGET").unwrap();
     let target_os = std::env::var("CARGO_CFG_TARGET_OS").expect("target_os not defined!");
     let target_env = std::env::var("CARGO_CFG_TARGET_ENV").expect("target_env not defined!");
-	let target_family = std::env::var("CARGO_CFG_TARGET_FAMILY").expect("target family not set");
+    let target_family = std::env::var("CARGO_CFG_TARGET_FAMILY").expect("target family not set");
 
-	
     if triple.contains("android") {
         if cfg!(feature = "android-lld") {
             build.define("ANDROID_LD", "lld");
@@ -54,16 +65,16 @@ fn main() {
             build.define("ANDROID_ABI", "armeabi-v7a");
         }
     }
-	
-    if target_os=="windows" && target_env == "gnu" {
+
+    if target_os == "windows" && target_env == "gnu" {
         build.define("CMAKE_SH", "CMAKE_SH-NOTFOUND");
         if cfg!(feature = "local_dynamic_tls") {
             build.flag_if_supported("-ftls-model=local-dynamic");
         } else {
             build.flag_if_supported("-ftls-model=initial-exec");
         }
     }
-	
+
     if target_family == "unix" && target_os != "haiku" {
         if cfg!(feature = "local_dynamic_tls") {
             build.flag_if_supported("-ftls-model=local-dynamic");
@@ -82,7 +93,7 @@ fn main() {
 
     if cfg!(feature = "native-cpu") {
         build.define("SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE", "ON");
-		build.flag_if_supported("-march=native");
+        build.flag_if_supported("-march=native");
     }
 
     if cfg!(feature = "stats") {
@@ -107,8 +118,8 @@ fn main() {
         println!("cargo:rustc-link-lib=dylib=mincore");
     }
 
-    if target_os=="windows" && target_env == "gnu" {
-        println!("cargo:rustc-link-lib=dylib=stdc++");
+    if target_os == "windows" && target_env == "gnu" {
+        //using cc
         println!("cargo:rustc-link-lib=dylib=atomic");
     }
 
@@ -129,3 +140,161 @@ fn main() {
         println!("cargo:rustc-link-lib=dylib=atomic");
     };
 }
+
+
+#[cfg(not(feature = "build_cc"))]
+fn main() {
+    let mut cfg = &mut cmake::Config::new("snmalloc");
+
+    let build_type = if cfg!(feature = "debug") {
+        "Debug"
+    } else {
+        "Release"
+    };
+
+    cfg = cfg
+        .define("SNMALLOC_RUST_SUPPORT", "ON")
+        .profile(build_type)
+        .very_verbose(true);
+
+    let triple = std::env::var("TARGET").unwrap();
+    if triple.contains("android") {
+        if let Ok(ndk) = std::env::var("ANDROID_NDK") {
+            cfg = cfg.define(
+                "CMAKE_TOOLCHAIN_FILE",
+                format!("{}/build/cmake/android.toolchain.cmake", ndk),
+            );
+        } else {
+            eprintln!("please set ANDROID_NDK environment variable");
+            std::process::abort();
+        }
+
+        if let Ok(platform) = std::env::var("ANDROID_PLATFORM") {
+            cfg = cfg.define("ANDROID_PLATFORM", platform);
+        }
+
+        if cfg!(feature = "android-lld") {
+            cfg = cfg.define("ANDROID_LD", "lld");
+        }
+
+        if cfg!(feature = "android-shared-stl") {
+            println!("cargo:rustc-link-lib=dylib=c++_shared");
+            cfg = cfg.define("ANDROID_STL", "c++_shared");
+        }
+
+        if triple.contains("aarch64") {
+            cfg = cfg.define("ANDROID_ABI", "arm64-v8a");
+        } else if triple.contains("armv7") {
+            cfg = cfg
+                .define("ANDROID_ABI", "armeabi-v7a")
+                .define("ANDROID_ARM_MODE", "arm");
+        } else if triple.contains("x86_64") {
+            cfg = cfg.define("ANDROID_ABI", "x86_64");
+        } else if triple.contains("i686") {
+            cfg = cfg.define("ANDROID_ABI", "x86_64");
+        } else if triple.contains("neon") {
+            cfg = cfg.define("ANDROID_ABI", "armeabi-v7a with NEON")
+        } else if triple.contains("arm") {
+            cfg = cfg.define("ANDROID_ABI", "armeabi-v7a");
+        }
+    }
+
+    if cfg!(all(windows, target_env = "msvc")) {
+        cfg = cfg.define("CMAKE_CXX_FLAGS_RELEASE", "/O2 /Ob2 /DNDEBUG /EHsc");
+        cfg = cfg.define("CMAKE_C_FLAGS_RELEASE", "/O2 /Ob2 /DNDEBUG /EHsc");
+    }
+
+    if cfg!(all(windows, target_env = "gnu")) {
+        cfg = cfg.define("CMAKE_SH", "CMAKE_SH-NOTFOUND");
+    }
+
+    let target = if cfg!(feature = "1mib") {
+        "snmallocshim-1mib-rust"
+    } else if cfg!(feature = "16mib") {
+        "snmallocshim-16mib-rust"
+    } else {
+        panic!("please set a chunk configuration");
+    };
+
+    if cfg!(feature = "native-cpu") {
+        cfg = cfg.define("SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE", "ON")
+    }
+
+    if cfg!(feature = "stats") {
+        cfg = cfg.define("USE_SNMALLOC_STATS", "ON")
+    }
+
+    if cfg!(feature = "qemu") {
+        cfg = cfg.define("SNMALLOC_QEMU_WORKAROUND", "ON")
+    }
+
+    let mut dst = if cfg!(feature = "cache-friendly") {
+        cfg.define("CACHE_FRIENDLY_OFFSET", "64")
+            .build_target(target)
+            .build()
+    } else {
+        cfg.build_target(target).build()
+    };
+
+    dst.push("./build");
+
+    println!("cargo:rustc-link-lib={}", target);
+
+    if cfg!(all(windows, target_env = "msvc")) {
+        println!("cargo:rustc-link-lib=dylib=mincore");
+        println!(
+            "cargo:rustc-link-search=native={}/{}",
+            dst.display(),
+            build_type
+        );
+    } else {
+        println!("cargo:rustc-link-search=native={}", dst.display());
+    }
+
+    if cfg!(all(windows, target_env = "gnu")) {
+        let stdout = std::process::Command::new("gcc")
+            .args(&["-print-search-dirs"])
+            .output()
+            .unwrap_or_else(|_| {
+                eprintln!("Cannot run gcc.exe");
+                std::process::abort();
+            })
+            .stdout;
+
+        let outputs = String::from_utf8(stdout).unwrap_or_else(|_| {
+            eprintln!("gcc output contains non-utf8 characters");
+            std::process::abort();
+        });
+
+        outputs
+            .lines()
+            .filter(|line| line.starts_with("libraries: ="))
+            .map(|line| line.split_at("libraries: =".len()).1)
+            .flat_map(|line| line.split(";"))
+            .for_each(|path| {
+                println!("cargo:rustc-link-search=native={}", path);
+            });
+
+        println!("cargo:rustc-link-lib=dylib=stdc++");
+        println!("cargo:rustc-link-lib=dylib=atomic");
+        println!("cargo:rustc-link-lib=dylib=winpthread");
+        println!("cargo:rustc-link-lib=dylib=gcc_s");
+    }
+
+    if cfg!(target_os = "macos") {
+        println!("cargo:rustc-link-lib=dylib=c++");
+    }
+
+    if cfg!(target_os = "openbsd") {
+        println!("cargo:rustc-link-lib=dylib=c++");
+    }
+
+    if cfg!(target_os = "freebsd") {
+        println!("cargo:rustc-link-lib=dylib=c++");
+    }
+
+    if cfg!(target_os = "linux") {
+        println!("cargo:rustc-link-lib=dylib=stdc++");
+        println!("cargo:rustc-link-lib=dylib=atomic");
+    }
+}

src/lib.rs

@@ -4,22 +4,22 @@
 //! - 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]
@@ -32,8 +32,8 @@ 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. 
+    /// 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
@@ -44,7 +44,7 @@ unsafe impl GlobalAlloc for SnMalloc {
         ffi::rust_alloc(layout.align(), layout.size()) as _
     }
 
-    /// De-allocate the memory at the given address with the given alignment and size. 
+    /// 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.
@@ -54,8 +54,8 @@ unsafe impl GlobalAlloc for SnMalloc {
         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. 
+    /// 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: