html_translation_lib/storage/

memory_pool.rs

//! 内存池管理模块
//!
//! 提供对象池和内存优化功能，减少内存分配和GC压力

use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::borrow::Cow;

/// 字符串池，重用字符串对象
pub struct StringPool {
    /// 小字符串池 (<=64字符)
    small_strings: VecDeque<String>,
    /// 大字符串池 (>64字符)
    large_strings: VecDeque<String>,
    /// 最大池大小
    max_size: usize,
}

impl StringPool {
    /// 创建新的字符串池
    pub fn new(max_size: usize) -> Self {
        Self {
            small_strings: VecDeque::with_capacity(max_size / 2),
            large_strings: VecDeque::with_capacity(max_size / 2),
            max_size,
        }
    }
    
    /// 获取字符串（从池中取出或创建新的）
    pub fn acquire(&mut self, initial_capacity: usize) -> String {
        let pool = if initial_capacity <= 64 {
            &mut self.small_strings
        } else {
            &mut self.large_strings
        };
        
        if let Some(mut string) = pool.pop_front() {
            string.clear();
            if string.capacity() < initial_capacity {
                string.reserve(initial_capacity - string.capacity());
            }
            string
        } else {
            String::with_capacity(initial_capacity)
        }
    }
    
    /// 释放字符串回池中
    pub fn release(&mut self, string: String) {
        if string.capacity() == 0 {
            return;
        }
        
        let pool = if string.capacity() <= 64 {
            &mut self.small_strings
        } else {
            &mut self.large_strings
        };
        
        if pool.len() < self.max_size / 2 {
            pool.push_back(string);
        }
    }
    
    /// 清理池，释放过多的内存
    pub fn cleanup(&mut self) {
        let keep_size = self.max_size / 4;
        
        while self.small_strings.len() > keep_size {
            self.small_strings.pop_back();
        }
        
        while self.large_strings.len() > keep_size {
            self.large_strings.pop_back();
        }
    }
    
    /// 获取池状态信息
    pub fn stats(&self) -> PoolStats {
        PoolStats {
            small_pool_size: self.small_strings.len(),
            large_pool_size: self.large_strings.len(),
            total_capacity: self.small_strings.iter().map(|s| s.capacity()).sum::<usize>()
                + self.large_strings.iter().map(|s| s.capacity()).sum::<usize>(),
        }
    }
}

/// 向量池，重用Vec对象
pub struct VecPool<T> {
    pools: Vec<VecDeque<Vec<T>>>,
    max_size_per_pool: usize,
}

impl<T> VecPool<T> {
    /// 创建新的向量池
    pub fn new(max_size_per_pool: usize) -> Self {
        Self {
            pools: vec![
                VecDeque::new(), // 0-16 capacity
                VecDeque::new(), // 17-64 capacity  
                VecDeque::new(), // 65-256 capacity
                VecDeque::new(), // 257+ capacity
            ],
            max_size_per_pool,
        }
    }
    
    /// 获取向量
    pub fn acquire(&mut self, initial_capacity: usize) -> Vec<T> {
        let pool_index = self.capacity_to_pool_index(initial_capacity);
        
        if let Some(mut vec) = self.pools[pool_index].pop_front() {
            vec.clear();
            if vec.capacity() < initial_capacity {
                vec.reserve(initial_capacity - vec.capacity());
            }
            vec
        } else {
            Vec::with_capacity(initial_capacity)
        }
    }
    
    /// 释放向量回池中
    pub fn release(&mut self, vec: Vec<T>) {
        if vec.capacity() == 0 {
            return;
        }
        
        let pool_index = self.capacity_to_pool_index(vec.capacity());
        
        if self.pools[pool_index].len() < self.max_size_per_pool {
            self.pools[pool_index].push_back(vec);
        }
    }
    
    /// 将容量映射到池索引
    fn capacity_to_pool_index(&self, capacity: usize) -> usize {
        match capacity {
            0..=16 => 0,
            17..=64 => 1,
            65..=256 => 2,
            _ => 3,
        }
    }
    
    /// 清理所有池
    pub fn cleanup(&mut self) {
        let keep_size = self.max_size_per_pool / 4;
        
        for pool in &mut self.pools {
            while pool.len() > keep_size {
                pool.pop_back();
            }
        }
    }
}

