moka 0.12.15

A fast and concurrent cache library inspired by Java Caffeine
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crossbeam_utils::atomic::AtomicCell;

#[derive(Clone, Debug)]
pub struct GlobalDebugCounters {
    pub bucket_array_creation_count: u64,
    pub bucket_array_allocation_bytes: u64,
    pub bucket_array_drop_count: u64,
    pub bucket_array_release_bytes: u64,
    pub bucket_creation_count: u64,
    pub bucket_drop_count: u64,
    pub value_entry_creation_count: u64,
    pub value_entry_drop_count: u64,
    pub entry_info_creation_count: u64,
    pub entry_info_drop_count: u64,
    pub deq_node_creation_count: u64,
    pub deq_node_drop_count: u64,
}

impl GlobalDebugCounters {
    pub fn current() -> Self {
        InternalGlobalDebugCounters::current()
    }
}

static COUNTERS: InternalGlobalDebugCounters = InternalGlobalDebugCounters {
    bucket_array_creation_count: AtomicCell::new(0),
    bucket_array_allocation_bytes: AtomicCell::new(0),
    bucket_array_drop_count: AtomicCell::new(0),
    bucket_array_release_bytes: AtomicCell::new(0),
    bucket_creation_count: AtomicCell::new(0),
    bucket_drop_count: AtomicCell::new(0),
    value_entry_creation_count: AtomicCell::new(0),
    value_entry_drop_count: AtomicCell::new(0),
    entry_info_creation_count: AtomicCell::new(0),
    entry_info_drop_count: AtomicCell::new(0),
    deq_node_creation_count: AtomicCell::new(0),
    deq_node_drop_count: AtomicCell::new(0),
};

#[derive(Default)]
pub(crate) struct InternalGlobalDebugCounters {
    bucket_array_creation_count: AtomicCell<u64>,
    bucket_array_allocation_bytes: AtomicCell<u64>,
    bucket_array_drop_count: AtomicCell<u64>,
    bucket_array_release_bytes: AtomicCell<u64>,
    bucket_creation_count: AtomicCell<u64>,
    bucket_drop_count: AtomicCell<u64>,
    value_entry_creation_count: AtomicCell<u64>,
    value_entry_drop_count: AtomicCell<u64>,
    entry_info_creation_count: AtomicCell<u64>,
    entry_info_drop_count: AtomicCell<u64>,
    deq_node_creation_count: AtomicCell<u64>,
    deq_node_drop_count: AtomicCell<u64>,
}

impl InternalGlobalDebugCounters {
    fn current() -> GlobalDebugCounters {
        let c = &COUNTERS;
        GlobalDebugCounters {
            bucket_array_creation_count: c.bucket_array_creation_count.load(),
            bucket_array_allocation_bytes: c.bucket_array_allocation_bytes.load(),
            bucket_array_drop_count: c.bucket_array_drop_count.load(),
            bucket_array_release_bytes: c.bucket_array_release_bytes.load(),
            bucket_creation_count: c.bucket_creation_count.load(),
            bucket_drop_count: c.bucket_drop_count.load(),
            value_entry_creation_count: c.value_entry_creation_count.load(),
            value_entry_drop_count: c.value_entry_drop_count.load(),
            entry_info_creation_count: c.entry_info_creation_count.load(),
            entry_info_drop_count: c.entry_info_drop_count.load(),
            deq_node_creation_count: c.deq_node_creation_count.load(),
            deq_node_drop_count: c.deq_node_drop_count.load(),
        }
    }

    pub(crate) fn bucket_array_created(byte_size: u64) {
        COUNTERS.bucket_array_creation_count.fetch_add(1);
        COUNTERS.bucket_array_allocation_bytes.fetch_add(byte_size);
    }

    pub(crate) fn bucket_array_dropped(byte_size: u64) {
        COUNTERS.bucket_array_drop_count.fetch_add(1);
        COUNTERS.bucket_array_release_bytes.fetch_add(byte_size);
    }

    pub(crate) fn bucket_created() {
        COUNTERS.bucket_creation_count.fetch_add(1);
    }

    pub(crate) fn bucket_dropped() {
        COUNTERS.bucket_drop_count.fetch_add(1);
    }

    pub(crate) fn value_entry_created() {
        COUNTERS.value_entry_creation_count.fetch_add(1);
    }

    pub(crate) fn value_entry_dropped() {
        COUNTERS.value_entry_drop_count.fetch_add(1);
    }

    pub(crate) fn entry_info_created() {
        COUNTERS.entry_info_creation_count.fetch_add(1);
    }

    pub(crate) fn entry_info_dropped() {
        COUNTERS.entry_info_drop_count.fetch_add(1);
    }

    pub(crate) fn deq_node_created() {
        COUNTERS.deq_node_creation_count.fetch_add(1);
    }

    pub(crate) fn deq_node_dropped() {
        COUNTERS.deq_node_drop_count.fetch_add(1);
    }
}

#[derive(Clone, Debug)]
pub struct CacheDebugStats {
    pub entry_count: u64,
    pub weighted_size: u64,
    // bytes
    pub freq_sketch_size: u64,
    // max entries
    pub hashmap_capacity: u64,
}

impl CacheDebugStats {
    pub(crate) fn new(
        entry_count: u64,
        weighted_size: u64,
        hashmap_capacity: u64,
        freq_sketch_size: u64,
    ) -> Self {
        Self {
            entry_count,
            weighted_size,
            freq_sketch_size,
            hashmap_capacity,
        }
    }
}