---

yaml
---
r: 42479
b: refs/heads/try
c: db1abbe
h: refs/heads/master
i:
  42477: 80fbeec
  42475: 3004f0e
  42471: ec23b11
  42463: dca9d33
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 1244c0b6fd8325e1eab274e6d9b989e1ee1e2c57
+refs/heads/try: db1abbec4ca9f18a224441c483cf23bb4f8361fd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/doc/tutorial.md

@@ -863,34 +863,11 @@ allocating memory and indirecting through a pointer. But for big structs, or
 those with mutable fields, it can be useful to have a single copy on
 the stack or on the heap, and refer to that through a pointer.
 
-Whenever memory is allocated on the heap, the program needs a strategy to
-dispose of the memory when no longer needed. Most languages, such as Java or
-Python, use *garbage collection* for this, a strategy in which the program
-periodically searches for allocations that are no longer reachable in order
-to dispose of them. Other languages, such as C, use *manual memory
-management*, which relies on the programmer to specify when memory should be
-reclaimed.
-
-Rust is in a different position. It differs from the garbage-collected
-environments in that allows the programmer to choose the disposal
-strategy on an object-by-object basis. Not only does this have benefits for
-performance, but we will later see that this model has benefits for
-concurrency as well, by making it possible for the Rust compiler to detect
-data races at compile time. Rust also differs from the manually managed
-languages in that it is *safe*—it uses a [pointer lifetime
-analysis][borrow] to ensure that manual memory management cannot cause memory
-errors at runtime.
-
-[borrow]: tutorial-borrowed-ptr.html
-
-The cornerstone of Rust's memory management is the concept of a *smart
-pointer*—a pointer type that indicates the lifetime of the object it points
-to. This solution is familiar to C++ programmers; Rust differs from C++,
-however, in that a small set of smart pointers are built into the language.
-The safe pointer types are `@T`, for *managed* boxes allocated on the *local
-heap*, `~T`, for *uniquely-owned* boxes allocated on the *exchange
-heap*, and `&T`, for *borrowed* pointers, which may point to any memory, and
-whose lifetimes are governed by the call stack.
+Rust supports several types of pointers. The safe pointer types are
+`@T`, for managed boxes allocated on the local heap, `~T`, for
+uniquely-owned boxes allocated on the exchange heap, and `&T`, for
+borrowed pointers, which may point to any memory, and whose lifetimes
+are governed by the call stack.
 
 All pointer types can be dereferenced with the `*` unary operator.
 
@@ -942,17 +919,7 @@ node2.next = SomeNode(node3);
 node3.prev = SomeNode(node2);
 ~~~
 
-Managed boxes never cross task boundaries. This has several benefits for
-performance:
-
-* The Rust garbage collector does not need to stop multiple threads in order
-  to collect garbage.
-
-* You can separate your application into "real-time" tasks that do not use
-  the garbage collector and "non-real-time" tasks that do, and the real-time
-  tasks will not be interrupted by the non-real-time tasks.
-
-C++ programmers will recognize `@T` as similar to `std::shared_ptr<T>`.
+Managed boxes never cross task boundaries.
 
 > ***Note:*** Currently, the Rust compiler generates code to reclaim
 > managed boxes through reference counting and a cycle collector, but
@@ -989,19 +956,10 @@ let z = *x + *y;
 assert z == 20;
 ~~~~
 
-When they do not contain any managed boxes, owned boxes can be sent
-to other tasks. The sending task will give up ownership of the box
+Owned boxes, when they do not contain any managed boxes, can be sent
+to other tasks. The sending task will give up ownership of the box,
 and won't be able to access it afterwards. The receiving task will
-become the sole owner of the box. This prevents *data races*—errors
-that could otherwise result from multiple tasks working on the same
-data without synchronization.
-
-When an owned pointer goes out of scope or is overwritten, the object
-it points to is immediately freed. Effective use of owned boxes can
-therefore be an efficient alternative to garbage collection.
-
-C++ programmers will recognize `~T` as similar to `std::unique_ptr<T>`
-(or `std::auto_ptr<T>` in C++03 and below).
+become the sole owner of the box.
 
 ## Borrowed pointers
 

branches/try/src/libcore/at_vec.rs

@@ -216,7 +216,7 @@ pub mod raw {
     }
 
     pub unsafe fn push_slow<T>(v: &mut @[const T], initval: T) {
-        reserve_at_least(&mut *v, v.len() + 1u);
+        reserve_at_least(v, v.len() + 1u);
         push_fast(v, move initval);
     }
 
