adze-stack-pool-core 0.1.0

Thread-local and reusable stack pool utilities for parser 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

use adze_stack_pool_core::{StackPool, get_thread_local_pool, init_thread_local_pool};

#[test]
fn new_pool_has_zero_stats() {
    let pool: StackPool<u32> = StackPool::new(4);
    let stats = pool.stats();
    assert_eq!(stats.total_allocations, 0);
    assert_eq!(stats.reuse_count, 0);
    assert_eq!(stats.pool_hits, 0);
    assert_eq!(stats.pool_misses, 0);
    assert_eq!(stats.max_pool_depth, 0);
}

#[test]
fn acquire_release_acquire_reuses() {
    let pool: StackPool<u32> = StackPool::new(4);
    let mut stack = pool.acquire();
    stack.push(1);
    stack.push(2);
    pool.release(stack);

    let reused = pool.acquire();
    assert!(reused.is_empty());
    assert_eq!(pool.stats().reuse_count, 1);
    assert_eq!(pool.stats().pool_hits, 1);
}

#[test]
fn acquire_with_capacity_finds_large_enough_stack() {
    let pool: StackPool<u32> = StackPool::new(4);
    let small = Vec::with_capacity(32);
    let large = Vec::with_capacity(512);
    pool.release(small);
    pool.release(large);

    let acquired = pool.acquire_with_capacity(256);
    assert!(acquired.capacity() >= 256);
    assert_eq!(pool.stats().pool_hits, 1);
}

#[test]
fn release_respects_max_pool_size() {
    let pool: StackPool<u32> = StackPool::new(2);
    pool.release(Vec::with_capacity(8));
    pool.release(Vec::with_capacity(8));
    pool.release(Vec::with_capacity(8)); // over limit
    assert_eq!(pool.stats().max_pool_depth, 2);
}

#[test]
fn release_rejects_oversized_stacks() {
    let pool: StackPool<u32> = StackPool::new(4);
    let big = vec![0u32; 5000];
    pool.release(big);
    assert_eq!(pool.stats().max_pool_depth, 0);
}

#[test]
fn clone_stack_preserves_contents() {
    let pool: StackPool<u32> = StackPool::new(4);
    let original = vec![10, 20, 30];
    let cloned = pool.clone_stack(&original);
    assert_eq!(cloned, vec![10, 20, 30]);
}

#[test]
fn clear_empties_pool() {
    let pool: StackPool<u32> = StackPool::new(4);
    let s = pool.acquire();
    pool.release(s);
    pool.clear();
    pool.reset_stats();

    let _ = pool.acquire();
    assert_eq!(pool.stats().pool_hits, 0);
    assert_eq!(pool.stats().pool_misses, 1);
}

#[test]
fn reset_stats_clears_all_counters() {
    let pool: StackPool<u32> = StackPool::new(4);
    let s = pool.acquire();
    pool.release(s);
    let _ = pool.acquire();

    pool.reset_stats();
    let stats = pool.stats();
    assert_eq!(stats.total_allocations, 0);
    assert_eq!(stats.reuse_count, 0);
    assert_eq!(stats.pool_hits, 0);
    assert_eq!(stats.pool_misses, 0);
    assert_eq!(stats.max_pool_depth, 0);
}

#[test]
fn debug_format_contains_pool_info() {
    let pool: StackPool<u32> = StackPool::new(4);
    let debug = format!("{pool:?}");
    assert!(debug.contains("StackPool"));
    assert!(debug.contains("max_pool_size"));
}

#[test]
fn thread_local_pool_initializes_and_works() {
    init_thread_local_pool(8);
    let pool = get_thread_local_pool();
    let stack = pool.acquire();
    assert_eq!(stack.capacity(), 256);
    pool.release(stack);

    let reused = pool.acquire();
    assert!(reused.is_empty());
    assert_eq!(pool.stats().reuse_count, 1);
}