C语言再学习 -- 关键字volatile

原文链接：链接

一、volatile 介绍

参看：volatile详解

参看：C Language Keywords

Indicates that a variable can be changed by a background routine.

Keyword volatile is an extreme opposite of const.It indicates that a variable may be changed in a way which is absolutely unpredictable by analysing the normal program flow (for example, a variable which may be changed by an interrupt handler). This keyword uses the following syntax:

volatile data-definition;

Every reference to the variable will reload the contents from memory rather than take advantage of situations where a copy can be in a register.

翻译：

表示一个变量也许会被后台程序改变，关键字 volatile 是与 const 绝对对立的。它指示一个变量也许会被某种方式修改，这种方式按照正常程序流程分析是无法预知的（例如，一个变量也许会被一个中断服务程序所修改）。这个关键字使用下列语法定义：

volatile data-definition;

变量如果加了 volatile 修饰，则会从内存重新装载内容，而不是直接从寄存器拷贝内容。 

volatile应用比较多的场合，在中断服务程序和cpu相关寄存器的定义。

示例：

volatile 用于相关寄存器定义

1. //编译led.c文件

2.  

3. #define GPC1CON *((volatile unsigned int*)0xE0200080)

4. #define GPC1DAT *((volatile unsigned int*)0xE0200084)

5. #define GPC1PUD *((volatile unsigned int*)0xE0200088)

6. //隐式声明

7. void delay (unsigned int);

8. void led_test (void) {

9. //配置相应管脚为输出功能 GPC1_3

10. GPC1CON &= ~(0x0f << 12);

11. GPC1CON |= (1 << 12);

12. //GPC1_4为输出功能

13. GPC1CON |= (1 << 16);

14. //禁止内部上拉下拉功能

15. GPC1PUD &= ~(0x03 << 6);

16. GPC1PUD &= ~(0x03 << 8);

17. while (1) {

18. //灯亮

19. GPC1DAT |= (1 << 3);

20. GPC1DAT |= (1 << 4);

21. delay (0x100000);

22. //灯灭

23. GPC1DAT &= ~(1 << 3);

24. GPC1DAT &= ~(1 << 4);

25. delay (0x100000);

26. }

27. }

28.  

29. void delay (unsigned int n) {

30. unsigned int i = 0;

31. for (i = n; i != 0; i--);

32. }

33.  

34. 编译：

35. arm-linux-gcc -c led.c -o led.o –nostdlib

36. 不使用标准库，生成led.o文件

二、为什么使用 volatile

我们上一篇文章讲到了 const 和 volatile 关键字是一种类型修饰符。volatile 的作用 是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。

现在考虑一个问题，编译器如何对代码进行优化的？

我们看一个例子：

1. //示例一

2. #include <stdio.h>

3. int main (void)

4. {

5. int i = 10;

6. int a = i; //优化

7. int b = i;

8.  

9. printf ("i = %d\n", b);

10. return 0;

11. }

1. //编译优化、查看汇编

2. gcc -O2 -S test.c

3. cat test.s

4.  

5. .file "test.c"

6. .section .rodata.str1.1,"aMS",@progbits,1

7. .LC0:

8. .string "i = %d\n"

9. .section .text.startup,"ax",@progbits

10. .p2align 4,,15

11. .globl main

12. .type main, @function

13. main:

14. .LFB22:

15. .cfi_startproc

16. pushl %ebp

17. .cfi_def_cfa_offset 8

18. .cfi_offset 5, -8

19. movl %esp, %ebp

20. .cfi_def_cfa_register 5

21. andl $-16, %esp

22. subl $16, %esp

23. movl $10, 8(%esp)

24. movl $.LC0, 4(%esp)

25. movl $1, (%esp)

26. call __printf_chk

27. xorl %eax, %eax

28. leave

29. .cfi_restore 5

30. .cfi_def_cfa 4, 4

31. ret

32. .cfi_endproc

33. .LFE22:

34. .size main, .-main

35. .ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"

36. .section .note.GNU-stack,"",@progbits

1. //示例二

2. #include <stdio.h>

3. int main (void)

4. {

5. volatile int i = 10;

6. int a = i; //未优化

7. int b = i;

8.  

9. printf ("i = %d\n", b);

10. return 0;

11. }

1. //编译优化、查看汇编

2. gcc -O2 -S test.c

3. cat test.s

4.  

5. .file "test.c"

6. .section .rodata.str1.1,"aMS",@progbits,1

7. .LC0:

8. .string "i = %d\n"

9. .section .text.startup,"ax",@progbits

10. .p2align 4,,15

11. .globl main

12. .type main, @function

13. main:

14. .LFB22:

15. .cfi_startproc

16. pushl %ebp

17. .cfi_def_cfa_offset 8

18. .cfi_offset 5, -8

19. movl %esp, %ebp

20. .cfi_def_cfa_register 5

21. andl $-16, %esp

22. subl $32, %esp

23. movl $10, 28(%esp)

