shuffling-allocator 1.1.2

A shuffling allocator, randomizing heap object locations; useful for avoiding accidental cache locality during benchmarking, which can obscure performance evaluation.
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

use shuffling_allocator::ShufflingAllocator;
use std::alloc::System;
use std::collections::HashMap;
use std::thread;

#[global_allocator]
static A: ShufflingAllocator<System> = shuffling_allocator::wrap!(&System);

#[test]
fn foo() {
    println!("hello");
}

#[test]
fn map() {
    let mut m = HashMap::new();
    m.insert(1, 2);
    m.insert(5, 3);
    drop(m);
}

#[test]
fn strings() {
    format!("foo, bar, {}", "baz");
}

#[test]
fn threads() {
    assert!(thread::spawn(|| panic!()).join().is_err());
}

#[test]
fn test_larger_than_word_alignment() {
    use std::mem;

    // Align to 32 bytes.
    #[repr(align(32))]
    struct Align32(u8);

    assert_eq!(mem::align_of::<Align32>(), 32);

    for _ in 0..100 {
        let b = Box::new(Align32(42));

        let p = Box::into_raw(b);
        assert_eq!(p as usize % 32, 0, "{:p} should be aligned to 32", p);

        unsafe {
            let b = Box::from_raw(p);
            assert_eq!(b.0, 42);
        }
    }
}

#[test]
fn many_small_allocs() {
    let boxes = (0..1024).map(|i| Box::new(i)).collect::<Vec<_>>();
    drop(boxes);
}