Remove rt::bookkeeping

This commit removes the runtime bookkeeping previously used to ensure
that all Rust tasks were joined before the runtime was shut down.

This functionality will be replaced by an RAII style `Thread` API, that
will also offer a detached mode.

Since this changes the semantics of shutdown, it is a:

[breaking-change]

src/libstd/rt/bookkeeping.rs

@@ -1,61 +0,0 @@
-// Copyright 2013-2014 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.
-
-//! Task bookkeeping
-//!
-//! This module keeps track of the number of running tasks so that entry points
-//! with libnative know when it's possible to exit the program (once all tasks
-//! have exited).
-//!
-//! The green counterpart for this is bookkeeping on sched pools, and it's up to
-//! each respective runtime to make sure that they call increment() and
-//! decrement() manually.
-
-use sync::atomic;
-use ops::Drop;
-
-use rt::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-
-static TASK_COUNT: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
-static TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
-
-#[allow(missing_copy_implementations)]
-pub struct Token { _private: () }
-
-impl Drop for Token {
-    fn drop(&mut self) { decrement() }
-}
-
-/// Increment the number of live tasks, returning a token which will decrement
-/// the count when dropped.
-pub fn increment() -> Token {
-    let _ = TASK_COUNT.fetch_add(1, atomic::SeqCst);
-    Token { _private: () }
-}
-
-pub fn decrement() {
-    unsafe {
-        if TASK_COUNT.fetch_sub(1, atomic::SeqCst) == 1 {
-            let guard = TASK_LOCK.lock();
-            guard.signal();
-        }
-    }
-}
-
-/// Waits for all other native tasks in the system to exit. This is only used by
-/// the entry points of native programs
-pub fn wait_for_other_tasks() {
-    unsafe {
-        let guard = TASK_LOCK.lock();
-        while TASK_COUNT.load(atomic::SeqCst) > 0 {
-            guard.wait();
-        }
-    }
-}

src/libstd/rt/mod.rs

@@ -73,7 +73,6 @@ pub mod mutex;
 pub mod thread;
 pub mod exclusive;
 pub mod util;
-pub mod bookkeeping;
 pub mod local;
 pub mod task;
 pub mod unwind;
@@ -207,7 +206,6 @@ pub fn at_exit(f: proc():Send) {
 /// Invoking cleanup while portions of the runtime are still in use may cause
 /// undefined behavior.
 pub unsafe fn cleanup() {
-    bookkeeping::wait_for_other_tasks();
     args::cleanup();
     thread::cleanup();
     local_ptr::cleanup();

src/libstd/rt/task.rs

@@ -29,7 +29,6 @@ use str::SendStr;
 use thunk::Thunk;
 
 use rt;
-use rt::bookkeeping;
 use rt::mutex::NativeMutex;
 use rt::local::Local;
 use rt::thread::{mod, Thread};
@@ -132,11 +131,6 @@ impl Task {
 
         let stack = stack_size.unwrap_or(rt::min_stack());
 
-        // Note that this increment must happen *before* the spawn in order to
-        // guarantee that if this task exits it will always end up waiting for
-        // the spawned task to exit.
-        let token = bookkeeping::increment();
-
         // Spawning a new OS thread guarantees that __morestack will never get
         // triggered, but we must manually set up the actual stack bounds once
         // this function starts executing. This raises the lower limit by a bit
@@ -156,7 +150,6 @@ impl Task {
 
             let mut f = Some(f);
             drop(task.run(|| { f.take().unwrap().invoke(()) }).destroy());
-            drop(token);
         })
     }
 

src/libstd/sys/common/helper_thread.rs

@@ -25,7 +25,7 @@ use prelude::*;
 use cell::UnsafeCell;
 use mem;
 use sync::{StaticMutex, StaticCondvar};
-use rt::{mod, bookkeeping};
+use rt;
 use sys::helper_signal;
 
 use task;
@@ -83,7 +83,6 @@ impl<M: Send> Helper<M> {
 
                 let t = f();
                 task::spawn(move |:| {
-                    bookkeeping::decrement();
                     helper(receive, rx, t);
                     let _g = self.lock.lock();
                     *self.shutdown.get() = true;