collections: flesh out Vec benchmarks

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index d53ecabd5a9cb147e5093e7ce172dd91acf1835a..e10fc66ea8567afec94aa0d43f0cd900e603b6e9 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1857,107 +1857,417 @@ fn drop(&mut self) {
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {
-            let v: Vec<int> = Vec::new();
+            let v: Vec<uint> = Vec::new();
+            assert_eq!(v.len(), 0);
             assert_eq!(v.capacity(), 0);
-            assert!(v.as_slice() == []);
         })
     }
 
-    #[bench]
-    fn bench_with_capacity_0(b: &mut Bencher) {
+    fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(0);
-            assert_eq!(v.capacity(), 0);
-            assert!(v.as_slice() == []);
+            let v: Vec<uint> = Vec::with_capacity(src_len);
+            assert_eq!(v.len(), 0);
+            assert_eq!(v.capacity(), src_len);
         })
     }
 
+    #[bench]
+    fn bench_with_capacity_0000(b: &mut Bencher) {
+        do_bench_with_capacity(b, 0)
+    }
 
     #[bench]
-    fn bench_with_capacity_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(5);
-            assert_eq!(v.capacity(), 5);
-            assert!(v.as_slice() == []);
-        })
+    fn bench_with_capacity_0010(b: &mut Bencher) {
+        do_bench_with_capacity(b, 10)
+    }
+
+    #[bench]
+    fn bench_with_capacity_0100(b: &mut Bencher) {
+        do_bench_with_capacity(b, 100)
     }
 
     #[bench]
-    fn bench_with_capacity_100(b: &mut Bencher) {
+    fn bench_with_capacity_1000(b: &mut Bencher) {
+        do_bench_with_capacity(b, 1000)
+    }
+
+    fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(100);
-            assert_eq!(v.capacity(), 100);
-            assert!(v.as_slice() == []);
+            let dst = Vec::from_fn(src_len, |i| i);
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         })
     }
 
     #[bench]
-    fn bench_from_fn_0(b: &mut Bencher) {
+    fn bench_from_fn_0000(b: &mut Bencher) {
+        do_bench_from_fn(b, 0)
+    }
+
+    #[bench]
+    fn bench_from_fn_0010(b: &mut Bencher) {
+        do_bench_from_fn(b, 10)
+    }
+
+    #[bench]
+    fn bench_from_fn_0100(b: &mut Bencher) {
+        do_bench_from_fn(b, 100)
+    }
+
+    #[bench]
+    fn bench_from_fn_1000(b: &mut Bencher) {
+        do_bench_from_fn(b, 1000)
+    }
+
+    fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::from_fn(0, |_| 5);
-            assert!(v.as_slice() == []);
+            let dst: Vec<uint> = Vec::from_elem(src_len, 5);
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().all(|x| *x == 5));
         })
     }
 
     #[bench]
-    fn bench_from_fn_5(b: &mut Bencher) {
+    fn bench_from_elem_0000(b: &mut Bencher) {
+        do_bench_from_elem(b, 0)
+    }
+
+    #[bench]
+    fn bench_from_elem_0010(b: &mut Bencher) {
+        do_bench_from_elem(b, 10)
+    }
+
+    #[bench]
+    fn bench_from_elem_0100(b: &mut Bencher) {
+        do_bench_from_elem(b, 100)
+    }
+
+    #[bench]
+    fn bench_from_elem_1000(b: &mut Bencher) {
+        do_bench_from_elem(b, 1000)
+    }
+
+    fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
+        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::from_fn(5, |_| 5);
-            assert!(v.as_slice() == [5, 5, 5, 5, 5]);
-        })
+            let dst = Vec::from_slice(src.clone().as_slice());
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_from_slice_0000(b: &mut Bencher) {
+        do_bench_from_slice(b, 0)
     }
 
     #[bench]
