src/liballoc/benches/vec.rs

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