3. Cache 一致性问题
3.1 什么是 cache 一致性问题
所谓的 Cache 一致性问题， 主要指的是由于 D-cache 存在时，表现在有多个 Host（典型的如 MCU 的 Core， DMA 等）访问同一块内存时， 由于数据会缓存在 D-cache 中而没有更新实际的物理内存。
, T. P; e9 R2 ]/ e9 V& h/ D4 D" u
在实际应用中，有以下两种情况：
0 m& _9 a9 b, Q; v( t# F8 b
# X- [4 k1 q6 O0 `& o3 a第一种情况是当有写物理内存的指令时，Core 会先去更新相应的 cache-line（Write-back 策略），在没有 clean 的情况下，会导致其对应的实际物理内存中的数据并没有被更新，如果这个时候有其它的 Host（如 DMA）访问这段内存时，就会出现问题（由于实际物理内存并未被更新，和 D-cache 中的不一致），这就是所谓的 cache 一致性的问题。

! y/ l" H# s8 J! b' C0 Q4 h* W5 f! u

图3.1 Cache 一致性问题 第1种情况

+ x8 Q+ Z4 s0 n4 u7 O
第二种情况是 DMA 更新了某段物理内存（DMA 和 cache 直接没有直接通道），而这个时候 Core 再读取这段内存的时候，由于相对应地址的 cache-line 没有被 invalidate，导致 Core 读到的是 cache-line 中的数据，而非被 DMA 更新过的实际物理内存的数据。
! `! o) I# n% p9 R$ E( x, x: B
( _6 S( k9 G7 ^! Q

- J7 m% I" p% }' b5 K5 v! `

图3.2 Cache 一致性问题 第2种情况

/ X% i# t6 z3 m- C9 ?5 O
7 ?6 R, n# E; T0 v7 Z3.2 如何处理 cache 一致性问题
我们知道，Cache 机制是为了提高存储系统的平均读写性能而设计的，但是这种机制带来了数据一致性问题，然而，却没有对一致性的硬件支持。
/ w+ J& ~6 h4 `1 J* z; _7 w: M$ i
" l; E6 Q" [& x因此为了解决一致性问题，一个办法就是禁用 Cache（cache 都禁用了，肯定不会有 cache 一致性的问题啦~）。但是如果你选择使用 STM32F7 这样高性能的微控制器，又不使用其带来的高性能特性，那你为什么要用 F7 呢，用 F3、F4 不就得了么？所以为了提高性能，还是使能 cache，并积极解决 cache 一致性问题吧。

好吧，解决 STM32F7 的 cache 一致性问题，有两种可选方案：

7 A3 U, t" ~" H( L+ u/ ]( h所有的共享存储器都定义为共享属性
0 ^4 K9 L$ j8 j& \0 W
' Q  X$ N) d2 ^  B这些区域将默认不被缓存到 D-Cache。
" u4 G: u3 P7 [9 w& T所有的操作都直接针对二级存储器（内部Flash，外部存储器），性能降低。
因为缓存对这些区域是透明的，写软件更容易。

) i5 O6 X$ v, l通过软件进行cache的维护
（1）Cortex-M7 的写操作要是全局可见的

使用透写属性（通过 MPU 设置）。
, `) z2 `; I+ i0 Y( a4 k+ D使用 SIWT@CACR（Shared = Write Through）。
通过指令清 D-cache，然后所有更新位置禁止 D-Cache操作。
% H- r% x4 D0 T6 ~6 W（2）其他主设备的写操作要对 Cortex-M7 可见
  D$ S2 Z5 U* {& P5 L3 v. t
( {, ~/ N, m" G比如作废 Cortex-M7 Dache 中数据。
- w' M- m" Q1 A. S& P8 j3.3 示例
3.3.1 程序描述
( \; W3 |9 ^$ @（1）首先将地址 0x20020000（SRAM1）处开始的 128 字节初始化为 0x55。
（2）将 Flash 中的 128 字节的常量数组 aSRC_Const_Buffer 拷贝到 SRAM1 地址 0x20020000（pBuffer）。
- h2 X: n- h* P（3）配置并使能 DMA，通过 DMA 将数据从 SRAM1 的地址 0x20020000 处拷贝到 DTCM RAM 中的数组 aDST_Buffer 中。
（4）将 Flash 中的数组 aSRC_Const_Buffer 与 DMA 读出的数组 aDST_Buffer 进行比较。
- p; S  e+ N6 ]/ V" w& w
$ E0 g0 T* h1 Z# N1 }  s显然，这个例子中的 cache 一致性问题， 展示的是上面（图3.1）的第一种情况。也就是在 Write-back 策略下，CPU 先去更新相应的 cache-line，然后 DMA 去访问对应的内存，从而导致数据不一致的现象。

0 f' g' r  v. u: d3 R程数据的传输流程和路径如下图所示：
. J" g1 ^! l5 Q( [

+ u; g' ^# k+ ]2 }

图3.3 Cache 示例数据传输框图

+ A7 @/ f9 J8 V+ O5 i9 L- F' e
: p  Q% A0 `3 ^3.3.2 复现 cache 一致性问题
/ F: r' g$ \4 x) V9 Z我们先来按照示例要求编写代码，复现 cache 一致性问题。有些人可能会疑惑，变量数据怎么放到 Flash、SRAM1、DTCM？实际上，可以通过一些相关的配置文件进行设置，比如 icf 文件、scatter 文件等，当然，这跟所使用开发环境和编译工具链有关。

