20260605 移除audit rule index和DB trace

src/ccr/accumulator.rs

@@ -26,6 +26,21 @@ pub struct CcrManifestContribution {
     pub subordinate_skis: Vec<Vec<u8>>,
 }
 
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct CcrAccumulatorMemoryStats {
+    pub trust_anchor_count: u64,
+    pub manifest_count: u64,
+    pub estimated_heap_bytes: u64,
+    pub string_bytes: u64,
+    pub string_capacity_bytes: u64,
+    pub vec_payload_bytes: u64,
+    pub vec_capacity_bytes: u64,
+    pub locations_der_count: u64,
+    pub subordinate_ski_count: u64,
+    pub btree_key_capacity_bytes: u64,
+    pub btree_entry_shallow_bytes: u64,
+}
+
 impl CcrManifestContribution {
     fn from_projection(projection: &VcirCcrManifestProjection) -> Result<Self, String> {
         let this_update = projection
@@ -57,6 +72,36 @@ impl CcrManifestContribution {
             subordinates: self.subordinate_skis.clone(),
         }
     }
+
+    fn add_memory_stats(&self, stats: &mut CcrAccumulatorMemoryStats) {
+        stats.string_bytes += self.manifest_rsync_uri.len() as u64;
+        stats.string_capacity_bytes += self.manifest_rsync_uri.capacity() as u64;
+        stats.estimated_heap_bytes += self.manifest_rsync_uri.capacity() as u64;
+
+        add_vec_stats(&self.hash, stats);
+        add_vec_stats(&self.aki, stats);
+        add_vec_stats(&self.manifest_number_be, stats);
+        add_vec_of_vec_stats(&self.locations_der, stats);
+        add_vec_of_vec_stats(&self.subordinate_skis, stats);
+        stats.locations_der_count += self.locations_der.len() as u64;
+        stats.subordinate_ski_count += self.subordinate_skis.len() as u64;
+    }
+}
+
+fn add_vec_stats(value: &Vec<u8>, stats: &mut CcrAccumulatorMemoryStats) {
+    stats.vec_payload_bytes += value.len() as u64;
+    stats.vec_capacity_bytes += value.capacity() as u64;
+    stats.estimated_heap_bytes += value.capacity() as u64;
+}
+
+fn add_vec_of_vec_stats(values: &Vec<Vec<u8>>, stats: &mut CcrAccumulatorMemoryStats) {
+    let outer_capacity = values.capacity() * std::mem::size_of::<Vec<u8>>();
+    stats.vec_payload_bytes += (values.len() * std::mem::size_of::<Vec<u8>>()) as u64;
+    stats.vec_capacity_bytes += outer_capacity as u64;
+    stats.estimated_heap_bytes += outer_capacity as u64;
+    for value in values {
+        add_vec_stats(value, stats);
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -138,6 +183,61 @@ impl CcrAccumulator {
     pub fn manifest_count(&self) -> usize {
         self.manifests_by_hash.len()
     }
+
+    pub fn memory_stats(&self) -> CcrAccumulatorMemoryStats {
+        let mut stats = CcrAccumulatorMemoryStats {
+            trust_anchor_count: self.trust_anchors.len() as u64,
+            manifest_count: self.manifests_by_hash.len() as u64,
+            ..CcrAccumulatorMemoryStats::default()
+        };
+        stats.estimated_heap_bytes +=
+            (self.trust_anchors.capacity() * std::mem::size_of::<TrustAnchor>()) as u64;
+        for trust_anchor in &self.trust_anchors {
+            add_vec_stats(&trust_anchor.tal.raw, &mut stats);
+            add_vec_of_string_stats(&trust_anchor.tal.comments, &mut stats);
+            stats.vec_payload_bytes +=
+                (trust_anchor.tal.ta_uris.len() * std::mem::size_of::<url::Url>()) as u64;
+            stats.vec_capacity_bytes +=
+                (trust_anchor.tal.ta_uris.capacity() * std::mem::size_of::<url::Url>()) as u64;
+            stats.estimated_heap_bytes +=
+                (trust_anchor.tal.ta_uris.capacity() * std::mem::size_of::<url::Url>()) as u64;
+            for uri in &trust_anchor.tal.ta_uris {
+                stats.string_bytes += uri.as_str().len() as u64;
+                stats.string_capacity_bytes += uri.as_str().len() as u64;
+                stats.estimated_heap_bytes += uri.as_str().len() as u64;
+            }
+            add_vec_stats(&trust_anchor.tal.subject_public_key_info_der, &mut stats);
+            add_vec_stats(&trust_anchor.ta_certificate.raw_der, &mut stats);
+            if let Some(uri) = &trust_anchor.resolved_ta_uri {
+                stats.string_bytes += uri.as_str().len() as u64;
+                stats.string_capacity_bytes += uri.as_str().len() as u64;
+                stats.estimated_heap_bytes += uri.as_str().len() as u64;
+            }
+        }
+
+        stats.btree_entry_shallow_bytes = (self.manifests_by_hash.len()
+            * (std::mem::size_of::<Vec<u8>>() + std::mem::size_of::<CcrManifestContribution>()))
+            as u64;
+        stats.estimated_heap_bytes += stats.btree_entry_shallow_bytes;
+        for (key, contribution) in &self.manifests_by_hash {
+            stats.btree_key_capacity_bytes += key.capacity() as u64;
+            stats.estimated_heap_bytes += key.capacity() as u64;
+            contribution.add_memory_stats(&mut stats);
+        }
+        stats
+    }
+}
+
+fn add_vec_of_string_stats(values: &Vec<String>, stats: &mut CcrAccumulatorMemoryStats) {
+    let outer_capacity = values.capacity() * std::mem::size_of::<String>();
+    stats.vec_payload_bytes += (values.len() * std::mem::size_of::<String>()) as u64;
+    stats.vec_capacity_bytes += outer_capacity as u64;
+    stats.estimated_heap_bytes += outer_capacity as u64;
+    for value in values {
+        stats.string_bytes += value.len() as u64;
+        stats.string_capacity_bytes += value.capacity() as u64;
+        stats.estimated_heap_bytes += value.capacity() as u64;
+    }
 }
 
 #[cfg(test)]