unsized-vec 0.0.2-alpha.13

Like Vec, but for unsized values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#![feature(test)]

extern crate test;

use std::hint::black_box;

use test::bench::Bencher;
use unsized_vec::UnsizedVec;

const ARR0: [i32; 0] = [];
const ARR1: [i32; 1] = [23];
const ARR2: [i32; 2] = [-4, 27];
const ARR3: [i32; 3] = [-4, 27, 31];

const ARR4: [i32; 4] = [-4, 27, 31, 42];

const ARR13: [i32; 13] = [
    -4, 27, 31, 42, 43, 342, 2342, -324, 234, 234, 65, 123, 32465532,
];

#[bench]
fn test_push_arrays(b: &mut Bencher) {
    //let mut lock = stdout().lock();
    b.iter(|| {
        let mut v: UnsizedVec<[i32]> = UnsizedVec::new();

        for _ in 0..255 {
            // writeln!(lock, "0");
            v.push_unsize(black_box(ARR0));
            // writeln!(lock, "1");
            v.push_unsize(black_box(ARR1));
            // writeln!(lock, "2");
            v.push_unsize(black_box(ARR2));
            // writeln!(lock, "3");
            v.push_unsize(black_box(ARR3));
            // writeln!(lock, "4");
            v.push_unsize(black_box(ARR4));
            //writeln!(lock, "5");
            v.push_unsize(black_box(ARR13));
            //writeln!(lock, "6");
        }

        black_box(v);
    });
}

#[bench]
fn test_push_arrays_boxed(b: &mut Bencher) {
    b.iter(|| {
        let mut v: Vec<Box<[i32]>> = Vec::new();

        for _ in 0..255 {
            v.push(Box::new(black_box(ARR0)));
            v.push(Box::new(black_box(ARR1)));
            v.push(Box::new(black_box(ARR2)));
            v.push(Box::new(black_box(ARR3)));
            v.push(Box::new(black_box(ARR4)));
            v.push(Box::new(black_box(ARR13)));
        }

        black_box(v);
    });
}

#[bench]
fn test_push_arrays_preallocated(b: &mut Bencher) {
    b.iter(|| {
        let mut v: UnsizedVec<[i32]> =
            UnsizedVec::with_capacity_bytes(256 * 6, 256 * 4 * (13 + 4 + 3 + 2 + 1));

        for _ in 0..255 {
            v.push_unsize(black_box(ARR0));
            v.push_unsize(black_box(ARR1));
            v.push_unsize(black_box(ARR2));
            v.push_unsize(black_box(ARR3));
            v.push_unsize(black_box(ARR4));
            v.push_unsize(black_box(ARR13));
        }

        black_box(v);
    });
}

#[bench]
fn test_push_arrays_boxed_preallocated(b: &mut Bencher) {
    b.iter(|| {
        let mut v: Vec<Box<[i32]>> = Vec::with_capacity(6 * 256);

        for _ in 0..255 {
            v.push(Box::new(black_box(ARR0)));
            v.push(Box::new(black_box(ARR1)));
            v.push(Box::new(black_box(ARR2)));
            v.push(Box::new(black_box(ARR3)));
            v.push(Box::new(black_box(ARR4)));
            v.push(Box::new(black_box(ARR13)));
        }

        black_box(v);
    });
}