alloc_cat 1.1.1

a simple allocator for small-to-tiny Wasm projects in rust
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

use core::fmt;

use crate::metrics::SizeInfo;


#[derive(Debug)]
pub struct SimpleAllocatorStats {
    pub regions: usize,
    pub total_words: usize,
    pub allocated_words: usize,
    pub unused_words: usize,     // free contiguous space unallocated
    pub fragment_words: usize,   // free words in bits & pieces
    pub fragments: usize,
}

impl fmt::Display for SimpleAllocatorStats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f, "SimpleAllocatorStats(regions={}, total_words={}, allocated_words={}, unused_words={}, \
            fragments={}, fragment_words={})",
            self.regions, self.total_words, self.allocated_words, self.unused_words,
            self.fragments, self.fragment_words,
        )
    }
}

impl SimpleAllocatorStats {
    pub(crate) fn add(&mut self, stats: SimpleAllocatorStats) {
        self.regions += stats.regions;
        self.total_words += stats.total_words;
        self.allocated_words += stats.allocated_words;
        self.unused_words += stats.unused_words;
        self.fragment_words += stats.fragment_words;
        self.fragments += stats.fragments;
    }
}


#[derive(Clone, Debug)]
pub struct AllocatorStats {
    // bytes:
    pub in_use: usize,
    pub high_water: usize,
    pub trip_high_water: usize,

    // track count of each allocation size:
    pub size_table: [SizeInfo; 257],
    // track count of each alignment request:
    pub align_table: [usize; 16],

    // these metrics only exist in wasm:
    pub regions: usize,
    pub total_words: usize,
    pub allocated_words: usize,
    pub unused_words: usize,        // free contiguous space unallocated
    pub fragment_words: usize,      // free words in bits & pieces
    pub fragments: usize,
    pub total_large_pages: usize,   // pages allocated to >32KB blocks
    pub unused_large_pages: usize,
    pub allocated_large_pages_words: usize,
    pub heap_start: usize,          // address of start of heap
}

impl fmt::Display for AllocatorStats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f, "AllocatorStats(regions={}, total_words={}, allocated_words={}, unused_words={}, \
            fragments={}, fragment_words={}, total_large={}, unused_large={}, large_words={}, heap_start={})",
            self.regions, self.total_words, self.allocated_words, self.unused_words,
            self.fragments, self.fragment_words, self.total_large_pages, self.unused_large_pages,
            self.allocated_large_pages_words, self.heap_start,
        )
    }
}

impl Default for AllocatorStats {
    fn default() -> AllocatorStats {
        AllocatorStats {
            in_use: 0,
            high_water: 0,
            trip_high_water: 0,
            size_table: [SizeInfo::default(); 257],
            align_table: [0; 16],
            regions: 0,
            total_words: 0,
            allocated_words: 0,
            unused_words: 0,
            fragment_words: 0,
            fragments: 0,
            total_large_pages: 0,
            unused_large_pages: 0,
            allocated_large_pages_words: 0,
            heap_start: 0,
        }
    }
}

impl AllocatorStats {
    pub(crate) fn from_simple_allocator_stats(stats: SimpleAllocatorStats) -> AllocatorStats {
        AllocatorStats {
            regions: stats.regions,
            total_words: stats.total_words,
            allocated_words: stats.allocated_words,
            unused_words: stats.unused_words,
            fragment_words: stats.fragment_words,
            fragments: stats.fragments,
            ..Default::default()
        }
    }
}


pub trait Statsable {
    fn get_stats(&self) -> AllocatorStats;
    fn reset_trip(&self);
}