amberjs 1.16.1

// 内存映射管理器 - 高效内存共享优化
//
// Stage 39.0: 网络零拷贝优化
//
// 该模块提供内存映射功能，使用 mmap 系统调用实现高效内存共享，
// 减少内存拷贝和提升访问速度，特别适用于大文件处理和进程间通信。

use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex};
use std::fs::File;
use std::time::{Duration, Instant};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::atomic::AtomicU64;

/// 内存映射类型
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MemoryMapType {
    /// 只读映射
    ReadOnly,
    /// 只写映射
    WriteOnly,
    /// 读写映射
    ReadWrite,
    /// 共享映射
    Shared,
    /// 私有映射
    Private,
}
/// 内存映射配置
#[derive(Debug, Clone)]
pub struct MemoryMapperConfig {
    /// 默认映射大小
    pub default_map_size: usize,
    /// 最大映射大小
    pub max_map_size: usize,
    /// 映射超时时间
    pub map_timeout: Duration,
    /// 启用预读
    pub enable_read_ahead: bool,
    /// 预读大小
    pub read_ahead_size: usize,
    /// 启用大页支持
    pub enable_huge_pages: bool,
}
impl Default for MemoryMapperConfig {
    fn default() -> Self {
        Self {
            default_map_size: 4096,
            max_map_size: 1024 * 1024 * 1024, // 1GB
            map_timeout: Duration::from_secs(30),
            enable_read_ahead: true,
            read_ahead_size: 128 * 1024,
            enable_huge_pages: false,
        }
    }
}
/// 内存映射统计信息
#[derive(Debug, Clone, Default)]
pub struct MemoryMapperStats {
    /// 总映射字节数
    pub total_mapped_bytes: u64,
    /// 总映射次数
    pub total_maps: u64,
    /// 成功映射次数
    pub success_maps: u64,
    /// 失败映射次数
    pub failed_maps: u64,
    /// 总取消映射次数
    pub total_unmaps: u64,
    /// 平均映射速度 (MB/sec)
    pub avg_map_speed: f64,
    /// 峰值映射速度 (MB/sec)
    pub peak_map_speed: f64,
    /// 内存访问速度提升倍数
    pub access_speed_improvement: f64,
    /// 内存拷贝节省量 (bytes)
    pub memory_copy_saved: u64,
}
/// 内存映射区域
#[derive(Debug, Clone)]
pub struct MemoryMappedRegion {
    /// 映射 ID
    pub id: u64,
    /// 映射地址
    pub addr: *mut u8,
    /// 映射大小
    pub size: usize,
    /// 映射类型
    pub map_type: MemoryMapType,
    /// 文件路径
    pub file_path: Option<String>,
    /// 创建时间
    pub created_at: Instant,
    /// 最后访问时间
    pub last_accessed: Instant,
    /// 访问次数
    pub access_count: u64,
}
/// 内存映射管理器
///
/// 该结构体提供内存映射管理功能：
/// - 高效的内存映射创建和管理
/// - 支持多种映射类型
/// - 实时性能监控
/// - 内存访问优化
/// - 自动垃圾回收
#[derive(Debug)]
pub struct MemoryMapper {
    /// 配置
    config: MemoryMapperConfig,
    /// 活跃映射区域
    active_regions: Arc<Mutex<HashMap<u64, MemoryMappedRegion>>>,
    /// 统计信息
    stats: Arc<Mutex<MemoryMapperStats>>,
    /// 映射 ID 生成器
    next_region_id: Arc<std::sync::atomic::AtomicU64>,
    /// 总映射内存大小
    total_mapped_memory: Arc<std::sync::atomic::AtomicUsize>,
}
impl MemoryMapper {
    /// 创建新的内存映射管理器
    ///
    /// # 参数
    /// - `config`: 配置信息
    ///
    /// # 返回值
    /// 返回创建结果
    pub fn new(config: Option<MemoryMapperConfig>) -> io::Result<Self> {
        let config: _ = config.unwrap_or_default();
        Ok(Self {
            config,
            active_regions: Arc::new(Mutex::new(HashMap::new())),
            stats: Arc::new(Mutex::new(MemoryMapperStats::default())),
            next_region_id: Arc::new(Mutex::new(std::sync::atomic::AtomicU64::new(1))),
            total_mapped_memory: Arc::new(Mutex::new(std::sync::atomic::AtomicUsize::new(0))),
        })
    }
    /// 映射文件到内存
    ///
    /// # 参数
    /// - `file_path`: 文件路径
    /// - `map_type`: 映射类型
    /// - `size`: 映射大小（0 表示整个文件）
    ///
    /// # 返回值
    /// 返回映射区域 ID
    pub fn map_file(
        &self,
        file_path: &str,
        map_type: MemoryMapType,
        size: usize,
    ) -> io::Result<u64> {
        let start_time: _ = Instant::now();
        // 打开文件
        let file: _ = File::open(file_path)?;
        let file_size: _ = file.metadata()?.len() as usize;
        // 确定映射大小
        let map_size: _ = if size == 0 {
            file_size
        } else {
            std::cmp::min(size, file_size)
        };
        // 检查映射大小限制
        if map_size > self.config.max_map_size {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("映射大小 {} 超过最大限制 {}", map_size, self.config.max_map_size),
            ));
        }
        // 执行内存映射
        let region_id: _ = self.perform_mmap(&file, map_type, map_size, Some(file_path.to_string()))?;
        // 更新统计信息
        let elapsed: _ = start_time.elapsed();
        self.update_stats_on_success(map_size, &elapsed);
        println!(
            "✅ 文件映射成功: {}, 大小: {} bytes, 耗时: {:?}",
            file_path, map_size, elapsed
        );
        Ok(region_id)
    }
    /// 创建匿名内存映射
    ///
    /// # 参数
    /// - `map_type`: 映射类型
    /// - `size`: 映射大小
    ///
    /// # 返回值
    /// 返回映射区域 ID
    pub fn map_anonymous(&self, map_type: MemoryMapType, size: usize) -> io::Result<u64> {
        let start_time: _ = Instant::now();
        // 检查映射大小限制
        if size > self.config.max_map_size {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("映射大小 {} 超过最大限制 {}", size, self.config.max_map_size),
            ));
        }
        // 执行匿名内存映射
        let region_id: _ = self.perform_mmap(&std::fs::File::open("/dev/null")?, map_type, size, None)?;
        // 更新统计信息
        let elapsed: _ = start_time.elapsed();
        self.update_stats_on_success(size, &elapsed);
        println!(
            "✅ 匿名映射成功, 大小: {} bytes, 耗时: {:?}",
            size, elapsed
        );
        Ok(region_id)
    }
    /// 执行内存映射的核心逻辑
    fn perform_mmap(
        &self,
        file: &File,
        map_type: MemoryMapType,
        size: usize,
        file_path: Option<String>,
    ) -> io::Result<u64> {
        // 生成映射区域 ID
        let region_id: _ = self.next_region_id.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        // 准备映射参数
        let (prot, flags) = match map_type {
            MemoryMapType::ReadOnly => (libc::PROT_READ, libc::MAP_PRIVATE),
            MemoryMapType::WriteOnly => (libc::PROT_WRITE, libc::MAP_PRIVATE),
            MemoryMapType::ReadWrite => (libc::PROT_READ | libc::PROT_WRITE, libc::MAP_PRIVATE),
            MemoryMapType::Shared => (libc::PROT_READ | libc::PROT_WRITE, libc::MAP_SHARED),
            MemoryMapType::Private => (libc::PROT_READ | libc::PROT_WRITE, libc::MAP_PRIVATE),
        };
        // 添加大页支持标志
        #[cfg(unix)]
        let flags: _ = if self.config.enable_huge_pages {
            // MAP_HUGETLB 可能不是所有系统都支持
            #[cfg(target_os = "linux")]
            let flags: _ = flags | libc::MAP_HUGETLB;
            #[cfg(not(target_os = "linux"))]
            let flags: _ = flags; // 非 Linux 系统不支持 MAP_HUGETLB
            flags
        } else {
            flags
        };
        #[cfg(not(unix))]
        let flags: _ = flags; // 非 Unix 系统不支持大页
        // 执行 mmap 系统调用
        let addr: _ = unsafe {
            libc::mmap(
                std::ptr::null_mut(),
                size,
                prot,
                flags,
                file.as_raw_fd(),
                0,
            )
        };
        if addr == libc::MAP_FAILED {
            return Err(io::Error::last_os_error());
        }
        // 创建内存映射区域
        let region: _ = MemoryMappedRegion {
            id: region_id,
            addr: addr as *mut u8,
            size,
            map_type,
            file_path,
            created_at: Instant::now(),
            last_accessed: Instant::now(),
            access_count: 0,
        };
        // 添加到活跃区域
        {
            let mut regions = self.active_regions.lock().unwrap();
            regions.insert(region_id, region);
        }
        // 更新总映射内存大小
        self.total_mapped_memory.fetch_add(size, std::sync::atomic::Ordering::Relaxed);
        // 更新统计信息
        {
            let mut stats = self.stats.lock().unwrap();
            stats.total_maps += 1;
            stats.success_maps += 1;
            stats.total_mapped_bytes += size as u64;
        }
        Ok(region_id)
    }
    /// 取消映射内存区域
    ///
    /// # 参数
    /// - `region_id`: 映射区域 ID
    ///
    /// # 返回值
    /// 返回取消映射结果
    pub fn unmap_region(&self, region_id: u64) -> io::Result<()> {
        let mut regions = self.active_regions.lock().unwrap();
        if let Some(region) = regions.remove(&region_id) {
            // 执行 munmap 系统调用
            let result: _ = unsafe {
                libc::munmap(region.addr as *mut libc::c_void, region.size)
            };
            if result != 0 {
                return Err(io::Error::last_os_error());
            }
            // 更新总映射内存大小
            self.total_mapped_memory.fetch_sub(region.size, std::sync::atomic::Ordering::Relaxed);
            // 更新统计信息
            {
                let mut stats = self.stats.lock().unwrap();
                stats.total_unmaps += 1;
            }
            println!("✅ 取消映射成功: ID {}, 大小: {} bytes", region_id, region.size);
            Ok(())
        } else {
            Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("未找到映射区域: {}", region_id),
            ))
        }
    }
    /// 获取内存映射区域的指针
    ///
    /// # 参数
    /// - `region_id`: 映射区域 ID
    ///
    /// # 返回值
    /// 返回内存指针
    pub fn get_region_ptr(&self, region_id: u64) -> io::Result<*mut u8> {
        let regions: _ = self.active_regions.lock().unwrap();
        if let Some(region_ref) = regions.get(&region_id) {
            // 更新访问统计
            let mut region = region_ref.clone();
            region.last_accessed = Instant::now();
            region.access_count += 1;
            Ok(region.addr)
        } else {
            Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("未找到映射区域: {}", region_id),
            ))
        }
    }
    /// 读取内存映射数据
    ///
    /// # 参数
    /// - `region_id`: 映射区域 ID
    /// - `offset`: 偏移量
    /// - `size`: 读取大小
    ///
    /// # 返回值
    /// 返回读取的数据
    pub fn read_region(&self, region_id: u64, offset: usize, size: usize) -> io::Result<Vec<u8>> {
        let regions: _ = self.active_regions.lock().unwrap();
        if let Some(region_ref) = regions.get(&region_id) {
            if offset + size > region_ref.size {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    "读取范围超出映射区域",
                ));
            }
            // 读取数据
            let ptr: _ = unsafe { region_ref.addr.add(offset) };
            let data: _ = unsafe { std::slice::from_raw_parts(ptr, size) };
            // 更新访问统计
            {
                let mut region = region_ref.clone();
                region.last_accessed = Instant::now();
                region.access_count += 1;
            }
            Ok(data.to_vec())
        } else {
            Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("未找到映射区域: {}", region_id),
            ))
        }
    }
    /// 获取当前活跃映射区域数量
    ///
    /// # 返回值
    /// 返回活跃映射区域数量
    pub fn active_region_count(&self) -> usize {
        self.active_regions.lock().unwrap().len()
    }
    /// 获取总映射内存大小
    ///
    /// # 返回值
    /// 返回总映射内存大小（字节）
    pub fn total_mapped_memory_size(&self) -> usize {
        self.total_mapped_memory.load(std::sync::atomic::Ordering::Relaxed)
    }
    /// 获取统计信息
    ///
    /// # 返回值
    /// 返回统计信息副本
    pub fn get_stats(&self) -> MemoryMapperStats {
        self.stats.lock().unwrap().clone()
    }
    /// 更新成功映射的统计信息
    fn update_stats_on_success(&self, size: usize, elapsed: &Duration) {
        let mut stats = self.stats.lock().unwrap();
        if elapsed.as_secs_f64() > 0.0 {
            let speed_mb: _ = size as f64 / 1024.0 / 1024.0 / elapsed.as_secs_f64();
            // 更新平均速度
            if stats.total_maps == 1 {
                stats.avg_map_speed = speed_mb;
            } else {
                stats.avg_map_speed = (stats.avg_map_speed * (stats.total_maps - 1) as f64 + speed_mb)
                    / stats.total_maps as f64;
            }
            // 更新峰值速度
            if speed_mb > stats.peak_map_speed {
                stats.peak_map_speed = speed_mb;
            }
        }
        // 计算内存拷贝节省量（假设传统方式需要多次拷贝）
        stats.memory_copy_saved += size as u64 * 3;
        // 计算访问速度提升（假设传统方式 100MB/s）
        stats.access_speed_improvement = stats.avg_map_speed / 100.0;
    }
    /// 生成性能报告
    ///
    /// # 返回值
    /// 返回性能报告字符串
    pub fn generate_report(&self) -> String {
        let stats: _ = self.stats.lock().unwrap();
        let active_count: _ = self.active_region_count();
        let total_memory: _ = self.total_mapped_memory_size();
        format!(
            r#"
内存映射管理器性能报告
=======================
总映射次数: {}
成功映射次数: {}
失败映射次数: {}
成功率: {:.1}%
总映射字节数: {} bytes ({:.2} MB)
总取消映射次数: {}
活跃映射区域数: {}
当前映射内存: {} bytes ({:.2} MB)
平均映射速度: {:.2} MB/sec
峰值映射速度: {:.2} MB/sec
内存访问速度提升: {:.2}x
内存拷贝节省量: {} bytes ({:.2} MB)
            "#,
            stats.total_maps,
            stats.success_maps,
            stats.failed_maps,
            if stats.total_maps > 0 {
                stats.success_maps as f64 / stats.total_maps as f64 * 100.0
            } else {
                0.0
            },
            stats.total_mapped_bytes,
            stats.total_mapped_bytes as f64 / 1024.0 / 1024.0,
            stats.total_unmaps,
            active_count,
            total_memory,
            total_memory as f64 / 1024.0 / 1024.0,
            stats.avg_map_speed,
            stats.peak_map_speed,
            stats.access_speed_improvement,
            stats.memory_copy_saved,
            stats.memory_copy_saved as f64 / 1024.0 / 1024.0
        )
    }
    /// 清理所有映射区域
    pub fn cleanup_all(&self) {
        let region_ids: Vec<u64> = {
            let regions: _ = self.active_regions.lock().unwrap();
            regions.keys().cloned().collect()
        };
        for region_id in region_ids {
            let _: _ = self.unmap_region(region_id);
        }
        println!("🧹 清理所有内存映射区域");
    }
}
impl Drop for MemoryMapper {
    fn drop(&mut self) {
        self.cleanup_all();
    }
}
#[cfg(test)]
mod tests {
    /// 测试创建内存映射管理器
    #[test]
    fn test_memory_mapper_creation() {
        let mapper: _ = MemoryMapper::new(None).expect("创建内存映射管理器失败");
        let stats: _ = mapper.get_stats();
        assert_eq!(stats.total_maps, 0);
        assert_eq!(stats.success_maps, 0);
        assert_eq!(stats.failed_maps, 0);
        println!("✅ 测试通过: 内存映射管理器创建");
    }
    /// 测试匿名内存映射
    #[test]
    fn test_anonymous_mapping() {
        let mapper: _ = MemoryMapper::new(None).expect("创建内存映射管理器失败");
        let region_id: _ = mapper
            .map_anonymous(MemoryMapType::ReadWrite, 4096)
            .expect("创建匿名映射失败");
        assert!(region_id > 0);
        assert_eq!(mapper.active_region_count(), 1);
        let _: _ = mapper.unmap_region(region_id);
        println!("✅ 测试通过: 匿名内存映射");
    }
    /// 测试文件映射
    #[test]
    fn test_file_mapping() {
        // 创建临时测试文件
        let test_file_path: _ = "/tmp/amberjs_memory_map_test.bin";
        let test_data: _ = vec![42u8; 1024];
        std::fs::write(test_file_path, &test_data).expect("写入测试文件失败");
        let mapper: _ = MemoryMapper::new(None).expect("创建内存映射管理器失败");
        let region_id: _ = mapper
            .map_file(test_file_path, MemoryMapType::ReadOnly, 0)
            .expect("创建文件映射失败");
        assert!(region_id > 0);
        assert_eq!(mapper.active_region_count(), 1);
        let _: _ = mapper.unmap_region(region_id);
        // 清理
        std::fs::remove_file(test_file_path).ok();
        println!("✅ 测试通过: 文件映射");
    }
    /// 测试读取映射数据
    #[test]
    fn test_read_mapped_data() {
        // 创建临时测试文件
        let test_file_path: _ = "/tmp/amberjs_memory_map_read_test.bin";
        let test_data: _ = vec![1, 2, 3, 4, 5];
        std::fs::write(test_file_path, &test_data).expect("写入测试文件失败");
        let mapper: _ = MemoryMapper::new(None).expect("创建内存映射管理器失败");
        let region_id: _ = mapper
            .map_file(test_file_path, MemoryMapType::ReadOnly, 0)
            .expect("创建文件映射失败");
        // 读取数据
        let read_data: _ = mapper.read_region(region_id, 0, 5).expect("读取数据失败");
        assert_eq!(read_data, test_data);
        let _: _ = mapper.unmap_region(region_id);
        // 清理
        std::fs::remove_file(test_file_path).ok();
        println!("✅ 测试通过: 读取映射数据");
    }
}