-    fn bench_from_slice_0(b: &mut Bencher) {
+    fn bench_from_slice_0010(b: &mut Bencher) {
+        do_bench_from_slice(b, 10)
+    }
+
+    #[bench]
+    fn bench_from_slice_0100(b: &mut Bencher) {
+        do_bench_from_slice(b, 100)
+    }
+
+    #[bench]
+    fn bench_from_slice_1000(b: &mut Bencher) {
+        do_bench_from_slice(b, 1000)
+    }
+
+    fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
+        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::from_slice([]);
-            assert!(v.as_slice() == []);
-        })
+            let dst: Vec<uint> = FromIterator::from_iter(src.clone().move_iter());
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_from_iter_0000(b: &mut Bencher) {
+        do_bench_from_iter(b, 0)
+    }
+
+    #[bench]
+    fn bench_from_iter_0010(b: &mut Bencher) {
+        do_bench_from_iter(b, 10)
     }
 
     #[bench]
-    fn bench_from_slice_5(b: &mut Bencher) {
+    fn bench_from_iter_0100(b: &mut Bencher) {
+        do_bench_from_iter(b, 100)
+    }
+
+    #[bench]
+    fn bench_from_iter_1000(b: &mut Bencher) {
+        do_bench_from_iter(b, 1000)
+    }
+
+    fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
+        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
+        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v: Vec<int> = Vec::from_slice([1i, 2, 3, 4, 5]);
-            assert!(v.as_slice() == [1, 2, 3, 4, 5]);
-        })
+            let mut dst = dst.clone();
+            dst.extend(src.clone().move_iter());
+            assert_eq!(dst.len(), dst_len + src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_extend_0000_0000(b: &mut Bencher) {
+        do_bench_extend(b, 0, 0)
     }
 
     #[bench]
-    fn bench_from_iter_0(b: &mut Bencher) {
+    fn bench_extend_0000_0010(b: &mut Bencher) {
+        do_bench_extend(b, 0, 10)
+    }
+
+    #[bench]
+    fn bench_extend_0000_0100(b: &mut Bencher) {
+        do_bench_extend(b, 0, 100)
+    }
+
+    #[bench]
+    fn bench_extend_0000_1000(b: &mut Bencher) {
+        do_bench_extend(b, 0, 1000)
+    }
+
+    #[bench]
+    fn bench_extend_0010_0010(b: &mut Bencher) {
+        do_bench_extend(b, 10, 10)
+    }
+
+    #[bench]
+    fn bench_extend_0100_0100(b: &mut Bencher) {
+        do_bench_extend(b, 100, 100)
+    }
+
+    #[bench]
+    fn bench_extend_1000_1000(b: &mut Bencher) {
+        do_bench_extend(b, 1000, 1000)
+    }
+
+    fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
+        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
+        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v0: Vec<int> = vec!();
-            let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
-            assert!(v1.as_slice() == []);
-        })
+            let mut dst = dst.clone();
+            dst.push_all(src.as_slice());
+            assert_eq!(dst.len(), dst_len + src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_push_all_0000_0000(b: &mut Bencher) {
+        do_bench_push_all(b, 0, 0)
     }
 
     #[bench]
-    fn bench_from_iter_5(b: &mut Bencher) {
+    fn bench_push_all_0000_0010(b: &mut Bencher) {
+        do_bench_push_all(b, 0, 10)
+    }
+
+    #[bench]
+    fn bench_push_all_0000_0100(b: &mut Bencher) {
+        do_bench_push_all(b, 0, 100)
+    }
+
+    #[bench]
+    fn bench_push_all_0000_1000(b: &mut Bencher) {
+        do_bench_push_all(b, 0, 1000)
+    }
+
+    #[bench]
+    fn bench_push_all_0010_0010(b: &mut Bencher) {
+        do_bench_push_all(b, 10, 10)
+    }
+
+    #[bench]
+    fn bench_push_all_0100_0100(b: &mut Bencher) {
+        do_bench_push_all(b, 100, 100)
+    }
+
+    #[bench]
+    fn bench_push_all_1000_1000(b: &mut Bencher) {
+        do_bench_push_all(b, 1000, 1000)
+    }
+
+    fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
+        let dst: Vec<uint> = FromIterator::from_iter(range(0u, dst_len));
+        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
-            let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
-        })
+            let mut dst = dst.clone();
+            dst.push_all_move(src.clone());
+            assert_eq!(dst.len(), dst_len + src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_push_all_move_0000_0000(b: &mut Bencher) {
+        do_bench_push_all_move(b, 0, 0)
     }
 
     #[bench]
-    fn bench_extend_0(b: &mut Bencher) {
+    fn bench_push_all_move_0000_0010(b: &mut Bencher) {
+        do_bench_push_all_move(b, 0, 10)
+    }
+
+    #[bench]
+    fn bench_push_all_move_0000_0100(b: &mut Bencher) {
+        do_bench_push_all_move(b, 0, 100)
+    }
+
+    #[bench]
+    fn bench_push_all_move_0000_1000(b: &mut Bencher) {
+        do_bench_push_all_move(b, 0, 1000)
+    }
+
+    #[bench]
+    fn bench_push_all_move_0010_0010(b: &mut Bencher) {
+        do_bench_push_all_move(b, 10, 10)
+    }
+
+    #[bench]
+    fn bench_push_all_move_0100_0100(b: &mut Bencher) {
+        do_bench_push_all_move(b, 100, 100)
+    }
+
+    #[bench]
+    fn bench_push_all_move_1000_1000(b: &mut Bencher) {
+        do_bench_push_all_move(b, 1000, 1000)
+    }
+
+    fn do_bench_clone(b: &mut Bencher, src_len: uint) {
+        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v0: Vec<int> = vec!();
-            let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
-            v1.extend(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
-        })
+            let dst = src.clone();
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        });
     }
 
     #[bench]
