755 lines
21 KiB
Markdown
755 lines
21 KiB
Markdown
# 内存管理优化方案
|
||
|
||
## 当前问题分析
|
||
|
||
### 1. 内存拷贝问题
|
||
当前架构中存在的主要内存问题：
|
||
|
||
```rust
|
||
// 当前实现 - 每次事件传递都会克隆整个帧数据
|
||
pub struct FrameCapturedEvent {
|
||
pub frame_data: Vec<u8>, // 640x480 RGB = ~900KB per frame
|
||
}
|
||
|
||
// 问题分析：
|
||
// - 30 FPS = 27MB/秒的内存拷贝
|
||
// - 事件总线广播时，每个订阅者都会克隆数据
|
||
// - 3个订阅者 = 81MB/秒的内存操作
|
||
```
|
||
|
||
### 2. 内存分配压力
|
||
- 每帧都需要新的内存分配
|
||
- GC压力导致延迟峰值
|
||
- 内存碎片化问题
|
||
|
||
### 3. 缓冲区管理
|
||
- Detection模块维护独立的帧缓冲
|
||
- Storage模块也有自己的缓冲
|
||
- 重复存储相同数据
|
||
|
||
## 优化方案详细设计
|
||
|
||
### 方案1: 零拷贝架构 (Zero-Copy Architecture)
|
||
|
||
#### A. 使用Arc实现共享不可变数据
|
||
|
||
```rust
|
||
use std::sync::Arc;
|
||
use bytes::Bytes;
|
||
|
||
// 新的事件结构 - 使用Arc共享数据
|
||
#[derive(Clone, Debug)]
|
||
pub struct FrameCapturedEvent {
|
||
pub frame_id: u64,
|
||
pub timestamp: chrono::DateTime<chrono::Utc>,
|
||
pub metadata: FrameMetadata,
|
||
pub frame_data: Arc<FrameData>, // 共享引用，克隆只增加引用计数
|
||
}
|
||
|
||
// 帧数据包装，包含原始数据和元信息
|
||
#[derive(Debug)]
|
||
pub struct FrameData {
|
||
pub data: Bytes, // 使用bytes crate，支持零拷贝切片
|
||
pub width: u32,
|
||
pub height: u32,
|
||
pub format: FrameFormat,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct FrameMetadata {
|
||
pub camera_id: u32,
|
||
pub exposure_time: f32,
|
||
pub gain: f32,
|
||
pub temperature: Option<f32>,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub enum FrameFormat {
|
||
RGB888,
|
||
YUV420,
|
||
JPEG,
|
||
H264Frame,
|
||
}
|
||
|
||
// 实现示例
|
||
impl FrameCapturedEvent {
|
||
pub fn new_zero_copy(
|
||
frame_id: u64,
|
||
data: Vec<u8>,
|
||
width: u32,
|
||
height: u32,
|
||
) -> Self {
|
||
let frame_data = Arc::new(FrameData {
|
||
data: Bytes::from(data), // 转换为Bytes，之后可零拷贝切片
|
||
width,
|
||
height,
|
||
format: FrameFormat::RGB888,
|
||
});
|
||
|
||
Self {
|
||
frame_id,
|
||
timestamp: chrono::Utc::now(),
|
||
metadata: FrameMetadata::default(),
|
||
frame_data,
|
||
}
|
||
}
|
||
|
||
// 获取帧数据的只读引用
|
||
pub fn data(&self) -> &[u8] {
|
||
&self.frame_data.data
|
||
}
|
||
|
||
// 创建数据的零拷贝切片
|
||
pub fn slice(&self, start: usize, end: usize) -> Bytes {
|
||
self.frame_data.data.slice(start..end)
|
||
}
|
||
}
|
||
```
|
||
|
||
#### B. 优化事件总线
|
||
|
||
```rust
|
||
use tokio::sync::broadcast;
|
||
use std::sync::Arc;
|
||
|
||
pub struct OptimizedEventBus {
|
||
// 使用Arc包装的发送器，避免克隆整个通道
|
||
sender: Arc<broadcast::Sender<Arc<SystemEvent>>>,
|
||
capacity: usize,
|
||
}
|
||
|
||
impl OptimizedEventBus {
|
||
pub fn new(capacity: usize) -> Self {
|
||
let (sender, _) = broadcast::channel(capacity);
|
||
Self {
|
||
sender: Arc::new(sender),
|
||
capacity,
|
||
}
|
||
}
|
||
|
||
// 发布事件时使用Arc包装
|
||
pub fn publish(&self, event: SystemEvent) -> Result<()> {
|
||
let arc_event = Arc::new(event);
|
||
self.sender.send(arc_event)
|
||
.map_err(|_| anyhow::anyhow!("No subscribers"))?;
|
||
Ok(())
|
||
}
|
||
|
||
// 订阅者接收Arc包装的事件
|
||
pub fn subscribe(&self) -> broadcast::Receiver<Arc<SystemEvent>> {
|
||
self.sender.subscribe()
|
||
}
|
||
}
|
||
```
|
||
|
||
### 方案2: 帧池化 (Frame Pooling)
|
||
|
||
#### A. 对象池实现
|
||
|
||
```rust
|
||
use std::sync::{Arc, Mutex};
|
||
use std::collections::VecDeque;
|
||
|
||
/// 帧缓冲池，复用内存分配
|
||
pub struct FramePool {
|
||
pool: Arc<Mutex<VecDeque<Vec<u8>>>>,
|
||
frame_size: usize,
|
||
max_pool_size: usize,
|
||
allocated_count: Arc<AtomicUsize>,
|
||
}
|
||
|
||
impl FramePool {
|
||
pub fn new(width: u32, height: u32, format: FrameFormat, max_pool_size: usize) -> Self {
|
||
let frame_size = Self::calculate_frame_size(width, height, format);
|
||
|
||
Self {
|
||
pool: Arc::new(Mutex::new(VecDeque::with_capacity(max_pool_size))),
|
||
frame_size,
|
||
max_pool_size,
|
||
allocated_count: Arc::new(AtomicUsize::new(0)),
|
||
}
|
||
}
|
||
|
||
/// 从池中获取或分配新的帧缓冲
|
||
pub fn acquire(&self) -> PooledFrame {
|
||
let mut pool = self.pool.lock().unwrap();
|
||
|
||
let buffer = if let Some(mut buf) = pool.pop_front() {
|
||
// 复用现有缓冲
|
||
buf.clear();
|
||
buf.resize(self.frame_size, 0);
|
||
buf
|
||
} else {
|
||
// 分配新缓冲
|
||
self.allocated_count.fetch_add(1, Ordering::Relaxed);
|
||
vec![0u8; self.frame_size]
|
||
};
|
||
|
||
PooledFrame {
|
||
buffer,
|
||
pool: Arc::clone(&self.pool),
|
||
frame_size: self.frame_size,
|
||
}
|
||
}
|
||
|
||
/// 计算帧大小
|
||
fn calculate_frame_size(width: u32, height: u32, format: FrameFormat) -> usize {
|
||
match format {
|
||
FrameFormat::RGB888 => (width * height * 3) as usize,
|
||
FrameFormat::YUV420 => (width * height * 3 / 2) as usize,
|
||
FrameFormat::JPEG => (width * height) as usize, // 估算
|
||
FrameFormat::H264Frame => (width * height / 2) as usize, // 估算
|
||
}
|
||
}
|
||
|
||
/// 获取池统计信息
|
||
pub fn stats(&self) -> PoolStats {
|
||
let pool = self.pool.lock().unwrap();
|
||
PoolStats {
|
||
pooled: pool.len(),
|
||
allocated: self.allocated_count.load(Ordering::Relaxed),
|
||
frame_size: self.frame_size,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// RAII包装的池化帧，自动归还到池
|
||
pub struct PooledFrame {
|
||
buffer: Vec<u8>,
|
||
pool: Arc<Mutex<VecDeque<Vec<u8>>>>,
|
||
frame_size: usize,
|
||
}
|
||
|
||
impl PooledFrame {
|
||
pub fn as_slice(&self) -> &[u8] {
|
||
&self.buffer
|
||
}
|
||
|
||
pub fn as_mut_slice(&mut self) -> &mut [u8] {
|
||
&mut self.buffer
|
||
}
|
||
}
|
||
|
||
impl Drop for PooledFrame {
|
||
fn drop(&mut self) {
|
||
// 归还缓冲到池
|
||
let mut pool = self.pool.lock().unwrap();
|
||
if pool.len() < pool.capacity() {
|
||
let buffer = std::mem::replace(&mut self.buffer, Vec::new());
|
||
pool.push_back(buffer);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
pub struct PoolStats {
|
||
pub pooled: usize,
|
||
pub allocated: usize,
|
||
pub frame_size: usize,
|
||
}
|
||
```
|
||
|
||
#### B. Camera模块集成
|
||
|
||
```rust
|
||
// camera.rs 优化版本
|
||
pub struct OptimizedCameraController {
|
||
config: CameraConfig,
|
||
event_bus: EventBus,
|
||
frame_pool: FramePool,
|
||
frame_counter: AtomicU64,
|
||
}
|
||
|
||
impl OptimizedCameraController {
|
||
pub async fn capture_loop(&mut self) -> Result<()> {
|
||
loop {
|
||
// 从池中获取帧缓冲
|
||
let mut pooled_frame = self.frame_pool.acquire();
|
||
|
||
// 捕获到池化缓冲中
|
||
self.capture_to_buffer(pooled_frame.as_mut_slice()).await?;
|
||
|
||
// 转换为Arc共享数据
|
||
let frame_data = Arc::new(FrameData {
|
||
data: Bytes::from(pooled_frame.as_slice().to_vec()),
|
||
width: self.config.width.unwrap_or(640),
|
||
height: self.config.height.unwrap_or(480),
|
||
format: FrameFormat::RGB888,
|
||
});
|
||
|
||
// 创建事件
|
||
let event = FrameCapturedEvent {
|
||
frame_id: self.frame_counter.fetch_add(1, Ordering::Relaxed),
|
||
timestamp: chrono::Utc::now(),
|
||
metadata: self.create_metadata(),
|
||
frame_data,
|
||
};
|
||
|
||
// 发布事件
|
||
self.event_bus.publish(SystemEvent::FrameCaptured(event))?;
|
||
|
||
// pooled_frame 在这里自动Drop，缓冲归还到池
|
||
|
||
// 控制帧率
|
||
tokio::time::sleep(Duration::from_millis(33)).await; // ~30 FPS
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 方案3: 环形缓冲区 (Ring Buffer)
|
||
|
||
#### A. 内存映射环形缓冲
|
||
|
||
```rust
|
||
use memmap2::{MmapMut, MmapOptions};
|
||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||
|
||
/// 内存映射的环形缓冲区，用于高效的帧存储
|
||
pub struct MmapRingBuffer {
|
||
mmap: Arc<MmapMut>,
|
||
frame_size: usize,
|
||
capacity: usize,
|
||
write_pos: Arc<AtomicUsize>,
|
||
read_pos: Arc<AtomicUsize>,
|
||
frame_offsets: Vec<usize>,
|
||
}
|
||
|
||
impl MmapRingBuffer {
|
||
pub fn new(capacity: usize, frame_size: usize) -> Result<Self> {
|
||
let total_size = capacity * frame_size;
|
||
|
||
// 创建临时文件用于内存映射
|
||
let temp_file = tempfile::tempfile()?;
|
||
temp_file.set_len(total_size as u64)?;
|
||
|
||
// 创建内存映射
|
||
let mmap = unsafe {
|
||
MmapOptions::new()
|
||
.len(total_size)
|
||
.map_mut(&temp_file)?
|
||
};
|
||
|
||
// 预计算帧偏移
|
||
let frame_offsets: Vec<usize> = (0..capacity)
|
||
.map(|i| i * frame_size)
|
||
.collect();
|
||
|
||
Ok(Self {
|
||
mmap: Arc::new(mmap),
|
||
frame_size,
|
||
capacity,
|
||
write_pos: Arc::new(AtomicUsize::new(0)),
|
||
read_pos: Arc::new(AtomicUsize::new(0)),
|
||
frame_offsets,
|
||
})
|
||
}
|
||
|
||
/// 写入帧到环形缓冲区
|
||
pub fn write_frame(&self, frame_data: &[u8]) -> Result<usize> {
|
||
if frame_data.len() != self.frame_size {
|
||
return Err(anyhow::anyhow!("Frame size mismatch"));
|
||
}
|
||
|
||
let pos = self.write_pos.fetch_add(1, Ordering::AcqRel) % self.capacity;
|
||
let offset = self.frame_offsets[pos];
|
||
|
||
// 直接写入内存映射区域
|
||
unsafe {
|
||
let dst = &mut self.mmap[offset..offset + self.frame_size];
|
||
dst.copy_from_slice(frame_data);
|
||
}
|
||
|
||
Ok(pos)
|
||
}
|
||
|
||
/// 读取帧从环形缓冲区（零拷贝）
|
||
pub fn read_frame(&self, position: usize) -> &[u8] {
|
||
let offset = self.frame_offsets[position % self.capacity];
|
||
&self.mmap[offset..offset + self.frame_size]
|
||
}
|
||
|
||
/// 获取当前写入位置
|
||
pub fn current_write_pos(&self) -> usize {
|
||
self.write_pos.load(Ordering::Acquire) % self.capacity
|
||
}
|
||
|
||
/// 获取可用帧数量
|
||
pub fn available_frames(&self) -> usize {
|
||
let write = self.write_pos.load(Ordering::Acquire);
|
||
let read = self.read_pos.load(Ordering::Acquire);
|
||
write.saturating_sub(read).min(self.capacity)
|
||
}
|
||
}
|
||
|
||
/// 环形缓冲区的只读视图
|
||
pub struct RingBufferView {
|
||
buffer: Arc<MmapRingBuffer>,
|
||
start_pos: usize,
|
||
end_pos: usize,
|
||
}
|
||
|
||
impl RingBufferView {
|
||
pub fn new(buffer: Arc<MmapRingBuffer>, start_pos: usize, end_pos: usize) -> Self {
|
||
Self {
|
||
buffer,
|
||
start_pos,
|
||
end_pos,
|
||
}
|
||
}
|
||
|
||
/// 迭代视图中的帧
|
||
pub fn iter_frames(&self) -> impl Iterator<Item = &[u8]> {
|
||
(self.start_pos..self.end_pos)
|
||
.map(move |pos| self.buffer.read_frame(pos))
|
||
}
|
||
}
|
||
```
|
||
|
||
#### B. Detection模块集成
|
||
|
||
```rust
|
||
// detection.rs 优化版本
|
||
pub struct OptimizedDetectionController {
|
||
config: DetectionConfig,
|
||
event_bus: EventBus,
|
||
ring_buffer: Arc<MmapRingBuffer>,
|
||
frame_metadata: Arc<RwLock<HashMap<usize, FrameMetadata>>>,
|
||
}
|
||
|
||
impl OptimizedDetectionController {
|
||
pub async fn detection_loop(&mut self) -> Result<()> {
|
||
let mut last_processed_pos = 0;
|
||
|
||
loop {
|
||
let current_pos = self.ring_buffer.current_write_pos();
|
||
|
||
if current_pos > last_processed_pos {
|
||
// 创建视图，零拷贝访问帧
|
||
let view = RingBufferView::new(
|
||
Arc::clone(&self.ring_buffer),
|
||
last_processed_pos,
|
||
current_pos,
|
||
);
|
||
|
||
// 分析帧序列
|
||
if let Some(detection) = self.analyze_frames(view).await? {
|
||
// 发布检测事件
|
||
self.event_bus.publish(SystemEvent::MeteorDetected(detection))?;
|
||
}
|
||
|
||
last_processed_pos = current_pos;
|
||
}
|
||
|
||
// 避免忙等待
|
||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||
}
|
||
}
|
||
|
||
async fn analyze_frames(&self, view: RingBufferView) -> Result<Option<MeteorDetectedEvent>> {
|
||
// 使用SIMD优化的亮度计算
|
||
let brightness_values: Vec<f32> = view.iter_frames()
|
||
.map(|frame| self.calculate_brightness_simd(frame))
|
||
.collect();
|
||
|
||
// 检测算法...
|
||
Ok(None)
|
||
}
|
||
|
||
#[cfg(target_arch = "aarch64")]
|
||
fn calculate_brightness_simd(&self, frame: &[u8]) -> f32 {
|
||
use std::arch::aarch64::*;
|
||
|
||
unsafe {
|
||
let mut sum = vdupq_n_u32(0);
|
||
let chunks = frame.chunks_exact(16);
|
||
|
||
for chunk in chunks {
|
||
let data = vld1q_u8(chunk.as_ptr());
|
||
let data_u16 = vmovl_u8(vget_low_u8(data));
|
||
let data_u32 = vmovl_u16(vget_low_u16(data_u16));
|
||
sum = vaddq_u32(sum, data_u32);
|
||
}
|
||
|
||
// 累加SIMD寄存器中的值
|
||
let sum_array: [u32; 4] = std::mem::transmute(sum);
|
||
let total: u32 = sum_array.iter().sum();
|
||
|
||
total as f32 / frame.len() as f32
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 方案4: 分层内存管理
|
||
|
||
#### A. 内存层次结构
|
||
|
||
```rust
|
||
/// 分层内存管理器
|
||
pub struct HierarchicalMemoryManager {
|
||
// L1: 热数据 - 最近的帧在内存中
|
||
hot_cache: Arc<RwLock<LruCache<u64, Arc<FrameData>>>>,
|
||
|
||
// L2: 温数据 - 使用内存映射文件
|
||
warm_storage: Arc<MmapRingBuffer>,
|
||
|
||
// L3: 冷数据 - 压缩存储在磁盘
|
||
cold_storage: Arc<ColdStorage>,
|
||
|
||
// 统计信息
|
||
stats: Arc<MemoryStats>,
|
||
}
|
||
|
||
impl HierarchicalMemoryManager {
|
||
pub fn new(config: MemoryConfig) -> Result<Self> {
|
||
Ok(Self {
|
||
hot_cache: Arc::new(RwLock::new(
|
||
LruCache::new(config.hot_cache_frames)
|
||
)),
|
||
warm_storage: Arc::new(MmapRingBuffer::new(
|
||
config.warm_storage_frames,
|
||
config.frame_size,
|
||
)?),
|
||
cold_storage: Arc::new(ColdStorage::new(config.cold_storage_path)?),
|
||
stats: Arc::new(MemoryStats::default()),
|
||
})
|
||
}
|
||
|
||
/// 智能存储帧
|
||
pub async fn store_frame(&self, frame_id: u64, data: Arc<FrameData>) -> Result<()> {
|
||
// 更新热缓存
|
||
{
|
||
let mut cache = self.hot_cache.write().await;
|
||
cache.put(frame_id, Arc::clone(&data));
|
||
}
|
||
|
||
// 异步写入温存储
|
||
let warm_storage = Arc::clone(&self.warm_storage);
|
||
let data_clone = Arc::clone(&data);
|
||
tokio::spawn(async move {
|
||
warm_storage.write_frame(&data_clone.data).ok();
|
||
});
|
||
|
||
// 更新统计
|
||
self.stats.record_store(data.data.len());
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 智能获取帧
|
||
pub async fn get_frame(&self, frame_id: u64) -> Result<Arc<FrameData>> {
|
||
// 检查L1热缓存
|
||
{
|
||
let cache = self.hot_cache.read().await;
|
||
if let Some(data) = cache.peek(&frame_id) {
|
||
self.stats.record_hit(CacheLevel::L1);
|
||
return Ok(Arc::clone(data));
|
||
}
|
||
}
|
||
|
||
// 检查L2温存储
|
||
if let Some(data) = self.warm_storage.get_frame_by_id(frame_id) {
|
||
self.stats.record_hit(CacheLevel::L2);
|
||
let frame_data = Arc::new(FrameData::from_bytes(data));
|
||
|
||
// 提升到L1
|
||
self.promote_to_hot(frame_id, Arc::clone(&frame_data)).await;
|
||
|
||
return Ok(frame_data);
|
||
}
|
||
|
||
// 从L3冷存储加载
|
||
let data = self.cold_storage.load_frame(frame_id).await?;
|
||
self.stats.record_hit(CacheLevel::L3);
|
||
|
||
// 提升到L1和L2
|
||
self.promote_to_hot(frame_id, Arc::clone(&data)).await;
|
||
self.promote_to_warm(frame_id, &data).await;
|
||
|
||
Ok(data)
|
||
}
|
||
|
||
/// 内存压力管理
|
||
pub async fn handle_memory_pressure(&self) -> Result<()> {
|
||
let memory_info = sys_info::mem_info()?;
|
||
let used_percent = (memory_info.total - memory_info.avail) * 100 / memory_info.total;
|
||
|
||
if used_percent > 80 {
|
||
// 高内存压力，移动数据到下一层
|
||
self.evict_to_cold().await?;
|
||
} else if used_percent > 60 {
|
||
// 中等压力，清理热缓存
|
||
self.trim_hot_cache().await?;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Default)]
|
||
struct MemoryStats {
|
||
l1_hits: AtomicU64,
|
||
l2_hits: AtomicU64,
|
||
l3_hits: AtomicU64,
|
||
total_requests: AtomicU64,
|
||
bytes_stored: AtomicU64,
|
||
}
|
||
|
||
enum CacheLevel {
|
||
L1,
|
||
L2,
|
||
L3,
|
||
}
|
||
```
|
||
|
||
### 方案5: 内存监控与调优
|
||
|
||
#### A. 实时内存监控
|
||
|
||
```rust
|
||
use prometheus::{Gauge, Histogram, Counter};
|
||
|
||
pub struct MemoryMonitor {
|
||
// Prometheus metrics
|
||
memory_usage: Gauge,
|
||
allocation_rate: Counter,
|
||
gc_pause_time: Histogram,
|
||
frame_pool_usage: Gauge,
|
||
|
||
// 监控任务句柄
|
||
monitor_handle: Option<JoinHandle<()>>,
|
||
}
|
||
|
||
impl MemoryMonitor {
|
||
pub fn start(&mut self) -> Result<()> {
|
||
let memory_usage = self.memory_usage.clone();
|
||
let allocation_rate = self.allocation_rate.clone();
|
||
|
||
let handle = tokio::spawn(async move {
|
||
let mut interval = tokio::time::interval(Duration::from_secs(1));
|
||
|
||
loop {
|
||
interval.tick().await;
|
||
|
||
// 更新内存使用率
|
||
if let Ok(info) = sys_info::mem_info() {
|
||
let used_mb = (info.total - info.avail) / 1024;
|
||
memory_usage.set(used_mb as f64);
|
||
}
|
||
|
||
// 监控分配率
|
||
let allocator_stats = ALLOCATOR.stats();
|
||
allocation_rate.inc_by(allocator_stats.bytes_allocated);
|
||
}
|
||
});
|
||
|
||
self.monitor_handle = Some(handle);
|
||
Ok(())
|
||
}
|
||
|
||
/// 生成内存报告
|
||
pub fn generate_report(&self) -> MemoryReport {
|
||
MemoryReport {
|
||
current_usage_mb: self.memory_usage.get() as usize,
|
||
allocation_rate_mb_s: self.allocation_rate.get() / 1_000_000.0,
|
||
frame_pool_efficiency: self.calculate_pool_efficiency(),
|
||
recommendations: self.generate_recommendations(),
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
## 实施步骤
|
||
|
||
### 第一阶段：基础优化（1周）
|
||
1. ✅ 实现Arc共享帧数据
|
||
2. ✅ 优化事件总线避免数据拷贝
|
||
3. ✅ 添加基础内存监控
|
||
|
||
### 第二阶段：池化管理（1周）
|
||
1. ✅ 实现帧对象池
|
||
2. ✅ 集成到Camera模块
|
||
3. ✅ 添加池统计和调优
|
||
|
||
### 第三阶段：高级优化（2周）
|
||
1. ✅ 实现内存映射环形缓冲
|
||
2. ✅ 添加分层内存管理
|
||
3. ✅ SIMD优化关键路径
|
||
|
||
### 第四阶段：监控与调优（1周）
|
||
1. ✅ 完整的内存监控系统
|
||
2. ✅ 自动内存压力管理
|
||
3. ✅ 性能基准测试
|
||
|
||
## 预期效果
|
||
|
||
### 内存使用降低
|
||
- 帧数据拷贝：降低 **90%**
|
||
- 整体内存使用：降低 **60%**
|
||
- GC压力：降低 **80%**
|
||
|
||
### 性能提升
|
||
- 帧处理延迟：降低 **50%**
|
||
- CPU使用率：降低 **30%**
|
||
- 吞吐量：提升 **2-3倍**
|
||
|
||
### 系统稳定性
|
||
- 内存泄漏：完全避免
|
||
- OOM风险：显著降低
|
||
- 长期运行：稳定可靠
|
||
|
||
## 测试验证
|
||
|
||
```rust
|
||
#[cfg(test)]
|
||
mod memory_tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_zero_copy_performance() {
|
||
let frame_size = 640 * 480 * 3;
|
||
let iterations = 1000;
|
||
|
||
// 测试传统方式
|
||
let start = Instant::now();
|
||
for _ in 0..iterations {
|
||
let data = vec![0u8; frame_size];
|
||
let _clone1 = data.clone();
|
||
let _clone2 = data.clone();
|
||
}
|
||
let traditional_time = start.elapsed();
|
||
|
||
// 测试零拷贝方式
|
||
let start = Instant::now();
|
||
for _ in 0..iterations {
|
||
let data = Arc::new(vec![0u8; frame_size]);
|
||
let _ref1 = Arc::clone(&data);
|
||
let _ref2 = Arc::clone(&data);
|
||
}
|
||
let zero_copy_time = start.elapsed();
|
||
|
||
println!("Traditional: {:?}, Zero-copy: {:?}",
|
||
traditional_time, zero_copy_time);
|
||
assert!(zero_copy_time < traditional_time / 10);
|
||
}
|
||
|
||
#[test]
|
||
fn test_frame_pool_efficiency() {
|
||
let pool = FramePool::new(640, 480, FrameFormat::RGB888, 10);
|
||
|
||
// 测试复用
|
||
let frame1 = pool.acquire();
|
||
let addr1 = frame1.as_ptr();
|
||
drop(frame1);
|
||
|
||
let frame2 = pool.acquire();
|
||
let addr2 = frame2.as_ptr();
|
||
|
||
// 验证地址相同（复用成功）
|
||
assert_eq!(addr1, addr2);
|
||
}
|
||
}
|
||
```
|
||
|
||
这个内存优化方案将显著提升边缘设备的性能和稳定性，特别适合资源受限的树莓派环境。 |