/// 内存优化的文本项
#[derive(Debug, Clone)]
pub struct MemoryOptimizedTextItem<'a> {
    /// 使用Cow避免不必要的字符串分配
    pub text: Cow<'a, str>,
    /// 文本类型（使用&'static str减少内存使用）
    pub text_type: &'static str,
    /// 原始长度（用于统计）
    pub original_length: usize,
    /// 是否已翻译
    pub is_translated: bool,
}

impl<'a> MemoryOptimizedTextItem<'a> {
    /// 创建新的内存优化文本项
    pub fn new(text: impl Into<Cow<'a, str>>, text_type: &'static str) -> Self {
        let text = text.into();
        let original_length = text.len();
        
        Self {
            text,
            text_type,
            original_length,
            is_translated: false,
        }
    }
    
    /// 应用翻译（延迟克隆直到需要修改）
    pub fn apply_translation(&mut self, translation: String) {
        self.text = Cow::Owned(translation);
        self.is_translated = true;
    }
    
    /// 获取内存使用情况
    pub fn memory_usage(&self) -> usize {
        match &self.text {
            Cow::Borrowed(_) => 0, // 借用的字符串不占用额外内存
            Cow::Owned(s) => s.capacity() * std::mem::size_of::<u8>(),
        }
    }
}

/// 全局内存管理器
pub struct GlobalMemoryManager {
    string_pool: Arc<Mutex<StringPool>>,
    vec_pool: Arc<Mutex<VecPool<String>>>,
    /// 内存使用统计
    memory_stats: Arc<Mutex<MemoryStats>>,
}

impl GlobalMemoryManager {
    /// 创建全局内存管理器
    pub fn new() -> Self {
        Self {
            string_pool: Arc::new(Mutex::new(StringPool::new(1000))),
            vec_pool: Arc::new(Mutex::new(VecPool::new(100))),
            memory_stats: Arc::new(Mutex::new(MemoryStats::default())),
        }
    }
    
    /// 获取字符串
    pub fn acquire_string(&self, initial_capacity: usize) -> String {
        let mut pool = self.string_pool.lock().unwrap();
        let string = pool.acquire(initial_capacity);
        
        // 更新统计
        let mut stats = self.memory_stats.lock().unwrap();
        stats.strings_acquired += 1;
        stats.total_string_capacity += string.capacity();
        
        string
    }
    
    /// 释放字符串
    pub fn release_string(&self, string: String) {
        let capacity = string.capacity();
        
        let mut pool = self.string_pool.lock().unwrap();
        pool.release(string);
        
        // 更新统计
        let mut stats = self.memory_stats.lock().unwrap();
        stats.strings_released += 1;
        stats.total_string_capacity = stats.total_string_capacity.saturating_sub(capacity);
    }
    
    /// 获取向量
    pub fn acquire_vec(&self, initial_capacity: usize) -> Vec<String> {
        let mut pool = self.vec_pool.lock().unwrap();
        pool.acquire(initial_capacity)
    }
    
    /// 释放向量
    pub fn release_vec(&self, vec: Vec<String>) {
        let mut pool = self.vec_pool.lock().unwrap();
        pool.release(vec);
    }
    
    /// 执行清理操作
    pub fn cleanup(&self) {
        {
            let mut string_pool = self.string_pool.lock().unwrap();
            string_pool.cleanup();
        }
        
        {
            let mut vec_pool = self.vec_pool.lock().unwrap();
            vec_pool.cleanup();
        }
        
        // 重置统计
        let mut stats = self.memory_stats.lock().unwrap();
        *stats = MemoryStats::default();
    }
    
    /// 获取内存统计
    pub fn get_stats(&self) -> MemoryStats {
        self.memory_stats.lock().unwrap().clone()
    }
    
    /// 获取池统计
    pub fn get_pool_stats(&self) -> (PoolStats, usize) {
        let string_stats = {
            let pool = self.string_pool.lock().unwrap();
            pool.stats()
        };
        
        let vec_pools_len = {
            let pool = self.vec_pool.lock().unwrap();
            pool.pools.iter().map(|p| p.len()).sum()
        };
        
        (string_stats, vec_pools_len)
    }
}

impl Default for GlobalMemoryManager {
    fn default() -> Self {
        Self::new()
    }
}

/// 池统计信息
#[derive(Debug, Clone)]
pub struct PoolStats {
    pub small_pool_size: usize,
    pub large_pool_size: usize,
    pub total_capacity: usize,
}

