From b2b50635172254777d16d0fc6112e6d5b68b63f2 Mon Sep 17 00:00:00 2001 From: Tobias Schaffner Date: Sat, 9 Sep 2017 11:09:34 +0200 Subject: [PATCH] Move default stack min size to thread implementations The default min stack size value is smaller on l4re and therefore this value has to be different depending on the platform. --- src/libstd/sys/redox/thread.rs | 2 ++ src/libstd/sys/unix/l4re.rs | 4 ++-- src/libstd/sys/unix/thread.rs | 5 +++++ src/libstd/sys/windows/thread.rs | 2 ++ src/libstd/sys_common/thread.rs | 18 ++++++++++++++++++ src/libstd/sys_common/util.rs | 21 --------------------- src/libstd/thread/mod.rs | 4 ++-- 7 files changed, 31 insertions(+), 25 deletions(-) diff --git a/src/libstd/sys/redox/thread.rs b/src/libstd/sys/redox/thread.rs index b2c0e285f0663..c4aad8d86f8b1 100644 --- a/src/libstd/sys/redox/thread.rs +++ b/src/libstd/sys/redox/thread.rs @@ -16,6 +16,8 @@ use sys_common::thread::start_thread; use sys::{cvt, syscall}; use time::Duration; +pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; + pub struct Thread { id: usize, } diff --git a/src/libstd/sys/unix/l4re.rs b/src/libstd/sys/unix/l4re.rs index e07c864a6cbdc..2121848967939 100644 --- a/src/libstd/sys/unix/l4re.rs +++ b/src/libstd/sys/unix/l4re.rs @@ -104,11 +104,11 @@ pub mod net { impl AsInner for Socket { fn as_inner(&self) -> &libc::c_int { self.0.as_inner() } } - + impl FromInner for Socket { fn from_inner(fd: libc::c_int) -> Socket { Socket(FileDesc::new(fd)) } } - + impl IntoInner for Socket { fn into_inner(self) -> libc::c_int { self.0.into_raw() } } diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index 60bce7924cdd8..6c4a332429646 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -20,6 +20,11 @@ use time::Duration; use sys_common::thread::*; +#[cfg(not(target_os = "l4re"))] +pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; +#[cfg(target_os = "l4re")] +pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024; + pub struct Thread { id: libc::pthread_t, } diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs index 2cdd86e88b0a0..6aea9d1fb560f 100644 --- a/src/libstd/sys/windows/thread.rs +++ b/src/libstd/sys/windows/thread.rs @@ -19,6 +19,8 @@ use sys::handle::Handle; use sys_common::thread::*; use time::Duration; +pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; + pub struct Thread { handle: Handle } diff --git a/src/libstd/sys_common/thread.rs b/src/libstd/sys_common/thread.rs index 3ee160da5fa5b..87fb34a9dec06 100644 --- a/src/libstd/sys_common/thread.rs +++ b/src/libstd/sys_common/thread.rs @@ -8,9 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use env; use alloc::boxed::FnBox; use libc; +use sync::atomic::{self, Ordering}; use sys::stack_overflow; +use sys::thread as imp; pub unsafe fn start_thread(main: *mut libc::c_void) { // Next, set up our stack overflow handler which may get triggered if we run @@ -20,3 +23,18 @@ pub unsafe fn start_thread(main: *mut libc::c_void) { // Finally, let's run some code. Box::from_raw(main as *mut Box)() } + +pub fn min_stack() -> usize { + static MIN: atomic::AtomicUsize = atomic::AtomicUsize::new(0); + match MIN.load(Ordering::SeqCst) { + 0 => {} + n => return n - 1, + } + let amt = env::var("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()); + let amt = amt.unwrap_or(imp::DEFAULT_MIN_STACK_SIZE); + + // 0 is our sentinel value, so ensure that we'll never see 0 after + // initialization has run + MIN.store(amt + 1, Ordering::SeqCst); + amt +} diff --git a/src/libstd/sys_common/util.rs b/src/libstd/sys_common/util.rs index 41be6f4376348..a391c7cc6ef0c 100644 --- a/src/libstd/sys_common/util.rs +++ b/src/libstd/sys_common/util.rs @@ -8,32 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use env; use fmt; use io::prelude::*; -use sync::atomic::{self, Ordering}; use sys::stdio::Stderr; use thread; -pub fn min_stack() -> usize { - static MIN: atomic::AtomicUsize = atomic::AtomicUsize::new(0); - match MIN.load(Ordering::SeqCst) { - 0 => {} - n => return n - 1, - } - let amt = env::var("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()); - #[cfg(not(target_os = "l4re"))] - let amt = amt.unwrap_or(2 * 1024 * 1024); - // L4Re only supports a maximum of 1Mb per default. - #[cfg(target_os = "l4re")] - let amt = amt.unwrap_or(1024 * 1024); - - // 0 is our sentinel value, so ensure that we'll never see 0 after - // initialization has run - MIN.store(amt + 1, Ordering::SeqCst); - amt -} - pub fn dumb_print(args: fmt::Arguments) { let _ = Stderr::new().map(|mut stderr| stderr.write_fmt(args)); } diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 4912ff93abdb3..ca01eaefcaef4 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -174,7 +174,7 @@ use sync::{Mutex, Condvar, Arc}; use sys::thread as imp; use sys_common::mutex; use sys_common::thread_info; -use sys_common::util; +use sys_common::thread; use sys_common::{AsInner, IntoInner}; use time::Duration; @@ -374,7 +374,7 @@ impl Builder { { let Builder { name, stack_size } = self; - let stack_size = stack_size.unwrap_or_else(util::min_stack); + let stack_size = stack_size.unwrap_or_else(thread::min_stack); let my_thread = Thread::new(name); let their_thread = my_thread.clone();