---

yaml
---
r: 156247
b: refs/heads/snap-stage3
c: 403cd40
h: refs/heads/master
i:
  156245: 50fab1c
  156243: 4354095
  156239: a4d06e6
v: v3

Author: Jakub Wieczorek

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 86509d8d7ab68c5e4202dea9ff1bfb79409f2f8d
+refs/heads/snap-stage3: 403cd40e6a29cc0f897e4b3d80e1e2bcf38f8875
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/crates.mk

@@ -101,7 +101,7 @@ DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex
 DEPS_fmt_macros = std
 
-TOOL_DEPS_compiletest := test getopts native
+TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc native
 TOOL_DEPS_rustc := rustc native
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs

branches/snap-stage3/src/compiletest/runtest.rs

@@ -952,10 +952,10 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
 
-    #[cfg(any(target_os = "linux",
-              target_os = "macos",
-              target_os = "freebsd",
-              target_os = "dragonfly"))]
+    #[cfg(target_os = "linux")]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "freebsd")]
+    #[cfg(target_os = "dragonfly")]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         line.starts_with( prefix )
     }
@@ -1356,10 +1356,10 @@ fn program_output(config: &Config, testfile: &Path, lib_path: &str, prog: String
 }
 
 // Linux and mac don't require adjusting the library search path
-#[cfg(any(target_os = "linux",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "dragonfly"))]
+#[cfg(target_os = "linux")]
+#[cfg(target_os = "macos")]
+#[cfg(target_os = "freebsd")]
+#[cfg(target_os = "dragonfly")]
 fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {}", prog, args.connect(" "))
 }

branches/snap-stage3/src/libcollections/btree/map.rs

@@ -29,47 +29,6 @@ use ringbuf::RingBuf;
 
 
 /// A map based on a B-Tree.