@@ -234,7 +234,7 @@ pub mod raw {
     pub unsafe fn reserve<T>(v: &mut @[const T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if capacity(*v) < n {
-            let ptr: **VecRepr = transmute(v);
+            let ptr: **VecRepr = transmute(copy v);
             rustrt::vec_reserve_shared_actual(sys::get_type_desc::<T>(),
                                               ptr, n as libc::size_t);
         }

branches/try/src/libcore/core.rc

@@ -95,8 +95,8 @@ pub mod at_vec;
 pub mod str;
 
 pub mod ptr;
-pub mod owned;
 pub mod managed;
+pub mod owned;
 
 
 /* Core language traits */

branches/try/src/libcore/managed.rs

@@ -14,9 +14,7 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use cast::transmute;
 use cmp::{Eq, Ord};
-use managed::raw::BoxRepr;
 use prelude::*;
 use ptr;
 

branches/try/src/libcore/private.rs

@@ -28,6 +28,11 @@ use task;
 use task::{TaskBuilder, atomically};
 use uint;
 
+#[path = "private/at_exit.rs"]
+pub mod at_exit;
+#[path = "private/global.rs"]
+pub mod global;
+
 extern mod rustrt {
     #[legacy_exports];
     unsafe fn rust_task_weaken(ch: rust_port_id);
@@ -519,6 +524,12 @@ pub unsafe fn clone_shared_mutable_state<T: Owned>(rc: &SharedMutableState<T>)
     ArcDestruct((*rc).data)
 }
 
+impl<T: Owned> SharedMutableState<T>: Clone {
+    fn clone(&self) -> SharedMutableState<T> unsafe {
+        clone_shared_mutable_state(self)
+    }
+}
+
 /****************************************************************************/
 
 #[allow(non_camel_case_types)] // runtime type

branches/try/src/libcore/private/at_exit.rs

@@ -0,0 +1,86 @@
+use sys;
+use cast;
+use ptr;
+use task;
+use uint;
+use vec;
+use rand;
+use libc::{c_void, size_t};
+
+/**
+Register a function to be run during runtime shutdown.
+
+After all non-weak tasks have exited, registered exit functions will
+execute, in random order, on the primary scheduler. Each function runs
+in its own unsupervised task.
+*/
+pub fn at_exit(f: ~fn()) unsafe {
+    let runner: &fn(*ExitFunctions) = exit_runner;
+    let runner_pair: sys::Closure = cast::transmute(runner);
+    let runner_ptr = runner_pair.code;
+    let runner_ptr = cast::transmute(runner_ptr);
+    rustrt::rust_register_exit_function(runner_ptr, ~f);
+}
+
+// NB: The double pointer indirection here is because ~fn() is a fat
+// pointer and due to FFI problems I am more comfortable making the
+// interface use a normal pointer
+extern mod rustrt {
+    fn rust_register_exit_function(runner: *c_void, f: ~~fn());
+}
+
+struct ExitFunctions {
+    // The number of exit functions
+    count: size_t,
+    // The buffer of exit functions
+    start: *~~fn()
+}
+
+fn exit_runner(exit_fns: *ExitFunctions) unsafe {
+    let exit_fns = &*exit_fns;
+    let count = (*exit_fns).count;
+    let start = (*exit_fns).start;
+
+    // NB: from_buf memcpys from the source, which will
+    // give us ownership of the array of functions
+    let mut exit_fns_vec = vec::from_buf(start, count as uint);
+    // Let's not make any promises about execution order
+    rand::Rng().shuffle_mut(exit_fns_vec);
+
+    debug!("running %u exit functions", exit_fns_vec.len());
+
+    while exit_fns_vec.is_not_empty() {
+        match exit_fns_vec.pop() {
+            ~f => {
+                task::task().supervised().spawn(f);
+            }
+        }
+    }
+}
+
+#[abi = "rust-intrinsic"]
+pub extern mod rusti {
+    fn move_val_init<T>(dst: &mut T, -src: T);
+    fn init<T>() -> T;
+}
+
+#[test]
+fn test_at_exit() {
+    let i = 10;
+    do at_exit {
+        debug!("at_exit1");
+        assert i == 10;
+    }
+}
+
+#[test]
+fn test_at_exit_many() {
+    let i = 10;
+    for uint::range(20, 100) |j| {
+        do at_exit {
+            debug!("at_exit2");
+            assert i == 10;
+            assert j > i;
+        }
+    }
+}