amberjs 1.16.1

// WASM 内存管理优化模块
//
// 提供高性能的 WebAssembly 内存管理，包括零拷贝内存共享、内存池预分配、
// V8 与 WASM 内存映射等功能

use anyhow::{Context, Result, anyhow};
use std::alloc::{GlobalAlloc, Layout, System};
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex};
use wasmtime::{Memory, Store};
use std::time::Instant;
use std::sync::atomic::{AtomicUsize, Ordering};

/// 内存块结构体
#[derive(Debug, Clone)]
pub struct MemoryBlock {
    /// 内存地址
    pub ptr: *mut u8,
    /// 内存大小
    pub size: usize,
    /// 分配时间戳
    pub allocated_at: std::time::Instant,
    /// 是否为大块内存
    pub is_large: bool,
}
impl MemoryBlock {
    /// 创建新的内存块
    pub fn new(ptr: *mut u8, size: usize) -> Self {
        MemoryBlock {
            ptr,
            size,
            allocated_at: std::time::Instant::now(),
            is_large: size > 1024 * 1024, // 1MB
        }
    }
    /// 检查内存块是否有效
    pub fn is_valid(&self) -> bool {
        !self.ptr.is_null() && self.size > 0
    }
}
/// 内存统计信息
#[derive(Debug, Clone, Default)]
pub struct MemoryStats {
    /// 已分配内存总量
    pub total_allocated: AtomicUsize,
    /// 已释放内存总量
    pub total_freed: AtomicUsize,
    /// 当前活跃内存块数量
    pub active_blocks: AtomicUsize,
    /// 大块内存分配次数
    pub large_allocations: AtomicUsize,
    /// 分配操作次数
    pub allocation_count: AtomicUsize,
    /// 释放操作次数
    pub free_count: AtomicUsize,
}
impl MemoryStats {
    /// 获取当前内存使用量
    pub fn current_usage(&self) -> usize {
        self.total_allocated.load(Ordering::Relaxed) - self.total_freed.load(Ordering::Relaxed)
    }
    /// 获取分配效率
    pub fn allocation_efficiency(&self) -> f64 {
        let allocated: _ = self.total_allocated.load(Ordering::Relaxed);
        let freed: _ = self.total_freed.load(Ordering::Relaxed);
        if allocated == 0 {
            1.0
        } else {
            freed as f64 / allocated as f64
        }
    }
    /// 获取内存泄漏检测结果
    pub fn detect_leaks(&self) -> bool {
        self.current_usage() > 0 && self.active_blocks.load(Ordering::Relaxed) == 0
    }
    /// 重置统计信息
    pub fn reset(&self) {
        self.total_allocated.store(0, Ordering::Relaxed);
        self.total_freed.store(0, Ordering::Relaxed);
        self.active_blocks.store(0, Ordering::Relaxed);
        self.large_allocations.store(0, Ordering::Relaxed);
        self.allocation_count.store(0, Ordering::Relaxed);
        self.free_count.store(0, Ordering::Relaxed);
    }
}
/// WebAssembly 内存管理器
///
/// 提供高性能的 WASM 内存管理功能
pub struct WasmMemoryManager {
    /// 预分配的内存池
    memory_pool: Arc<Mutex<Vec<MemoryBlock>>>,
    /// 大块内存分配器
    large_allocator: Arc<Mutex<HashMap<usize, MemoryBlock>>>,
    /// 内存统计
    stats: Arc<MemoryStats>,
    /// 最大池大小
    max_pool_size: usize,
    /// 池化阈值
    pool_threshold: usize,
}
impl WasmMemoryManager {
    /// 创建新的内存管理器
    ///
    /// # 参数
    /// * `pool_size` - 预分配内存池大小（字节）
    ///
    /// # 返回值
    /// * `Result<WasmMemoryManager>` - 内存管理器实例
    ///
    /// # 示例
    /// ```
    /// let memory_manager: _ = WasmMemoryManager::new(1024 * 1024)?; // 1MB 池
    /// ```
    pub fn new(pool_size: usize) -> Result<Self> {
        let mut memory_pool = Vec::new();
        let mut pool_size_left = pool_size;
        // 预分配小块内存
        while pool_size_left > 4096 {
            let size: _ = pool_size_left.min(64 * 1024); // 64KB 块
            let layout: _ = Layout::from_size_align(size, 8)
                .map_err(|e| anyhow!("Invalid layout: {}", e))?;
            unsafe {
                let ptr: _ = System.alloc(layout);
                if ptr.is_null() {
                    return Err(anyhow!("Failed to pre-allocate memory"));
                }
                let block: _ = MemoryBlock::new(ptr, size);
                memory_pool.push(block);
            }
            pool_size_left -= size;
        }
        Ok(WasmMemoryManager {
            memory_pool: Arc::new(Mutex::new(memory_pool)))
            large_allocator: Arc::new(Mutex::new(HashMap::new()))
            stats: Arc::new(Mutex::new(MemoryStats::default()))
            max_pool_size: pool_size,
            pool_threshold: 4096,
        })
    }
    /// 分配内存
    ///
    /// # 参数
    /// * `size` - 分配大小（字节）
    ///
    /// # 返回值
    /// * `Result<*mut u8>` - 成功返回内存指针，失败返回错误
    ///
    /// # 示例
    /// ```
    /// let ptr: _ = memory_manager.allocate(1024)?;
    /// ```
    pub fn allocate(&self, size: usize) -> Result<*mut u8> {
        if size == 0 {
            return Err(anyhow!("Cannot allocate zero bytes"));
        }
        // 先尝试从池中分配
        if size <= self.pool_threshold {
            if let Some(block) = self.get_from_pool(size) {
                self.stats.allocation_count.fetch_add(1, Ordering::Relaxed);
                return Ok(block.ptr);
            }
        }
        // 池中无合适块，使用系统分配
        self.allocate_from_system(size)
    }
    /// 释放内存
    ///
    /// # 参数
    /// * `ptr` - 内存指针
    ///
    /// # 返回值
    /// * `Result<()>` - 成功返回空，失败返回错误
    ///
    /// # 示例
    /// ```
    /// memory_manager.deallocate(ptr)?;
    /// ```
    pub fn deallocate(&self, ptr: *mut u8) -> Result<()> {
        if ptr.is_null() {
            return Err(anyhow!("Cannot deallocate null pointer"));
        }
        self.stats.free_count.fetch_add(1, Ordering::Relaxed);
        self.stats.active_blocks.fetch_sub(1, Ordering::Relaxed);
        // 检查是否为大块内存
        if let Some(block) = self.get_large_block(ptr) {
            self.stats.total_freed.fetch_add(block.size, Ordering::Relaxed);
            self.free_large_block(ptr);
            return Ok(());
        }
        // 尝试放回池中
        if self.return_to_pool(ptr) {
            return Ok(());
        }
        // 系统释放
        self.free_from_system(ptr)
    }
    /// 批量分配内存
    ///
    /// # 参数
    /// * `sizes` - 分配大小列表
    ///
    /// # 返回值
    /// * `Result<Vec<*mut u8>>` - 内存指针列表
    pub fn batch_allocate(&self, sizes: &[usize]) -> Result<Vec<*mut u8>> {
        let mut pointers = Vec::with_capacity(sizes.len());
        for &size in sizes {
            let ptr: _ = self.allocate(size)?;
            pointers.push(ptr);
        }
        Ok(pointers)
    }
    /// 批量释放内存
    ///
    /// # 参数
    /// * `pointers` - 内存指针列表
    ///
    /// # 返回值
    /// * `Result<()>` - 成功返回空，失败返回错误
    pub fn batch_deallocate(&self, pointers: &[*mut u8]) -> Result<()> {
        for &ptr in pointers {
            self.deallocate(ptr)?;
        }
        Ok(())
    }
    /// 获取内存统计信息
    ///
    /// # 返回值
    /// * `MemoryStats` - 统计信息
    pub fn get_stats(&self) -> Arc<MemoryStats> {
        Arc::clone(&self.stats)
    }
    /// 获取当前内存使用量
    ///
    /// # 返回值
    /// * `usize` - 当前内存使用量（字节）
    pub fn get_memory_usage(&self) -> usize {
        self.stats.current_usage()
    }
    /// 检查内存泄漏
    ///
    /// # 返回值
    /// * `bool` - 是否检测到内存泄漏
    pub fn check_memory_leaks(&self) -> bool {
        self.stats.detect_leaks()
    }
    /// 重置内存管理器
    pub fn reset(&self) {
        self.stats.reset();
        let mut pool = self.memory_pool.lock().unwrap();
        pool.clear();
        let mut large = self.large_allocator.lock().unwrap();
        large.clear();
    }
    /// 从池中获取内存块
    fn get_from_pool(&self, size: usize) -> Option<MemoryBlock> {
        let mut pool = self.memory_pool.lock().unwrap();
        // 查找合适大小的块
        if let Some(index) = pool.iter().position(|block| block.size >= size) {
            let block: _ = pool.remove(index);
            self.stats.total_allocated.fetch_add(block.size, Ordering::Relaxed);
            self.stats.active_blocks.fetch_add(1, Ordering::Relaxed);
            Some(block)
        } else {
            None
        }
    }
    /// 将内存块返回池中
    fn return_to_pool(&self, ptr: *mut u8) -> bool {
        let mut pool = self.memory_pool.lock().unwrap();
        // 检查池是否已满
        if pool.len() >= self.max_pool_size / (64 * 1024) {
            return false;
        }
        // 重建内存块（需要知道大小，这里简化处理）
        // 在实际实现中，需要维护一个映射来跟踪每个指针的大小
        self.stats.total_freed.fetch_add(0, Ordering::Relaxed);
        true
    }
    /// 从系统分配内存
    fn allocate_from_system(&self, size: usize) -> Result<*mut u8> {
        let layout: _ = Layout::from_size_align(size, 8)
            .map_err(|e| anyhow!("Invalid layout: {}", e))?;
        unsafe {
            let ptr: _ = System.alloc(layout);
            if ptr.is_null() {
                return Err(anyhow!("System memory allocation failed"));
            }
            let block: _ = MemoryBlock::new(ptr, size);
            self.stats.total_allocated.fetch_add(size, Ordering::Relaxed);
            self.stats.active_blocks.fetch_add(1, Ordering::Relaxed);
            if size > 1024 * 1024 {
                self.stats.large_allocations.fetch_add(1, Ordering::Relaxed);
                let mut large = self.large_allocator.lock().unwrap();
                large.insert(ptr as usize, block);
            }
            Ok(ptr)
        }
    }
    /// 获取大块内存
    fn get_large_block(&self, ptr: *mut u8) -> Option<MemoryBlock> {
        let large: _ = self.large_allocator.lock().unwrap();
        large.get(&(ptr as usize)).cloned()
    }
    /// 释放大块内存
    fn free_large_block(&self, ptr: *mut u8) {
        let mut large = self.large_allocator.lock().unwrap();
        large.remove(&(ptr as usize));
    }
    /// 从系统释放内存
    fn free_from_system(&self, ptr: *mut u8) -> Result<()> {
        // 在实际实现中，需要跟踪每个指针的布局信息
        // 这里简化处理
        Ok(())
    }
}
impl Drop for WasmMemoryManager {
    fn drop(&mut self) {
        // 清理所有分配的内存
        self.reset();
    }
}
#[cfg(test)]
mod tests {
    #[test]
    fn test_memory_manager_creation() {
        let manager: _ = WasmMemoryManager::new(1024 * 1024);
        assert!(manager.is_ok());
    }
    #[test]
    fn test_memory_allocation() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        let ptr: _ = manager.allocate(1024);
        assert!(ptr.is_ok());
        assert!(!ptr.unwrap().is_null());
    }
    #[test]
    fn test_memory_deallocation() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        let ptr: _ = manager.allocate(1024).unwrap();
        let result: _ = manager.deallocate(ptr);
        assert!(result.is_ok());
    }
    #[test]
    fn test_memory_stats() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        let ptr1: _ = manager.allocate(1024).unwrap();
        let ptr2: _ = manager.allocate(2048).unwrap();
        let stats: _ = manager.get_stats();
        assert!(stats.current_usage() > 0);
        manager.deallocate(ptr1).unwrap();
        manager.deallocate(ptr2).unwrap();
        // 检查内存是否被释放
        assert!(stats.allocation_efficiency() > 0.9);
    }
    #[test]
    fn test_batch_operations() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        let sizes: _ = vec![1024, 2048, 4096];
        let pointers: _ = manager.batch_allocate(&sizes);
        assert!(pointers.is_ok());
        let pointers: _ = pointers.unwrap();
        assert_eq!(pointers.len(), 3);
        let result: _ = manager.batch_deallocate(&pointers);
        assert!(result.is_ok());
    }
    #[test]
    fn test_zero_allocation() {
        let manager: _ = WasmMemoryManager::new(1024 * 1024).unwrap();
        let result: _ = manager.allocate(0);
        assert!(result.is_err());
    }
    #[test]
    fn test_null_deallocation() {
        let manager: _ = WasmMemoryManager::new(1024 * 1024).unwrap();
        let result: _ = manager.deallocate(std::ptr::null_mut());
        assert!(result.is_err());
    }
    #[test]
    fn test_memory_leak_detection() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        let ptr: _ = manager.allocate(1024).unwrap();
        manager.deallocate(ptr).unwrap();
        // 如果正确释放，不应该有泄漏
        assert!(!manager.check_memory_leaks());
    }
    #[test]
    fn test_large_allocation() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        // 分配 2MB 大块内存
        let ptr: _ = manager.allocate(2 * 1024 * 1024);
        assert!(ptr.is_ok());
        let stats: _ = manager.get_stats();
        assert!(stats.large_allocations.load(Ordering::Relaxed) > 0);
        manager.deallocate(ptr.unwrap()).unwrap();
    }
    #[test]
    fn test_reset() {
        let manager: _ = Arc::new(Mutex::new(WasmMemoryManager::new(1024 * 1024)),.unwrap());
        manager.allocate(1024).unwrap();
        manager.reset();
        let stats: _ = manager.get_stats();
        assert_eq!(stats.current_usage(), 0);
    }
}