高性能MCU的MPU与Cache优化详解

概述

在现代高性能单片机（如ARM Cortex-M7、Cortex-A系列在MCU中的应用）中，Memory Protection Unit (MPU) 和Cache系统的协同工作对系统性能有着决定性影响。本文将深入分析MPU配置如何影响Cache命中率，多主设备对RAM访问的竞争问题，以及Cache一致性维护策略。

高性能MCU的存储子系统架构

典型的多主设备架构

现代高性能MCU通常具有复杂的总线架构，支持多个主设备同时访问存储器：

STM32H7系列存储器映射

以STM32H7为例的详细存储器布局：

// STM32H7存储器映射定义
#define ITCM_BASE           0x00000000UL  // 指令TCM，64KB
#define FLASH_BASE          0x08000000UL  // Flash存储器，2MB
#define DTCM_BASE           0x20000000UL  // 数据TCM，128KB
#define SRAM1_BASE          0x20020000UL  // SRAM1，128KB
#define SRAM2_BASE          0x20040000UL  // SRAM2，128KB  
#define SRAM3_BASE          0x20060000UL  // SRAM3，32KB
#define SRAM4_BASE          0x38000000UL  // SRAM4，64KB
#define BACKUP_SRAM_BASE    0x38800000UL  // 备份SRAM，4KB
#define SDRAM_BASE          0xC0000000UL  // 外部SDRAM

// 各存储器的访问特性
typedef struct {
    uint32_t base_addr;
    uint32_t size;
    uint8_t  wait_states;      // 等待周期
    uint8_t  cache_policy;     // 缓存策略
    uint8_t  shareable;        // 是否可共享
    uint8_t  dma_coherent;     // DMA一致性
} memory_region_info_t;

static const memory_region_info_t memory_map[] = {
    {ITCM_BASE,    64*1024,  0, CACHE_WRITEBACK, 0, 1},   // ITCM - 零等待
    {DTCM_BASE,   128*1024,  0, CACHE_WRITEBACK, 0, 1},   // DTCM - 零等待
    {SRAM1_BASE,  128*1024,  1, CACHE_WRITEBACK, 1, 1},   // SRAM1 - 1等待周期
    {SRAM2_BASE,  128*1024,  1, CACHE_WRITEBACK, 1, 1},   // SRAM2 - 1等待周期
    {SRAM3_BASE,   32*1024,  1, CACHE_WRITEBACK, 1, 1},   // SRAM3 - 1等待周期
    {SRAM4_BASE,   64*1024,  2, CACHE_WRITETHROUGH, 1, 1}, // SRAM4 - 2等待周期
    {SDRAM_BASE, 32*1024*1024, 4, CACHE_WRITETHROUGH, 1, 1}, // SDRAM - 4等待周期
};

MPU配置对Cache性能的深度影响

1. 缓存策略的性能对比

不同的MPU缓存策略对性能有显著影响：

// 缓存策略性能测试
typedef enum {
    TEST_POLICY_NOCACHE = 0,      // 不缓存
    TEST_POLICY_WRITETHROUGH,     // 写通
    TEST_POLICY_WRITEBACK,        // 写回
    TEST_POLICY_WRITE_ALLOCATE    // 写分配
} cache_test_policy_t;

// 性能测试结果结构
typedef struct {
    uint32_t read_cycles;
    uint32_t write_cycles;
    uint32_t cache_hits;
    uint32_t cache_misses;
    float hit_ratio;
} performance_result_t;

