lgalloc 0.7.0

Large object allocator
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::mem::MaybeUninit;
use std::ptr::NonNull;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

use lgalloc::{
    allocate, deallocate, lgalloc_set_config, lgalloc_stats, AllocError, BackgroundWorkerConfig,
    Handle, LgAlloc,
};

fn initialize() {
    lgalloc_set_config(
        LgAlloc::new()
            .enable()
            .with_background_config(BackgroundWorkerConfig {
                interval: Duration::from_secs(1),
                clear_bytes: 4 << 20,
            })
            .growth_dampener(1),
    );
}

struct Wrapper<T> {
    handle: MaybeUninit<Handle>,
    ptr: NonNull<MaybeUninit<T>>,
    cap: usize,
}

unsafe impl<T: Send> Send for Wrapper<T> {}
unsafe impl<T: Sync> Sync for Wrapper<T> {}

impl<T> Wrapper<T> {
    fn allocate(capacity: usize) -> Result<Self, AllocError> {
        let (ptr, cap, handle) = allocate(capacity)?;
        assert!(cap > 0);
        let handle = MaybeUninit::new(handle);
        Ok(Self { ptr, cap, handle })
    }

    fn as_slice(&mut self) -> &mut [MaybeUninit<T>] {
        unsafe { std::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.cap) }
    }
}

impl<T> Drop for Wrapper<T> {
    fn drop(&mut self) {
        unsafe { deallocate(self.handle.assume_init_read()) };
    }
}

#[test]
fn concurrent_single_alloc() -> Result<(), AllocError> {
    initialize();
    let until = Arc::new(AtomicBool::new(true));

    let inner = || {
        let until = Arc::clone(&until);
        move || {
            let mut i = 0;
            let until = &*until;
            while until.load(Ordering::Relaxed) {
                i += 1;
                let mut r = <Wrapper<u8>>::allocate(4 << 20).unwrap();
                r.as_slice()[0] = MaybeUninit::new(1);
            }
            println!("repetitions: {i}");
        }
    };
    let handles = [
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
    ];
    std::thread::sleep(Duration::from_secs(4));
    until.store(false, Ordering::Relaxed);
    for handle in handles {
        handle.join().unwrap();
    }
    Ok(())
}

#[test]
fn concurrent_batch_alloc() -> Result<(), AllocError> {
    initialize();
    let until = Arc::new(AtomicBool::new(true));

    let inner = || {
        let until = Arc::clone(&until);
        move || {
            let mut i = 0;
            let until = &*until;
            let batch = 64;
            let mut buffer = Vec::with_capacity(batch);
            while until.load(Ordering::Relaxed) {
                i += 64;
                buffer.extend((0..batch).map(|_| {
                    let mut r = <Wrapper<u8>>::allocate(2 << 20).unwrap();
                    r.as_slice()[0] = MaybeUninit::new(1);
                    r
                }));
                buffer.clear();
            }
            println!("repetitions vec: {i}");
        }
    };
    let handles = [
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
        std::thread::spawn(inner()),
    ];
    std::thread::sleep(Duration::from_secs(4));
    until.store(false, Ordering::Relaxed);
    for handle in handles {
        handle.join().unwrap();
    }
    std::thread::sleep(Duration::from_secs(1));
    let stats = lgalloc_stats();
    for size_class in &stats.size_class {
        println!("size_class {:?}", size_class);
    }
    Ok(())
}