---

yaml
---
r: 30521
b: refs/heads/incoming
c: 62b51d9
h: refs/heads/master
i:
  30519: 0ae2038
v: v3

Author: Blei

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 1faa288a362e781b77527f2dd59193be605286f0
+refs/heads/incoming: 62b51d9152e3289c8054792035ea63088247fead
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/cargo/cargo.rs

@@ -13,7 +13,6 @@ use std::{map, json, tempfile, term, sort, getopts};
 use map::HashMap;
 use to_str::to_str;
 use getopts::{optflag, optopt, opt_present};
-use dvec::DVec;
 
 type package = {
     name: ~str,
@@ -61,7 +60,7 @@ type source = @{
     mut method: ~str,
     mut key: Option<~str>,
     mut keyfp: Option<~str>,
-    packages: DVec<package>
+    mut packages: ~[mut package]
 };
 
 type cargo = {
@@ -449,7 +448,7 @@ fn parse_source(name: ~str, j: json::Json) -> source {
                 mut method: method,
                 mut key: key,
                 mut keyfp: keyfp,
-                packages: DVec() };
+                mut packages: ~[mut] };
         }
         _ => fail ~"needed dict value in source"
     };
@@ -559,14 +558,14 @@ fn load_one_source_package(src: source, p: map::HashMap<~str, json::Json>) {
         versions: ~[]
     };
 
