library/alloc/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_extend_from_slice(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_extend_from_slice_0000_0000(b: &mut Bencher) {
 232     do_bench_extend_from_slice(b, 0, 0)
 233 }
 234
 235 #[bench]
 236 fn bench_extend_from_slice_0000_0010(b: &mut Bencher) {
 237     do_bench_extend_from_slice(b, 0, 10)
 238 }
 239
 240 #[bench]
 241 fn bench_extend_from_slice_0000_0100(b: &mut Bencher) {
 242     do_bench_extend_from_slice(b, 0, 100)
 243 }
 244
 245 #[bench]
 246 fn bench_extend_from_slice_0000_1000(b: &mut Bencher) {
 247     do_bench_extend_from_slice(b, 0, 1000)
 248 }
 249
 250 #[bench]
 251 fn bench_extend_from_slice_0010_0010(b: &mut Bencher) {
 252     do_bench_extend_from_slice(b, 10, 10)
 253 }
 254
 255 #[bench]
 256 fn bench_extend_from_slice_0100_0100(b: &mut Bencher) {
 257     do_bench_extend_from_slice(b, 100, 100)
 258 }
 259
 260 #[bench]
 261 fn bench_extend_from_slice_1000_1000(b: &mut Bencher) {
 262     do_bench_extend_from_slice(b, 1000, 1000)
 263 }
 264
 265 fn do_bench_clone(b: &mut Bencher, src_len: usize) {
 266     let src: Vec<usize> = FromIterator::from_iter(0..src_len);
 267
 268     b.bytes = src_len as u64;
 269
 270     b.iter(|| {
 271         let dst = src.clone();
 272         assert_eq!(dst.len(), src_len);
 273         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 274     });
 275 }
 276
 277 #[bench]
 278 fn bench_clone_0000(b: &mut Bencher) {
 279     do_bench_clone(b, 0)
 280 }
 281
 282 #[bench]
 283 fn bench_clone_0010(b: &mut Bencher) {
 284     do_bench_clone(b, 10)
 285 }
 286
 287 #[bench]
 288 fn bench_clone_0100(b: &mut Bencher) {
 289     do_bench_clone(b, 100)
 290 }
 291
 292 #[bench]
 293 fn bench_clone_1000(b: &mut Bencher) {
 294     do_bench_clone(b, 1000)
 295 }
 296
 297 fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
 298     let dst: Vec<_> = FromIterator::from_iter(0..src_len);
 299     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 300
 301     b.bytes = (times * src_len) as u64;
 302
 303     b.iter(|| {
 304         let mut dst = dst.clone();
 305
 306         for _ in 0..times {
 307             dst.clone_from(&src);
 308
 309             assert_eq!(dst.len(), src_len);
 310             assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
 311         }
 312     });
 313 }
 314
 315 #[bench]
 316 fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
 317     do_bench_clone_from(b, 1, 0, 0)
 318 }
 319
 320 #[bench]
 321 fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
 322     do_bench_clone_from(b, 1, 0, 10)
 323 }
 324
 325 #[bench]
 326 fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
 327     do_bench_clone_from(b, 1, 0, 100)
 328 }
 329
 330 #[bench]
 331 fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
 332     do_bench_clone_from(b, 1, 0, 1000)
 333 }
 334
 335 #[bench]
 336 fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
 337     do_bench_clone_from(b, 1, 10, 10)
 338 }
 339
 340 #[bench]
 341 fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
 342     do_bench_clone_from(b, 1, 100, 100)
 343 }
 344
 345 #[bench]
 346 fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
 347     do_bench_clone_from(b, 1, 1000, 1000)
 348 }
 349
 350 #[bench]
 351 fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
 352     do_bench_clone_from(b, 1, 10, 100)
 353 }
 354
 355 #[bench]
 356 fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
 357     do_bench_clone_from(b, 1, 100, 1000)
 358 }
 359
 360 #[bench]
 361 fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
 362     do_bench_clone_from(b, 1, 10, 0)
 363 }
 364
 365 #[bench]
 366 fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
 367     do_bench_clone_from(b, 1, 100, 10)
 368 }
 369
 370 #[bench]
 371 fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
 372     do_bench_clone_from(b, 1, 1000, 100)
 373 }
 374
 375 #[bench]
 376 fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
 377     do_bench_clone_from(b, 10, 0, 0)
 378 }
 379
 380 #[bench]
 381 fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
 382     do_bench_clone_from(b, 10, 0, 10)
 383 }
 384
 385 #[bench]
 386 fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
 387     do_bench_clone_from(b, 10, 0, 100)
 388 }
 389
 390 #[bench]
 391 fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
 392     do_bench_clone_from(b, 10, 0, 1000)
 393 }
 394
 395 #[bench]
 396 fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
 397     do_bench_clone_from(b, 10, 10, 10)
 398 }
 399
 400 #[bench]
 401 fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
 402     do_bench_clone_from(b, 10, 100, 100)
 403 }
 404
 405 #[bench]
 406 fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
 407     do_bench_clone_from(b, 10, 1000, 1000)
 408 }
 409
 410 #[bench]
 411 fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
 412     do_bench_clone_from(b, 10, 10, 100)
 413 }
 414
 415 #[bench]
 416 fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
 417     do_bench_clone_from(b, 10, 100, 1000)
 418 }
 419
 420 #[bench]
 421 fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
 422     do_bench_clone_from(b, 10, 10, 0)
 423 }
 424
 425 #[bench]
 426 fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
 427     do_bench_clone_from(b, 10, 100, 10)
 428 }
 429
 430 #[bench]
 431 fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
 432     do_bench_clone_from(b, 10, 1000, 100)
 433 }