// 配置MPU区域的详细函数
void configure_mpu_detailed(uint8_t region, uint32_t base_addr, uint32_t size_code,
                           uint8_t cache_policy, uint8_t access_perm) {
    // 禁用MPU进行配置
    MPU->CTRL = 0;
    __DSB();
    __ISB();
    
    // 选择区域
    MPU->RNR = region;
    
    // 设置基地址和有效位
    MPU->RBAR = base_addr | MPU_RBAR_VALID_Msk | region;
    
    // 构造RASR寄存器值
    uint32_t rasr = 0;
    rasr |= MPU_RASR_ENABLE_Msk;                    // 启用区域
    rasr |= (size_code << MPU_RASR_SIZE_Pos);       // 区域大小
    rasr |= (access_perm << MPU_RASR_AP_Pos);       // 访问权限
    
    // 根据缓存策略设置TEX、C、B位
    switch (cache_policy) {
        case TEST_POLICY_NOCACHE:
            // TEX=001, C=0, B=0 - 共享设备
            rasr |= (1 << MPU_RASR_TEX_Pos);
            rasr |= MPU_RASR_S_Msk;  // 共享
            break;
            
        case TEST_POLICY_WRITETHROUGH:
            // TEX=000, C=1, B=0 - 正常内存，写通，无写分配
            rasr |= MPU_RASR_C_Msk;
            break;
            
        case TEST_POLICY_WRITEBACK:
            // TEX=001, C=1, B=1 - 正常内存，写回，写分配
            rasr |= (1 << MPU_RASR_TEX_Pos);
            rasr |= MPU_RASR_C_Msk | MPU_RASR_B_Msk;
            break;
            
        case TEST_POLICY_WRITE_ALLOCATE:
            // TEX=001, C=1, B=1 - 正常内存，写回，读写分配
            rasr |= (1 << MPU_RASR_TEX_Pos);
            rasr |= MPU_RASR_C_Msk | MPU_RASR_B_Msk;
            break;
    }
    
    MPU->RASR = rasr;
    
    // 启用MPU
    MPU->CTRL = MPU_CTRL_ENABLE_Msk | MPU_CTRL_PRIVDEFENA_Msk;
    __DSB();
    __ISB();
}

// 综合性能测试
performance_result_t test_cache_performance(void *test_buffer, size_t buffer_size,
                                           cache_test_policy_t policy) {
    performance_result_t result = {0};
    
    // 配置测试区域的MPU
    uint32_t region_size_code = 0;
    size_t size = buffer_size;
    while (size > 1) {
        size >>= 1;
        region_size_code++;
    }
    region_size_code--; // MPU size encoding
    
    configure_mpu_detailed(7, (uint32_t)test_buffer, region_size_code, 
                          policy, MPU_REGION_FULL_ACCESS);
    
    // 清空Cache统计
    reset_cache_counters();
    
    // 读取性能测试
    uint32_t start_cycles = DWT->CYCCNT;
    volatile uint32_t *buffer = (volatile uint32_t*)test_buffer;
    
    for (int i = 0; i < buffer_size/4; i++) {
        volatile uint32_t data = buffer[i];  // 防止编译器优化
        (void)data;
    }
    
    result.read_cycles = DWT->CYCCNT - start_cycles;
    
    // 写入性能测试
    start_cycles = DWT->CYCCNT;
    
    for (int i = 0; i < buffer_size/4; i++) {
        buffer[i] = 0x12345678 + i;
    }
    
    result.write_cycles = DWT->CYCCNT - start_cycles;
    
    // 获取Cache统计
    get_cache_statistics(&result.cache_hits, &result.cache_misses);
    result.hit_ratio = (float)result.cache_hits / 
                      (result.cache_hits + result.cache_misses) * 100.0f;
    
    return result;
}

2. Cache行为分析与优化

// Cache行为分析工具
typedef struct {
    uint32_t line_size;        // Cache行大小
    uint32_t associativity;    // 组相联度
    uint32_t total_size;       // 总Cache大小
    uint32_t sets;             // 组数
} cache_info_t;

// 获取Cache信息（ARM Cortex-M7）
cache_info_t get_cache_info(void) {
    cache_info_t info = {0};
    
    // 读取Cache类型寄存器
    uint32_t ctr = __get_CTR();
    
    // L1数据Cache信息
    uint32_t dminline = (ctr >> 16) & 0xF;
    info.line_size = 4 << dminline;  // Cache行大小
    
    // 对于Cortex-M7，通常是4KB，4路组相联，32字节行
    info.total_size = 4096;
    info.associativity = 4;
    info.sets = info.total_size / (info.associativity * info.line_size);
    
    return info;
}

// Cache友好的数据结构设计
#define CACHE_LINE_SIZE 32

// 避免伪共享的结构设计
typedef struct {
    // 频繁访问的数据放在一起
    uint32_t hot_data[7];     // 28字节
    uint8_t  flag;            // 1字节
    uint8_t  padding[3];      // 填充到32字节边界
} __attribute__((aligned(CACHE_LINE_SIZE))) cache_optimized_struct_t;

