---

yaml
---
r: 44703
b: refs/heads/master
c: c4ef822
h: refs/heads/master
i:
  44701: ef28c4b
  44699: 7c06166
  44695: a1c6851
  44687: d315980
  44671: dddeda5
v: v3

Author: jjjjw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a712d828f93ca08c072808d57fb110b1f9d0ca72
+refs/heads/master: c4ef822dc7e4fcd05f9e4663e6f5c2196129d605
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/doc/tutorial-tasks.md

@@ -157,7 +157,7 @@ concurrently:
 
 ~~~~
 use task::spawn;
-use comm::{stream, Port, Chan};
+use pipes::{stream, Port, Chan};
 
 let (port, chan): (Port<int>, Chan<int>) = stream();
 
@@ -178,7 +178,7 @@ stream for sending and receiving integers (the left-hand side of the `let`,
 a tuple into its component parts).
 
 ~~~~
-# use comm::{stream, Chan, Port};
+# use pipes::{stream, Chan, Port};
 let (port, chan): (Port<int>, Chan<int>) = stream();
 ~~~~
 
@@ -189,7 +189,7 @@ spawns the child task.
 ~~~~
 # use task::{spawn};
 # use task::spawn;
-# use comm::{stream, Port, Chan};
+# use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
 # let (port, chan) = stream();
 do spawn || {
@@ -209,7 +209,7 @@ computation, then waits for the child's result to arrive on the
 port:
 
 ~~~~
-# use comm::{stream, Port, Chan};
+# use pipes::{stream, Port, Chan};
 # fn some_other_expensive_computation() {}
 # let (port, chan) = stream::<int>();
 # chan.send(0);
@@ -225,7 +225,7 @@ following program is ill-typed:
 
 ~~~ {.xfail-test}
 # use task::{spawn};
-# use comm::{stream, Port, Chan};
+# use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
 let (port, chan) = stream();
 
@@ -245,7 +245,7 @@ Instead we can use a `SharedChan`, a type that allows a single
 
 ~~~
 # use task::spawn;
-use comm::{stream, SharedChan};
+use pipes::{stream, SharedChan};
 
 let (port, chan) = stream();
 let chan = SharedChan(chan);
@@ -278,7 +278,7 @@ might look like the example below.
 
 ~~~
 # use task::spawn;
-# use comm::{stream, Port, Chan};
+# use pipes::{stream, Port, Chan};
 
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
@@ -393,7 +393,7 @@ internally, with additional logic to wait for the child task to finish
 before returning. Hence:
 
 ~~~
-# use comm::{stream, Chan, Port};
+# use pipes::{stream, Chan, Port};
 # use task::{spawn, try};
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
@@ -468,7 +468,7 @@ Here is the function that implements the child task:
 
 ~~~~
 # use std::comm::DuplexStream;
-# use comm::{Port, Chan};
+# use pipes::{Port, Chan};
 fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
@@ -491,7 +491,7 @@ Here is the code for the parent task:
 
 ~~~~
 # use std::comm::DuplexStream;
-# use comm::{Port, Chan};
+# use pipes::{Port, Chan};
 # use task::spawn;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;

trunk/src/compiletest/procsrv.rs

@@ -76,7 +76,7 @@ pub fn run(lib_path: ~str,
 
 
     writeclose(pipe_in.out, input);
-    let p = comm::PortSet();
+    let p = pipes::PortSet();
     let ch = p.chan();
     do task::spawn_sched(task::SingleThreaded) || {
         let errput = readclose(pipe_err.in);

trunk/src/etc/x86.supp

@@ -415,13 +415,6 @@
    ...
 }
 
-{
-   enum-instruction-scheduling-8
-   Memcheck:Cond
-   fun:*should_set_output_format_to_markdown_if_requested*
-   ...
-}
-
 {  
    llvm-user-new-leak
    Memcheck:Leak

trunk/src/libcore/cleanup.rs

@@ -111,102 +111,45 @@ struct Task {
  * This runs at task death to free all boxes.
  */
 
-struct AnnihilateStats {
-    n_total_boxes: uint,
-    n_unique_boxes: uint,
-    n_bytes_freed: uint
-}
-
-unsafe fn each_live_alloc(f: fn(box: *mut BoxRepr, uniq: bool) -> bool) {
-    use managed;
-
-    let task: *Task = transmute(rustrt::rust_get_task());
-    let box = (*task).boxed_region.live_allocs;
-    let mut box: *mut BoxRepr = transmute(copy box);
-    while box != mut_null() {
-        let next = transmute(copy (*box).header.next);
-        let uniq =
-            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
-
-        if ! f(box, uniq) {
-            break
-        }
-
-        box = next
-    }
-}
-
-#[cfg(unix)]
-fn debug_mem() -> bool {
-    use os;
-    use libc;
-    do os::as_c_charp("RUST_DEBUG_MEM") |p| {
-        unsafe { libc::getenv(p) != null() }
-    }
-}
-
-#[cfg(windows)]
-fn debug_mem() -> bool {
-    false
-}
-
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
     use rt::rt_free;
     use io::WriterUtil;
-    use io;
-    use libc;
-    use sys;
-    use managed;
 
-    let mut stats = AnnihilateStats {
-        n_total_boxes: 0,
-        n_unique_boxes: 0,
-        n_bytes_freed: 0
-    };
+    let task: *Task = transmute(rustrt::rust_get_task());
 
     // Pass 1: Make all boxes immortal.
-    for each_live_alloc |box, uniq| {
-        stats.n_total_boxes += 1;
-        if uniq {
-            stats.n_unique_boxes += 1;
-        } else {
-            (*box).header.ref_count = managed::raw::RC_IMMORTAL;
-        }
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        debug!("making box immortal: %x", box as uint);
+        (*box).header.ref_count = 0x77777777;
+        box = transmute(copy (*box).header.next);
     }
 
     // Pass 2: Drop all boxes.
-    for each_live_alloc |box, uniq| {
-        if !uniq {
-            let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
-            let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
-            drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
-        }
-    }
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        debug!("calling drop glue for box: %x", box as uint);
+        let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
+        let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
+        drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
 
-    // Pass 3: Free all boxes.
-    for each_live_alloc |box, uniq| {
-        if !uniq {
-            stats.n_bytes_freed +=
-                (*((*box).header.type_desc)).size
-                + sys::size_of::<BoxRepr>();
-            rt_free(transmute(box));
-        }
+        box = transmute(copy (*box).header.next);
     }
 
-    if debug_mem() {
-        // We do logging here w/o allocation.
-        let dbg = libc::STDERR_FILENO as io::fd_t;
-        dbg.write_str("annihilator stats:");
-        dbg.write_str("\n  total_boxes: ");
-        dbg.write_uint(stats.n_total_boxes);
-        dbg.write_str("\n  unique_boxes: ");
-        dbg.write_uint(stats.n_unique_boxes);
-        dbg.write_str("\n  bytes_freed: ");
-        dbg.write_uint(stats.n_bytes_freed);
-        dbg.write_str("\n");
+    // Pass 3: Free all boxes.
+    loop {
+        let box = (*task).boxed_region.live_allocs;
+        if box == null() { break; }
+        let mut box: *mut BoxRepr = transmute(copy box);
+        assert (*box).header.prev == null();
+
+        debug!("freeing box: %x", box as uint);
+        rt_free(transmute(box));
     }
 }