oxirs_vec/adaptive_intelligent_caching/
metrics.rs

1//! Performance metrics for the adaptive intelligent caching system
2
3use serde::{Deserialize, Serialize};
4use std::collections::{HashMap, VecDeque};
5use std::sync::atomic::{AtomicU64, Ordering};
6
7use super::types::{HistoricalMetric, TierMetrics};
8
9/// Comprehensive cache performance metrics
10#[derive(Debug, Default)]
11pub struct CachePerformanceMetrics {
12    /// Hit/miss statistics
13    pub hit_count: AtomicU64,
14    pub miss_count: AtomicU64,
15    pub total_requests: AtomicU64,
16
17    /// Latency statistics
18    pub avg_hit_latency_ns: AtomicU64,
19    pub avg_miss_latency_ns: AtomicU64,
20    pub p99_latency_ns: AtomicU64,
21
22    /// Throughput metrics
23    pub requests_per_second: AtomicU64,
24    pub bytes_per_second: AtomicU64,
25
26    /// Cache efficiency
27    pub cache_efficiency_score: f64,
28    pub memory_utilization: f64,
29    pub fragmentation_ratio: f64,
30
31    /// Detailed statistics by tier
32    pub tier_metrics: HashMap<u32, TierMetrics>,
33
34    /// Time-series data for trend analysis
35    pub historical_metrics: VecDeque<HistoricalMetric>,
36}
37
38impl Clone for CachePerformanceMetrics {
39    fn clone(&self) -> Self {
40        Self {
41            hit_count: AtomicU64::new(self.hit_count.load(Ordering::SeqCst)),
42            miss_count: AtomicU64::new(self.miss_count.load(Ordering::SeqCst)),
43            total_requests: AtomicU64::new(self.total_requests.load(Ordering::SeqCst)),
44            avg_hit_latency_ns: AtomicU64::new(self.avg_hit_latency_ns.load(Ordering::SeqCst)),
45            avg_miss_latency_ns: AtomicU64::new(self.avg_miss_latency_ns.load(Ordering::SeqCst)),
46            p99_latency_ns: AtomicU64::new(self.p99_latency_ns.load(Ordering::SeqCst)),
47            requests_per_second: AtomicU64::new(self.requests_per_second.load(Ordering::SeqCst)),
48            bytes_per_second: AtomicU64::new(self.bytes_per_second.load(Ordering::SeqCst)),
49            cache_efficiency_score: self.cache_efficiency_score,
50            memory_utilization: self.memory_utilization,
51            fragmentation_ratio: self.fragmentation_ratio,
52            tier_metrics: self.tier_metrics.clone(),
53            historical_metrics: self.historical_metrics.clone(),
54        }
55    }
56}
57
58impl Serialize for CachePerformanceMetrics {
59    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60    where
61        S: serde::Serializer,
62    {
63        use serde::ser::SerializeStruct;
64        let mut state = serializer.serialize_struct("CachePerformanceMetrics", 11)?;
65        state.serialize_field("hit_count", &self.hit_count.load(Ordering::SeqCst))?;
66        state.serialize_field("miss_count", &self.miss_count.load(Ordering::SeqCst))?;
67        state.serialize_field(
68            "total_requests",
69            &self.total_requests.load(Ordering::SeqCst),
70        )?;
71        state.serialize_field(
72            "avg_hit_latency_ns",
73            &self.avg_hit_latency_ns.load(Ordering::SeqCst),
74        )?;
75        state.serialize_field(
76            "avg_miss_latency_ns",
77            &self.avg_miss_latency_ns.load(Ordering::SeqCst),
78        )?;
79        state.serialize_field(
80            "p99_latency_ns",
81            &self.p99_latency_ns.load(Ordering::SeqCst),
82        )?;
83        state.serialize_field(
84            "requests_per_second",
85            &self.requests_per_second.load(Ordering::SeqCst),
86        )?;
87        state.serialize_field(
88            "bytes_per_second",
89            &self.bytes_per_second.load(Ordering::SeqCst),
90        )?;
91        state.serialize_field("cache_efficiency_score", &self.cache_efficiency_score)?;
92        state.serialize_field("memory_utilization", &self.memory_utilization)?;
93        state.serialize_field("fragmentation_ratio", &self.fragmentation_ratio)?;
94        state.serialize_field("tier_metrics", &self.tier_metrics)?;
95        state.serialize_field("historical_metrics", &self.historical_metrics)?;
96        state.end()
97    }
98}
99
100impl<'de> Deserialize<'de> for CachePerformanceMetrics {
101    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
102    where
103        D: serde::Deserializer<'de>,
104    {
105        use serde::de::{self, MapAccess, Visitor};
106        use std::fmt;
107
108        #[derive(Deserialize)]
109        #[serde(field_identifier, rename_all = "snake_case")]
110        enum Field {
111            HitCount,
112            MissCount,
113            TotalRequests,
114            AvgHitLatencyNs,
115            AvgMissLatencyNs,
116            P99LatencyNs,
117            RequestsPerSecond,
118            BytesPerSecond,
119            CacheEfficiencyScore,
120            MemoryUtilization,
121            FragmentationRatio,
122            TierMetrics,
123            HistoricalMetrics,
124        }
125
126        struct CachePerformanceMetricsVisitor;
127
128        impl<'de> Visitor<'de> for CachePerformanceMetricsVisitor {
129            type Value = CachePerformanceMetrics;
130
131            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
132                formatter.write_str("struct CachePerformanceMetrics")
133            }
134
135            fn visit_map<V>(self, mut map: V) -> Result<CachePerformanceMetrics, V::Error>
136            where
137                V: MapAccess<'de>,
138            {
139                let mut hit_count = None;
140                let mut miss_count = None;
141                let mut total_requests = None;
142                let mut avg_hit_latency_ns = None;
143                let mut avg_miss_latency_ns = None;
144                let mut p99_latency_ns = None;
145                let mut requests_per_second = None;
146                let mut bytes_per_second = None;
147                let mut cache_efficiency_score = None;
148                let mut memory_utilization = None;
149                let mut fragmentation_ratio = None;
150                let mut tier_metrics = None;
151                let mut historical_metrics = None;
152
153                while let Some(key) = map.next_key()? {
154                    match key {
155                        Field::HitCount => {
156                            if hit_count.is_some() {
157                                return Err(de::Error::duplicate_field("hit_count"));
158                            }
159                            hit_count = Some(map.next_value::<u64>()?);
160                        }
161                        Field::MissCount => {
162                            if miss_count.is_some() {
163                                return Err(de::Error::duplicate_field("miss_count"));
164                            }
165                            miss_count = Some(map.next_value::<u64>()?);
166                        }
167                        Field::TotalRequests => {
168                            if total_requests.is_some() {
169                                return Err(de::Error::duplicate_field("total_requests"));
170                            }
171                            total_requests = Some(map.next_value::<u64>()?);
172                        }
173                        Field::AvgHitLatencyNs => {
174                            if avg_hit_latency_ns.is_some() {
175                                return Err(de::Error::duplicate_field("avg_hit_latency_ns"));
176                            }
177                            avg_hit_latency_ns = Some(map.next_value::<u64>()?);
178                        }
179                        Field::AvgMissLatencyNs => {
180                            if avg_miss_latency_ns.is_some() {
181                                return Err(de::Error::duplicate_field("avg_miss_latency_ns"));
182                            }
183                            avg_miss_latency_ns = Some(map.next_value::<u64>()?);
184                        }
185                        Field::P99LatencyNs => {
186                            if p99_latency_ns.is_some() {
187                                return Err(de::Error::duplicate_field("p99_latency_ns"));
188                            }
189                            p99_latency_ns = Some(map.next_value::<u64>()?);
190                        }
191                        Field::RequestsPerSecond => {
192                            if requests_per_second.is_some() {
193                                return Err(de::Error::duplicate_field("requests_per_second"));
194                            }
195                            requests_per_second = Some(map.next_value::<u64>()?);
196                        }
197                        Field::BytesPerSecond => {
198                            if bytes_per_second.is_some() {
199                                return Err(de::Error::duplicate_field("bytes_per_second"));
200                            }
201                            bytes_per_second = Some(map.next_value::<u64>()?);
202                        }
203                        Field::CacheEfficiencyScore => {
204                            if cache_efficiency_score.is_some() {
205                                return Err(de::Error::duplicate_field("cache_efficiency_score"));
206                            }
207                            cache_efficiency_score = Some(map.next_value()?);
208                        }
209                        Field::MemoryUtilization => {
210                            if memory_utilization.is_some() {
211                                return Err(de::Error::duplicate_field("memory_utilization"));
212                            }
213                            memory_utilization = Some(map.next_value()?);
214                        }
215                        Field::FragmentationRatio => {
216                            if fragmentation_ratio.is_some() {
217                                return Err(de::Error::duplicate_field("fragmentation_ratio"));
218                            }
219                            fragmentation_ratio = Some(map.next_value()?);
220                        }
221                        Field::TierMetrics => {
222                            if tier_metrics.is_some() {
223                                return Err(de::Error::duplicate_field("tier_metrics"));
224                            }
225                            tier_metrics = Some(map.next_value()?);
226                        }
227                        Field::HistoricalMetrics => {
228                            if historical_metrics.is_some() {
229                                return Err(de::Error::duplicate_field("historical_metrics"));
230                            }
231                            historical_metrics = Some(map.next_value()?);
232                        }
233                    }
234                }
235
236                Ok(CachePerformanceMetrics {
237                    hit_count: AtomicU64::new(hit_count.unwrap_or(0)),
238                    miss_count: AtomicU64::new(miss_count.unwrap_or(0)),
239                    total_requests: AtomicU64::new(total_requests.unwrap_or(0)),
240                    avg_hit_latency_ns: AtomicU64::new(avg_hit_latency_ns.unwrap_or(0)),
241                    avg_miss_latency_ns: AtomicU64::new(avg_miss_latency_ns.unwrap_or(0)),
242                    p99_latency_ns: AtomicU64::new(p99_latency_ns.unwrap_or(0)),
243                    requests_per_second: AtomicU64::new(requests_per_second.unwrap_or(0)),
244                    bytes_per_second: AtomicU64::new(bytes_per_second.unwrap_or(0)),
245                    cache_efficiency_score: cache_efficiency_score.unwrap_or(0.0),
246                    memory_utilization: memory_utilization.unwrap_or(0.0),
247                    fragmentation_ratio: fragmentation_ratio.unwrap_or(0.0),
248                    tier_metrics: tier_metrics.unwrap_or_default(),
249                    historical_metrics: historical_metrics.unwrap_or_default(),
250                })
251            }
252        }
253
254        deserializer.deserialize_struct(
255            "CachePerformanceMetrics",
256            &[
257                "hit_count",
258                "miss_count",
259                "total_requests",
260                "avg_hit_latency_ns",
261                "avg_miss_latency_ns",
262                "p99_latency_ns",
263                "requests_per_second",
264                "bytes_per_second",
265                "cache_efficiency_score",
266                "memory_utilization",
267                "fragmentation_ratio",
268                "tier_metrics",
269                "historical_metrics",
270            ],
271            CachePerformanceMetricsVisitor,
272        )
273    }
274}
oxirs_vec/adaptive_intelligent_caching/metrics.rs

oxirs_vec/adaptive_intelligent_caching/
metrics.rs