// 多线程/多DMA场景下避免伪共享
typedef struct {
    volatile uint32_t cpu_counter;
    uint8_t cpu_padding[CACHE_LINE_SIZE - sizeof(uint32_t)];
    
    volatile uint32_t dma_counter;
    uint8_t dma_padding[CACHE_LINE_SIZE - sizeof(uint32_t)];
} __attribute__((aligned(CACHE_LINE_SIZE))) separated_counters_t;

// Cache预热和数据预取
void cache_warmup_and_prefetch(void *data, size_t size) {
    cache_info_t info = get_cache_info();
    volatile uint8_t *ptr = (uint8_t*)data;
    
    // 按Cache行进行预热
    for (size_t i = 0; i < size; i += info.line_size) {
        // 读取每个Cache行的第一个字节
        volatile uint8_t dummy = ptr[i];
        (void)dummy;
        
        // 使用ARM的预取指令（如果支持）
        #ifdef __ARM_FEATURE_UNALIGNED
        __PLD(ptr + i + info.line_size);  // 预取下一个Cache行
        #endif
    }
}

多主设备RAM访问冲突与优化

1. 总线仲裁和优先级配置

// STM32H7总线矩阵配置
typedef enum {
    BUS_MASTER_CPU = 0,
    BUS_MASTER_DMA1,
    BUS_MASTER_DMA2,
    BUS_MASTER_MDMA,
    BUS_MASTER_ETH,
    BUS_MASTER_USB,
    BUS_MASTER_GPU,
    BUS_MASTER_COUNT
} bus_master_t;

typedef struct {
    uint8_t priority;         // 0-15, 15最高优先级
    uint8_t round_robin;      // 是否启用轮询
    uint8_t fixed_priority;   // 固定优先级模式
} bus_arbitration_config_t;

// 配置总线仲裁优先级
void configure_bus_arbitration(void) {
    // 配置AHB总线矩阵寄存器 (具体地址依芯片而定)
    // 以下为概念性代码，实际地址需查阅参考手册
    
    // CPU获得最高优先级用于实时任务
    *((volatile uint32_t*)0x52005400) = 0x0F;  // CPU master priority
    
    // DMA获得中等优先级
    *((volatile uint32_t*)0x52005404) = 0x08;  // DMA1 priority
    *((volatile uint32_t*)0x52005408) = 0x08;  // DMA2 priority
    
    // 大容量传输设备获得较低优先级
    *((volatile uint32_t*)0x5200540C) = 0x04;  // ETH priority
    *((volatile uint32_t*)0x52005410) = 0x04;  // USB priority
    
    // 启用轮询仲裁减少饥饿
    *((volatile uint32_t*)0x52005420) = 0x01;  // Round-robin enable
}

// 内存带宽监控
typedef struct {
    uint32_t cpu_accesses;
    uint32_t dma_accesses;
    uint32_t conflicts;
    uint32_t wait_cycles;
    float bandwidth_utilization;
} memory_bandwidth_stats_t;

memory_bandwidth_stats_t monitor_memory_bandwidth(uint32_t duration_ms) {
    memory_bandwidth_stats_t stats = {0};
    
    // 启用性能计数器
    enable_bus_performance_counters();
    
    uint32_t start_time = HAL_GetTick();
    uint32_t start_cycles = DWT->CYCCNT;
    
    // 重置计数器
    reset_bus_counters();
    
    // 监控期间
    while (HAL_GetTick() - start_time < duration_ms) {
        // 继续正常操作
    }
    
    uint32_t total_cycles = DWT->CYCCNT - start_cycles;
    
    // 读取性能计数器
    stats.cpu_accesses = read_cpu_access_counter();
    stats.dma_accesses = read_dma_access_counter();
    stats.conflicts = read_conflict_counter();
    stats.wait_cycles = read_wait_cycle_counter();
    
    // 计算带宽利用率
    uint32_t total_accesses = stats.cpu_accesses + stats.dma_accesses;
    stats.bandwidth_utilization = (float)total_accesses / total_cycles * 100.0f;
    
    return stats;
}

2. DMA与CPU的Cache一致性管理

// DMA操作的Cache管理策略
typedef enum {
    DMA_CACHE_NONE = 0,       // 无Cache操作
    DMA_CACHE_CLEAN,          // 清理Cache
    DMA_CACHE_INVALIDATE,     // 使Cache无效
    DMA_CACHE_CLEAN_INVALIDATE // 清理并使无效
} dma_cache_operation_t;

