std: Extract librustrt out of libstd

As part of the libstd facade efforts, this commit extracts the runtime interface
out of the standard library into a standalone crate, librustrt. This crate will
provide the following services:

* Definition of the rtio interface
* Definition of the Runtime interface
* Implementation of the Task structure
* Implementation of task-local-data
* Implementation of task failure via unwinding via libunwind
* Implementation of runtime initialization and shutdown
* Implementation of thread-local-storage for the local rust Task

Notably, this crate avoids the following services:

* Thread creation and destruction. The crate does not require the knowledge of
  an OS threading system, and as a result it seemed best to leave out the
  `rt::thread` module from librustrt. The librustrt module does depend on
  mutexes, however.
* Implementation of backtraces. There is no inherent requirement for the runtime
  to be able to generate backtraces. As will be discussed later, this
  functionality continues to live in libstd rather than librustrt.

As usual, a number of architectural changes were required to make this crate
possible. Users of "stable" functionality will not be impacted by this change,
but users of the `std::rt` module will likely note the changes. A list of
architectural changes made is:

* The stdout/stderr handles no longer live directly inside of the `Task`
  structure. This is a consequence of librustrt not knowing about `std::io`.
  These two handles are now stored inside of task-local-data.

  The handles were originally stored inside of the `Task` for perf reasons, and
  TLD is not currently as fast as it could be. For comparison, 100k prints goes
  from 59ms to 68ms (a 15% slowdown). This appeared to me to be an acceptable
  perf loss for the successful extraction of a librustrt crate.

* The `rtio` module was forced to duplicate more functionality of `std::io`. As
  the module no longer depends on `std::io`, `rtio` now defines structures such
  as socket addresses, addrinfo fiddly bits, etc. The primary change made was
  that `rtio` now defines its own `IoError` type. This type is distinct from
  `std::io::IoError` in that it does not have an enum for what error occurred,
  but rather a platform-specific error code.

  The native and green libraries will be updated in later commits for this
  change, and the bulk of this effort was put behind updating the two libraries
  for this change (with `rtio`).

* Printing a message on task failure (along with the backtrace) continues to
  live in libstd, not in librustrt. This is a consequence of the above decision
  to move the stdout/stderr handles to TLD rather than inside the `Task` itself.
  The unwinding API now supports registration of global callback functions which
  will be invoked when a task fails, allowing for libstd to register a function
  to print a message and a backtrace.

  The API for registering a callback is experimental and unsafe, as the
  ramifications of running code on unwinding is pretty hairy.

* The `std::unstable::mutex` module has moved to `std::rt::mutex`.

* The `std::unstable::sync` module has been moved to `std::rt::exclusive` and
  the type has been rewritten to not internally have an Arc and to have an RAII
  guard structure when locking. Old code should stop using `Exclusive` in favor
  of the primitives in `libsync`, but if necessary, old code should port to
  `Arc<Exclusive<T>>`.

* The local heap has been stripped down to have fewer debugging options. None of
  these were tested, and none of these have been used in a very long time.

[breaking-change]

Author: alexcrichton

mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rlibc alloc debug
+                 url log regex graphviz core rlibc alloc debug rustrt
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -60,7 +60,9 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core rand libc alloc collections native:rustrt native:backtrace
+DEPS_rustrt := alloc core libc collections native:rustrt_native
+DEPS_std := core libc rand alloc collections rustrt \
+	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support

mk/rt.mk

@@ -35,8 +35,8 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch \
-		rust_test_helpers
+NATIVE_LIBS := rust_builtin hoedown uv_support morestack miniz context_switch \
+		rustrt_native rust_test_helpers
 
 # $(1) is the target triple
 define NATIVE_LIBRARIES
@@ -52,8 +52,9 @@ NATIVE_DEPS_hoedown_$(1) := hoedown/src/autolink.c \
 			hoedown/src/version.c
 NATIVE_DEPS_uv_support_$(1) := rust_uv.c
 NATIVE_DEPS_miniz_$(1) = miniz.c
-NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
-			rust_android_dummy.c \
+NATIVE_DEPS_rust_builtin_$(1) := rust_builtin.c \
+			rust_android_dummy.c
+NATIVE_DEPS_rustrt_native_$(1) := \
 			rust_try.ll \
 			arch/$$(HOST_$(1))/record_sp.S
 NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c

src/libcore/macros.rs

@@ -98,6 +98,20 @@ macro_rules! try(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )
 
