562 lines
16 KiB
Rust
562 lines
16 KiB
Rust
///! 状态分片优化模块
|
||
///!
|
||
///! 优化分片状态存储和访问性能
|
||
///!
|
||
///! **NAC原生设计原则**：
|
||
///! - 使用Asset（资产），不是Token
|
||
///! - 使用Certificate（证书），不是Contract
|
||
///! - 使用SHA3-384哈希，不是SHA256/Keccak256
|
||
///! - 通过CBPP共识协调
|
||
|
||
use crate::primitives::{Address, Hash};
|
||
use std::collections::HashMap;
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// 状态分片优化器
|
||
#[derive(Debug, Clone)]
|
||
/// StateShardOptimizer
|
||
pub struct StateShardOptimizer {
|
||
/// 分片ID
|
||
shard_id: u64,
|
||
/// 状态缓存
|
||
state_cache: HashMap<Hash, StateEntry>,
|
||
/// 热点账户追踪
|
||
hot_accounts: HashMap<Address, HotAccountStats>,
|
||
/// 冷数据归档阈值（秒）
|
||
cold_threshold: u64,
|
||
/// 缓存大小限制（字节）
|
||
max_cache_size: u64,
|
||
/// 当前缓存大小
|
||
current_cache_size: u64,
|
||
/// 优化统计
|
||
stats: OptimizationStats,
|
||
}
|
||
|
||
/// 状态条目
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// StateEntry
|
||
pub struct StateEntry {
|
||
/// 状态键
|
||
pub key: Hash,
|
||
/// 状态值
|
||
pub value: Vec<u8>,
|
||
/// 最后访问时间
|
||
pub last_access: u64,
|
||
/// 访问次数
|
||
pub access_count: u64,
|
||
/// 是否为热点数据
|
||
pub is_hot: bool,
|
||
/// 数据大小（字节）
|
||
pub size: u64,
|
||
}
|
||
|
||
impl StateEntry {
|
||
/// 创建新的状态条目
|
||
pub fn new(key: Hash, value: Vec<u8>, timestamp: u64) -> Self {
|
||
let size = value.len() as u64;
|
||
Self {
|
||
key,
|
||
value,
|
||
last_access: timestamp,
|
||
access_count: 1,
|
||
is_hot: false,
|
||
size,
|
||
}
|
||
}
|
||
|
||
/// 更新访问信息
|
||
pub fn update_access(&mut self, timestamp: u64) {
|
||
self.last_access = timestamp;
|
||
self.access_count += 1;
|
||
|
||
// 访问次数超过阈值标记为热点
|
||
if self.access_count > 100 {
|
||
self.is_hot = true;
|
||
}
|
||
}
|
||
|
||
/// 检查是否为冷数据
|
||
pub fn is_cold(&self, current_time: u64, threshold: u64) -> bool {
|
||
current_time - self.last_access > threshold
|
||
}
|
||
}
|
||
|
||
/// 热点账户统计
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// HotAccountStats
|
||
pub struct HotAccountStats {
|
||
/// 账户地址
|
||
pub address: Address,
|
||
/// 读取次数
|
||
pub read_count: u64,
|
||
/// 写入次数
|
||
pub write_count: u64,
|
||
/// 最后活动时间
|
||
pub last_activity: u64,
|
||
/// 平均交易大小
|
||
pub avg_tx_size: u64,
|
||
/// 是否为高频账户
|
||
pub is_high_frequency: bool,
|
||
}
|
||
|
||
impl HotAccountStats {
|
||
/// 创建新的热点账户统计
|
||
pub fn new(address: Address, timestamp: u64) -> Self {
|
||
Self {
|
||
address,
|
||
read_count: 0,
|
||
write_count: 0,
|
||
last_activity: timestamp,
|
||
avg_tx_size: 0,
|
||
is_high_frequency: false,
|
||
}
|
||
}
|
||
|
||
/// 记录读取操作
|
||
pub fn record_read(&mut self, timestamp: u64) {
|
||
self.read_count += 1;
|
||
self.last_activity = timestamp;
|
||
self.update_frequency();
|
||
}
|
||
|
||
/// 记录写入操作
|
||
pub fn record_write(&mut self, timestamp: u64, tx_size: u64) {
|
||
self.write_count += 1;
|
||
self.last_activity = timestamp;
|
||
|
||
// 更新平均交易大小
|
||
let total_count = self.read_count + self.write_count;
|
||
self.avg_tx_size = (self.avg_tx_size * (total_count - 1) + tx_size) / total_count;
|
||
|
||
self.update_frequency();
|
||
}
|
||
|
||
/// 更新频率标记
|
||
fn update_frequency(&mut self) {
|
||
// 读写总次数超过1000标记为高频
|
||
if self.read_count + self.write_count > 1000 {
|
||
self.is_high_frequency = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 优化统计
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
/// OptimizationStats
|
||
pub struct OptimizationStats {
|
||
/// 缓存命中次数
|
||
pub cache_hits: u64,
|
||
/// 缓存未命中次数
|
||
pub cache_misses: u64,
|
||
/// 冷数据归档次数
|
||
pub cold_data_archived: u64,
|
||
/// 热点数据提升次数
|
||
pub hot_data_promoted: u64,
|
||
/// 缓存驱逐次数
|
||
pub cache_evictions: u64,
|
||
/// 总状态访问次数
|
||
pub total_accesses: u64,
|
||
}
|
||
|
||
impl OptimizationStats {
|
||
/// 计算缓存命中率
|
||
pub fn cache_hit_rate(&self) -> f64 {
|
||
if self.total_accesses == 0 {
|
||
return 0.0;
|
||
}
|
||
self.cache_hits as f64 / self.total_accesses as f64
|
||
}
|
||
}
|
||
|
||
impl StateShardOptimizer {
|
||
/// 创建新的状态分片优化器
|
||
pub fn new(shard_id: u64, cold_threshold: u64, max_cache_size: u64) -> Self {
|
||
Self {
|
||
shard_id,
|
||
state_cache: HashMap::new(),
|
||
hot_accounts: HashMap::new(),
|
||
cold_threshold,
|
||
max_cache_size,
|
||
current_cache_size: 0,
|
||
stats: OptimizationStats::default(),
|
||
}
|
||
}
|
||
|
||
/// 读取状态
|
||
pub fn read_state(&mut self, key: &Hash, current_time: u64) -> Option<Vec<u8>> {
|
||
self.stats.total_accesses += 1;
|
||
|
||
if let Some(entry) = self.state_cache.get_mut(key) {
|
||
// 缓存命中
|
||
self.stats.cache_hits += 1;
|
||
entry.update_access(current_time);
|
||
Some(entry.value.clone())
|
||
} else {
|
||
// 缓存未命中
|
||
self.stats.cache_misses += 1;
|
||
None
|
||
}
|
||
}
|
||
|
||
/// 写入状态
|
||
pub fn write_state(&mut self, key: Hash, value: Vec<u8>, current_time: u64) -> Result<(), String> {
|
||
let entry_size = value.len() as u64;
|
||
|
||
// 检查缓存大小限制
|
||
if self.current_cache_size + entry_size > self.max_cache_size {
|
||
// 驱逐冷数据
|
||
self.evict_cold_data(current_time)?;
|
||
}
|
||
|
||
// 创建或更新状态条目
|
||
if let Some(existing) = self.state_cache.get_mut(&key) {
|
||
self.current_cache_size -= existing.size;
|
||
existing.value = value;
|
||
existing.size = entry_size;
|
||
existing.update_access(current_time);
|
||
self.current_cache_size += entry_size;
|
||
} else {
|
||
let entry = StateEntry::new(key.clone(), value, current_time);
|
||
self.state_cache.insert(key, entry);
|
||
self.current_cache_size += entry_size;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 驱逐冷数据
|
||
pub fn evict_cold_data(&mut self, current_time: u64) -> Result<(), String> {
|
||
let mut cold_keys = Vec::new();
|
||
|
||
// 查找冷数据
|
||
for (key, entry) in &self.state_cache {
|
||
if entry.is_cold(current_time, self.cold_threshold) && !entry.is_hot {
|
||
cold_keys.push(key.clone());
|
||
}
|
||
}
|
||
|
||
if cold_keys.is_empty() {
|
||
return Err("No cold data to evict".to_string());
|
||
}
|
||
|
||
// 驱逐冷数据
|
||
for key in cold_keys {
|
||
if let Some(entry) = self.state_cache.remove(&key) {
|
||
self.current_cache_size -= entry.size;
|
||
self.stats.cache_evictions += 1;
|
||
self.stats.cold_data_archived += 1;
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 提升热点数据
|
||
pub fn promote_hot_data(&mut self, key: &Hash) -> Result<(), String> {
|
||
if let Some(entry) = self.state_cache.get_mut(key) {
|
||
if !entry.is_hot {
|
||
entry.is_hot = true;
|
||
self.stats.hot_data_promoted += 1;
|
||
}
|
||
Ok(())
|
||
} else {
|
||
Err("State entry not found".to_string())
|
||
}
|
||
}
|
||
|
||
/// 记录账户活动
|
||
pub fn record_account_activity(
|
||
&mut self,
|
||
address: Address,
|
||
is_write: bool,
|
||
tx_size: u64,
|
||
timestamp: u64,
|
||
) {
|
||
let stats = self.hot_accounts
|
||
.entry(address.clone())
|
||
.or_insert_with(|| HotAccountStats::new(address, timestamp));
|
||
|
||
if is_write {
|
||
stats.record_write(timestamp, tx_size);
|
||
} else {
|
||
stats.record_read(timestamp);
|
||
}
|
||
}
|
||
|
||
/// 获取热点账户列表
|
||
pub fn get_hot_accounts(&self) -> Vec<Address> {
|
||
self.hot_accounts
|
||
.values()
|
||
.filter(|stats| stats.is_high_frequency)
|
||
.map(|stats| stats.address.clone())
|
||
.collect()
|
||
}
|
||
|
||
/// 获取优化统计
|
||
pub fn get_stats(&self) -> OptimizationStats {
|
||
self.stats.clone()
|
||
}
|
||
|
||
/// 获取缓存使用率
|
||
pub fn get_cache_usage(&self) -> f64 {
|
||
if self.max_cache_size == 0 {
|
||
return 0.0;
|
||
}
|
||
self.current_cache_size as f64 / self.max_cache_size as f64
|
||
}
|
||
|
||
/// 清理过期数据
|
||
pub fn cleanup_expired(&mut self, current_time: u64) -> usize {
|
||
let mut expired_keys = Vec::new();
|
||
|
||
// 查找过期数据（超过冷数据阈值的2倍）
|
||
let expiry_threshold = self.cold_threshold * 2;
|
||
for (key, entry) in &self.state_cache {
|
||
if current_time - entry.last_access > expiry_threshold {
|
||
expired_keys.push(key.clone());
|
||
}
|
||
}
|
||
|
||
let count = expired_keys.len();
|
||
|
||
// 删除过期数据
|
||
for key in expired_keys {
|
||
if let Some(entry) = self.state_cache.remove(&key) {
|
||
self.current_cache_size -= entry.size;
|
||
}
|
||
}
|
||
|
||
count
|
||
}
|
||
|
||
/// 优化分片状态
|
||
pub fn optimize(&mut self, current_time: u64) -> Result<OptimizationReport, String> {
|
||
let initial_cache_size = self.current_cache_size;
|
||
let initial_entry_count = self.state_cache.len();
|
||
|
||
// 1. 清理过期数据
|
||
let expired_count = self.cleanup_expired(current_time);
|
||
|
||
// 2. 驱逐冷数据（如果缓存使用率超过80%）
|
||
let evicted_count = if self.get_cache_usage() > 0.8 {
|
||
let before = self.state_cache.len();
|
||
self.evict_cold_data(current_time)?;
|
||
before - self.state_cache.len()
|
||
} else {
|
||
0
|
||
};
|
||
|
||
// 3. 提升热点数据
|
||
let hot_keys: Vec<Hash> = self.state_cache
|
||
.iter()
|
||
.filter(|(_, entry)| entry.access_count > 50 && !entry.is_hot)
|
||
.map(|(key, _)| key.clone())
|
||
.collect();
|
||
|
||
for key in &hot_keys {
|
||
let _ = self.promote_hot_data(key);
|
||
}
|
||
|
||
Ok(OptimizationReport {
|
||
shard_id: self.shard_id,
|
||
expired_count,
|
||
evicted_count,
|
||
promoted_count: hot_keys.len(),
|
||
space_freed: initial_cache_size - self.current_cache_size,
|
||
entries_before: initial_entry_count,
|
||
entries_after: self.state_cache.len(),
|
||
cache_hit_rate: self.stats.cache_hit_rate(),
|
||
})
|
||
}
|
||
}
|
||
|
||
/// 优化报告
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// OptimizationReport
|
||
pub struct OptimizationReport {
|
||
/// 分片ID
|
||
pub shard_id: u64,
|
||
/// 清理的过期数据数量
|
||
pub expired_count: usize,
|
||
/// 驱逐的冷数据数量
|
||
pub evicted_count: usize,
|
||
/// 提升的热点数据数量
|
||
pub promoted_count: usize,
|
||
/// 释放的空间（字节）
|
||
pub space_freed: u64,
|
||
/// 优化前条目数
|
||
pub entries_before: usize,
|
||
/// 优化后条目数
|
||
pub entries_after: usize,
|
||
/// 缓存命中率
|
||
pub cache_hit_rate: f64,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_state_entry_creation() {
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let value = vec![1, 2, 3, 4];
|
||
let entry = StateEntry::new(key, value.clone(), 1000);
|
||
|
||
assert_eq!(entry.value, value);
|
||
assert_eq!(entry.last_access, 1000);
|
||
assert_eq!(entry.access_count, 1);
|
||
assert!(!entry.is_hot);
|
||
assert_eq!(entry.size, 4);
|
||
}
|
||
|
||
#[test]
|
||
fn test_state_entry_hot_promotion() {
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let value = vec![1, 2, 3];
|
||
let mut entry = StateEntry::new(key, value, 1000);
|
||
|
||
// 访问101次应该变为热点
|
||
for i in 0..101 {
|
||
entry.update_access(1000 + i);
|
||
}
|
||
|
||
assert!(entry.is_hot);
|
||
assert_eq!(entry.access_count, 102); // 初始1次 + 101次
|
||
}
|
||
|
||
#[test]
|
||
fn test_state_entry_cold_detection() {
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let value = vec![1, 2, 3];
|
||
let entry = StateEntry::new(key, value, 1000);
|
||
|
||
// 在阈值内不是冷数据
|
||
assert!(!entry.is_cold(1500, 1000));
|
||
|
||
// 超过阈值是冷数据
|
||
assert!(entry.is_cold(2001, 1000));
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_read_write() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 3600, 1024 * 1024);
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let value = vec![1, 2, 3, 4];
|
||
|
||
// 写入状态
|
||
assert!(optimizer.write_state(key.clone(), value.clone(), 1000).is_ok());
|
||
|
||
// 读取状态
|
||
let read_value = optimizer.read_state(&key, 1001);
|
||
assert_eq!(read_value, Some(value));
|
||
|
||
// 验证统计
|
||
assert_eq!(optimizer.stats.cache_hits, 1);
|
||
assert_eq!(optimizer.stats.total_accesses, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_cache_miss() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 3600, 1024 * 1024);
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
|
||
// 读取不存在的状态
|
||
let result = optimizer.read_state(&key, 1000);
|
||
assert!(result.is_none());
|
||
|
||
// 验证统计
|
||
assert_eq!(optimizer.stats.cache_misses, 1);
|
||
assert_eq!(optimizer.stats.total_accesses, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_evict_cold_data() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 1000, 1024);
|
||
|
||
// 写入一些数据
|
||
for i in 0..5 {
|
||
let key = Hash::from_slice(&[i; 32]).unwrap();
|
||
let value = vec![i; 100];
|
||
optimizer.write_state(key, value, 1000 + i as u64).unwrap();
|
||
}
|
||
|
||
// 等待一段时间后驱逐冷数据
|
||
assert!(optimizer.evict_cold_data(3000).is_ok());
|
||
|
||
// 验证统计
|
||
assert!(optimizer.stats.cold_data_archived > 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_hot_account_tracking() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 3600, 1024 * 1024);
|
||
let address = Address::from_slice(&[1u8; 32]).unwrap();
|
||
|
||
// 记录大量活动
|
||
for i in 0..1001 {
|
||
optimizer.record_account_activity(address.clone(), i % 2 == 0, 100, 1000 + i);
|
||
}
|
||
|
||
// 验证热点账户
|
||
let hot_accounts = optimizer.get_hot_accounts();
|
||
assert_eq!(hot_accounts.len(), 1);
|
||
assert_eq!(hot_accounts[0], address);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_cache_usage() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 3600, 1000);
|
||
|
||
// 写入500字节数据
|
||
let key = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let value = vec![1u8; 500];
|
||
optimizer.write_state(key, value, 1000).unwrap();
|
||
|
||
// 验证缓存使用率
|
||
assert_eq!(optimizer.get_cache_usage(), 0.5);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_cleanup_expired() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 1000, 1024 * 1024);
|
||
|
||
// 写入一些数据
|
||
for i in 0..5 {
|
||
let key = Hash::from_slice(&[i; 32]).unwrap();
|
||
let value = vec![i; 10];
|
||
optimizer.write_state(key, value, 1000).unwrap();
|
||
}
|
||
|
||
// 清理过期数据（超过2000秒）
|
||
let expired = optimizer.cleanup_expired(4000);
|
||
assert_eq!(expired, 5);
|
||
}
|
||
|
||
#[test]
|
||
fn test_optimizer_full_optimization() {
|
||
let mut optimizer = StateShardOptimizer::new(1, 1000, 1024 * 1024);
|
||
|
||
// 写入一些数据
|
||
for i in 0..10 {
|
||
let key = Hash::from_slice(&[i; 32]).unwrap();
|
||
let value = vec![i; 100];
|
||
optimizer.write_state(key, value, 1000 + i as u64).unwrap();
|
||
}
|
||
|
||
// 访问部分数据使其成为热点（但不超过100次，避免自动标记为hot）
|
||
for i in 0..3 {
|
||
let key = Hash::from_slice(&[i; 32]).unwrap();
|
||
for _ in 0..50 {
|
||
optimizer.read_state(&key, 2000);
|
||
}
|
||
}
|
||
|
||
// 执行优化
|
||
let report = optimizer.optimize(4000).unwrap();
|
||
|
||
assert_eq!(report.shard_id, 1);
|
||
assert!(report.promoted_count > 0);
|
||
assert!(report.cache_hit_rate > 0.0);
|
||
}
|
||
}
|