// DMA传输前的Cache管理
void dma_transfer_prepare(void *buffer, size_t size, 
                         DMA_HandleTypeDef *hdma, 
                         dma_cache_operation_t cache_op) {
    // 确保地址Cache行对齐
    uint32_t addr = (uint32_t)buffer;
    uint32_t aligned_addr = addr & ~(CACHE_LINE_SIZE - 1);
    uint32_t aligned_size = ((addr + size + CACHE_LINE_SIZE - 1) & 
                            ~(CACHE_LINE_SIZE - 1)) - aligned_addr;
    
    // 根据传输方向执行Cache操作
    switch (cache_op) {
        case DMA_CACHE_CLEAN:
            // DMA从内存读取数据前，清理CPU Cache到内存
            SCB_CleanDCache_by_Addr((uint32_t*)aligned_addr, aligned_size);
            break;
            
        case DMA_CACHE_INVALIDATE:
            // DMA向内存写入数据前，使CPU Cache无效
            SCB_InvalidateDCache_by_Addr((uint32_t*)aligned_addr, aligned_size);
            break;
            
        case DMA_CACHE_CLEAN_INVALIDATE:
            // 双向传输，先清理再无效
            SCB_CleanInvalidateDCache_by_Addr((uint32_t*)aligned_addr, aligned_size);
            break;
            
        default:
            break;
    }
    
    // 确保操作完成
    __DSB();
    __ISB();
}

// DMA传输完成后的Cache管理
void dma_transfer_complete(void *buffer, size_t size, 
                          DMA_HandleTypeDef *hdma,
                          dma_cache_operation_t cache_op) {
    uint32_t addr = (uint32_t)buffer;
    uint32_t aligned_addr = addr & ~(CACHE_LINE_SIZE - 1);
    uint32_t aligned_size = ((addr + size + CACHE_LINE_SIZE - 1) & 
                            ~(CACHE_LINE_SIZE - 1)) - aligned_addr;
    
    // DMA写入完成后，使相关Cache无效
    if (cache_op == DMA_CACHE_INVALIDATE || 
        cache_op == DMA_CACHE_CLEAN_INVALIDATE) {
        SCB_InvalidateDCache_by_Addr((uint32_t*)aligned_addr, aligned_size);
    }
    
    __DSB();
    __ISB();
}

// 高性能DMA配置示例
void configure_high_performance_dma(DMA_HandleTypeDef *hdma) {
    // DMA优先级设置
    hdma->Init.Priority = DMA_PRIORITY_VERY_HIGH;
    
    // 使用双缓冲模式减少Cache冲突
    hdma->Init.Mode = DMA_DOUBLE_BUFFER_MODE;
    
    // 配置突发传输减少总线占用
    hdma->Init.PeriphBurst = DMA_PBURST_INC4;  // 4-word burst
    hdma->Init.MemBurst = DMA_MBURST_INC4;     // 4-word burst
    
    // FIFO模式优化传输效率
    hdma->Init.FIFOMode = DMA_FIFOMODE_ENABLE;
    hdma->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    
    HAL_DMA_Init(hdma);
}

3. 多主设备内存分配策略

// 基于访问模式的内存分配策略
typedef enum {
    MEMORY_USAGE_CPU_ONLY = 0,    // 仅CPU访问
    MEMORY_USAGE_DMA_ONLY,        // 仅DMA访问
    MEMORY_USAGE_SHARED,          // CPU和DMA共享
    MEMORY_USAGE_REALTIME         // 实时访问
} memory_usage_pattern_t;

typedef struct {
    void *base_addr;
    size_t size;
    memory_usage_pattern_t usage;
    uint8_t cache_policy;
    uint8_t mpu_region;
} memory_pool_t;

// 定义专用内存池
static memory_pool_t memory_pools[] = {
    // CPU密集型数据放在DTCM，零等待周期
    {(void*)DTCM_BASE, 128*1024, MEMORY_USAGE_CPU_ONLY, 
     CACHE_WRITEBACK, 0},
    
    // DMA缓冲区放在SRAM1，使用写通Cache减少一致性开销
    {(void*)SRAM1_BASE, 128*1024, MEMORY_USAGE_DMA_ONLY, 
     CACHE_WRITETHROUGH, 1},
    
    // 共享数据放在SRAM2，仔细管理Cache一致性
    {(void*)SRAM2_BASE, 128*1024, MEMORY_USAGE_SHARED, 
     CACHE_WRITETHROUGH, 2},
     
    // 实时数据放在SRAM3，关闭Cache确保确定性延迟
    {(void*)SRAM3_BASE, 32*1024, MEMORY_USAGE_REALTIME, 
     CACHE_DISABLE, 3}
};

