Volatile Variable - Revision history

Proj user14 at 02:21, 18 December 2016

2016-12-18T02:21:48Z

Preet at 22:19, 18 October 2012

2012-10-18T22:19:11Z

Preet at 16:57, 18 September 2012

2012-09-18T16:57:14Z

Preet at 16:55, 18 September 2012

2012-09-18T16:55:36Z

Preet: Created page with "This famous '''volatile''' variable article... Reading this article might just find you a job because C/C++ interviews tend to have this very common question on the list! Th..."

2012-09-18T16:54:16Z

Created page with "This famous '''volatile''' variable article... Reading this article might just find you a job because C/C++ interviews tend to have this very common question on the list! Th..."

New page

This famous '''volatile''' variable article... Reading this article might just find you a job because C/C++ interviews tend to have this very common question on the list!

The textbook definition of a volatile variable is:
"Any variable that is subject to change externally should be declared volatile".

This often doesn't click in people's mind on what the '''volatile''' keyword actually does. It has to do with the way CPUs work and the way compilers optimize your programs. Let's assume that you are compiling in GCC with optimizations turned on and we've got a following loop:
<syntaxhighlight lang="c">
// Assume you have a CPU register called UART_STATUS
// and you expect bit 0 to set sometime in near future
while(UART_STATUS & (1 << 0) == 0) {
; // Keep waiting
}
</syntaxhighlight>

If UART_STATUS variable is not volatile, you've got a potential infinite loop even if the bit sets. This is a GCC optimization technique that has gotten you in trouble.

Assembly code without volatile:
<syntaxhighlight lang="assembly">
LOAD R0, &UART_STATUS
LOOP:
CHECK R0, BIT0
JUMP LOOP IF R0
</syntaxhighlight>

Assembly code *with* volatile:
<syntaxhighlight lang="assembly">
LOOP:
LOAD R0, &UART_STATUS
CHECK R0, BIT0
JUMP LOOP IF R0
</syntaxhighlight>

<BR/>
=== Compiler Optimization ===
The compiler basically optimizes the loop taking for granted that the memory variable UART_STATUS is not changing INSIDE the loop, therefore, there is no need for a LOAD from memory instructions inside the loop, thus enhancing the loop performance. Using volatile keyword in this case tells the compiler that the variable '''is subject to change externally (outside of the context of the loop), therefore it should reload the memory whenever it is referenced'''.

@@ Line 11: / Line 11: @@
+}
 </syntaxhighlight>
-−
 If UART_STATUS variable is not volatile, you've got a potential infinite loop even if the bit sets due to GCC optimization technique.  Remember that CPUs have to bring information from MEMORY to REGISTERS and GCC may optimize your code such that MEMORY to REGISTER instruction is minimally used to enhance performance.

@@ Line 15: / Line 15: @@
 If UART_STATUS variable is not volatile, you've got a potential infinite loop even if the bit sets.  This is a GCC optimization technique that has gotten you in trouble.
-Assembly code without volatile:
+'''Assembly code without volatile:'''
 <syntaxhighlight lang="asm">
 LOAD R0, &UART_STATUS
@@ Line 23: / Line 23: @@
 </syntaxhighlight>
-Assembly code *with* volatile:
+'''Assembly code *with* volatile:'''
 <syntaxhighlight lang="asm">
 LOOP:
@@ Line 33: / Line 33: @@
 <BR/>
 === Compiler Optimization ===
-The compiler basically optimizes the loop taking for granted that the memory variable UART_STATUS is not changing INSIDE the loop, therefore, there is no need for a LOAD from memory instructions inside the loop, thus enhancing the loop performance.  Using volatile keyword in this case tells the compiler that the variable '''is subject to change externally (outside of the context of the loop), therefore it should reload the memory whenever it is referenced'''.
+The compiler basically optimizes the loop taking for granted that the memory variable UART_STATUS is not changing INSIDE the loop, therefore, there is no need for a LOAD from memory instruction inside the loop.  This enhances the loop performance.  Using volatile keyword in this case tells the compiler that the variable '''is subject to change externally (outside of the context of the loop), therefore it should reload the memory whenever it is referenced'''.

@@ Line 1: / Line 1: @@
-This famous '''volatile''' variable article...  Reading this article might just find you a job because C/C++ interviews tend to have this very common question on the list!
+This famous '''volatile''' variable article...  Reading this article might just find you a job because C/C++ interviews tend to have this very common question on the list!  The textbook definition of a volatile variable is:
 "Any variable that is subject to change externally should be declared volatile".
-This often doesn't click in people's mind on what the '''volatile''' keyword actually does.  It has to do with the way CPUs work and the way compilers optimize your programs.  Let's assume that you are compiling in GCC with optimizations turned on and we've got a following loop:
+This often doesn't click in people's mind on what the '''volatile''' keyword actually does.  It has to do with the way CPUs work and the way compilers optimize your programs.  Let's assume that you are compiling in GCC with optimizations turned on and you're working on a loop until a certain bit is set :
 <syntaxhighlight lang="c">
 // Assume you have a CPU register called UART_STATUS
@@ Line 13: / Line 12: @@
 </syntaxhighlight>
-If UART_STATUS variable is not volatile, you've got a potential infinite loop even if the bit sets.  This is a GCC optimization technique that has gotten you in trouble.
+If UART_STATUS variable is not volatile, you've got a potential infinite loop even if the bit sets due to GCC optimization technique.  Remember that CPUs have to bring information from MEMORY to REGISTERS and GCC may optimize your code such that MEMORY to REGISTER instruction is minimally used to enhance performance.
 '''Assembly code without volatile:'''
@@ Line 33: / Line 33: @@
 <BR/>
 === Compiler Optimization ===
-The compiler basically optimizes the loop taking for granted that the memory variable UART_STATUS is not changing INSIDE the loop, therefore, there is no need for a LOAD from memory instruction inside the loop.  This enhances the loop performance.  Using volatile keyword in this case tells the compiler that the variable '''is subject to change externally (outside of the context of the loop), therefore it should reload the memory whenever it is referenced'''.
+The compiler basically optimizes the loop taking for granted that the memory variable UART_STATUS is not changing INSIDE the loop, therefore, there is no need for a (re)LOAD from memory instruction inside the loop.  Using volatile keyword in this case tells the compiler that the variable '''is subject to change externally (outside of the context of the loop), therefore it should reload the memory whenever it is referenced'''.