diskallocator 0.1.1

For really big vectors: allocate on disk
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

#![feature(allocator_api)]


use diskallocator::{self, DiskAlloc};
use rand::Rng;

#[test]
fn fill_slowly() {
    let alloc = DiskAlloc::new().unwrap();
    let mut v: Vec<u64, DiskAlloc> = Vec::new_in(alloc);
    for i in 0..9999 {
        v.push(i);
    }
}

#[test]
fn random_operations() {
    let mut rng = rand::thread_rng();

    let alloc = DiskAlloc::new().unwrap();
    let mut alloc_vec: Vec<u32, _> = Vec::new_in(alloc);
    let mut usual_vec = Vec::new();

    for _ in 0..1_000_000 {
        let branch: usize = rng.gen();

        // higher number means more pushes,
        // and less differnt operations
        match branch % 32 {
            0 => {
                alloc_vec.shrink_to_fit();
                usual_vec.shrink_to_fit();
            }
            1 => {
                alloc_vec.pop();
                usual_vec.pop();
            }
            2 => {
                let reserve = rng.gen::<usize>() % 1_000_000;
                alloc_vec.reserve(reserve);
                usual_vec.reserve(reserve);
            }
            3 => {
                if usual_vec.is_empty() {
                    return;
                }
                let truncation = rng.gen::<usize>() % usual_vec.len();
                alloc_vec.truncate(truncation);
                usual_vec.truncate(truncation);
            }
            _ => {
                let value = rng.gen();
                alloc_vec.push(value);
                usual_vec.push(value);
            }
        }
        assert_eq!(alloc_vec, usual_vec);
    }
}

#[test]
fn build_big_vec() {
    let mut rng = rand::thread_rng();

    // 1GiB of u64 (8B) makes 128M elements
    let alloc = DiskAlloc::new().unwrap();
    let mut alloc_vec: Vec<u64, _> = Vec::new_in(alloc);
    let mut usual_vec: Vec<u64> = Vec::new();

    for _ in 0..128 * 1024 {
        let value: u64 = rng.gen();
        for i in 0..1024 {
            alloc_vec.push(value);
            usual_vec.push(value ^ i);
        }
    }
    assert_eq!(alloc_vec.len(), usual_vec.len());
}

#[test]
fn multi_allocs() {
    let count = 32;

    let allocator_collection: Vec<DiskAlloc> = (0..count)
        .map(|_| DiskAlloc::new().unwrap())
        .collect::<Vec<DiskAlloc>>();
    assert_eq!(allocator_collection.len(), count);
}