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
use std::collections::BTreeMap;
use re_byte_size::SizeBytes as _;
use crate::{QueryCache, QueryCacheKey};
// ---
/// Stats for all primary caches.
///
/// Fetch them via [`QueryCache::stats`].
#[derive(Default, Debug, Clone)]
pub struct QueryCachesStats {
pub latest_at: BTreeMap<QueryCacheKey, QueryCacheStats>,
pub range: BTreeMap<QueryCacheKey, QueryCacheStats>,
}
impl QueryCachesStats {
#[inline]
pub fn total_size_bytes(&self) -> u64 {
re_tracing::profile_function!();
let Self { latest_at, range } = self;
let latest_at_size_bytes: u64 = latest_at
.values()
.map(|stats| stats.total_actual_size_bytes)
.sum();
let range_size_bytes: u64 = range
.values()
.map(|stats| stats.total_actual_size_bytes)
.sum();
latest_at_size_bytes + range_size_bytes
}
}
/// Stats for a single `crate::RangeCache`.
#[derive(Default, Debug, Clone)]
pub struct QueryCacheStats {
/// How many chunks in the cache?
pub total_chunks: u64,
/// What would be the size of this cache in the worst case, i.e. if all chunks had
/// been fully copied?
pub total_effective_size_bytes: u64,
/// What is the actual size of this cache after deduplication?
pub total_actual_size_bytes: u64,
}
impl QueryCache {
/// Computes the stats for all primary caches.
pub fn stats(&self) -> QueryCachesStats {
re_tracing::profile_function!();
let latest_at = {
let latest_at = self.latest_at_per_cache_key.read().clone();
// Implicitly releasing top-level cache mappings -- concurrent queries can run once again.
latest_at
.iter()
.map(|(key, cache)| {
let cache = cache.read();
(
key.clone(),
QueryCacheStats {
total_chunks: cache.per_query_time.len() as _,
total_effective_size_bytes: cache
.per_query_time
.values()
.map(|cached| cached.unit.total_size_bytes())
.sum(),
total_actual_size_bytes: cache.per_query_time.total_size_bytes(),
},
)
})
.collect()
};
let range = {
let range = self.range_per_cache_key.read().clone();
// Implicitly releasing top-level cache mappings -- concurrent queries can run once again.
range
.iter()
.map(|(key, cache)| {
let cache = cache.read();
(
key.clone(),
QueryCacheStats {
total_chunks: cache.chunks.len() as _,
total_effective_size_bytes: cache
.chunks
.values()
.map(|cached| cached.chunk.total_size_bytes())
.sum(),
total_actual_size_bytes: cache.chunks.total_size_bytes(),
},
)
})
.collect()
};
QueryCachesStats { latest_at, range }
}
}