本文所使用的环境是 IAR，其链接文件 *.icf 如下：

然后将 aSRC_Const_Buffer 数组定义为常量，即可分配到 RO 区域，aDST_Buffer 定义为普通的全局变量或静态变量即可，因为内存区域从 0x20000000 开始，也就是 DTCM RAM。
  M; @6 W6 ?' I6 Q& E, D% R1 I  |- b% s
# y# T' U, m, t好了，代码主体部分如下：

& z# I, }9 j6 `% F$ r" @+ [

1. #define SRAM1_ADDRESS_START   (0x20020000UL)
   " S9 W6 K% S0 ]; N
2. 
   
3. static const uint32_t aSRC_Const_Buffer[BUFFER_SIZE] =
   
4. {
   
5.   0x01020304, 0x05060708, 0x090A0B0C, 0x0D0E0F10,
   " _+ j1 o$ _" p+ E3 H
6.   0x11121314, 0x15161718, 0x191A1B1C, 0x1D1E1F20,
   : `" |! J. {1 {& ^' G  ~, e! n
7.   0x21222324, 0x25262728, 0x292A2B2C, 0x2D2E2F30,
   
8.   0x31323334, 0x35363738, 0x393A3B3C, 0x3D3E3F40,
   
9.   0x41424344, 0x45464748, 0x494A4B4C, 0x4D4E4F50,
   - t5 P$ }  l- s; J) c0 }
10.   0x51525354, 0x55565758, 0x595A5B5C, 0x5D5E5F60,
    " _9 \9 V! G, L; d
11.   0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70,
    5 [, u+ G# L( W) U& {. v; ^, F1 a2 ^
12.   0x71727374, 0x75767778, 0x797A7B7C, 0x7D7E7F80
    
13. };
    
14. 
    7 E/ X3 l2 x2 U- o+ g6 `
15. static uint32_t aDST_Buffer[BUFFER_SIZE];
    . ]3 _; ?& C$ O# J& S; |  ~4 o* N
16. 
    
17. int main(void)
    2 n& ~' w* P" s! e- o* i% c2 @
