---

yaml
---
r: 44685
b: refs/heads/master
c: 0309af4
h: refs/heads/master
i:
  44683: 05515a8
v: v3

Author: graydon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4a853894fab6b9a4b60c1b3260b446a3473577fa
+refs/heads/master: 0309af458cc0a911adfa974c3800feac6b3ed858
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/cleanup.rs

@@ -111,45 +111,102 @@ 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 task: *Task = transmute(rustrt::rust_get_task());
+    let mut stats = AnnihilateStats {
+        n_total_boxes: 0,
+        n_unique_boxes: 0,
+        n_bytes_freed: 0
+    };
 
     // Pass 1: Make all boxes 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);
+    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;
+        }
     }
 
     // Pass 2: Drop all boxes.
-    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));
-
-        box = transmute(copy (*box).header.next);
+    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));
+        }
     }
 
     // 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));
+    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));
+        }
+    }
+
+    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");
     }
 }
 

trunk/src/libcore/managed.rs

@@ -16,7 +16,13 @@ use managed::raw::BoxRepr;
 use prelude::*;
 use ptr;
 
+
 pub mod raw {
+
+    pub const RC_EXCHANGE_UNIQUE : uint = (-1) as uint;
+    pub const RC_MANAGED_UNIQUE : uint = (-2) as uint;
+    pub const RC_IMMORTAL : uint = 0x77777777;
+
     use intrinsic::TyDesc;
 
     pub struct BoxHeaderRepr {

trunk/src/libcore/vec.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -31,9 +31,14 @@ use vec;
 
 #[abi = "cdecl"]
 pub extern mod rustrt {
+    // These names are terrible. reserve_shared applies
+    // to ~[] and reserve_shared_actual applies to @[].
     unsafe fn vec_reserve_shared(++t: *sys::TypeDesc,
                                  ++v: **raw::VecRepr,
                                  ++n: libc::size_t);
+    unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
+                                        ++v: **raw::VecRepr,
+                                        ++n: libc::size_t);
 }
 
 /// Returns true if a vector contains no elements
@@ -59,11 +64,17 @@ pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  */
 pub fn reserve<T>(v: &mut ~[T], n: uint) {
     // Only make the (slow) call into the runtime if we have to
+    use managed;
     if capacity(v) < n {
         unsafe {
             let ptr: **raw::VecRepr = cast::transmute(v);
-            rustrt::vec_reserve_shared(sys::get_type_desc::<T>(),
-                                       ptr, n as size_t);
+            let td = sys::get_type_desc::<T>();
+            if ((**ptr).box_header.ref_count ==
+                managed::raw::RC_MANAGED_UNIQUE) {
+                rustrt::vec_reserve_shared_actual(td, ptr, n as size_t);
+            } else {
+                rustrt::vec_reserve_shared(td, ptr, n as size_t);
+            }
         }
     }
 }

trunk/src/librustc/driver/session.rs

@@ -165,49 +165,49 @@ pub struct Session_ {
 pub type Session = @Session_;
 
 pub impl Session {
-    fn span_fatal(&self, sp: span, msg: ~str) -> ! {
+    fn span_fatal(sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_fatal(sp, msg)
     }
-    fn fatal(&self, msg: ~str) -> ! {
+    fn fatal(msg: ~str) -> ! {
         self.span_diagnostic.handler().fatal(msg)
     }
-    fn span_err(&self, sp: span, msg: ~str) {
+    fn span_err(sp: span, msg: ~str) {
         self.span_diagnostic.span_err(sp, msg)
     }
-    fn err(&self, msg: ~str) {
+    fn err(msg: ~str) {
         self.span_diagnostic.handler().err(msg)
     }
-    fn has_errors(&self) -> bool {
+    fn has_errors() -> bool {
         self.span_diagnostic.handler().has_errors()
     }
-    fn abort_if_errors(&self) {
+    fn abort_if_errors() {
         self.span_diagnostic.handler().abort_if_errors()
     }
-    fn span_warn(&self, sp: span, msg: ~str) {
+    fn span_warn(sp: span, msg: ~str) {
         self.span_diagnostic.span_warn(sp, msg)
     }
-    fn warn(&self, msg: ~str) {
+    fn warn(msg: ~str) {
         self.span_diagnostic.handler().warn(msg)
     }
-    fn span_note(&self, sp: span, msg: ~str) {
+    fn span_note(sp: span, msg: ~str) {
         self.span_diagnostic.span_note(sp, msg)
     }
-    fn note(&self, msg: ~str) {
+    fn note(msg: ~str) {
         self.span_diagnostic.handler().note(msg)
     }
-    fn span_bug(&self, sp: span, msg: ~str) -> ! {
+    fn span_bug(sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_bug(sp, msg)
     }
-    fn bug(&self, msg: ~str) -> ! {
+    fn bug(msg: ~str) -> ! {
         self.span_diagnostic.handler().bug(msg)
     }
-    fn span_unimpl(&self, sp: span, msg: ~str) -> ! {
+    fn span_unimpl(sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_unimpl(sp, msg)
     }
-    fn unimpl(&self, msg: ~str) -> ! {
+    fn unimpl(msg: ~str) -> ! {
         self.span_diagnostic.handler().unimpl(msg)
     }
-    fn span_lint_level(&self, level: lint::level, sp: span, +msg: ~str) {
+    fn span_lint_level(level: lint::level, sp: span, +msg: ~str) {
         match level {
           lint::allow => { },
           lint::warn => self.span_warn(sp, msg),
@@ -216,7 +216,7 @@ pub impl Session {
           }
         }
     }
-    fn span_lint(&self, lint_mode: lint::lint,
+    fn span_lint(lint_mode: lint::lint,
                  expr_id: ast::node_id,
                  item_id: ast::node_id,
                  span: span,
@@ -225,55 +225,45 @@ pub impl Session {
             self.lint_settings, lint_mode, expr_id, item_id);
         self.span_lint_level(level, span, msg);
     }
-    fn next_node_id(&self) -> ast::node_id {
+    fn next_node_id() -> ast::node_id {
         return syntax::parse::next_node_id(self.parse_sess);
     }
-    fn diagnostic(&self) -> diagnostic::span_handler {
+    fn diagnostic() -> diagnostic::span_handler {
         self.span_diagnostic
     }
-    fn debugging_opt(&self, opt: uint) -> bool {
+    fn debugging_opt(opt: uint) -> bool {
         (self.opts.debugging_opts & opt) != 0u
     }
     // This exists to help with refactoring to eliminate impossible
     // cases later on
-    fn impossible_case(&self, sp: span, msg: &str) -> ! {
+    fn impossible_case(sp: span, msg: &str) -> ! {
         self.span_bug(sp, fmt!("Impossible case reached: %s", msg));
     }
-    fn verbose(&self) -> bool { self.debugging_opt(verbose) }
-    fn time_passes(&self) -> bool { self.debugging_opt(time_passes) }
-    fn count_llvm_insns(&self) -> bool {
-        self.debugging_opt(count_llvm_insns)
-    }
-    fn count_type_sizes(&self) -> bool {
-        self.debugging_opt(count_type_sizes)
-    }
-    fn time_llvm_passes(&self) -> bool {
-        self.debugging_opt(time_llvm_passes)
-    }
-    fn trans_stats(&self) -> bool { self.debugging_opt(trans_stats) }
-    fn meta_stats(&self) -> bool { self.debugging_opt(meta_stats) }
-    fn no_asm_comments(&self) -> bool { self.debugging_opt(no_asm_comments) }
-    fn no_verify(&self) -> bool { self.debugging_opt(no_verify) }
-    fn trace(&self) -> bool { self.debugging_opt(trace) }
-    fn coherence(&self) -> bool { self.debugging_opt(coherence) }
-    fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) }
-    fn borrowck_note_pure(&self) -> bool {
-        self.debugging_opt(borrowck_note_pure)
-    }
-    fn borrowck_note_loan(&self) -> bool {
-        self.debugging_opt(borrowck_note_loan)
-    }
-    fn no_monomorphic_collapse(&self) -> bool {
+    fn verbose() -> bool { self.debugging_opt(verbose) }
+    fn time_passes() -> bool { self.debugging_opt(time_passes) }
+    fn count_llvm_insns() -> bool { self.debugging_opt(count_llvm_insns) }
+    fn count_type_sizes() -> bool { self.debugging_opt(count_type_sizes) }
+    fn time_llvm_passes() -> bool { self.debugging_opt(time_llvm_passes) }
+    fn trans_stats() -> bool { self.debugging_opt(trans_stats) }
+    fn meta_stats() -> bool { self.debugging_opt(meta_stats) }
+    fn no_asm_comments() -> bool { self.debugging_opt(no_asm_comments) }
+    fn no_verify() -> bool { self.debugging_opt(no_verify) }
+    fn trace() -> bool { self.debugging_opt(trace) }
+    fn coherence() -> bool { self.debugging_opt(coherence) }
+    fn borrowck_stats() -> bool { self.debugging_opt(borrowck_stats) }
+    fn borrowck_note_pure() -> bool { self.debugging_opt(borrowck_note_pure) }
+    fn borrowck_note_loan() -> bool { self.debugging_opt(borrowck_note_loan) }
+    fn no_monomorphic_collapse() -> bool {
         self.debugging_opt(no_monomorphic_collapse)
     }
 
-    fn str_of(&self, id: ast::ident) -> @~str {
+    fn str_of(id: ast::ident) -> @~str {
         self.parse_sess.interner.get(id)
     }
-    fn ident_of(&self, +st: ~str) -> ast::ident {
+    fn ident_of(+st: ~str) -> ast::ident {
         self.parse_sess.interner.intern(@st)
     }
-    fn intr(&self) -> @syntax::parse::token::ident_interner {
+    fn intr() -> @syntax::parse::token::ident_interner {
         self.parse_sess.interner
     }
 }

trunk/src/librustc/metadata/filesearch.rs

@@ -29,10 +29,10 @@ pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
 }
 
 pub trait FileSearch {
-    fn sysroot(&self) -> Path;
-    fn lib_search_paths(&self) -> ~[Path];
-    fn get_target_lib_path(&self) -> Path;
-    fn get_target_lib_file_path(&self, file: &Path) -> Path;
+    fn sysroot() -> Path;
+    fn lib_search_paths() -> ~[Path];
+    fn get_target_lib_path() -> Path;
+    fn get_target_lib_file_path(file: &Path) -> Path;
 }
 
 pub fn mk_filesearch(maybe_sysroot: Option<Path>,
@@ -44,8 +44,8 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
         target_triple: ~str
     }
     impl FileSearch for FileSearchImpl {
-        fn sysroot(&self) -> Path { /*bad*/copy self.sysroot }
-        fn lib_search_paths(&self) -> ~[Path] {
+        fn sysroot() -> Path { /*bad*/copy self.sysroot }
+        fn lib_search_paths() -> ~[Path] {
             let mut paths = /*bad*/copy self.addl_lib_search_paths;
 
             paths.push(
@@ -61,10 +61,10 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
             }
             paths
         }
-        fn get_target_lib_path(&self) -> Path {
+        fn get_target_lib_path() -> Path {
             make_target_lib_path(&self.sysroot, self.target_triple)
         }
-        fn get_target_lib_file_path(&self, file: &Path) -> Path {
+        fn get_target_lib_file_path(file: &Path) -> Path {
             self.get_target_lib_path().push_rel(file)
         }
     }