参考博客:https://blog.csdn.net/qq_29350001/article/details/54024070
一: volatile 介绍
语法定义: volatile data-definition;
变量如果加了volatile修饰,则会从内存重新装载内容,而不是直接从寄存器拷贝内容。
应用场景:中断服务程序 + cpu相关寄存器的定义 (较多场合)
例:
// Led.c文件
#define GPC1CON *((volatile unsigned int*)0xE0200080)
#define GPC1DAT *((volatile unsigned int*)0xE0200084)
#define GPC1PUD *((volatile unsigned int*)0xE0200088)
// 隐式声明
void delay(unsigned int);
void led_test(void)
{
// 配置相应管脚为输出功能 GPC1_3
GPC1CON &= !(0x0F << 12);
GPC1CON |= (1<<12);
// GPC1_4 为输出功能
GPC1CON |= (1 << 16);
// 禁止内部上拉下拉功能
GPC1PUD &= ~(0x03 << 6);
GPC1PUD &= ~(0x03 << 8);
while(1)
{
// 灯亮
GPC1DAT |= (1 << 3);
GPC1DAT |= (1 << 4);
delay(0x100000);
// 灯灭
GPC1DAT &= ~(1 << 3);
GPC1DAT &= ~(1 << 4);
delay(0x100000);
}
}
void delay(unsigned int n)
{
unsigned int i = 0;
for (i = n; i != 0; i--);
}
编译:
arm-linux-gcc -c led.c -o led.o -nostdlib
不是用标准库,生成led.o文件
二: 为什么使用volatile
作用: 确保本条指令不会因编译器的优化而省略,且要求每次直接读值。
编译器如何对代码进行优化?
//示例一
#include <stdio.h>
int main (void)
{
int i = 10;
int a = i; //优化
int b = i;
printf ("i = %d\n", b);
return 0;
}
//编译优化、查看汇编
gcc -O2 -S test.c
cat test.s
.file "test.c"
.section .rodata.str1.1,"aMS",@progbits,1
.LC0:
.string "i = %d\n"
.section .text.startup,"ax",@progbits
.p2align 4,,15
.globl main
.type main, @function
main:
.LFB22:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
andl $-16, %esp
subl $16, %esp
movl $10, 8(%esp)
movl $.LC0, 4(%esp)
movl $1, (%esp)
call __printf_chk
xorl %eax, %eax
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE22:
.size main, .-main
.ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"
.section .note.GNU-stack,"",@progbits
//示例二
#include <stdio.h>
int main (void)
{
volatile int i = 10;
int a = i; //未优化
int b = i;
printf ("i = %d\n", b);
return 0;
}
//编译优化、查看汇编
gcc -O2 -S test.c
cat test.s
.file "test.c"
.section .rodata.str1.1,"aMS",@progbits,1
.LC0:
.string "i = %d\n"
.section .text.startup,"ax",@progbits
.p2align 4,,15
.globl main
.type main, @function
main:
.LFB22:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
andl $-16, %esp
subl $32, %esp
movl $10, 28(%esp)
movl 28(%esp), %eax
movl 28(%esp), %eax
movl $.LC0, 4(%esp)
movl $1, (%esp)
movl %eax, 8(%esp)
call __printf_chk
xorl %eax, %eax
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE22:
.size main, .-main
.ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"
.section .note.GNU-stack,"",@progbits
比较:
分析:
volatile 指出 i 是随时可能发生变化的,每次使用它的时候必须从 i 的地址中读取,因而编译器生成的汇编代码会重新从 i 的地址读取数据放在 b 中。而优化的做法是,由于编译器发现两次从 i 读数据的代码之间的代码没有对 i 进行过操作,它会自动把上次读的数据放在 b 中。而不是重新从 i 里面读。这样一来,如果 i 是一个寄存器变量或者表示一个端口数据就容易出错。 因此 volatile 可以保证对特殊地址的稳定访问。
#include <stdio.h>
#include <sys/timeb.h>
long long getSystemTime()
{
struct timeb t;
ftime(&t);
return 1000 * t.time + t.millitm;
}
#define TIME 1000000000
int main(void)
{
volatile int a, b = TIME; // volatile 修饰变量
int x, y = TIME; // 一般变量
long long start = 0, end = 0;
start = getSystemTime();
for (a = 0; a < b; a++);
end = getSystemTime();
printf("volatile 修饰变量用时: %lld ms\n", end - start);
start = getSystemTime();
for (x = 0; x < y; x++);
end = getSystemTime();
printf("一般变量用时: %lld ms \n", end - start);
return 0;
}
编译: gcc test.c
输出结果:
volatile 修饰变量用时: 3738 ms
一般变量用时: 3742 ms
优化编译: gcc -02 test.c
输出结果:
volatile 修饰变量用时: 3550 ms
一般变量用时: 0 ms
分析:
for (int i = 0; i < 100000; i++); 用来测试空循环的速度的,但是编译器肯定要把它优化掉,根本就不执行。
for (volatile int i = 0; i < 100000; i++); 它就会执行。
说明: volatile 不会被编译器优化了。
1. 编译器优化介绍。
常用优化方法: (1) 将内存变量缓存到寄存器;(2) 调整指令顺序充分利用CPU指令流水线,常见的是重新排序读写指令。
2. volatile 总是与优化有关。
编译器有一种技术叫做数据流分析,分析程序中的变量在哪里赋值、在哪里使用、在哪里失效,分析结果可以用于常量合并,常量传播等优化。进一步可以消除一些代码。但有时这些优化不是程序所需要的。这时可以用 volatile 关键字禁止做这些优化。
volatile 的本意是 “易变的”。访问寄存器要比访问内存单元快的多,所以编译器一般都会作减少存取内存的优化,但有可能会读取数据。当要求使用 volatile 声明变量值得时候,系统总是重新从它所在的内存读取数据。即使它前面的指令刚刚从该处读取数据。精确地说就是,遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地质的稳定访问。如果不使用 volatile,则编译器将对所声明的语句进行优化。(volatile 关键字影响编译器编译的结果,用volatile 声明的变量表示该变量随时可能发生变化,与该变量有关的运算,不要进行编译优化,以免出错)
三、 volatile 使用
1. 并行设备的硬件寄存器(如:状态寄存器)
存储器映射的硬件寄存器通常也要加 volatile, 因为每次对他的读写都可能有不同意义。
2. 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
由于访问寄存器的速度要快过RAM,所以编译器一般都会作减少存取外部RAM的优化,例如:
static int i = 0; // i 为非自动变量
int main(void)
{
...
while(1)
{
if (i)
do something();
}
}
// Interrupt service routine
void ISR_2(void)
{
i = 1;
}
程序的本意是希望ISR_2中断产生时,在 main 函数中调用 do something 函数,但是由于编译器判断在 main 函数里面没有修改过 i,因此可能只执行一次对从 i 到某寄存器的读操作,然后每次 if 判断都只使用这个寄存器里面的“i副本”,导致 dosomething 永远也不会被调用。如果将变量加上 volatile 修饰,则编译器保证对此变量的读写操作都不会被优化(肯定执行)。此例中 i 也应该如此说明。
3. 多线程应用中被几个任务共享的变量
当两个线程都要用到某一个变量且该变量的值会被改变时,应该用 volatile 声明,该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器,那么两个线程有可能一个使用内存中的变量,一个使用寄存器中的变量,这会造成程序的错误执行。volatile 的意思是让编译器每次操作该变量时一定要从内存中真正取出,而不是使用已经存在寄存器中的值,如下:
volatile BOOL bStop = FALSE; // bStop 为共享全局变量
(1) 在一个线程中:
while(!bStop) { ... }
bStop = FALSE;
return;
(2) 在另外一个线程中,要终止上面的线程循环:
bStop = TRUE;
while(bStop);
等待上面的线程终止,如果bStop不使用volatile申明,那么这个循环将是一个死循环,因为 bStop 已经读取到了寄存器中。寄存器中bStop的值永远不会变成FALSE,加上volatile,程序在执行时,每次均从内存中读出 bStop 的值,就不会死循环了。
四: volatile 问题和总结
总结: volatile 关键字是一种类型修饰符,用它声明的类型变量表示可以被某些编译器未知的因素更改。volatile 提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候,都会直接从变量地址中读取数据。如果没有 volatile 关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一i致的现象。所以 遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。