Volatile Keyword in C – Guide with Code Examples

In C programming, efficient and dependable code can only be achieved successfully by understanding the complexities that involve the memory model and compiler optimizations. The volatile keyword undoubtedly is crucial in the functioning of the program in several situations especially when dealing with real-time programming, hardware interfaces, and multithreads. As C compilers are designed to optimise code to improve performance, some variables particularly those associated with hardware or interrupt service procedures might be altered beyond the control of the application.

In this guide, we will cover everything in detail about the Volatile keyword in C. We will learn how the volatile keyword in C works, its applications, advantages and disadvantages, and various code examples.

What is a Volatile Keyword in C?

Many programming languages allocate space in memory for storing variables so the compiler tries to make the best use of the available resources when accessing the data and performing operations. However, when working in programming environments where external processes such as hardware, interrupts, and threads can manipulate the variables, such optimization processes can lead to bizarre consequences. In this context, the volatile keyword is very important. Volatile keyword tells the compiler that this variable should not be regarded to be within the focus of the program being run as it can change at any point.

The volatile keyword tells the compiler that the value of a variable may be altered by an external event, such as:

• Hardware updates (registers or ports)
• Interrupt service routines (ISRs)
• Concurrent access in multithreaded programs

In simpler words, a volatile keyword instructs the compiler to get its value every time it fetches the variable, which in turn, stops the compiler from deleting redundant reads or writes.

Also Read: Identifiers in C Language

Syntax of Volatile Keyword in C Language

volatile with Data Types

The basic syntax for declaring the volatile keyword with data types in C is as follows:

volatile data_type variable_name

In the above syntax, a volatile variable of the designated data type is declared and given the variable name. To indicate that the variable’s value could change unexpectedly and that the compiler shouldn’t optimise it, therefore the keyword `volatile` is positioned before the variable name.

volatile with Pointers

The basic syntax for declaring the volatile keyword with pointers in C is as follows:

1. Pointer to volatile Data

volatile data_type *ptr_name;

Here, ptr_name is a pointer to volatile data_type, meaning the data type value it points to can change unexpectedly. This requires any dereferencing of *ptr_name to read directly from memory.

2. volatile Pointer to Data

data_type *volatile ptr_name;

Here, ptr_name itself is volatile, meaning the memory address stored in ptr_name may change unexpectedly. However, the data pointed to by ptr_name is non-volatile.

3. volatile Pointer to volatile Data

volatile data_type *volatile ptr_name;

Here, both ptr_name (the pointer) and the data it points to are volatile. This is helpful in cases when the data it references and the pointer itself may be altered externally.

These were the two ways by which we can use the volatile keyword in C so that our C program code can operate predictably and consistently in dynamic situations.

There are several reasons to use volatile keywords in C, as it ensures each access reads directly from memory, and the compiler doesn’t optimise or reorder accesses to the volatile variables, which is crucial when the variable can change without the compiler’s knowledge.

The volatile keyword is essential in the following scenarios:

• Hardware Programming: When working with hardware registers that fluctuate without the program’s intervention.
• Interrupt Service Routines (ISR): When an ISR and main code share a variable.
• Multi-threaded Programming: Programming that uses variables shared by several threads.

How does the Volatile Keyword work in C?

The term “volatile” in C indicates to the compiler that this variable might change the value at any time, for instance, if the hardware changes or the code jumps to an INTERUPT SERVICE ROUTINE  – all these aspects are beyond the purview of the C compiler. In more detail, a programmer requests the compiler to:

• Avoid Optimising Access: Most compilers do optimizations where they keep the values of variables in CPU registers or change the order of lines of code for better performance. So with volatile, the compiler cannot be sure that a particular value of a variable will be the one used in between two calls of that variable.

This means that every time the variable is active, it has to be accessed directly from memory and not from its cached copy in a register.

• Prevent Code Reordering for Volatile Variables: To enhance performance, it’s common for compilers to rearrange the order of lines, however, this can present problems when code invoking volatile variables interacts with these reordered lines, especially when these volatile variables are modified elsewhere within code or even external programs.

• Apply Strict Rules for Accessing Memory: For all available variable qualifiers, ‘volatile’ is the most crucial since it indicates that the value in these variables should not be cached in any way as they constantly change so there always exists some kind of a pointer to these variables in the memory.

Example:

Consider a scenario with a hardware status register that updates independently of the main program:

In this example, in the absence of a volatile keyword, the compiler may optimize the code by reading register_st only once and presume that register_st does not change inside the loop. This would stop the loop from identifying hardware modifications.

But by declaring register_st as volatile, the compiler is compelled to verify its value at every iteration, guaranteeing that variations brought about by outside influences are acknowledged.

Volatile keyword is known as the programmer’s friend in C programming. Although it’s a simple keyword, it works well to maintain our code in line with the programming’s unpredictable nature.

Examples of the Volatile Keyword in C

Let’s now see some code examples of using the volatile keyword in C.

Example 1: Using the volatile for memory-mapped counter device in C.

Output:

Explanation:

In this example,

