bitcoin-mem 0.1.19

traits for tracking dynamic and recursive memory usage
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

// ---------------- [ File: bitcoin-mem/src/dynamic_usage_std.rs ]
crate::ix!();

use core::hash::BuildHasher;
use std::collections::{HashMap as StdHashMap, HashSet as StdHashSet};

// -----------------------------------------------------------------------------
// NEW – std‑collections variants
//   The `bitcoin_imports::*` re‑exports use the hashbrown back‑end, which is a
//   *different* type from `std::collections`.  Our tests construct the standard
//   library containers directly, so we must implement `DynamicUsage` for them
//   as well.
// -----------------------------------------------------------------------------

impl<T, S> DynamicUsage for StdHashSet<T, S>
where
    S: BuildHasher,
{
    #[inline]
    fn dynamic_usage(&self) -> usize {
        let node_sz = core::mem::size_of::<StlTreeNode<T>>();
        let bytes   = self.len() * node_sz;
        trace!(
            "DynamicUsage<std::collections::HashSet<{}>> len={} node_sz={} bytes={}",
            core::any::type_name::<T>(),
            self.len(),
            node_sz,
            bytes
        );
        malloc_usage(bytes)
    }
}

impl<K, V, S> DynamicUsage for StdHashMap<K, V, S>
where
    S: BuildHasher,
{
    #[inline]
    fn dynamic_usage(&self) -> usize {
        let node_sz = core::mem::size_of::<StlTreeNode<(K, V)>>();
        let bytes   = self.len() * node_sz;
        trace!(
            "DynamicUsage<std::collections::HashMap<{}, {}>> len={} node_sz={} bytes={}",
            core::any::type_name::<K>(),
            core::any::type_name::<V>(),
            self.len(),
            node_sz,
            bytes
        );
        malloc_usage(bytes)
    }
}

// -----------------------------------------------------------------------------
// NEW – incremental allocation cost for the *standard‑library* hash containers.
// -----------------------------------------------------------------------------

impl<T, S> IncrementalDynamicUsage for StdHashSet<T, S>
where
    S: BuildHasher,
{
    #[inline]
    fn incremental_dynamic_usage(&self) -> usize {
        malloc_usage(core::mem::size_of::<StlTreeNode<T>>())
    }
}

impl<K, V, S> IncrementalDynamicUsage for StdHashMap<K, V, S>
where
    S: BuildHasher,
{
    #[inline]
    fn incremental_dynamic_usage(&self) -> usize {
        malloc_usage(core::mem::size_of::<StlTreeNode<(K, V)>>())
    }
}