-    fn bench_extend_5(b: &mut Bencher) {
+    fn bench_clone_0000(b: &mut Bencher) {
+        do_bench_clone(b, 0)
+    }
+
+    #[bench]
+    fn bench_clone_0010(b: &mut Bencher) {
+        do_bench_clone(b, 10)
+    }
+
+    #[bench]
+    fn bench_clone_0100(b: &mut Bencher) {
+        do_bench_clone(b, 100)
+    }
+
+    #[bench]
+    fn bench_clone_1000(b: &mut Bencher) {
+        do_bench_clone(b, 1000)
+    }
+
+    fn do_bench_clone_from(b: &mut Bencher, dst_len: uint, src_len: uint) {
+        let dst: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+        b.bytes = src_len as u64;
+
         b.iter(|| {
-            let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
-            let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
-            v1.extend(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]);
-        })
+            let mut dst = dst.clone();
+            let src = src.clone();
+            dst.clone_from(&src);
+            assert_eq!(dst.len(), src_len);
+            assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
+        });
+    }
+
+    #[bench]
+    fn bench_clone_from_0000_0000(b: &mut Bencher) {
+        do_bench_clone_from(b, 0, 0)
+    }
+
+    #[bench]
+    fn bench_clone_from_0000_0010(b: &mut Bencher) {
+        do_bench_clone_from(b, 0, 10)
+    }
+
+    #[bench]
+    fn bench_clone_from_0000_0100(b: &mut Bencher) {
+        do_bench_clone_from(b, 0, 100)
+    }
+
+    #[bench]
+    fn bench_clone_from_0000_1000(b: &mut Bencher) {
+        do_bench_clone_from(b, 0, 1000)
+    }
+
+    #[bench]
+    fn bench_clone_from_0010_0010(b: &mut Bencher) {
+        do_bench_clone_from(b, 10, 10)
+    }
+
+    #[bench]
+    fn bench_clone_from_0100_0100(b: &mut Bencher) {
+        do_bench_clone_from(b, 100, 100)
+    }
+
+    #[bench]
+    fn bench_clone_from_1000_1000(b: &mut Bencher) {
+        do_bench_clone_from(b, 1000, 1000)
+    }
+
+    #[bench]
+    fn bench_clone_from_0010_0100(b: &mut Bencher) {
+        do_bench_clone_from(b, 10, 100)
+    }
+
+    #[bench]
+    fn bench_clone_from_0100_1000(b: &mut Bencher) {
+        do_bench_clone_from(b, 100, 1000)
+    }
+
+    #[bench]
+    fn bench_clone_from_0010_0000(b: &mut Bencher) {
+        do_bench_clone_from(b, 10, 0)
+    }
+
+    #[bench]
+    fn bench_clone_from_0100_0010(b: &mut Bencher) {
+        do_bench_clone_from(b, 100, 10)
+    }
+
+    #[bench]
+    fn bench_clone_from_1000_0100(b: &mut Bencher) {
+        do_bench_clone_from(b, 1000, 100)
     }
 }