src/libcollections/benches/vec.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use test::Bencher;
  12 use std::iter::{FromIterator, repeat};
  13
  14 #[bench]
  15 fn bench_new(b: &mut Bencher) {
  16     b.iter(|| {
  17         let v: Vec<u32> = Vec::new();
  18         assert_eq!(v.len(), 0);
  19         assert_eq!(v.capacity(), 0);
  20     })
  21 }
  22
  23 fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
  24     b.bytes = src_len as u64;
  25
  26     b.iter(|| {
  27         let v: Vec<u32> = Vec::with_capacity(src_len);
  28         assert_eq!(v.len(), 0);
  29         assert_eq!(v.capacity(), src_len);
  30     })
  31 }
  32
  33 #[bench]
  34 fn bench_with_capacity_0000(b: &mut Bencher) {
  35     do_bench_with_capacity(b, 0)
  36 }
  37
  38 #[bench]
  39 fn bench_with_capacity_0010(b: &mut Bencher) {
  40     do_bench_with_capacity(b, 10)
  41 }
  42
  43 #[bench]
  44 fn bench_with_capacity_0100(b: &mut Bencher) {
  45     do_bench_with_capacity(b, 100)
  46 }
  47
  48 #[bench]
  49 fn bench_with_capacity_1000(b: &mut Bencher) {
  50     do_bench_with_capacity(b, 1000)
  51 }
  52
  53 fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
  54     b.bytes = src_len as u64;
  55
  56     b.iter(|| {
  57         let dst = (0..src_len).collect::<Vec<_>>();
  58         assert_eq!(dst.len(), src_len);
  59         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
  60     })
  61 }
  62
  63 #[bench]
  64 fn bench_from_fn_0000(b: &mut Bencher) {
  65     do_bench_from_fn(b, 0)
  66 }
  67
  68 #[bench]
  69 fn bench_from_fn_0010(b: &mut Bencher) {
  70     do_bench_from_fn(b, 10)
  71 }
  72
  73 #[bench]
  74 fn bench_from_fn_0100(b: &mut Bencher) {
  75     do_bench_from_fn(b, 100)
  76 }
  77
  78 #[bench]
  79 fn bench_from_fn_1000(b: &mut Bencher) {
  80     do_bench_from_fn(b, 1000)
  81 }
  82
  83 fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
  84     b.bytes = src_len as u64;
  85
  86     b.iter(|| {
  87         let dst: Vec<usize> = repeat(5).take(src_len).collect();
  88         assert_eq!(dst.len(), src_len);
  89         assert!(dst.iter().all(|x| *x == 5));
  90     })
  91 }
  92
  93 #[bench]
  94 fn bench_from_elem_0000(b: &mut Bencher) {
  95     do_bench_from_elem(b, 0)
  96 }
  97
  98 #[bench]
  99 fn bench_from_elem_0010(b: &mut Bencher) {
 100     do_bench_from_elem(b, 10)
 101 }
 102
 103 #[bench]
 104 fn bench_from_elem_0100(b: &mut Bencher) {
 105     do_bench_from_elem(b, 100)
 106 }
 107
 108 #[bench]
 109 fn bench_from_elem_1000(b: &mut Bencher) {
 110     do_bench_from_elem(b, 1000)
 111 }
 112
 113 fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
 114     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 115
 116     b.bytes = src_len as u64;
 117
 118     b.iter(|| {
 119         let dst = src.clone()[..].to_vec();
 120         assert_eq!(dst.len(), src_len);
 121         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 122     });
 123 }
 124
 125 #[bench]
 126 fn bench_from_slice_0000(b: &mut Bencher) {
 127     do_bench_from_slice(b, 0)
 128 }
 129
 130 #[bench]
 131 fn bench_from_slice_0010(b: &mut Bencher) {
 132     do_bench_from_slice(b, 10)
 133 }
 134
 135 #[bench]
 136 fn bench_from_slice_0100(b: &mut Bencher) {
 137     do_bench_from_slice(b, 100)
 138 }
 139
 140 #[bench]
 141 fn bench_from_slice_1000(b: &mut Bencher) {
 142     do_bench_from_slice(b, 1000)
 143 }
 144
 145 fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
 146     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 147
 148     b.bytes = src_len as u64;
 149
 150     b.iter(|| {
 151         let dst: Vec<_> = FromIterator::from_iter(src.clone());
 152         assert_eq!(dst.len(), src_len);
 153         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 154     });
 155 }
 156
 157 #[bench]
 158 fn bench_from_iter_0000(b: &mut Bencher) {
 159     do_bench_from_iter(b, 0)
 160 }
 161
 162 #[bench]
 163 fn bench_from_iter_0010(b: &mut Bencher) {
 164     do_bench_from_iter(b, 10)
 165 }
 166
 167 #[bench]
 168 fn bench_from_iter_0100(b: &mut Bencher) {
 169     do_bench_from_iter(b, 100)
 170 }
 171
 172 #[bench]
 173 fn bench_from_iter_1000(b: &mut Bencher) {
 174     do_bench_from_iter(b, 1000)
 175 }
 176
 177 fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
 178     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 179     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 180
 181     b.bytes = src_len as u64;
 182
 183     b.iter(|| {
 184         let mut dst = dst.clone();
 185         dst.extend(src.clone());
 186         assert_eq!(dst.len(), dst_len + src_len);
 187         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 188     });
 189 }
 190
 191 #[bench]
 192 fn bench_extend_0000_0000(b: &mut Bencher) {
 193     do_bench_extend(b, 0, 0)
 194 }
 195
 196 #[bench]
 197 fn bench_extend_0000_0010(b: &mut Bencher) {
 198     do_bench_extend(b, 0, 10)
 199 }
 200
 201 #[bench]
 202 fn bench_extend_0000_0100(b: &mut Bencher) {
 203     do_bench_extend(b, 0, 100)
 204 }
 205
 206 #[bench]
 207 fn bench_extend_0000_1000(b: &mut Bencher) {
 208     do_bench_extend(b, 0, 1000)
 209 }
 210
 211 #[bench]
 212 fn bench_extend_0010_0010(b: &mut Bencher) {
 213     do_bench_extend(b, 10, 10)
 214 }
 215
 216 #[bench]
 217 fn bench_extend_0100_0100(b: &mut Bencher) {
 218     do_bench_extend(b, 100, 100)
 219 }
 220
 221 #[bench]
 222 fn bench_extend_1000_1000(b: &mut Bencher) {
 223     do_bench_extend(b, 1000, 1000)
 224 }
 225
 226 fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
 227     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 228     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 229
 230     b.bytes = src_len as u64;
 231
 232     b.iter(|| {
 233         let mut dst = dst.clone();
 234         dst.extend_from_slice(&src);
 235         assert_eq!(dst.len(), dst_len + src_len);
 236         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 237     });
 238 }
 239
 240 #[bench]
 241 fn bench_push_all_0000_0000(b: &mut Bencher) {
 242     do_bench_push_all(b, 0, 0)
 243 }
 244
 245 #[bench]
 246 fn bench_push_all_0000_0010(b: &mut Bencher) {
 247     do_bench_push_all(b, 0, 10)
 248 }
 249
 250 #[bench]
 251 fn bench_push_all_0000_0100(b: &mut Bencher) {
 252     do_bench_push_all(b, 0, 100)
 253 }
 254
 255 #[bench]
 256 fn bench_push_all_0000_1000(b: &mut Bencher) {
 257     do_bench_push_all(b, 0, 1000)
 258 }
 259
 260 #[bench]
 261 fn bench_push_all_0010_0010(b: &mut Bencher) {
 262     do_bench_push_all(b, 10, 10)
 263 }
 264
 265 #[bench]
 266 fn bench_push_all_0100_0100(b: &mut Bencher) {
 267     do_bench_push_all(b, 100, 100)
 268 }
 269
 270 #[bench]
 271 fn bench_push_all_1000_1000(b: &mut Bencher) {
 272     do_bench_push_all(b, 1000, 1000)
 273 }
 274
 275 fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
 276     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 277     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 278
 279     b.bytes = src_len as u64;
 280
 281     b.iter(|| {
 282         let mut dst = dst.clone();
 283         dst.extend(src.clone());
 284         assert_eq!(dst.len(), dst_len + src_len);
 285         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 286     });
 287 }
 288
 289 #[bench]
 290 fn bench_push_all_move_0000_0000(b: &mut Bencher) {
 291     do_bench_push_all_move(b, 0, 0)
 292 }
 293
 294 #[bench]
 295 fn bench_push_all_move_0000_0010(b: &mut Bencher) {
 296     do_bench_push_all_move(b, 0, 10)
 297 }
 298
 299 #[bench]
 300 fn bench_push_all_move_0000_0100(b: &mut Bencher) {
 301     do_bench_push_all_move(b, 0, 100)
 302 }
 303
 304 #[bench]
 305 fn bench_push_all_move_0000_1000(b: &mut Bencher) {
 306     do_bench_push_all_move(b, 0, 1000)
 307 }
 308
 309 #[bench]
 310 fn bench_push_all_move_0010_0010(b: &mut Bencher) {
 311     do_bench_push_all_move(b, 10, 10)
 312 }
 313
 314 #[bench]
 315 fn bench_push_all_move_0100_0100(b: &mut Bencher) {
 316     do_bench_push_all_move(b, 100, 100)
 317 }
 318
 319 #[bench]
 320 fn bench_push_all_move_1000_1000(b: &mut Bencher) {
 321     do_bench_push_all_move(b, 1000, 1000)
 322 }
 323
 324 fn do_bench_clone(b: &mut Bencher, src_len: usize) {
 325     let src: Vec<usize> = FromIterator::from_iter(0..src_len);
 326
 327     b.bytes = src_len as u64;
 328
 329     b.iter(|| {
 330         let dst = src.clone();
 331         assert_eq!(dst.len(), src_len);
 332         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 333     });
 334 }
 335
 336 #[bench]
 337 fn bench_clone_0000(b: &mut Bencher) {
 338     do_bench_clone(b, 0)
 339 }
 340
 341 #[bench]
 342 fn bench_clone_0010(b: &mut Bencher) {
 343     do_bench_clone(b, 10)
 344 }
 345
 346 #[bench]
 347 fn bench_clone_0100(b: &mut Bencher) {
 348     do_bench_clone(b, 100)
 349 }
 350
 351 #[bench]
 352 fn bench_clone_1000(b: &mut Bencher) {
 353     do_bench_clone(b, 1000)
 354 }
 355
 356 fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
 357     let dst: Vec<_> = FromIterator::from_iter(0..src_len);
 358     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 359
 360     b.bytes = (times * src_len) as u64;
 361
 362     b.iter(|| {
 363         let mut dst = dst.clone();
 364
 365         for _ in 0..times {
 366             dst.clone_from(&src);
 367
 368             assert_eq!(dst.len(), src_len);
 369             assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
 370         }
 371     });
 372 }
 373
 374 #[bench]
 375 fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
 376     do_bench_clone_from(b, 1, 0, 0)
 377 }
 378
 379 #[bench]
 380 fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
 381     do_bench_clone_from(b, 1, 0, 10)
 382 }
 383
 384 #[bench]
 385 fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
 386     do_bench_clone_from(b, 1, 0, 100)
 387 }
 388
 389 #[bench]
 390 fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
 391     do_bench_clone_from(b, 1, 0, 1000)
 392 }
 393
 394 #[bench]
 395 fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
 396     do_bench_clone_from(b, 1, 10, 10)
 397 }
 398
 399 #[bench]
 400 fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
 401     do_bench_clone_from(b, 1, 100, 100)
 402 }
 403
 404 #[bench]
 405 fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
 406     do_bench_clone_from(b, 1, 1000, 1000)
 407 }
 408
 409 #[bench]
 410 fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
 411     do_bench_clone_from(b, 1, 10, 100)
 412 }
 413
 414 #[bench]
 415 fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
 416     do_bench_clone_from(b, 1, 100, 1000)
 417 }
 418
 419 #[bench]
 420 fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
 421     do_bench_clone_from(b, 1, 10, 0)
 422 }
 423
 424 #[bench]
 425 fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
 426     do_bench_clone_from(b, 1, 100, 10)
 427 }
 428
 429 #[bench]
 430 fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
 431     do_bench_clone_from(b, 1, 1000, 100)
 432 }
 433
 434 #[bench]
 435 fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
 436     do_bench_clone_from(b, 10, 0, 0)
 437 }
 438
 439 #[bench]
 440 fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
 441     do_bench_clone_from(b, 10, 0, 10)
 442 }
 443
 444 #[bench]
 445 fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
 446     do_bench_clone_from(b, 10, 0, 100)
 447 }
 448
 449 #[bench]
 450 fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
 451     do_bench_clone_from(b, 10, 0, 1000)
 452 }
 453
 454 #[bench]
 455 fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
 456     do_bench_clone_from(b, 10, 10, 10)
 457 }
 458
 459 #[bench]
 460 fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
 461     do_bench_clone_from(b, 10, 100, 100)
 462 }
 463
 464 #[bench]
 465 fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
 466     do_bench_clone_from(b, 10, 1000, 1000)
 467 }
 468
 469 #[bench]
 470 fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
 471     do_bench_clone_from(b, 10, 10, 100)
 472 }
 473
 474 #[bench]
 475 fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
 476     do_bench_clone_from(b, 10, 100, 1000)
 477 }
 478
 479 #[bench]
 480 fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
 481     do_bench_clone_from(b, 10, 10, 0)
 482 }
 483
 484 #[bench]
 485 fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
 486     do_bench_clone_from(b, 10, 100, 10)
 487 }
 488
 489 #[bench]
 490 fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
 491     do_bench_clone_from(b, 10, 1000, 100)
 492 }