// 智能内存分配器
void* allocate_optimized_memory(size_t size, memory_usage_pattern_t usage) {
    for (int i = 0; i < sizeof(memory_pools)/sizeof(memory_pools[0]); i++) {
        if (memory_pools[i].usage == usage && memory_pools[i].size >= size) {
            // 找到匹配的内存池
            memory_pool_t *pool = &memory_pools[i];
            
            // 配置对应的MPU区域
            configure_mpu_detailed(pool->mpu_region, 
                                 (uint32_t)pool->base_addr,
                                 get_mpu_size_code(pool->size),
                                 pool->cache_policy,
                                 MPU_REGION_FULL_ACCESS);
            
            // 从内存池分配
            // 这里简化处理，实际需要实现内存池管理
            return pool->base_addr;
        }
    }
    
    return NULL;  // 分配失败
}

// Cache感知的数据搬移函数
void cache_aware_memcpy(void *dest, const void *src, size_t size) {
    cache_info_t cache_info = get_cache_info();
    
    // 小数据量直接复制
    if (size <= cache_info.line_size) {
        memcpy(dest, src, size);
        return;
    }
    
    // 大数据量使用Cache优化策略
    const uint8_t *src_ptr = (const uint8_t*)src;
    uint8_t *dest_ptr = (uint8_t*)dest;
    
    // 处理非对齐的开头部分
    uint32_t src_align = (uint32_t)src_ptr & (cache_info.line_size - 1);
    if (src_align != 0) {
        uint32_t head_size = cache_info.line_size - src_align;
        head_size = (head_size > size) ? size : head_size;
        
        memcpy(dest_ptr, src_ptr, head_size);
        src_ptr += head_size;
        dest_ptr += head_size;
        size -= head_size;
    }
    
    // 按Cache行处理主体部分
    while (size >= cache_info.line_size) {
        // 预取下一个Cache行
        __PLD(src_ptr + cache_info.line_size);
        
        // 复制当前Cache行
        memcpy(dest_ptr, src_ptr, cache_info.line_size);
        
        src_ptr += cache_info.line_size;
        dest_ptr += cache_info.line_size;
        size -= cache_info.line_size;
    }
    
    // 处理剩余部分
    if (size > 0) {
        memcpy(dest_ptr, src_ptr, size);
    }
}

4. 实时性能监控和调优

// 实时性能监控结构
typedef struct {
    uint32_t timestamp;
    uint32_t cpu_cycles;
    uint32_t memory_stalls;
    uint32_t cache_misses;
    uint32_t dma_conflicts;
    float cpu_utilization;
    float memory_bandwidth;
} performance_snapshot_t;

#define PERF_HISTORY_SIZE 100
static performance_snapshot_t perf_history[PERF_HISTORY_SIZE];
static uint32_t perf_history_index = 0;

// 性能快照采集
void capture_performance_snapshot(void) {
    performance_snapshot_t *snapshot = &perf_history[perf_history_index];
    
    snapshot->timestamp = HAL_GetTick();
    snapshot->cpu_cycles = DWT->CYCCNT;
    
    // 读取性能计数器（需要事先配置）
    snapshot->memory_stalls = read_performance_counter(PERF_CNT_MEMORY_STALL);
    snapshot->cache_misses = read_performance_counter(PERF_CNT_CACHE_MISS);
    snapshot->dma_conflicts = read_bus_conflict_counter();
    
    // 计算利用率
    static uint32_t last_cycles = 0;
    static uint32_t last_timestamp = 0;
    
    if (last_timestamp != 0) {
        uint32_t time_diff = snapshot->timestamp - last_timestamp;
        uint32_t cycle_diff = snapshot->cpu_cycles - last_cycles;
        
        // CPU利用率 = 实际执行周期 / 可用周期
        snapshot->cpu_utilization = (float)cycle_diff / 
                                   (SystemCoreClock * time_diff / 1000) * 100.0f;
    }
    
    last_cycles = snapshot->cpu_cycles;
    last_timestamp = snapshot->timestamp;
    
    // 更新环形缓冲区索引
    perf_history_index = (perf_history_index + 1) % PERF_HISTORY_SIZE;
}

