stack-allocator 0.1.1

A stack-based memory allocator with optional fallback to a global/secondary 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

#![cfg_attr(nightly, feature(allocator_api))]
#![allow(unused)]

use stack_allocator::HybridAllocator;
use std::sync::Arc;

const STACK_SIZE: usize = 8 * 1024;
const MAX_USIZE: usize = STACK_SIZE / std::mem::size_of::<usize>();

#[test]
#[cfg(nightly)]
fn vec_hybrid_test() {
    use std::alloc::Global;
    let hybrid_alloc: HybridAllocator<1024, Global> = HybridAllocator::<1024, _>::new(Global);
    let alloc = Arc::new(hybrid_alloc);
    let mut v = Vec::with_capacity_in(MAX_USIZE * 2, alloc.clone());
    for i in 0..(MAX_USIZE * 2) {
        v.push(i);
    }
    assert_eq!(v.len(), MAX_USIZE * 2);
    for (i, &val) in v.iter().enumerate() {
        assert_eq!(i, val);
    }
}

#[test]
#[cfg(not(nightly))]
fn hash_brown_test() {
    use allocator_api2::alloc::Global;
    let alloc: HybridAllocator<1024, Global> = HybridAllocator::<1024, _>::new(Global);
    let mut map = hashbrown::HashMap::new_in(alloc);
    for i in 0..MAX_USIZE {
        map.insert(i, i);
    }
    assert_eq!(map.len(), MAX_USIZE);
    for i in 0..MAX_USIZE {
        assert_eq!(map.get(&i), Some(&i));
    }
    // move it to heap now
    let mut heap_map = hashbrown::HashMap::with_capacity(map.capacity());
    heap_map.extend(map.into_iter());
}