• We have defined a CTR_REGISTER_ADD as 0x35000000, simulating a hardware counter device.
• We declared a ctr_register as a volatile pointer int* pointing to the counter’s address to ensure direct memory access.
• Inside an infinite loop, the program continuously reads from *ctr_register and detects changes.
• Finally, when curr differs from prev, it prints the updated counter value and sets prev to curr.

Example 2: Using the volatile keyword with ISR in C.

Output:

Explanation:

In this example,

• We have defined a volatile flag is_itr as volatile int, modified by the ISR on receiving a signal.
• Then a signal handler is created which registers handle_signal for SIGINT, which sets is_itr to 1 upon receiving the signal and prints a message.
• The main program waits for is_itr to be set by looping through it repeatedly.
• The program then prints “Interrupt flag detected” and ends the loop when is_itr equals 1.

Real-World Use Cases of volatile

1. Using volatile with Hardware Registers

Hardware registers or ports often change their values independently of the software flow. For example, check how the volatile keyword is used to access a hardware status register in C.

Example:

In this example, the ST_REGISTER is a memory-mapped register that is subject to change independently of the program. By declaring it as volatile, the software is guaranteed to always check the register’s current value.

2. volatile in Interrupt Service Routines

In embedded systems, variables modified in an ISR should be marked as volatile. See the below example for more details about interrupt service routines in C.

Example:

In this example, the compiler may optimise away the while loop’s read of the flag, if the flag is not declared volatile, presuming that it cannot change in the program’s regular flow.

3. Multithreading

In multithreaded applications, shared variables often need to be volatile. Here’s how it can be implemented in the C programming language.

Example:

In the absence of a volatile keyword, mySharedData might be stored in a register, preventing thread2 from ever seeing the update that thread1 made.

Advantages of the Volatile Keyword in C

Volatile keyword in C provides various advantages in specific scenarios, enhancing the code readability, and predictability in situations like hardware or system programming. Here are some of the benefits of the volatile keyword in C:

• Prevents Dangerous Optimizations

The keyword volatile also disallows the compiler from removing code that may seem redundant at a local level but is required for the entire system. This behaviour is critical when variables are changed outside the regular program flow, such as by an ISR or hardware device.

• Ensures Real-Time Data Access

The volatile keyword gives an assurance that each access to the variable will obtain the most recent version stored in the memory. This is valuable in situations involving embedded systems where hardware inputs cause the state of certain variables to change in real-time or frequently.

• Critical in Embedded Systems and Hardware Programming

For embedded systems, registers, ports, and memory-mapped I/Os are interfaces that are visible to hardware that operates outside the program flow. Declaring such registers as volatile enables a program to interact with these registers to always read the most up-to-date value of the register.

• Code Readability for Concurrency

When volatile is used in a multithreading context, it means that a particular value of a variable may change unexpectedly. This enhances code readability and also informs the coder that some variables are used by other threads or processes and thus cautions against making certain errors in multithreaded programming.

Disadvantages of the Volatile Keyword in C

While the volatile keyword provides benefits in C programming, it also comes with some drawbacks. Here are some of the disadvantages of the volatile keyword in C:

• No Thread Safety: As a safety measure, the volatile keyword is not to be used as a substitute for synchronisation primitives. In a multithreaded environment, the volatile variable may return up-to-date value with every access but does not provide any form of mutual exclusion to prevent data races. Therefore, volatility is not enough when attempting to guarantee thread safety.
• Increased Memory Access Overhead: These performance penalties might result because the compiler is algorithmically constrained and every time the volatile variable is invoked to be affected, it could go straight to the memory. Hence, on systems where register access is quicker than memory access, such overhead may lower efficiency, particularly in the cusp of loops.
• Potential for Misuse: Developers may incorrectly assume that volatile can handle concurrency and atomicity, leading to bugs in multithreaded applications.
• Limits Compiler Optimizations: When the variables are declared as volatile, it creates fewer opportunities for the compiler to conduct optimization, hence the performance of such types of applications is lower as opposed to where such markers will not be present.
• Less Debugging: Debugging could get more challenging. It could be due to variables changing as the program executes. “Volatile” variables can change abruptly, making it challenging to identify the cause of a problem.

Also Read: C Programming Interview Questions and Answers

Conclusion

The volatile keyword in C has great uses by systems programmers as well as by hardware-related codes and limited multitasking applications. We have covered the basic definitions of the volatile keyword, its syntax, how it works in C, and various code examples. The various benefits and drawbacks of using the volatile keyword in C have also been discussed in this guide.

The volatile keyword in C has the essence of driving memory accesses as it makes a program responsive to changes made to the data, which is critical in embedded and concurrent settings.  However, this volatile keyword has some drawbacks, like it does not address atomicity or thread safety issues, and may inhibit compiler optimizations.

It is important, therefore, to pay close attention to volatile keywords and use them only when necessary and for variables whose circumstances are beyond the current working stack. If you’re someone who wants to kickstart your coding career, consider pursuing Hero Vired’s Certificate Program in DevOps & Cloud Engineering, which is offered in collaboration with Microsoft.