// 性能趋势分析
typedef struct {
    float avg_cpu_utilization;
    float avg_cache_hit_ratio;
    uint32_t peak_memory_stalls;
    uint32_t total_dma_conflicts;
    uint8_t performance_grade;  // 0-100分
} performance_analysis_t;

performance_analysis_t analyze_performance_trend(void) {
    performance_analysis_t analysis = {0};
    uint32_t valid_samples = 0;
    
    // 分析最近的性能数据
    for (int i = 0; i < PERF_HISTORY_SIZE; i++) {
        performance_snapshot_t *snapshot = &perf_history[i];
        
        if (snapshot->timestamp != 0) {
            analysis.avg_cpu_utilization += snapshot->cpu_utilization;
            
            // Cache命中率计算
            uint32_t total_accesses = snapshot->cache_misses + 
                                    estimate_cache_hits(snapshot);
            if (total_accesses > 0) {
                float hit_ratio = (float)(total_accesses - snapshot->cache_misses) /
                                 total_accesses * 100.0f;
                analysis.avg_cache_hit_ratio += hit_ratio;
            }
            
            // 峰值统计
            if (snapshot->memory_stalls > analysis.peak_memory_stalls) {
                analysis.peak_memory_stalls = snapshot->memory_stalls;
            }
            
            analysis.total_dma_conflicts += snapshot->dma_conflicts;
            valid_samples++;
        }
    }
    
    // 计算平均值
    if (valid_samples > 0) {
        analysis.avg_cpu_utilization /= valid_samples;
        analysis.avg_cache_hit_ratio /= valid_samples;
    }
    
    // 性能评分算法
    uint8_t cpu_score = (analysis.avg_cpu_utilization < 80) ? 
                       (100 - analysis.avg_cpu_utilization) : 20;
    uint8_t cache_score = analysis.avg_cache_hit_ratio;
    uint8_t stall_score = (analysis.peak_memory_stalls < 1000) ? 
                         100 : (2000 - analysis.peak_memory_stalls) / 10;
    uint8_t conflict_score = (analysis.total_dma_conflicts < 100) ? 
                            100 : (200 - analysis.total_dma_conflicts);
    
    analysis.performance_grade = (cpu_score + cache_score + 
                                 stall_score + conflict_score) / 4;
    
    return analysis;
}

// 自适应优化策略
void adaptive_performance_optimization(void) {
    performance_analysis_t analysis = analyze_performance_trend();
    
    // 根据分析结果调整系统配置
    if (analysis.avg_cache_hit_ratio < 85.0f) {
        // Cache命中率低，调整MPU配置
        puts("调整Cache策略以提高命中率");
        
        // 增加更多区域使用写回策略
        for (int i = 0; i < 4; i++) {
            if (memory_pools[i].cache_policy != CACHE_WRITEBACK) {
                configure_mpu_detailed(memory_pools[i].mpu_region,
                                     (uint32_t)memory_pools[i].base_addr,
                                     get_mpu_size_code(memory_pools[i].size),
                                     CACHE_WRITEBACK,
                                     MPU_REGION_FULL_ACCESS);
            }
        }
    }
    
    if (analysis.total_dma_conflicts > 50) {
        // DMA冲突较多，调整总线优先级
        puts("调整DMA优先级以减少总线冲突");
        configure_bus_arbitration();
    }
    
    if (analysis.avg_cpu_utilization > 90.0f) {
        // CPU利用率过高，启用更激进的预取
        puts("启用激进预取策略");
        
        // 启用硬件预取器（如果支持）
        enable_aggressive_prefetch();
    }
    
    // 打印优化建议
    printf("性能评分: %d/100\n", analysis.performance_grade);
    printf("CPU利用率: %.1f%%\n", analysis.avg_cpu_utilization);
    printf("Cache命中率: %.1f%%\n", analysis.avg_cache_hit_ratio);
    printf("最大内存停顿: %u周期\n", analysis.peak_memory_stalls);
    printf("DMA冲突总数: %u\n", analysis.total_dma_conflicts);
}