Auto merge of #138764 - Zoxc:win-mimalloc, r=<try>

Use mimalloc as the allocator on `x86_64-pc-windows-msvc`

try-job: dist-x86_64-msvc

Author: bors

Cargo.lock

@@ -756,7 +756,7 @@ checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681"
 dependencies = [
  "serde",
  "termcolor",
- "unicode-width 0.1.14",
+ "unicode-width 0.2.2",
 ]
 
 [[package]]
@@ -977,6 +977,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "cty"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35"
+
 [[package]]
 name = "curl"
 version = "0.4.49"
@@ -2216,6 +2222,16 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d1eacfa31c33ec25e873c136ba5669f00f9866d0688bea7be4d3f7e43067df6"
+dependencies = [
+ "cc",
+ "cty",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.10"
@@ -2399,6 +2415,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3627c4272df786b9260cabaa46aec1d59c93ede723d4c3ef646c503816b0640"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "minifier"
 version = "0.3.6"
@@ -3808,6 +3833,8 @@ dependencies = [
  "ctrlc",
  "jiff",
  "libc",
+ "libmimalloc-sys",
+ "mimalloc",
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",

INSTALL.md

@@ -96,7 +96,7 @@ See [the rustc-dev-guide for more info][sysllvm].
       --set llvm.libzstd=true \
       --set llvm.ninja=false \
       --set rust.debug-assertions=false \
-      --set rust.jemalloc \
+      --set rust.override-allocator=jemalloc \
       --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
       --set rust.codegen-units=1

bootstrap.example.toml

@@ -845,10 +845,11 @@
 # Useful for reproducible builds. Generally only set for releases
 #rust.remap-debuginfo = false
 
-# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
+# Link the compiler and LLVM against the specified allocator instead of the default libc allocator.
 # This option is only tested on Linux and OSX. It can also be configured per-target in the
 # [target.<tuple>] section.
-#rust.jemalloc = false
+# Possible options: "jemalloc"
+#rust.override-allocator = "jemalloc"
 
 # Run tests in various test suites with the "nll compare mode" in addition to
 # running the tests in normal mode. Largely only used on CI and during local
@@ -1120,9 +1121,9 @@
 # order to run `x check`.
 #optimized-compiler-builtins = build.optimized-compiler-builtins (bool or path)
 
-# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
-# This overrides the global `rust.jemalloc` option. See that option for more info.
-#jemalloc = rust.jemalloc (bool)
+# Link the compiler and LLVM against the specified allocator instead of the default libc allocator.
+# This overrides the global `rust.override-allocator` option. See that option for more info.
+#override-allocator = rust.override-allocator (string)
 
 # The linker configuration that will *override* the default linker used for Linux
 # targets in the built compiler.

compiler/rustc/Cargo.toml

@@ -40,6 +40,7 @@ llvm = ['rustc_driver_impl/llvm']
 llvm_enzyme = ['rustc_driver_impl/llvm_enzyme']
 llvm_offload = ['rustc_driver_impl/llvm_offload']
 max_level_info = ['rustc_driver_impl/max_level_info']
+mimalloc = ['rustc_driver_impl/mimalloc']
 rustc_randomized_layouts = ['rustc_driver_impl/rustc_randomized_layouts']
 # tidy-alphabetical-end
 

compiler/rustc_driver_impl/Cargo.toml

@@ -55,13 +55,23 @@ features = [
 ctrlc = "3.4.4"
 # tidy-alphabetical-end
 
+[target.'cfg(target_os = "windows")'.dependencies.mimalloc]
+version = "0.1.50"
+optional = true
+
+[target.'cfg(target_os = "windows")'.dependencies.libmimalloc-sys]
+version = "0.1.47"
+optional = true
+features = ["extended"]
+
 [features]
 # tidy-alphabetical-start
 check_only = ['rustc_interface/check_only']
 llvm = ['rustc_interface/llvm']
 llvm_enzyme = ['rustc_interface/llvm_enzyme']
 llvm_offload = ['rustc_interface/llvm_offload']
 max_level_info = ['rustc_log/max_level_info']
+mimalloc = ['dep:mimalloc', 'dep:libmimalloc-sys']
 rustc_randomized_layouts = [
     'rustc_index/rustc_randomized_layouts',
     'rustc_middle/rustc_randomized_layouts'

compiler/rustc_driver_impl/src/alloc.rs

@@ -0,0 +1,54 @@
+#[cfg(all(target_os = "windows", feature = "mimalloc"))]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(target_os = "windows", feature = "mimalloc"))]
+pub mod fns {
+    use std::os::raw::{c_char, c_int, c_void};
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn calloc(items: usize, size: usize) -> *mut c_void {
+        unsafe { libmimalloc_sys::mi_calloc(items, size) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn posix_memalign(
+        ptr: *mut *mut c_void,
+        align: usize,
+        size: usize,
+    ) -> c_int {
+        unsafe { libmimalloc_sys::mi_posix_memalign(ptr, align, size) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn strndup(s: *const c_char, n: usize) -> *mut c_char {
+        unsafe { libmimalloc_sys::mi_strndup(s, n) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn strdup(s: *const c_char) -> *mut c_char {
+        unsafe { libmimalloc_sys::mi_strdup(s) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn aligned_alloc(align: usize, size: usize) -> *mut c_void {
+        unsafe { libmimalloc_sys::mi_aligned_alloc(align, size) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn malloc(size: usize) -> *mut c_void {
+        unsafe { libmimalloc_sys::mi_malloc(size) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
+        unsafe { libmimalloc_sys::mi_realloc(ptr, size) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn free(ptr: *mut c_void) {
+        unsafe {
+            libmimalloc_sys::mi_free(ptr);
+        }
+    }
+}

compiler/rustc_driver_impl/src/lib.rs

@@ -63,6 +63,8 @@ use rustc_target::json::ToJson;
 use rustc_target::spec::{Target, TargetTuple};
 use tracing::trace;
 
+pub mod alloc;
+
 #[allow(unused_macros)]
 macro do_not_use_print($($t:tt)*) {
     std::compile_error!(

src/bootstrap/src/core/build_steps/compile.rs

@@ -28,7 +28,7 @@ use crate::core::builder::{
 };
 use crate::core::config::toml::target::DefaultLinuxLinkerOverride;
 use crate::core::config::{
-    CompilerBuiltins, DebuginfoLevel, LlvmLibunwind, RustcLto, TargetSelection,
+    CompilerBuiltins, DebuginfoLevel, LlvmLibunwind, OverrideAllocator, RustcLto, TargetSelection,
 };
 use crate::utils::build_stamp;
 use crate::utils::build_stamp::BuildStamp;
@@ -1411,7 +1411,9 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetS
     }
 
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the tool build step.
-    if builder.config.jemalloc(target) && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+    if let Some(OverrideAllocator::Jemalloc) = builder.config.override_allocator(target)
+        && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none()
+    {
         // Build jemalloc on AArch64 with support for page sizes up to 64K
         // See: https://github.com/rust-lang/rust/pull/135081
         if target.starts_with("aarch64") {

src/bootstrap/src/core/build_steps/tool.rs

@@ -20,7 +20,7 @@ use crate::core::builder;
 use crate::core::builder::{
     Builder, Cargo as CargoCommand, RunConfig, ShouldRun, Step, StepMetadata, cargo_profile_var,
 };
-use crate::core::config::{DebuginfoLevel, RustcLto, TargetSelection};
+use crate::core::config::{DebuginfoLevel, OverrideAllocator, RustcLto, TargetSelection};
 use crate::utils::exec::{BootstrapCommand, command};
 use crate::utils::helpers::{add_dylib_path, exe, t};
 use crate::{Compiler, FileType, Kind, Mode};
@@ -229,7 +229,9 @@ pub fn prepare_tool_cargo(
     cargo.env("LZMA_API_STATIC", "1");
 
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the compile build step.
-    if builder.config.jemalloc(target) && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+    if let Some(OverrideAllocator::Jemalloc) = builder.config.override_allocator(target)
+        && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none()
+    {
         // Build jemalloc on AArch64 with support for page sizes up to 64K
         // See: https://github.com/rust-lang/rust/pull/135081
         if target.starts_with("aarch64") {
@@ -752,8 +754,8 @@ impl Step for Rustdoc {
         // to build rustdoc.
         //
         let mut extra_features = Vec::new();
-        if builder.config.jemalloc(target) {
-            extra_features.push("jemalloc".to_string());
+        if let Some(allocator) = builder.config.override_allocator(target) {
+            extra_features.push(allocator.feature_name().to_string());
         }
 
         let compilers = RustcPrivateCompilers::from_target_compiler(builder, target_compiler);
@@ -1576,8 +1578,8 @@ tool_rustc_extended!(Clippy {
     stable: true,
     add_bins_to_sysroot: ["clippy-driver"],
     add_features: |builder, target, features| {
-        if builder.config.jemalloc(target) {
-            features.push("jemalloc".to_string());
+        if let Some(allocator) = builder.config.override_allocator(target) {
+            features.push(allocator.feature_name().to_string());
         }
     }
 });
@@ -1587,8 +1589,8 @@ tool_rustc_extended!(Miri {
     stable: false,
     add_bins_to_sysroot: ["miri"],
     add_features: |builder, target, features| {
-        if builder.config.jemalloc(target) {
-            features.push("jemalloc".to_string());
+        if let Some(allocator) = builder.config.override_allocator(target) {
+            features.push(allocator.feature_name().to_string());
         }
     },
     // Always compile also tests when building miri. Otherwise feature unification can cause rebuilds between building and testing miri.

src/bootstrap/src/core/config/config.rs

@@ -48,8 +48,8 @@ use crate::core::config::toml::target::{
     DefaultLinuxLinkerOverride, Target, TomlTarget, default_linux_linker_overrides,
 };
 use crate::core::config::{
-    CompilerBuiltins, DebuginfoLevel, DryRun, GccCiMode, LlvmLibunwind, Merge, ReplaceOpt,
-    RustcLto, SplitDebuginfo, StringOrBool, threads_from_config,
+    CompilerBuiltins, DebuginfoLevel, DryRun, GccCiMode, LlvmLibunwind, Merge, OverrideAllocator,
+    ReplaceOpt, RustcLto, SplitDebuginfo, StringOrBool, threads_from_config,
 };
 use crate::core::download::{
     DownloadContext, download_beta_toolchain, is_download_ci_available, maybe_download_rustfmt,
@@ -242,7 +242,7 @@ pub struct Config {
     pub hosts: Vec<TargetSelection>,
     pub targets: Vec<TargetSelection>,
     pub local_rebuild: bool,
-    pub jemalloc: bool,
+    pub override_allocator: Option<OverrideAllocator>,
     pub control_flow_guard: bool,
     pub ehcont_guard: bool,
 
@@ -570,7 +570,7 @@ impl Config {
             thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit,
             parallel_frontend_threads: rust_parallel_frontend_threads,
             remap_debuginfo: rust_remap_debuginfo,
-            jemalloc: rust_jemalloc,
+            override_allocator: rust_override_allocator,
             test_compare_mode: rust_test_compare_mode,
             llvm_libunwind: rust_llvm_libunwind,
             control_flow_guard: rust_control_flow_guard,
@@ -900,7 +900,7 @@ impl Config {
                     codegen_backends: target_codegen_backends,
                     runner: target_runner,
                     optimized_compiler_builtins: target_optimized_compiler_builtins,
-                    jemalloc: target_jemalloc,
+                    override_allocator: target_override_allocator,
                 } = cfg;
 
                 let mut target = Target::from_triple(&triple);
@@ -976,7 +976,7 @@ impl Config {
                 target.rpath = target_rpath;
                 target.rustflags = target_rustflags.unwrap_or_default();
                 target.optimized_compiler_builtins = target_optimized_compiler_builtins;
-                target.jemalloc = target_jemalloc;
+                target.override_allocator = target_override_allocator;
                 if let Some(backends) = target_codegen_backends {
                     target.codegen_backends =
                         Some(parse_codegen_backends(backends, &format!("target.{triple}")))
@@ -1371,7 +1371,6 @@ impl Config {
             initial_rustdoc,
             initial_rustfmt,
             initial_sysroot,
-            jemalloc: rust_jemalloc.unwrap_or(false),
             jobs: Some(threads_from_config(flags_jobs.or(build_jobs).unwrap_or(0))),
             json_output: flags_json_output,
             keep_stage: flags_keep_stage,
@@ -1433,6 +1432,7 @@ impl Config {
             on_fail: flags_on_fail,
             optimized_compiler_builtins,
             out,
+            override_allocator: rust_override_allocator,
             patch_binaries_for_nix: build_patch_binaries_for_nix,
             path_modification_cache,
             paths: flags_paths,
@@ -1864,8 +1864,11 @@ impl Config {
         self.enabled_codegen_backends(target).first().unwrap()
     }
 
-    pub fn jemalloc(&self, target: TargetSelection) -> bool {
-        self.target_config.get(&target).and_then(|cfg| cfg.jemalloc).unwrap_or(self.jemalloc)
+    pub fn override_allocator(&self, target: TargetSelection) -> Option<OverrideAllocator> {
+        self.target_config
+            .get(&target)
+            .and_then(|cfg| cfg.override_allocator)
+            .or(self.override_allocator)
     }
 
     pub fn rpath_enabled(&self, target: TargetSelection) -> bool {