18. {
    
19.   uint32_t counter = 0;
    
20.   uint32_t *pBuffer = (uint32_t*)SRAM1_ADDRESS_START;
    & z( d. k1 ~/ B( e8 x/ s% }
21. 
    
22.   if (HAL_Init() != HAL_OK)
    
23.   {
    6 o; U% L9 q; v" {1 Y
24.     Error_Handler();
    7 L% W. r  x9 E% j5 {9 f
25.   }
    : G& u$ J2 z4 k& D+ _; K3 N& E
26. 
    
27.   /* Initialize LEDs */
    
28.   BSP_LED_Init(LED1);
    
29. 
    + a  O" X. S9 E% V& S
30.   /* Configure the system clock to 216 MHz */
    . h. Q# W1 n. z: [2 U9 n' c0 \7 M
31.   SystemClock_Config();
    
32.   BSP_LCD_Config();
    - p6 h: \. r# Z* C8 p0 d
33. 
      f0 a: A7 g. Z! O1 o$ r
34.   /* Set to 1 if an transfer error is detected */
      m0 a3 v2 x6 r/ }, y
35.   transferErrorDetected = 0;
    & ]$ n+ Y/ ^, [# a4 {/ j
36.         
    - K5 B. ]6 r8 ]# Y8 @* {  Y
37.   /* Fill 128 bytes with 0x55 pattern */
    
38.   memset((uint8_t*)SRAM1_ADDRESS_START, 0x55, sizeof(aSRC_Const_Buffer));
    
39. 
    
40.   /* TODO:Enable MPU and change SRAM region attribute
    
41.   * set write-back policy on SRAM */
    5 [. t1 }! [+ K5 u. Q& I3 X
42.   MPU_Config();
    # _" r' m! ~! F/ S
43. 
    
44.   /* Enable Data cache */
    # D0 y% [& P% Q  X" k  s  \
45.   SCB_EnableDCache();
    0 C9 Q: |6 }& K. \+ K# o7 _
46. 
    $ I, v4 a0 ~) K5 K, [, @% Z
47.   /* Copy data from Flash to SRAM by CPU */
    
48.   for (counter = 0; counter < (sizeof(aSRC_Const_Buffer)/4); counter++)
    9 c7 k7 q7 X% Z2 ?9 J
49.   {
    
50.         *pBuffer++ = aSRC_Const_Buffer[counter];
    
51.   }
    / W9 j# e" d; t
52.         
    3 O  ~3 c& K+ n
53.   //* Configure and enable the DMA stream for Memory to Memory transfer */
    
54.   DMA_Config();
    ' A' L2 V4 N! u
55. 
    ' j% R3 A$ k: j8 U& B
56.   /* Wait for DMA end-of-transfer */
    9 U" v% v9 w1 }6 _% \5 ~4 E
57. 
    
58.   while(TransferCompleteFlag == RESET)
    , }6 [+ |+ M, L- U- W0 j4 `1 D2 v* p
59.   {
    6 o9 M5 W' i: [: ~/ O) G
60.   }
    
61. 
    ( R5 C  J7 h. d$ |6 ~3 [. M
62.   /* Check data integrity*/
    
63.   pBuffer = (uint32_t*)&aDST_Buffer;
    
64.   for(counter = 0; counter <(sizeof(aSRC_Const_Buffer)/4); counter++)
    
65.   {
    
66.                
    
67.     if(aSRC_Const_Buffer[counter] != *pBuffer)
    ' m2 l; @4 N  \& N% ]0 @
68.     {
    8 S! `6 F; e2 ~+ B) P
69.         compareErrorDetected++;
    5 x$ X  R0 G$ Z4 y* k3 L
70.     }
    
71.     pBuffer++;
    - x) r6 {9 F4 d. H6 M0 t* k. L
72.   }
    & C( d& i  p4 r" {
73.         
    7 k" M- a- H' X5 J$ |( v
74.   if (compareErrorDetected != 0)
    
75.   {
    
76.       /* Toggle LED1 */
      j! F1 T; a+ ?: Q- K
77.       BSP_LED_Off(LED1);
    
78.       compareErrorDetected = 0;        
    
79.       BSP_LCD_DisplayStringAtLine(10, (uint8_t *)"       Data comparation failed!      ");
    / Q0 |3 x5 X( ]# |- L1 l
80.   }
    
81.   else
    
82.   {
    
83.       /* Turn LED1 on */
    
84.       BSP_LED_On(LED1);
    # A  q' F, C  Z2 @' H( T6 @
85.       BSP_LCD_DisplayStringAtLine(10, (uint8_t *)"       Data comparation success!      ");
    2 z1 W, t0 O+ d1 z, @8 u2 A0 f8 O1 \
86.   }
    ' }6 ^( w* A" U% Y: k2 W" u
87. 
    
88.   while (1)
    
89.   {
    
90. 
    ! \  {9 s3 X; M* n. \/ V/ _
91.   }
    
92. }
    
93. 
    2 M5 g: |1 j! P- p8 ]4 f" A% d0 |