-    match src.packages.position(|pkg| pkg.uuid == uuid) {
-        Some(idx) => {
-            src.packages.set_elt(idx, newpkg);
-            log(debug, ~"  updated package: " + src.name + ~"/" + name);
-        }
-        None => {
-            src.packages.push(newpkg);
-        }
+    match vec::position(src.packages, |pkg| pkg.uuid == uuid) {
+      Some(idx) => {
+        src.packages[idx] = newpkg;
+        log(debug, ~"  updated package: " + src.name + ~"/" + name);
+      }
+      None => {
+        vec::grow(src.packages, 1u, newpkg);
+      }
     }
 
     log(debug, ~"  loaded package: " + src.name + ~"/" + name);
@@ -714,7 +713,10 @@ fn configure(opts: options) -> cargo {
 
 fn for_each_package(c: cargo, b: fn(source, package)) {
     for c.sources.each_value |v| {
-        for v.packages.each |p| {
+        // FIXME (#2280): this temporary shouldn't be
+        // necessary, but seems to be, for borrowing.
+        let pks = copy v.packages;
+        for vec::each(pks) |p| {
             b(v, p);
         }
     }
@@ -946,28 +948,30 @@ fn install_named(c: cargo, wd: &Path, name: ~str) {
 
 fn install_uuid_specific(c: cargo, wd: &Path, src: ~str, uuid: ~str) {
     match c.sources.find(src) {
-        Some(s) => {
-            for s.packages.each |p| {
-                if p.uuid == uuid {
-                    install_package(c, src, wd, p);
-                    return;
-                }
-            }
-        }
-        _ => ()
+      Some(s) => {
+        let packages = copy s.packages;
+        if vec::any(packages, |p| {
+            if p.uuid == uuid {
+                install_package(c, src, wd, p);
+                true
+            } else { false }
+        }) { return; }
+      }
+      _ => ()
     }
     error(~"can't find package: " + src + ~"/" + uuid);
 }
 
 fn install_named_specific(c: cargo, wd: &Path, src: ~str, name: ~str) {
     match c.sources.find(src) {
         Some(s) => {
-            for s.packages.each |p| {
+          let packages = copy s.packages;
+          if vec::any(packages, |p| {
                 if p.name == name {
                     install_package(c, src, wd, p);
-                    return;
-                }
-            }
+                    true
+                } else { false }
+            }) { return; }
         }
         _ => ()
     }
@@ -1496,7 +1500,8 @@ fn print_pkg(s: source, p: package) {
 fn print_source(s: source) {
     info(s.name + ~" (" + s.url + ~")");
 
-    let pks = sort::merge_sort(sys::shape_lt, s.packages.get());
+    let unsorted_pks = s.packages;  // to prevent illegal borrow?
+    let pks = sort::merge_sort(sys::shape_lt, unsorted_pks);
     let l = vec::len(pks);
 
     print(io::with_str_writer(|writer| {
@@ -1680,7 +1685,7 @@ fn cmd_sources(c: cargo) {
                     mut method: assume_source_method(url),
                     mut key: None,
                     mut keyfp: None,
-                    packages: DVec()
+                    mut packages: ~[mut]
                 });
                 info(fmt!("added source: %s", name));
             }

branches/incoming/src/libcore/iter-trait.rs

@@ -18,14 +18,14 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
-    pure fn position(f: fn(A) -> bool) -> Option<uint> {
-        iter::position(self, f)
-    }
 }
 
 impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
     pure fn contains(x: A) -> bool { iter::contains(self, x) }
     pure fn count(x: A) -> uint { iter::count(self, x) }
+    pure fn position(f: fn(A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {

branches/incoming/src/libcore/iter.rs

@@ -13,12 +13,12 @@ trait ExtendedIter<A> {
     pure fn all(blk: fn(A) -> bool) -> bool;
     pure fn any(blk: fn(A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
-    pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
 
 trait EqIter<A:Eq> {
     pure fn contains(x: A) -> bool;
     pure fn count(x: A) -> uint;
+    pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
 
 trait Times {
@@ -142,8 +142,7 @@ pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> uint {
 }
 
 pure fn position<A,IA:BaseIter<A>>(self: IA, f: fn(A) -> bool)
-    -> Option<uint>
-{
+        -> Option<uint> {
     let mut i = 0;
     for self.each |a| {
         if f(a) { return Some(i); }

branches/incoming/src/libcore/repr.rs

@@ -184,7 +184,7 @@ impl ReprPrinterWrapper {
             self.printer.ptr = transmute(&(*box).data);
             intrinsic::visit_tydesc((*box).type_desc, self as @TyVisitor);
             let box_size = sys::size_of::<*BoxRepr>();
-            self.printer.ptr = transmute(box_ptr as uint + box_size);
+            self.printer.ptr = transmute(self.printer.ptr as uint + box_size);
             true
         }
     }
@@ -200,7 +200,7 @@ impl ReprPrinterWrapper {
                 intrinsic::visit_tydesc(inner, self as @TyVisitor);
             }
             let ptr_size = sys::size_of::<*c_void>();
-            self.printer.ptr = transmute(data_ptr as uint + ptr_size);
+            self.printer.ptr = transmute(self.printer.ptr as uint + ptr_size);
             true
         }
     }
@@ -508,7 +508,7 @@ impl ReprPrinterWrapper : TyVisitor {
                                 _disr_val: int,
                                 n_fields: uint,
                                 _name: &str) -> bool {
-        if !self.printer.skip && n_fields >= 1 {
+        if !self.printer.skip && n_fields > 1 {
             self.printer.writer.write_char(')');
         }
         true

branches/incoming/src/libcore/task.rs

@@ -1403,11 +1403,9 @@ fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
 
         let num_threads = match opts.mode {
           SingleThreaded => 1u,
-          ThreadPerCore => {
-            fail ~"thread_per_core scheduling mode unimplemented"
-          }
+          ThreadPerCore => rustrt::rust_num_threads(),
           ThreadPerTask => {
-            fail ~"thread_per_task scheduling mode unimplemented"
+            fail ~"ThreadPerTask scheduling mode unimplemented"
           }
           ManualThreads(threads) => {
             if threads == 0u {
@@ -1657,6 +1655,8 @@ extern mod rustrt {
 
     fn rust_get_sched_id() -> sched_id;
     fn rust_new_sched(num_threads: libc::uintptr_t) -> sched_id;
+    fn sched_threads() -> libc::size_t;
+    fn rust_num_threads() -> libc::uintptr_t;
 
     fn get_task_id() -> task_id;
     #[rust_stack]
@@ -2422,3 +2422,13 @@ fn test_tls_cleanup_on_failure() unsafe {
     local_data_set(int_key, @31337);
     fail;
 }
+
+#[test]
+fn test_sched_thread_per_core() {
+    let cores = rustrt::rust_num_threads();
+    let mut reported_threads = 0u;
+    do spawn_sched(ThreadPerCore) {
+        reported_threads = rustrt::sched_threads();
+    }
+    assert(cores == reported_threads);
+}

branches/incoming/src/libcore/vec.rs

@@ -2019,14 +2019,14 @@ impl<A> &[A]: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
-    pure fn position(f: fn(A) -> bool) -> Option<uint> {
-        iter::position(self, f)
-    }
 }
 
 impl<A: Eq> &[A]: iter::EqIter<A> {
     pure fn contains(x: A) -> bool { iter::contains(self, x) }
     pure fn count(x: A) -> uint { iter::count(self, x) }
+    pure fn position(f: fn(A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {

branches/incoming/src/rt/rust_builtin.cpp

@@ -572,6 +572,12 @@ rust_get_sched_id() {
     return task->sched->get_id();
 }
 
+extern "C" CDECL uintptr_t
+rust_num_threads() {
+    rust_task *task = rust_get_current_task();
+    return task->kernel->env->num_sched_threads;
+}
+
 extern "C" CDECL rust_sched_id
 rust_new_sched(uintptr_t threads) {
     rust_task *task = rust_get_current_task();
@@ -620,7 +626,7 @@ start_task(rust_task *target, fn_env_pair *f) {
     target->start(f->f, f->env, NULL);
 }
 
-extern "C" CDECL int
+extern "C" CDECL size_t
 sched_threads() {
     rust_task *task = rust_get_current_task();
     return task->sched->number_of_threads();

branches/incoming/src/rt/rustrt.def.in

@@ -32,6 +32,7 @@ rand_seed
 rust_get_sched_id
 rust_new_sched
 rust_new_task_in_sched
+rust_num_threads
 rust_path_is_dir
 rust_path_exists
 rust_getcwd

branches/incoming/src/rustc/middle/trans/base.rs

@@ -2714,6 +2714,16 @@ fn trans_crate(sess: session::session,
         io::println(fmt!("n_monos: %u", ccx.stats.n_monos));
         io::println(fmt!("n_inlines: %u", ccx.stats.n_inlines));
         io::println(fmt!("n_closures: %u", ccx.stats.n_closures));
+
+        // FIXME (#2280): this temporary shouldn't be
+        // necessary, but seems to be, for borrowing.
+        /*
+        let times = copy *ccx.stats.fn_times;
+        for vec::each(times) |timing| {
+            io::println(fmt!("time: %s took %d ms", timing.ident,
+                             timing.time));
+        }
+        */
     }
 
     if ccx.sess.count_llvm_insns() {

branches/incoming/src/snapshots.txt

@@ -1,11 +1,3 @@
-S 2012-09-12 fa74edf
-  macos-i386 da38aa39fd1515ea765790a3c320194bc50fd602
-  macos-x86_64 7509861e5a6d3e082ad9a9d3474661856b7731c1
-  freebsd-x86_64 c4e0517d6894d18342eb852b6e738f48d086004f
-  linux-i386 ee0d36b221d8d2dbb02cd1fd1feb09294e0dbb6f
-  linux-x86_64 ce585fd55ae42e33398870c3bc77a671547411aa
-  winnt-i386 5b32231d75d65c057ccd91a6f810e67941f5400a
-
 S 2012-09-12 8fbe4b5
   macos-x86_64 bdbd0feff0391b902ea0a0c68948962c0acf5dae
   macos-i386 c7e0da4ffb778045f77b84878872dc3944d147da

branches/incoming/src/test/bench/shootout-mandelbrot.rs

@@ -118,7 +118,7 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
     };
     cout.write_line(~"P4");
     cout.write_line(fmt!("%u %u", size, size));
-    let lines: HashMap<uint, ~[u8]> = std::map::uint_hash();
+    let lines = std::map::uint_hash();
     let mut done = 0_u;
     let mut i = 0_u;
     while i < size {
@@ -131,7 +131,10 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
             while prev <= i {
                 if lines.contains_key(prev) {
                     debug!("WS %u", prev);
-                    cout.write(lines.get(prev));
+                    // FIXME (#2280): this temporary shouldn't be
+                    // necessary, but seems to be, for borrowing.
+                    let v : ~[u8] = lines.get(prev);
+                    cout.write(v);
                     done += 1_u;
                     lines.remove(prev);
                     prev += 1_u;

branches/incoming/src/test/run-pass/log-knows-the-names-of-variants.rs

@@ -4,13 +4,8 @@ enum foo {
   c,
 }
 
-enum bar {
-  d, e, f
-}
-
 fn main() {
     assert ~"a(22)" == fmt!("%?", a(22u));
     assert ~"b(~\"hi\")" == fmt!("%?", b(~"hi"));
     assert ~"c" == fmt!("%?", c);
-    assert ~"d" == fmt!("%?", d);
 }