整个测试分为5部分：
0 t* D0 l) k  N# g+ t, H8 P
+ p+ \' V8 U( t. n1. flash 读取速度
+ y! Q6 J8 p8 \! W: F5 n( ~2. flash 写入速度
3. SRAM读取速度
4. SRAM写入速度
7 f- L5 O& R* b1 g: h! O5. DMA传输速度

" p2 z' D; h; o1 O6 l这个测试的代码工程是基于前一篇分享文章做的，具体工程搭建可以参考上一篇文章查看。
【STM32H5 评测】CPU核心性能 - STM32H5E5跑 RTOS，观察任务切换速度、中断响应快慢
/ [9 ?2 Q9 C; r3 u2 ^7 Z

• 1. flash 读取速度
  

flash读性能测试，一次性读取32kbyte flash大小来测试耗时

1. #define MEM_BUF_SIZE    (32u * 1024u)   /* 32KB，足够体现带宽，不超 SRAM */
   
2. 
   ! K8 E8 l" ~0 T; N% t
3. static void run_flash_read_test(void)
   0 d/ g' \6 q, c
4. {
   
5.     const volatile uint32_t *src = (const volatile uint32_t *)0x08010000;
   
6.     const uint32_t words = MEM_BUF_SIZE / 4u;
   / ~  k' W+ e7 o5 v- j
7. 
   . L. t7 \7 o3 P3 |. _- A2 B
8.     uint32_t t0 = DWT_GET();
   3 ^( U- i" [2 o5 f. P8 I4 p
9.     for (uint32_t i = 0; i < words; i++)
   
10.         mem_dst[i] = src[i];
    
11.     uint32_t cycles = DWT_GET() - t0;
    
12. 
    
13.     printf("[3a] Flash Read  : %lu cycles -> %lu MB/s\r\n", cycles, cycles_to_mbps(MEM_BUF_SIZE, cycles));
    
14. }

复制代码

• 2. flash写入速度
  7 R  j! @0 n# A: y% u; e( t/ K

9 ^* H8 M" m& @4 c* g: vflash写入性能测试，这里将flash的擦除做了分别计时，写入的话只测了8kbyte大小。
# Y8 ^4 r1 E- `8 w

1. static void run_flash_write_test(void)
   
2. {
   
3.     FLASH_EraseInitTypeDef erase = {0};
   
4.     uint32_t sector_error = 0;
   ' A. ^" Q1 E2 Y# m* `$ r4 i5 N& s2 V
5.     uint32_t t0, erase_cycles, write_cycles;
   & Y' k. `4 R6 ^9 A
6. 
   
7.     /* 擦除计时 */
   ; W; ?4 P% ~# G3 D6 N
8.     HAL_FLASH_Unlock();
   - X4 C2 q  J  Y$ Z1 t
9.     erase.TypeErase = FLASH_TYPEERASE_SECTORS;
   ) b( A. g. r: R5 [" B" J: k' q
10.     erase.Banks     = FLASH_BANK_2;
    ! w9 R7 d5 |: Q( ^+ p
11.     erase.Sector    = FLASH_TEST_SECTOR;
    
12.     erase.NbSectors = 1;
    + w, f8 I6 C( I9 I9 K0 g+ ^
13. 
    
14.     t0 = DWT_GET();
    
15.     HAL_FLASHEx_Erase(&erase, &sector_error);
    7 W$ T* N+ ^5 l% v0 ~
16.     erase_cycles = DWT_GET() - t0;
    
17. 
    
18.     if (sector_error != 0xFFFFFFFFu)
    5 L3 o  z; r& M' Y; R
19.     {
    * I1 n8 c1 \% s5 o) ]8 N  o
20.         HAL_FLASH_Lock();
    - C% f( z& F$ ~/ {1 Q* `
21.         printf("[3b] Flash Erase : FAILED (sector error 0x%lX)\r\n", sector_error);
    
22.         return;
    
23.     }
    4 |1 N: t0 ~, s
24. 
    6 ?2 y! M, z' K* ]/ Q7 s4 K+ A
25.     /* 写入计时: 每次写 16 字节，共写 FLASH_TEST_SIZE 字节 */
    & G  T9 e8 h) P2 V% z+ t: i  p
26.     uint64_t pattern[2] = {0xDEADBEEFCAFEBABEull, 0x0123456789ABCDEFull};
    
27.     t0 = DWT_GET();
    ) ^: W/ A8 H, d& j5 C7 [- h
28.     for (uint32_t offset = 0; offset < FLASH_TEST_SIZE; offset += FLASH_WRITE_UNIT)
    
29.     {
    
30.         HAL_FLASH_Program(FLASH_TYPEPROGRAM_QUADWORD,
    " `, Z2 r/ f: U9 {7 x; m
31.         FLASH_TEST_ADDR + offset,
    
32.         (uint32_t)pattern);
    
33.     }
    ( ]3 R: c; G3 b& @$ P% k
34.     write_cycles = DWT_GET() - t0;
    $ L5 {; w( w$ K. K7 Z2 G0 P3 A
35.     HAL_FLASH_Lock();
    9 K6 z9 V* v2 C5 S# B, t
36. 
    . n/ d' n3 e; ~! N# T/ j  s& G" Z( F
37.     uint32_t erase_ms = CYCLES_TO_NS(erase_cycles) / 1000000u;
    & ~3 {2 n7 n& s! G0 p/ o7 j" b
38.     printf("[3b] Flash Erase : %lu cycles = %lu ms  (8KB)\r\n", erase_cycles, erase_ms);
    
39.     printf("[3b] Flash Write : %lu cycles -> %lu MB/s  (8KB)\r\n", write_cycles,
    
40.         (uint32_t)((uint64_t)FLASH_TEST_SIZE * CPU_FREQ_MHZ * 1000000u / ((uint64_t)write_cycles * 1024u * 1024u)));
    
41. }

复制代码

• 3. SRAM读取速度
  - _+ g8 [* \" E( L

) B5 q) S' S" Q! V6 ISRAM读取速度是通过一次性读取32kbyte来测试耗时

1. static void run_sram_read_test(void)
   
2. {
   9 }; f' V( B) S9 @" V9 u
3.     const volatile uint32_t *src = (const volatile uint32_t *)mem_src;
   
4.     const uint32_t words = MEM_BUF_SIZE / 4u;
     D# V: B- i+ Q6 ^% A" [
5. 
   
6.     /* 先填充，避免读到全零被优化掉 */
   
7.     for (uint32_t i = 0; i < words; i++)
   
8.         ((volatile uint32_t *)mem_src)[i] = i;

复制代码

• 4. SRAM写入速度
  

SRAM写入速度是通过一次性写入32kbyte来测试耗时

1. static void run_sram_write_test(void)
   ) S: I( o" Z# e3 T
2. {
   6 {# V" j! n: ^4 C4 Q
3.     volatile uint32_t *dst = (volatile uint32_t *)mem_dst;
   
4.     const uint32_t words = MEM_BUF_SIZE / 4u;
   ' g6 ]4 N2 k" e% e7 Z
5. 
   2 K- G& h1 O3 e& {& P4 n; t% o
6.     uint32_t t0 = DWT_GET();
   ; t  b+ V1 p! a. a$ u
7.     for (uint32_t i = 0; i < words; i++)
   " [$ ^% o4 }, Y9 O
8.         dst[i] = i;

复制代码

• 5. DMA传输速度
  % `& _! ~1 B, \7 t5 C

DMA传输是通过两个32kbyte大小的SRAM之间搬运数据，计算耗时

1. static volatile uint8_t dma_done;
   
2. 
   
3. void GPDMA1_Channel0_IRQHandler(void)
   ' T1 l( e& M' o. q
4. {
   . F0 J. Y& H; F0 H/ d+ c! f
5.     GPDMA1_Channel0->CFCR = GPDMA1_Channel0->CSR;  /* 清除所有标志 */
   
6.     dma_done = 1;
   ( o6 j) ~: p6 e' L8 c5 W1 ^
7. }
   
8. 
   
9. static void run_dma_test(void)
   7 k& e9 s  O* [' D! f- M
10. {
    . K6 V6 Q5 k. c
11.     /* 使能 GPDMA1 时钟 */
    
12.     __HAL_RCC_GPDMA1_CLK_ENABLE();
    ) S+ g1 [- ]$ j6 {4 s/ m
13. 
    
14.     /* 初始化源缓冲区 */
    
15.     for (uint32_t i = 0; i < MEM_BUF_SIZE; i++)
      G8 v% K' J& k+ [
16.         mem_src[i] = (uint8_t)i;

复制代码

最后编译代码，观察串口打印日志：
$ c% H3 I8 ?4 f/ V& g2 O3 a6 Z! G
[3] Memory Bandwidth Test (32 KB buffer)...
[3a] Flash Read  : 61639 cycles -> 126 MB/s
[3b] Flash Erase : 408500 cycles = 1 ms  (8KB)
[3b] Flash Write : 90731 cycles -> 21 MB/s  (8KB)
3 K, y, M! {) G[3b] SRAM Write  : 40971 cycles -> 190 MB/s
[3c] SRAM Read   : 49283 cycles -> 158 MB/s
6 K$ G8 H% g) h: Y0 p( b, d/ e[3d] DMA Transfer: 45942 cycles -> 170 MB/s  (32 KB)

  t  a! `% Y1 u; s* j3 c
从测试结果来看，性能还是非常不错的。