+/// Writing a formatted string into a writer
+#[macro_export]
+macro_rules! write(
+    ($dst:expr, $($arg:tt)*) => (format_args_method!($dst, write_fmt, $($arg)*))
+)
+
+/// Writing a formatted string plus a newline into a writer
+#[macro_export]
+macro_rules! writeln(
+    ($dst:expr, $fmt:expr $($arg:tt)*) => (
+        write!($dst, concat!($fmt, "\n") $($arg)*)
+    )
+)
+
 #[cfg(test)]
 macro_rules! vec( ($($e:expr),*) => ({
     let mut _v = ::std::vec::Vec::new();

src/libstd/rt/args.rs renamed to src/librustrt/args.rs

@@ -18,10 +18,9 @@
 //! discover the command line arguments.
 //!
 //! FIXME #7756: Would be nice for this to not exist.
-//! FIXME #7756: This has a lot of C glue for lack of globals.
 
-use option::Option;
-use vec::Vec;
+use core::prelude::*;
+use collections::vec::Vec;
 
 /// One-time global initialization.
 pub unsafe fn init(argc: int, argv: **u8) { imp::init(argc, argv) }
@@ -44,14 +43,14 @@ pub fn clone() -> Option<Vec<Vec<u8>>> { imp::clone() }
 #[cfg(target_os = "android")]
 #[cfg(target_os = "freebsd")]
 mod imp {
-    use clone::Clone;
-    use iter::Iterator;
-    use option::{Option, Some, None};
-    use owned::Box;
-    use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-    use mem;
-    use vec::Vec;
-    use ptr::RawPtr;
+    use core::prelude::*;
+
+    use alloc::owned::Box;
+    use collections::vec::Vec;
+    use core::mem;
+    use core::slice;
+
+    use mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
     static mut global_args_ptr: uint = 0;
     static mut lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
@@ -100,24 +99,23 @@ mod imp {
         unsafe { mem::transmute(&global_args_ptr) }
     }
 
-    // Copied from `os`.
     unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> Vec<Vec<u8>> {
-        use c_str::CString;
-        use ptr::RawPtr;
-        use libc;
-        use vec::Vec;
-
         Vec::from_fn(argc as uint, |i| {
-            let cs = CString::new(*(argv as **libc::c_char).offset(i as int), false);
-            Vec::from_slice(cs.as_bytes_no_nul())
+            let base = *argv.offset(i as int);
+            let mut len = 0;
+            while *base.offset(len) != 0 { len += 1; }
+            slice::raw::buf_as_slice(base, len as uint, |slice| {
+                Vec::from_slice(slice)
+            })
         })
     }
 
     #[cfg(test)]
     mod tests {
-        use prelude::*;
+        use std::prelude::*;
+        use std::finally::Finally;
+
         use super::*;
-        use finally::Finally;
 
         #[test]
         fn smoke_test() {
@@ -149,8 +147,8 @@ mod imp {
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "win32")]
 mod imp {
-    use option::Option;
-    use vec::Vec;
+    use core::prelude::*;
+    use collections::vec::Vec;
 
     pub unsafe fn init(_argc: int, _argv: **u8) {
     }

src/librustrt/at_exit_imp.rs

@@ -0,0 +1,63 @@
+// Copyright 2013 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation of running at_exit routines
+//!
+//! Documentation can be found on the `rt::at_exit` function.
+
+use core::prelude::*;
+
+use alloc::owned::Box;
+use collections::vec::Vec;
+use core::atomics;
+use core::mem;
+
+use exclusive::Exclusive;
+
+type Queue = Exclusive<Vec<proc():Send>>;
+
+static mut QUEUE: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
+static mut RUNNING: atomics::AtomicBool = atomics::INIT_ATOMIC_BOOL;
+
+pub fn init() {
+    let state: Box<Queue> = box Exclusive::new(Vec::new());
+    unsafe {
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        rtassert!(QUEUE.swap(mem::transmute(state), atomics::SeqCst) == 0);
+    }
+}
+
+pub fn push(f: proc():Send) {
+    unsafe {
+        // Note that the check against 0 for the queue pointer is not atomic at
+        // all with respect to `run`, meaning that this could theoretically be a
+        // use-after-free. There's not much we can do to protect against that,
+        // however. Let's just assume a well-behaved runtime and go from there!
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        let queue = QUEUE.load(atomics::SeqCst);
+        rtassert!(queue != 0);
+        (*(queue as *Queue)).lock().push(f);
+    }
+}
+
+pub fn run() {
+    let cur = unsafe {
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        let queue = QUEUE.swap(0, atomics::SeqCst);
+        rtassert!(queue != 0);
+
+        let queue: Box<Queue> = mem::transmute(queue);
+        mem::replace(&mut *queue.lock(), Vec::new())
+    };
+
+    for to_run in cur.move_iter() {
+        to_run();
+    }
+}

src/libstd/rt/bookkeeping.rs renamed to src/librustrt/bookkeeping.rs

@@ -18,11 +18,9 @@
 //! each respective runtime to make sure that they call increment() and
 //! decrement() manually.
 
-#![experimental] // this is a massive code smell
-#![doc(hidden)]
+use core::atomics;
 
-use sync::atomics;
-use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+use mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
 static mut TASK_COUNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
 static mut TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;

src/libstd/c_str.rs renamed to src/librustrt/c_str.rs

@@ -65,24 +65,17 @@ fn main() {
 
 */
 
-use clone::Clone;
-use cmp::PartialEq;
-use container::Container;
-use iter::{Iterator, range};
-use kinds::marker;
+use core::prelude::*;
+
+use alloc::libc_heap::malloc_raw;
+use collections::string::String;
+use core::kinds::marker;
+use core::mem;
+use core::ptr;
+use core::raw::Slice;
+use core::slice;
+use core::str;
 use libc;
-use mem;
-use ops::Drop;
-use option::{Option, Some, None};
-use ptr::RawPtr;
-use ptr;
-use raw::Slice;
-use rt::libc_heap::malloc_raw;
-use slice::{ImmutableVector, MutableVector};
-use slice;
-use str::StrSlice;
-use str;
-use string::String;
 
 /// The representation of a C String.
 ///
@@ -454,11 +447,12 @@ pub unsafe fn from_c_multistring(buf: *libc::c_char,
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use super::*;
+    use std::prelude::*;
+    use std::ptr;
+    use std::task;
     use libc;
-    use ptr;
-    use str::StrSlice;
+
+    use super::*;
 
     #[test]
     fn test_str_multistring_parsing() {
@@ -574,7 +568,6 @@ mod tests {
 
     #[test]
     fn test_to_c_str_fail() {
-        use task;
         assert!(task::try(proc() { "he\x00llo".to_c_str() }).is_err());
     }
 
@@ -700,10 +693,9 @@ mod tests {
 
 #[cfg(test)]
 mod bench {
-    extern crate test;
-    use self::test::Bencher;
+    use test::Bencher;
     use libc;
-    use prelude::*;
+    use std::prelude::*;
 
     #[inline]
     fn check(s: &str, c_str: *libc::c_char) {