94. static void MPU_Config(void)
    1 j+ m: c" {9 J& Y3 r4 {- X, b
95. {
    ; E/ S% c' v- c/ F) }; ]
96.   /* Disable MPU */
    
97.   MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk;
    5 @! ]3 G  p: q" G4 P( H. [: {( `
98. 
    
99.   /* Configure RAM region as Region N°0, 256kB of size and R/W region */
    
100.   MPU->RNR  = SRAM1_REGION_NUMBER;
     
101.   MPU->RBAR = SRAM1_ADDRESS_START;
     : g2 o5 q) P$ [& J$ f
102.          
     ! g* p  k& n! E, }' y9 L
103.    /* Write-Back policy */
     
104.   MPU->RASR = SRAM1_SIZE | MPU_RASR_C_Msk | MPU_RASR_B_Msk | SRAM1_ACCESS_PERMISSION | 1<<MPU_RASR_TEX_Pos;
     % y2 p) |2 D, c; h4 {- `
105. 
     6 A0 N2 `0 p; r+ S9 {
106.   /* Enable MPU */
     
107.   MPU->CTRL |= MPU_CTRL_PRIVDEFENA_Msk | MPU_CTRL_ENABLE_Msk;
     $ P( L  G. d, F& n
108. }
     

复制代码

为了确保 aSRC_Const_Buffer 在 Flash，aDST_Buffer 在 DTCM，我们可以在编译完之后查看 *.map 文件，如下：

( K% q; \' n0 _/ g! ^) P

图3.4 检查常量和变量分配情况

/ E! ]# X4 W. @! X7 @, V2 a, i
下载到 STM32F769I-DISCO 板子上，显然，由于此时开启了 D-Cache，会出现数据不一致的现象，执行结果如下所示：

2 u7 f5 \" Z9 L, h5 q6 ?

图3.5 Cache 数据不一致

% _( F* z5 ]* K) y8 R3 `3.3.3 解决方案
（1）不启动 D-Cache
. x& b8 k+ e5 u3 M: l5 M% R
注释掉 SCB_EnableDCache();
2 \# q9 F( ~9 r/ Y4 a
$ j. O" q! }' S+ p5 z' n/ K不启动 D-Cache，当然也就没有了 Cache 数据不一致的问题啦~

6 ~4 f% H" x: Y, {1 v- H' n（2）将 SRAM1 相应区域设置为 shareable
; E" |% Y2 l5 ~) P2 ^- s1 @
# U' A) M* x7 h! O8 [7 `6 G通过 MPU 将 SRAM1 相应区域设置为 shareable，MPU_Config() 函数处理如下：

1. static void MPU_Config(void)
   3 g' Z( H& C3 a
2. {
   ( J5 |6 H& y2 g) N1 {* C
3.   /* Disable MPU */
   
4.   MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk;
   8 a9 o' _$ z" G! S" @
5. 
   
6.   /* Configure RAM region as Region N°0, 256kB of size and R/W region */
   $ R" U9 U7 r5 G1 u
7.   MPU->RNR  = SRAM1_REGION_NUMBER;
   0 R/ r) l7 c" j3 t) I
8.   MPU->RBAR = SRAM1_ADDRESS_START;
   8 P: h; A8 F" d& P) c4 V
9. 
   
10.   /* Shareable */
    . {1 G( M/ x+ {3 p$ p
11.   MPU->RASR = SRAM1_SIZE | MPU_RASR_S_Msk | SRAM1_ACCESS_PERMISSION;
    " Q, e7 i+ J' p5 q& }( F
12. 
    
13.   /* Enable MPU */
    8 u* m! Y! O* _' b, e
14.   MPU->CTRL |= MPU_CTRL_PRIVDEFENA_Msk | MPU_CTRL_ENABLE_Msk;
    1 p! _; w5 _4 H' T
15. }

复制代码

' |% y" d1 V0 o( ?9 h2 i（3）DMA 访问 SRAM1 前先 Clean cache
) b( A6 P6 Y" F0 @. b
2 Y/ D# q0 t/ P0 _8 c  p在启动 DMA 访问之前，程序员需要在合适的地方将 D-Cache 数据回写到主内存中，也就是 Clean 的操作。

) q0 h" m+ @& R/ S$ j8 Z在本示例中，可以在 DMA_Config(); 前调用：

1. SCB_CleanDCache();

复制代码

或者

1. SCB_CleanDCache_by_Addr((uint32_t*)SRAM1_ADDRESS_START, sizeof(aSRC_Const_Buffer));

复制代码

（4）将 SRAM1 相应区域设置为 Write-through 策略
. o0 C: g0 V* q5 u# y0 n/ ?
+ X) Y8 o" S' q, x# C" e4 ^! r$ x通过 MPU 将 SRAM1 相应区域设置为透写模式（Write-through），MPU_Config() 函数处理如下：
: [4 @- d; a: K+ s2 _  }0 b
7 t5 U$ d* N7 G# q

1. static void MPU_Config(void)
   
2. {
   , t: L, a/ p& \; W  ?; {' `
3.   /* Disable MPU */
   
4.   MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk;
   
5. 
   
6.   /* Configure RAM region as Region N°0, 256kB of size and R/W region */
   
7.   MPU->RNR  = SRAM1_REGION_NUMBER;
     I5 O/ Y" `( m
8.   MPU->RBAR = SRAM1_ADDRESS_START;
   
9. 
   
10.   /*Write Through policy*/
    
11.   MPU->RASR = SRAM1_SIZE | MPU_RASR_C_Msk | SRAM1_ACCESS_PERMISSION;
    4 V1 s2 {( w6 T, U
12. 
    6 f% p8 G2 h3 z. b2 P
13.   /* Enable MPU */
    
14.   MPU->CTRL |= MPU_CTRL_PRIVDEFENA_Msk | MPU_CTRL_ENABLE_Msk;
    
15. }

复制代码

! f' ~$ R+ [% e' h  X（5）将所有 cacheable 的空间全部强制 Write-though

通过 cache 控制寄存器，将所有 cacheable 的空间全部强制 Write-though 模式。
  V* p  ^( x" S. a* `" }

0 c9 \) X1 m8 R& Z

图3.6 CACR 寄存器（来自 PM0253）

在初始化的时候进行设置：

1. __FORCE_WRITE_THROUGH();

复制代码

6 R+ h2 K% {# R0 Z" t宏定义为：

1. #define __FORCE_WRITE_THROUGH()    *(__IO uint32_t *)0xE000EF9C = 1UL<<2

复制代码

以上这是都是较为常用的方法，在实际的开发过程中，为了提高性能，一般都会开启 cache，同时将其配置为 WB 策略，这就需要开发者在使用时特别小心！
0 N5 v7 W: ]# c
值得一提的是：对于第二种情况（图3.2），就不是 clean 操作了，而是 invalidate。需要先调用 SCB_InvalidateDCache() 或 SCB_InvalidateDCache_by_Addr() 去 invalidate 相应的 cache-line， 这样当 CPU 在读取时，会忽略 D-cache 中的内容，去真实的物理地址读取对应的数据。
4 X+ v! Y3 G) {8 c

0 L/ f2 G7 p& ^* K
8 o6 ]" U; a; ]0 Z

图3.7 Cache 数据一致

) `+ Q  W: u2 B9 @5 s
好啦，通过上述几种方法，就可以解决 cache 数据一致性问题。当然，除了我这里提供的，还有其他方案，各种方案各有利弊，要根据实际应用场景去衡量，这就是嵌入式程序员展示才华的时候啦~

  n! k. F4 [! o9 N. b+ A* D