fastalloc 1.5.0

High-performance memory pooling library with type-safe handles, predictable latency, and zero fragmentation. Perfect for game engines, real-time systems, and high-churn workloads.
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
126
127
128

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use fastalloc::{PoolConfig, ThreadSafePool};
use std::sync::Arc;
use std::thread;

fn bench_thread_safe_pool(c: &mut Criterion) {
    let mut group = c.benchmark_group("thread_safe_pool");

    let thread_counts = [1, 2, 4, 8];

    for &threads in &thread_counts {
        group.bench_with_input(
            BenchmarkId::new("concurrent_allocation", threads),
            &threads,
            |b, &threads| {
                let config = PoolConfig::builder().capacity(10000).build().unwrap();
                let pool = Arc::new(ThreadSafePool::with_config(config).unwrap());

                b.iter(|| {
                    let mut handles = vec![];

                    for _ in 0..threads {
                        let pool_clone = Arc::clone(&pool);
                        handles.push(thread::spawn(move || {
                            for i in 0..100 {
                                if let Ok(handle) = pool_clone.allocate(black_box(i)) {
                                    black_box(handle);
                                }
                            }
                        }));
                    }

                    for handle in handles {
                        handle.join().unwrap();
                    }
                });
            },
        );
    }

    group.finish();
}

fn bench_contention(c: &mut Criterion) {
    let mut group = c.benchmark_group("contention");

    // High contention scenario: small pool, many threads
    group.bench_function("high_contention", |b| {
        let config = PoolConfig::builder().capacity(50).build().unwrap();
        let pool = Arc::new(ThreadSafePool::with_config(config).unwrap());

        b.iter(|| {
            let mut handles = vec![];

            for _ in 0..8 {
                let pool_clone = Arc::clone(&pool);
                handles.push(thread::spawn(move || {
                    for i in 0..10 {
                        if let Ok(handle) = pool_clone.allocate(black_box(i)) {
                            black_box(&handle);
                            // Hold briefly then release
                            drop(handle);
                        }
                    }
                }));
            }

            for handle in handles {
                handle.join().unwrap();
            }
        });
    });

    // Low contention scenario: large pool, few threads
    group.bench_function("low_contention", |b| {
        let config = PoolConfig::builder().capacity(10000).build().unwrap();
        let pool = Arc::new(ThreadSafePool::with_config(config).unwrap());

        b.iter(|| {
            let mut handles = vec![];

            for _ in 0..2 {
                let pool_clone = Arc::clone(&pool);
                handles.push(thread::spawn(move || {
                    for i in 0..100 {
                        if let Ok(handle) = pool_clone.allocate(black_box(i)) {
                            black_box(&handle);
                        }
                    }
                }));
            }

            for handle in handles {
                handle.join().unwrap();
            }
        });
    });

    group.finish();
}

fn bench_thread_local_pool(c: &mut Criterion) {
    let mut group = c.benchmark_group("thread_local_pool");

    group.bench_function("single_thread", |b| {
        use fastalloc::ThreadLocalPool;

        let pool = ThreadLocalPool::<i32>::new(1000).unwrap();

        b.iter(|| {
            for i in 0..100 {
                if let Ok(handle) = pool.allocate(black_box(i)) {
                    black_box(handle);
                }
            }
        });
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_thread_safe_pool,
    bench_contention,
    bench_thread_local_pool
);
criterion_main!(benches);