24. movl 28(%esp), %eax

25. movl 28(%esp), %eax

26. movl $.LC0, 4(%esp)

27. movl $1, (%esp)

28. movl %eax, 8(%esp)

29. call __printf_chk

30. xorl %eax, %eax

31. leave

32. .cfi_restore 5

33. .cfi_def_cfa 4, 4

34. ret

35. .cfi_endproc

36. .LFE22:

37. .size main, .-main

38. .ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"

39. .section .note.GNU-stack,"",@progbits

比较：

可以清楚的看到：使用 volatile 的代码编译未优化。

volatile 指出 i 是随时可能发生变化的，每次使用它的时候必须从 i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在 b 中。而优化做法是，由于编译器发现两次从 i读数据的代码之间的代码没有对 i 进行过操作，它会自动把上次读的数据放在 b 中。而不是重新从 i 里面读。这样以来，如果 i是一个寄存器变量或者表示一个端口数据就容易出错，所以说 volatile 可以保证对特殊地址的稳定访问。

如果上述例子，还是不够明显：

1. #include <stdio.h>

2. #include <sys/timeb.h>

3. long long getSystemTime() {

4. struct timeb t;

5. ftime(&t);

6. return 1000 * t.time + t.millitm;

7. }

8.  

9. #define TIME 1000000000

10.  

11. int main(void)

12. {

13.  

14. volatile int a, b = TIME; /* volatile修饰变量 */

15. int x, y = TIME; /* 一般变量 */

16. long long start = 0, end = 0;

17.  

18. start=getSystemTime();

19. for (a = 0; a < b; a++);

20. end=getSystemTime();

21. printf("vloatile修饰变量用时: %lld ms\n", end - start);

22.  

23. start=getSystemTime();

24. for (x = 0; x < y; x++);

25. end=getSystemTime();

26. printf("一般变量用时: %lld ms\n", end - start);

27.  

28. return 0;

29. }  

1. 编译：gcc test.c

2. 输出结果：

3. vloatile修饰变量用时: 3738 ms

4. 一般变量用时: 3742 ms

1. 优化编译：gcc -O2 test.c

2. 输出结果：

3. vloatile修饰变量用时: 3550 ms

4. 一般变量用时: 0 ms

可明显看出：

for(int i=0; i<100000; i++);
这个语句用来测试空循环的速度的，但是编译器肯定要把它优化掉，根本就不执行。
如果你写成，
for(volatile int i=0; i<100000; i++);

它就会执行了。

我们用上面的例子基本已经搞明白，volatile 不会被编译器优化了，现在讲点理论知识。

参看：C语言中volatile关键字的作用

1、编译器优化介绍：
由于内存访问速度远不及CPU处理速度，为提高机器整体性能，在硬件上引入硬件高速缓存Cache，加速对内存的访问。另外在现代CPU中指令的执行并不一定严格按照顺序执行，没有相关性的指令可以乱序执行，以充分利用CPU的指令流水线，提高执行速度。以上是硬件级别的优化。再看软件一级的优化：一种是在编写代码时由程序员优化，另一种是由编译器进行优化。编译器优化常用的方法有：将内存变量缓存到寄存器；调整指令顺序充分利用CPU指令流水线，常见的是重新排序读写指令。对常规内存进行优化的时候，这些优化是透明的，而且效率很好。由编译器优化或者硬件重新排序引起的问题的解决办法是在从硬件（或者其他处理器）的角度看必须以特定顺序执行的操作之间设置内存屏障（memory barrier），Linux 提供了一个宏解决编译器的执行顺序问题。
void Barrier(void)
这个函数通知编译器插入一个内存屏障，但对硬件无效，编译后的代码会把当前CPU寄存器中的所有修改过的数值存入内存，需要这些数据的时候再重新从内存中读出。

2、volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以消除一些代码。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做这些优化。

volatile的本意是“易变的” 因为访问寄存器要比访问内存单元快的多,所以编译器一般都会作减少存取内存的优化，但有可能会读脏数据。当要求使用volatile声明变量值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。精确地说就是，遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问；如果不使用valatile，则编译器将对所声明的语句进行优化。（简洁的说就是：volatile关键词影响编译器编译的结果，用volatile声明的变量表示该变量随时可能发生变化，与该变量有关的运算，不要进行编译优化，以免出错）

三、volatile 使用

1、并行设备的硬件寄存器（如：状态寄存器）

存储器映射的硬件寄存器通常也要加 voliate，因为每次对它的读写都可能有不同意义。

例如：
假设要对一个设备进行初始化，此设备的某一个寄存器为0xff800000。

1. int *output = (unsigned int *)0xff800000;//定义一个IO端口；

2. int init(void)

3. {

4. int i;

5. for(i=0;i< 10;i++){

6. *output = i;

7. }

8. }

经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为 9，所以编译器最后给你编译编译的代码结果相当于：

1. int init(void)

2. {

3. *output = 9;

4. }

