volatile (computer programming)
In computer programming, volatile means that a value is prone to change over time, outside the control of some code. Volatility has implications within function calling conventions, and also impacts how variables are stored, accessed and cached.
In the C, C++, C#, and Java programming languages, the volatile keyword indicates that a value may change between different accesses, even if it does not appear to be modified. This keyword prevents an optimizing compiler from optimizing away subsequent reads or writes and thus incorrectly reusing a stale value or omitting writes. Volatile values primarily arise in hardware access (memory-mapped I/O), where reading from or writing to memory is used to communicate with peripheral devices, and in threading, where a different thread may have modified a value.
Despite being a common keyword, the behavior of volatile differs significantly between programming languages, and is easily misunderstood. In C and C++, it is a type qualifier, like const, and is a property of the type. Furthermore, in C and C++ it does not work in most threading scenarios, and that use is discouraged. In Java and C#, it is a property of a variable and indicates that the object to which the variable is bound may mutate, and is specifically intended for threading. In the D programming language, there is a separate keyword shared for the threading usage, but no volatile keyword exists.
In C and C++
In C, and consequently C++, the volatile keyword was intended to:[1]
- allow access to memory-mapped I/O devices
- allow uses of variables between
setjmpandlongjmp - allow uses of
sig_atomic_tvariables in signal handlers.
Since variables marked as volatile are prone to change outside the standard flow of code, the compiler has to perform every read and write to the variable as indicated by the code. Any access to volatile variables cannot be optimised away, e.g. by use of registers for storage of intermediate values.
While intended by both C and C++, the C standards fail to express that the volatile semantics refer to the lvalue, not the referenced object. The respective defect report DR 476 (to C11) is still under review with C17.[2]
Operations on volatile variables are not atomic, nor do they establish a proper happens-before relationship for threading. This is specified in the relevant standards (C, C++, POSIX, WIN32),[1] and volatile variables are not threadsafe in the vast majority of current implementations. Thus, the usage of volatile keyword as a portable synchronization mechanism is discouraged by many C/C++ groups.[3][4][5]
Example of memory-mapped I/O in C
In this example, the code sets the value stored in foo to 0. It then starts to poll that value repeatedly until it changes to 255:
static int foo;
void bar(void) {
foo = 0;
while (foo != 255)
;
}
An optimizing compiler will notice that no other code can possibly change the value stored in foo, and will assume that it will remain equal to 0 at all times. The compiler will therefore replace the function body with an infinite loop similar to this:
void bar_optimized(void) {
foo = 0;
while (true)
;
}
However, foo might represent a location that can be changed by other elements of the computer system at any time, such as a hardware register of a device connected to the CPU. The above code would never detect such a change; without the volatile keyword, the compiler assumes that the current program is the only part of the system that could change the value (which is by far the most common situation).
To prevent the compiler from optimizing code as above, the volatile keyword is used:
static volatile int foo;
void bar (void) {
foo = 0;
while (foo != 255)
;
}
With this modification the loop condition will not be optimized away, and the system will detect the change when it occurs.
Generally, there are memory barrier operations available on platforms (which are exposed in C++11) that should be preferred instead of volatile as they allow the compiler to perform better optimization and more importantly they guarantee correct behaviour in multi-threaded scenarios; neither the C specification (before C11) nor the C++ specification (before C++11) specifies a multi-threaded memory model, so volatile may not behave deterministically across OSes/compilers/CPUs.[6]
Optimization comparison in C
The following C programs, and accompanying assembler language excerpts, demonstrate how the volatile keyword affects the compiler's output. The compiler in this case was GCC.
While observing the assembly code, it is clearly visible that the code generated with volatile objects is more verbose, making it longer so the nature of volatile objects can be fulfilled. The volatile keyword prevents the compiler from performing optimization on code involving volatile objects, thus ensuring that each volatile variable assignment and read has a corresponding memory access. Without the volatile keyword, the compiler knows a variable does not need to be reread from memory at each use, because there should not be any writes to its memory location from any other thread or process.
| Assembly comparison | |
|---|---|
Without volatile keyword |
With volatile keyword
|
# include <stdio.h>
int main() {
/* These variables will never be created on stack*/
int a = 10, b = 100, c = 0, d = 0;
/* "printf" will be called with arguments "%d" and
110 (the compiler computes the sum of a+b),
hence no overhead of performing addition at
run-time */
printf("%d", a + b);
/* This code will be removed via optimization, but
the impact of 'c' and 'd' becoming 100 can be
seen while calling "printf" */
a = b;
c = b;
d = b;
/* Compiler will generate code where printf is
called with arguments "%d" and 200 */
printf("%d", c + d);
return 0;
}
|
# include <stdio.h>
int main() {
volatile int a = 10, b = 100, c = 0, d = 0;
printf("%d", a + b);
a = b;
c = b;
d = b;
printf("%d", c + d);
return 0;
}
|
| gcc -S -O3 -masm=intel noVolatileVar.c -o without.s | gcc -S -O3 -masm=intel VolatileVar.c -o with.s |
.file "noVolatileVar.c" .intel_syntax noprefix .section .rodata.str1.1,"aMS",@progbits,1 .LC0: .string "%d" .section .text.startup,"ax",@progbits .p2align 4,,15 .globl main .type main, @function main: .LFB11: .cfi_startproc sub rsp, 8 .cfi_def_cfa_offset 16 mov esi, 110 mov edi, OFFSET FLAT:.LC0 xor eax, eax call printf mov esi, 200 mov edi, OFFSET FLAT:.LC0 xor eax, eax call printf xor eax, eax add rsp, 8 .cfi_def_cfa_offset 8 ret .cfi_endproc .LFE11: .size main, .-main .ident "GCC: (GNU) 4.8.2" .section .note.GNU-stack,"",@progbits |
.file "VolatileVar.c" .intel_syntax noprefix .section .rodata.str1.1,"aMS",@progbits,1 .LC0: .string "%d" .section .text.startup,"ax",@progbits .p2align 4,,15 .globl main .type main, @function main: .LFB11: .cfi_startproc sub rsp, 24 .cfi_def_cfa_offset 32 mov edi, OFFSET FLAT:.LC0 mov DWORD PTR [rsp], 10 mov DWORD PTR [rsp+4], 100 mov DWORD PTR [rsp+8], 0 mov DWORD PTR [rsp+12], 0 mov esi, DWORD PTR [rsp] mov eax, DWORD PTR [rsp+4] add esi, eax xor eax, eax call printf mov eax, DWORD PTR [rsp+4] mov edi, OFFSET FLAT:.LC0 mov DWORD PTR [rsp], eax mov eax, DWORD PTR [rsp+4] mov DWORD PTR [rsp+8], eax mov eax, DWORD PTR [rsp+4] mov DWORD PTR [rsp+12], eax mov esi, DWORD PTR [rsp+8] mov eax, DWORD PTR [rsp+12] add esi, eax xor eax, eax call printf xor eax, eax add rsp, 24 .cfi_def_cfa_offset 8 ret .cfi_endproc .LFE11: .size main, .-main .ident "GCC: (GNU) 4.8.2" .section .note.GNU-stack,"",@progbits |
C++11
According to the C++11 ISO Standard, the volatile keyword is only meant for use for hardware access; do not use it for inter-thread communication. For inter-thread communication, the standard library provides std::atomic<T> templates.[7]
In Java
The Java programming language also has the volatile keyword, but it is used for a somewhat different purpose. When applied to a field, the Java qualifier volatile provides the following guarantees:
- In all versions of Java, there is a global ordering on reads and writes of all volatile variables (this global ordering on volatiles is a partial order over the larger synchronization order (which is a total order over all synchronization actions)). This implies that every thread accessing a volatile field will read its current value before continuing, instead of (potentially) using a cached value. (However, there is no guarantee about the relative ordering of volatile reads and writes with regular reads and writes, meaning that it's generally not a useful threading construct.)
- In Java 5 or later, volatile reads and writes establish a happens-before relationship, much like acquiring and releasing a mutex.[8][9]
Using volatile may be faster than a lock, but it will not work in some situations before Java 5.[10] The range of situations in which volatile is effective was expanded in Java 5; in particular, double-checked locking now works correctly.[11]
In C#
In C#, volatile ensures that code accessing the field is not subject to some thread-unsafe optimizations that may be performed by the compiler, the CLR, or by hardware. When a field is marked volatile, the compiler is instructed to generate a "memory barrier" or "fence" around it, which prevents instruction reordering or caching tied to the field. When reading a volatile field, the compiler generates an acquire-fence, which prevents other reads and writes to the field from being moved before the fence. When writing to a volatile field, the compiler generates a release-fence; this fence prevents other reads and writes to the field from being moved after the fence.[12]
Only the following types can be marked volatile: all reference types, Single, Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Char, and all enumerated types with an underlying type of Byte, SByte, Int16, UInt16, Int32, or UInt32.[13] (This excludes value structs, as well as the primitive types Double, Int64, UInt64 and Decimal.)
Using the volatile keyword does not support fields that are passed by reference or captured local variables; in these cases, Thread.VolatileRead and Thread.VolatileWrite must be used instead.[12]
In effect, these methods disable some optimizations usually performed by the C# compiler, the JIT compiler, or the CPU itself. The guarantees provided by Thread.VolatileRead and Thread.VolatileWrite are a superset of the guarantees provided by the volatile keyword: instead of generating a "half fence" (ie an acquire-fence only prevents instruction reordering and caching that comes before it), VolatileRead and VolatileWrite generate a "full fence" which prevent instruction reordering and caching of that field in both directions.[12] These methods work as follows:[14]
- The
Thread.VolatileWritemethod forces the value in the field to be written to at the point of the call. In addition, any earlier program-order loads and stores must occur before the call toVolatileWriteand any later program-order loads and stores must occur after the call. - The
Thread.VolatileReadmethod forces the value in the field to be read from at the point of the call. In addition, any earlier program-order loads and stores must occur before the call toVolatileReadand any later program-order loads and stores must occur after the call.
The Thread.VolatileRead and Thread.VolatileWrite methods generate a full fence by calling the Thread.MemoryBarrier method, which constructs a memory barrier that works in both directions. In addition to the motivations for using a full fence given above, one potential problem with the volatile keyword that is solved by using a full fence generated by Thread.MemoryBarrier is as follows: due to the asymmetric nature of half fences, a volatile field with a write instruction followed by a read instruction may still have the execution order swapped by the compiler. Because full fences are symmetric, this is not a problem when using Thread.MemoryBarrier.[12]
In Fortran
VOLATILE is part of the Fortran 2003 standard,[15] although earlier version supported it as an extension. Making all variables volatile in a function is also useful finding aliasing related bugs.
integer, volatile :: i ! When not defined volatile the following two lines of code are identical write(*,*) i**2 ! Loads the variable i once from memory and multiplies that value times itself write(*,*) i*i ! Loads the variable i twice from memory and multiplies those values
By always "drilling down" to memory of a VOLATILE, the Fortran compiler is precluded from reordering reads or writes to volatiles. This makes visible to other threads actions done in this thread, and vice versa.[16]
Use of VOLATILE reduces and can even prevent optimization.[17]
References
- ↑ 1.0 1.1 "Publication on C++ standards committee". http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2016.html.
- ↑ Clarification Request Summary for C11. Version 1.13, October 2017.
- ↑ "Volatile Keyword In Visual C++". Microsoft MSDN. http://msdn2.microsoft.com/en-us/library/12a04hfd.aspx.
- ↑ "Linux Kernel Documentation – Why the "volatile" type class should not be used". kernel.org. https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html.
- ↑ "C++ and the Perils of Double-Checked Locking". DDJ. 2004. http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf.
- ↑ "Linux: Volatile Superstition". kerneltrap.org. 2007. http://kerneltrap.org/Linux/Volatile_Superstition.
- ↑ "volatile (C++)". Microsoft MSDN. https://msdn.microsoft.com/en-us/library/12a04hfd.aspx.
- ↑ Section 17.4.4: Synchronization Order "The Java® Language Specification, Java SE 7 Edition". Oracle Corporation. 2013. http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.4.4.
- ↑ "Java Concurrency: Understanding the 'Volatile' Keyword". dzone.com. 2021-03-08. https://dzone.com/articles/java-concurrency-understanding-the-volatile-keyword.
- ↑ "JSR 133 (Java Memory Model) FAQ". February 2004. https://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile.
- ↑ "Double-checked Locking (DCL) and how to fix it". Javamex. http://www.javamex.com/tutorials/double_checked_locking_fixing.shtml.
- ↑ 12.0 12.1 12.2 12.3 Albahari, Joseph. "Part 4: Advanced Threading". O'Reilly Media. http://www.albahari.com/threading/part4.aspx.
- ↑ Richter, Jeffrey (February 11, 2010). "Chapter 7: Constants and Fields". CLR Via C#. Microsoft Press. pp. 183. ISBN 978-0-7356-2704-8. https://archive.org/details/clrviac00rich_000.
- ↑ Richter, Jeffrey (February 11, 2010). "Chapter 28: Primitive Thread Synchronization Constructs". CLR Via C#. Microsoft Press. pp. 797–803. ISBN 978-0-7356-2704-8. https://archive.org/details/clrviac00rich_000.
- ↑ "VOLATILE Attribute and Statement". Cray. http://docs.cray.com/books/S-3692-51/html-S-3692-51/zfixedn3c8sk4c.html.
- ↑ "Volatile and shared array in Fortran". https://software.intel.com/en-us/forums/intel-moderncode-for-parallel-architectures/topic/279191.
- ↑ "VOLATILE". https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vnbq/index.html.
External links
 |  |
