From 0859e5ebb319ceddcce01ddb63470d8f59860aba Mon Sep 17 00:00:00 2001 From: James Miller Date: Sat, 17 Jan 2015 17:04:15 +1300 Subject: [PATCH 1/3] Use `zero_mem` instead of a zerointializer for `init` intrinsic LLVM gets overwhelmed when presented with a zeroinitializer for a large type. In unoptimised builds, it generates a long sequence of stores to memory. In optmised builds, it manages to generate a standard memset of zero values, but takes a long time doing so. Call out to the `llvm.memset` function to zero out the memory instead. --- src/librustc_trans/trans/intrinsic.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 91c7409182df..eaf9b4a6bf70 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -361,12 +361,11 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } (_, "init") => { let tp_ty = *substs.types.get(FnSpace, 0); - let lltp_ty = type_of::arg_type_of(ccx, tp_ty); - if return_type_is_void(ccx, tp_ty) { - C_nil(ccx) - } else { - C_null(lltp_ty) + if !return_type_is_void(ccx, tp_ty) { + // Just zero out the stack slot + zero_mem(bcx, llresult, tp_ty); } + C_nil(ccx) } // Effectively no-ops (_, "uninit") | (_, "forget") => { From 9c5173f8e5444862471eb079c93801ff13d4d525 Mon Sep 17 00:00:00 2001 From: James Miller Date: Sat, 17 Jan 2015 21:26:25 +1300 Subject: [PATCH 2/3] Add test to catch performance regressions --- src/librustc_trans/trans/intrinsic.rs | 2 +- src/test/run-pass/init-large-type.rs | 25 +++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 src/test/run-pass/init-large-type.rs diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index eaf9b4a6bf70..6d0f7746cad7 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -362,7 +362,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, (_, "init") => { let tp_ty = *substs.types.get(FnSpace, 0); if !return_type_is_void(ccx, tp_ty) { - // Just zero out the stack slot + // Just zero out the stack slot. (See comment on base::memzero for explaination) zero_mem(bcx, llresult, tp_ty); } C_nil(ccx) diff --git a/src/test/run-pass/init-large-type.rs b/src/test/run-pass/init-large-type.rs new file mode 100644 index 000000000000..a39a45f036e8 --- /dev/null +++ b/src/test/run-pass/init-large-type.rs @@ -0,0 +1,25 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Makes sure that zero-initializing large types is reasonably fast, +// Doing it incorrectly causes massive slowdown in LLVM during +// optimisation. + +#![feature(intrinsics)] + +extern "rust-intrinsic" { + pub fn init() -> T; +} + +const SIZE: usize = 512 * 1024 * 1024; + +fn main() { + let _memory: [u8; SIZE] = unsafe { init() }; +} From 25a4adc62f4a743b6696a248ef365aaaaee06362 Mon Sep 17 00:00:00 2001 From: James Miller Date: Mon, 19 Jan 2015 09:22:54 +1300 Subject: [PATCH 3/3] Reduce size of array in test case to 1MB --- src/test/run-pass/init-large-type.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/run-pass/init-large-type.rs b/src/test/run-pass/init-large-type.rs index a39a45f036e8..0534d0c054f4 100644 --- a/src/test/run-pass/init-large-type.rs +++ b/src/test/run-pass/init-large-type.rs @@ -18,7 +18,7 @@ extern "rust-intrinsic" { pub fn init() -> T; } -const SIZE: usize = 512 * 1024 * 1024; +const SIZE: usize = 1024 * 1024; fn main() { let _memory: [u8; SIZE] = unsafe { init() };