如果你对此外部设备进行初始化的过程是必须是像上面代码一样顺序的对其赋值，显然优化过程并不能达到目的。反之如果你不是对此端口反复写操作，而是反复读操作，其结果是一样的，编译器在优化后，也许你的代码对此地址的读操作只做了一次。然而从代码角度看是没有任何问题的。这时候就该使用volatile通知编译器这个变量是一个不稳定的，在遇到此变量时候不要优化。

再例如上面提到的 volatile 用于相关寄存器定义

1. //编译led.c文件

2.  

3. #define GPC1CON *((volatile unsigned int*)0xE0200080)

4. #define GPC1DAT *((volatile unsigned int*)0xE0200084)

5. #define GPC1PUD *((volatile unsigned int*)0xE0200088)

6. //隐式声明

7. void delay (unsigned int);

8. void led_test (void) {

9. //配置相应管脚为输出功能 GPC1_3

10. GPC1CON &= ~(0x0f << 12);

11. GPC1CON |= (1 << 12);

12. //GPC1_4为输出功能

13. GPC1CON |= (1 << 16);

14. //禁止内部上拉下拉功能

15. GPC1PUD &= ~(0x03 << 6);

16. GPC1PUD &= ~(0x03 << 8);

17. while (1) {

18. //灯亮

19. GPC1DAT |= (1 << 3);

20. GPC1DAT |= (1 << 4);

21. delay (0x100000);

22. //灯灭

23. GPC1DAT &= ~(1 << 3);

24. GPC1DAT &= ~(1 << 4);

25. delay (0x100000);

26. }

27. }

28.  

29. void delay (unsigned int n) {

30. unsigned int i = 0;

31. for (i = n; i != 0; i--);

32. }

33.  

34. 编译：

35. arm-linux-gcc -c led.c -o led.o –nostdlib

36. 不使用标准库，生成led.o文件

#define GPC1CON *((volatile unsigned int*)0xE0200080)   怎么理解？

这里其实就是定义了一个指针变量。

GPC1CON 为寄存器名称、0xE0200080 为寄存器地址、(volatile unsigned int*) 为强制类型转换。

我们知道 volatile 和 const 一样为类型修饰符，不改变变量类型。

寄存器地址为什么要加 volatile 修饰呢？

是因为，这些寄存器里面的值是随时变化的。如果我们没有将这个地址强制类型转换成 volatile，那么我们在使用GPC1CON 这个寄存器的时候， 会直接从 CPU 的寄存器中取值。因为之前GPC1CON  被访问过，也就是之前就从内存中取出 GPC1CON 的值保存到某个寄存器中。之所以直接从寄存器中取值，而不去内存中取值，是因为编译器优化代码的结果（访问 CPU寄存器比访问 RAM 快的多）。用 volatile 关键字对 0xE0200080  进行强制转换，使得每一次访问 GPC1CON 时，执行部件都会从 0xE0200080  这个内存单元中取出值来赋值给 GPC1CON  。

2、一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)

由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化，例如：

1. static int i=0; //i 为非自动变量

2. int main(void)

3. {

4. ...

5. while (1){

6. if (i) dosomething();

7. }

8. ｝

9. /* Interrupt service routine. */

10. void ISR_2(void)

11. {

12. i=1;

13. }

程序的本意是希望 ISR_2 中断产生时，在main函数中调用 dosomething 函数，但是，由于编译器判断在 main 函数里面没有修改过 i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致 dosomething 永远也不会被调用。如果将变量加上 volatile 修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。

3、多线程应用中被几个任务共享的变量

当两个线程都要用到某一个变量且该变量的值会被改变时，应该用 volatile 声明，该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值，如下：

1. volatile BOOL bStop = FALSE; //bStop 为共享全局变量

2. (1) 在一个线程中：

3. while( !bStop ) { ... }

4. bStop = FALSE;

5. return;

6.  

7. (2) 在另外一个线程中，要终止上面的线程循环：

8. bStop = TRUE;

9. while( bStop );

等待上面的线程终止，如果bStop不使用volatile申明，那么这个循环将是一个死循环，因为bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。

四、volatile 问题和总结

volatile 常见的几个面试题：

1、一个参数既可以是const还可以是volatile吗？

可以，例如只读的状态寄存器。它是 volatile 因为它可能被意想不到地改变。它是 const 因为 程序不应该试图去修改它。

2、一个指针可以是 volatile 吗？

可以，当一个中服务子程序修改一个指向一个 buffer 的指针时。

3、下面的函数有什么错误： 

1. int square(volatile int *ptr)

2. {

3. return *ptr * *ptr;

4. }

这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码： 

1. int square(volatile int *ptr)

2. {

3. int a,b;

4. a = *ptr;

5. b = *ptr;

6. return a * b;

7. }

  由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下： 

1. long square(volatile int *ptr)

2. {

3. int a;

4. a = *ptr;

5. return a * a;

6. }

总结：

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改。volatile 提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如 果没有 volatile 关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。所以遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。