-///
-/// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing
-/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal
-/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of
-/// comparisons necessary to find an element (log<sub>2</sub>n). However, in practice the way this
-/// is done is *very* inefficient for modern computer architectures. In particular, every element
-/// is stored in its own individually heap-allocated node. This means that every single insertion
-/// triggers a heap-allocation, and every single comparison should be a cache-miss. Since these
-/// are both notably expensive things to do in practice, we are forced to at very least reconsider
-/// the BST strategy.
-///
-/// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing
-/// this, we reduce the number of allocations by a factor of B, and improve cache effeciency in
-/// searches. However, this does mean that searches will have to do *more* comparisons on average.
-/// The precise number of comparisons depends on the node search strategy used. For optimal cache
-/// effeciency, one could search the nodes linearly. For optimal comparisons, one could search
-/// the node using binary search. As a compromise, one could also perform a linear search
-/// that initially only checks every i<sup>th</sup> element for some choice of i.
-///
-/// Currently, our implementation simply performs naive linear search. This provides excellent
-/// performance on *small* nodes of elements which are cheap to compare. However in the future we
-/// would like to further explore choosing the optimal search strategy based on the choice of B,
-/// and possibly other factors. Using linear search, searching for a random element is expected
-/// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,
-/// however, performance is excellent. `BTreeMap` is able to readily outperform `TreeMap` under
-/// many workloads, and is competetive where it doesn't. BTreeMap also generally *scales* better
-/// than TreeMap, making it more appropriate for large datasets.
-///
-/// However, `TreeMap` may still be more appropriate to use in many contexts. If elements are very
-/// large or expensive to compare, `TreeMap` may be more appropriate. It won't allocate any
-/// more space than is needed, and will perform the minimal number of comparisons necessary.
-/// `TreeMap` also provides much better performance stability guarantees. Generally, very few
-/// changes need to be made to update a BST, and two updates are expected to take about the same
-/// amount of time on roughly equal sized BSTs. However a B-Tree's performance is much more
-/// amortized. If a node is overfull, it must be split into two nodes. If a node is underfull, it
-/// may be merged with another. Both of these operations are relatively expensive to perform, and
-/// it's possible to force one to occur at every single level of the tree in a single insertion or
-/// deletion. In fact, a malicious or otherwise unlucky sequence of insertions and deletions can
-/// force this degenerate behaviour to occur on every operation. While the total amount of work
-/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B log<sub>B</sub>n),
-/// it is certainly much slower when it does.
 #[deriving(Clone)]
 pub struct BTreeMap<K, V> {
     root: Node<K, V>,
@@ -134,8 +93,6 @@ impl<K: Ord, V> BTreeMap<K, V> {
     }
 
     /// Makes a new empty BTreeMap with the given B.
-    ///
-    /// B cannot be less than 2.
     pub fn with_b(b: uint) -> BTreeMap<K, V> {
         assert!(b > 1, "B must be greater than 1");
         BTreeMap {
@@ -1188,12 +1145,9 @@ mod test {
 
 #[cfg(test)]
 mod bench {
-    use std::prelude::*;
-    use std::rand::{weak_rng, Rng};
-    use test::{Bencher, black_box};
+    use test::Bencher;
 
     use super::BTreeMap;
-    use MutableMap;
     use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
 
     #[bench]
@@ -1246,34 +1200,4 @@ mod bench {
         let mut m : BTreeMap<uint,uint> = BTreeMap::new();
         find_seq_n(10_000, &mut m, b);
     }
-
-    fn bench_iter(b: &mut Bencher, size: uint) {
-        let mut map = BTreeMap::<uint, uint>::new();
-        let mut rng = weak_rng();
-
-        for _ in range(0, size) {
-            map.swap(rng.gen(), rng.gen());
-        }
-
-        b.iter(|| {
-            for entry in map.iter() {
-                black_box(entry);
-            }
-        });
-    }
-
-    #[bench]
-    pub fn iter_20(b: &mut Bencher) {
-        bench_iter(b, 20);
-    }
-
-    #[bench]
-    pub fn iter_1000(b: &mut Bencher) {
-        bench_iter(b, 1000);
-    }
-
-    #[bench]
-    pub fn iter_100000(b: &mut Bencher) {
-        bench_iter(b, 100000);
-    }
 }

branches/snap-stage3/src/libcollections/btree/set.rs

@@ -23,9 +23,6 @@ use core::fmt::Show;
 use {Mutable, Set, MutableSet, MutableMap, Map};
 
 /// A set based on a B-Tree.
-///
-/// See BTreeMap's documentation for a detailed discussion of this collection's performance
-/// benefits and drawbacks.
 #[deriving(Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
 pub struct BTreeSet<T>{
     map: BTreeMap<T, ()>,
@@ -68,8 +65,6 @@ impl<T: Ord> BTreeSet<T> {
     }
 
     /// Makes a new BTreeSet with the given B.
-    ///
-    /// B cannot be less than 2.
     pub fn with_b(b: uint) -> BTreeSet<T> {
         BTreeSet { map: BTreeMap::with_b(b) }
     }

branches/snap-stage3/src/libcollections/slice.rs

@@ -277,14 +277,12 @@ pub trait CloneableVector<T> {
     }
 
     /// Converts `self` into an owned vector, not making a copy if possible.
-    /// Deprecated. Use 'to_vec'
-    #[deprecated = "Replaced by `to_vec`"]
     fn into_vec(self) -> Vec<T>;
 
-    /// Deprecated. Use `to_vec`
-    #[deprecated = "Replaced by `to_vec`"]
+    /// Deprecated. Use `into_vec`
+    #[deprecated = "Replaced by `into_vec`"]
     fn into_owned(self) -> Vec<T> {
-        self.to_vec()
+        self.into_vec()
     }
 }
 
@@ -2330,9 +2328,9 @@ mod tests {
     }
 
     #[test]
-    fn test_to_vec() {
+    fn test_into_vec() {
         let xs = box [1u, 2, 3];
-        let ys = xs.to_vec();
+        let ys = xs.into_vec();
         assert_eq!(ys.as_slice(), [1u, 2, 3].as_slice());
     }
 }

branches/snap-stage3/src/libcollections/treemap.rs

@@ -2232,12 +2232,9 @@ mod test_treemap {
 
 #[cfg(test)]
 mod bench {
-    use std::prelude::*;
-    use std::rand::{weak_rng, Rng};
-    use test::{Bencher, black_box};
+    use test::Bencher;
 
     use super::TreeMap;
-    use MutableMap;
     use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
 
     // Find seq
@@ -2291,36 +2288,6 @@ mod bench {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
         find_seq_n(10_000, &mut m, b);
     }
-
-    fn bench_iter(b: &mut Bencher, size: uint) {
-        let mut map = TreeMap::<uint, uint>::new();
-        let mut rng = weak_rng();
-
-        for _ in range(0, size) {
-            map.swap(rng.gen(), rng.gen());
-        }
-
-        b.iter(|| {
-            for entry in map.iter() {
-                black_box(entry);
-            }
-        });
-    }
-
-    #[bench]
-    pub fn iter_20(b: &mut Bencher) {
-        bench_iter(b, 20);
-    }
-
-    #[bench]
-    pub fn iter_1000(b: &mut Bencher) {
-        bench_iter(b, 1000);
-    }
-
-    #[bench]
-    pub fn iter_100000(b: &mut Bencher) {
-        bench_iter(b, 100000);
-    }
 }
 
 #[cfg(test)]

branches/snap-stage3/src/libcollections/trie.rs

@@ -949,8 +949,8 @@ macro_rules! iterator_impl {
                 // rules, and are just manipulating raw pointers like there's no
                 // such thing as invalid pointers and memory unsafety. The
                 // reason is performance, without doing this we can get the
-                // (now replaced) bench_iter_large microbenchmark down to about
-                // 30000 ns/iter (using .unsafe_get to index self.stack directly, 38000
+                // bench_iter_large microbenchmark down to about 30000 ns/iter
+                // (using .unsafe_get to index self.stack directly, 38000
                 // ns/iter with [] checked indexing), but this smashes that down
                 // to 13500 ns/iter.
                 //
@@ -1459,39 +1459,31 @@ mod test_map {
 mod bench_map {
     use std::prelude::*;
     use std::rand::{weak_rng, Rng};
-    use test::{Bencher, black_box};
+    use test::Bencher;
 
     use MutableMap;
     use super::TrieMap;
 
-    fn bench_iter(b: &mut Bencher, size: uint) {
-        let mut map = TrieMap::<uint>::new();
+    #[bench]
+    fn bench_iter_small(b: &mut Bencher) {
+        let mut m = TrieMap::<uint>::new();
         let mut rng = weak_rng();
-
-        for _ in range(0, size) {
-            map.swap(rng.gen(), rng.gen());
+        for _ in range(0u, 20) {
+            m.insert(rng.gen(), rng.gen());
         }
 
-        b.iter(|| {
-            for entry in map.iter() {
-                black_box(entry);
-            }
-        });
+        b.iter(|| for _ in m.iter() {})
     }
 
     #[bench]
-    pub fn iter_20(b: &mut Bencher) {
-        bench_iter(b, 20);
-    }
-
-    #[bench]
-    pub fn iter_1000(b: &mut Bencher) {
-        bench_iter(b, 1000);
-    }
+    fn bench_iter_large(b: &mut Bencher) {
+        let mut m = TrieMap::<uint>::new();
+        let mut rng = weak_rng();
+        for _ in range(0u, 1000) {
+            m.insert(rng.gen(), rng.gen());
+        }
 
-    #[bench]
-    pub fn iter_100000(b: &mut Bencher) {
-        bench_iter(b, 100000);
+        b.iter(|| for _ in m.iter() {})
     }
 
     #[bench]

branches/snap-stage3/src/libcollections/vec.rs

@@ -570,6 +570,13 @@ impl<T> Collection for Vec<T> {
     }
 }
 
+impl<T: Clone> CloneableVector<T> for Vec<T> {
+    #[deprecated = "call .clone() instead"]
+    fn to_vec(&self) -> Vec<T> { self.clone() }
+    #[deprecated = "move the vector instead"]
+    fn into_vec(self) -> Vec<T> { self }
+}
+
 // FIXME: #13996: need a way to mark the return value as `noalias`
 #[inline(never)]
 unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T {

branches/snap-stage3/src/libcoretest/mem.rs

@@ -19,10 +19,10 @@ fn size_of_basic() {
 }
 
 #[test]
-#[cfg(any(target_arch = "x86",
-          target_arch = "arm",
-          target_arch = "mips",
-          target_arch = "mipsel"))]
+#[cfg(target_arch = "x86")]
+#[cfg(target_arch = "arm")]
+#[cfg(target_arch = "mips")]
+#[cfg(target_arch = "mipsel")]
 fn size_of_32() {
     assert_eq!(size_of::<uint>(), 4u);
     assert_eq!(size_of::<*const uint>(), 4u);
@@ -51,10 +51,10 @@ fn align_of_basic() {
 }
 
 #[test]
-#[cfg(any(target_arch = "x86",
-          target_arch = "arm",
-          target_arch = "mips",
-          target_arch = "mipsel"))]
+#[cfg(target_arch = "x86")]
+#[cfg(target_arch = "arm")]
+#[cfg(target_arch = "mips")]
+#[cfg(target_arch = "mipsel")]
 fn align_of_32() {
     assert_eq!(align_of::<uint>(), 4u);
     assert_eq!(align_of::<*const uint>(), 4u);

branches/snap-stage3/src/libgraphviz/maybe_owned_vec.rs

@@ -140,7 +140,7 @@ impl<'a,T:Clone> CloneableVector<T> for MaybeOwnedVector<'a,T> {
 impl<'a, T: Clone> Clone for MaybeOwnedVector<'a, T> {
     fn clone(&self) -> MaybeOwnedVector<'a, T> {
         match *self {
-            Growable(ref v) => Growable(v.clone()),
+            Growable(ref v) => Growable(v.to_vec()),
             Borrowed(v) => Borrowed(v)
         }
     }

branches/snap-stage3/src/librustc/diagnostics.rs

@@ -56,7 +56,6 @@ register_diagnostics!(
     E0038,
     E0039,
     E0040,
-    E0041,
     E0044,
     E0045,
     E0046,
@@ -123,7 +122,6 @@ register_diagnostics!(
     E0121,
     E0122,
     E0124,
-    E0126,
     E0127,
     E0128,
     E0129,
@@ -141,9 +139,6 @@ register_diagnostics!(
     E0141,
     E0152,
     E0153,
-    E0154,
-    E0155,
-    E0156,
     E0157,
     E0158,
     E0159,