rustrt: Reorganize task usage

Most of the comments are available on the Task structure itself, but this commit
is aimed at making FFI-style usage of Rust tasks a little nicer.

Primarily, this commit enables re-use of tasks across multiple invocations. The
method `run` will no longer unconditionally destroy the task itself. Rather, the
task will be internally re-usable if the closure specified did not fail. Once a
task has failed once it is considered poisoned and it can never be used again.

Along the way I tried to document shortcomings of the current method of tearing
down a task, opening a few issues as well. For now none of the behavior is a
showstopper, but it's useful to acknowledge it. Also along the way I attempted
to remove as much `unsafe` code as possible, opting for safer abstractions.

Author: alexcrichton

src/libgreen/lib.rs

@@ -299,7 +299,7 @@ pub fn start(argc: int, argv: **u8,
     let mut ret = None;
     simple::task().run(|| {
         ret = Some(run(event_loop_factory, main.take_unwrap()));
-    });
+    }).destroy();
     // unsafe is ok b/c we're sure that the runtime is gone
     unsafe { rt::cleanup() }
     ret.unwrap()

src/libgreen/task.rs

@@ -110,7 +110,7 @@ extern fn bootstrap_green_task(task: uint, code: *(), env: *()) -> ! {
     // requested. This is the "try/catch" block for this green task and
     // is the wrapper for *all* code run in the task.
     let mut start = Some(start);
-    let task = task.swap().run(|| start.take_unwrap()());
+    let task = task.swap().run(|| start.take_unwrap()()).destroy();
 
     // Once the function has exited, it's time to run the termination
     // routine. This means we need to context switch one more time but
@@ -120,7 +120,7 @@ extern fn bootstrap_green_task(task: uint, code: *(), env: *()) -> ! {
     // this we could add a `terminate` function to the `Runtime` trait
     // in libstd, but that seems less appropriate since the coversion
     // method exists.
-    GreenTask::convert(task).terminate()
+    GreenTask::convert(task).terminate();
 }
 
 impl GreenTask {

src/libnative/lib.rs

@@ -134,13 +134,12 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
     let mut main = Some(main);
     let mut task = task::new((my_stack_bottom, my_stack_top));
     task.name = Some(str::Slice("<main>"));
-    let t = task.run(|| {
+    drop(task.run(|| {
         unsafe {
             rt::stack::record_stack_bounds(my_stack_bottom, my_stack_top);
         }
         exit_code = Some(run(main.take_unwrap()));
-    });
-    drop(t);
+    }).destroy());
     unsafe { rt::cleanup(); }
     // If the exit code wasn't set, then the task block must have failed.
     return exit_code.unwrap_or(rt::DEFAULT_ERROR_CODE);

src/libnative/task.rs

@@ -92,8 +92,7 @@ pub fn spawn_opts(opts: TaskOpts, f: proc():Send) {
         let mut f = Some(f);
         let mut task = task;
         task.put_runtime(ops);
-        let t = task.run(|| { f.take_unwrap()() });
-        drop(t);
+        drop(task.run(|| { f.take_unwrap()() }).destroy());
         bookkeeping::decrement();
     })
 }

src/librustrt/local_heap.rs

@@ -110,7 +110,12 @@ impl LocalHeap {
         self.memory_region.free(alloc);
     }
 
-    pub unsafe fn annihilate(&mut self) {
+    /// Immortalize all pending allocations, forcing them to live forever.
+    ///
+    /// This function will freeze all allocations to prevent all pending
+    /// allocations from being deallocated. This is used in preparation for when
+    /// a task is about to destroy TLD.
+    pub unsafe fn immortalize(&mut self) {
         let mut n_total_boxes = 0u;
 
         // Pass 1: Make all boxes immortal.
@@ -122,6 +127,17 @@ impl LocalHeap {
             (*alloc).ref_count = RC_IMMORTAL;
         });
 
+        if debug_mem() {
+            // We do logging here w/o allocation.
+            rterrln!("total boxes annihilated: {}", n_total_boxes);
+        }
+    }
+
+    /// Continues deallocation of the all pending allocations in this arena.
+    ///
+    /// This is invoked from the destructor, and requires that `immortalize` has
+    /// been called previously.
+    unsafe fn annihilate(&mut self) {
         // Pass 2: Drop all boxes.
         //
         // In this pass, unique-managed boxes may get freed, but not
@@ -142,11 +158,6 @@ impl LocalHeap {
         self.each_live_alloc(true, |me, alloc| {
             me.free(alloc);
         });
-
-        if debug_mem() {
-            // We do logging here w/o allocation.
-            rterrln!("total boxes annihilated: {}", n_total_boxes);
-        }
     }
 
     unsafe fn each_live_alloc(&mut self, read_next_before: bool,
@@ -170,6 +181,7 @@ impl LocalHeap {
 
 impl Drop for LocalHeap {
     fn drop(&mut self) {
+        unsafe { self.annihilate() }
         assert!(self.live_allocs.is_null());
     }
 }