/// 内存使用统计
#[derive(Debug, Clone, Default)]
pub struct MemoryStats {
    pub strings_acquired: usize,
    pub strings_released: usize,
    pub total_string_capacity: usize,
    pub peak_memory_usage: usize,
}

impl MemoryStats {
    /// 计算池效率（命中率）
    pub fn pool_hit_rate(&self) -> f64 {
        if self.strings_acquired == 0 {
            return 0.0;
        }
        self.strings_released as f64 / self.strings_acquired as f64
    }
    
    /// 更新峰值内存使用
    pub fn update_peak_usage(&mut self, current_usage: usize) {
        if current_usage > self.peak_memory_usage {
            self.peak_memory_usage = current_usage;
        }
    }
}

/// 内存优化的批处理器
pub struct MemoryOptimizedBatchProcessor {
    memory_manager: Arc<GlobalMemoryManager>,
    batch_size: usize,
    memory_threshold: usize, // 字节
}

impl MemoryOptimizedBatchProcessor {
    /// 创建新的批处理器
    pub fn new(memory_manager: Arc<GlobalMemoryManager>, batch_size: usize, memory_threshold: usize) -> Self {
        Self {
            memory_manager,
            batch_size,
            memory_threshold,
        }
    }
    
    /// 处理文本批次，自动管理内存
    pub fn process_texts<'a>(&self, texts: &'a [String]) -> Vec<MemoryOptimizedTextItem<'a>> {
        let items = self.memory_manager.acquire_vec(texts.len());
        let mut results = Vec::with_capacity(texts.len());
        
        for (i, text) in texts.iter().enumerate() {
            // 使用Cow借用原始字符串，避免复制
            let item = MemoryOptimizedTextItem::new(
                Cow::Borrowed(text.as_str()),
                "content"
            );
            results.push(item);
            
            // 每处理一定数量的项目后检查内存使用
            if i % 100 == 0 {
                let current_memory = self.estimate_memory_usage(&results);
                if current_memory > self.memory_threshold {
                    // 触发清理
                    self.memory_manager.cleanup();
                }
            }
        }
        
        // 释放工作向量
        self.memory_manager.release_vec(items);
        
        results
    }
    
    /// 估算当前内存使用
    fn estimate_memory_usage(&self, items: &[MemoryOptimizedTextItem<'_>]) -> usize {
        items.iter().map(|item| item.memory_usage()).sum::<usize>()
            + items.len() * std::mem::size_of::<MemoryOptimizedTextItem<'_>>()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_string_pool_basic() {
        let mut pool = StringPool::new(100);
        
        // 测试获取和释放
        let s1 = pool.acquire(10);
        assert_eq!(s1.capacity(), 10);
        
        pool.release(s1);
        
        let s2 = pool.acquire(10);
        assert!(s2.capacity() >= 10);
    }
    
    #[test]
    fn test_vec_pool_basic() {
        let mut pool: VecPool<String> = VecPool::new(50);
        
        let v1 = pool.acquire(20);
        assert_eq!(v1.capacity(), 20);
        
        pool.release(v1);
        
        let v2 = pool.acquire(15);
        assert!(v2.capacity() >= 15);
    }
    
    #[test]
    fn test_memory_optimized_text_item() {
        let text = "Hello World".to_string();
        let mut item = MemoryOptimizedTextItem::new(
            text.as_str(),
            "content"
        );
        
        // 初始时应该是借用的，内存使用为0
        assert_eq!(item.memory_usage(), 0);
        assert!(!item.is_translated);
        
        // 应用翻译后变为拥有的
        item.apply_translation("你好世界".to_string());
        assert!(item.memory_usage() > 0);
        assert!(item.is_translated);
    }
    
    #[test]
    fn test_global_memory_manager() {
        let manager = GlobalMemoryManager::new();
        
        let s1 = manager.acquire_string(100);
        assert_eq!(s1.capacity(), 100);
        
        let stats_before = manager.get_stats();
        assert_eq!(stats_before.strings_acquired, 1);
        
        manager.release_string(s1);
        
        let stats_after = manager.get_stats();
        assert_eq!(stats_after.strings_released, 1);
    }
    
    #[test]
    fn test_memory_stats() {
        let mut stats = MemoryStats::default();
        stats.strings_acquired = 100;
        stats.strings_released = 80;
        
        assert_eq!(stats.pool_hit_rate(), 0.8);
    }
}