Usage of volatile in C [Reproduced]

Volatile affects compiler compilation results. It is pointed out that volatile variables may change at any time. computation related to volatile variables should not be optimized to avoid errors, (VC ++ will compile and optimize the release executable code, and the computation related to variables with the volatile keyword will not be compiled and optimized .). Example: Volatile int I = 10; Int J = I ;... int K = I; volatile tells the compiler that I may change at any time. Each time you use it, you must read it from the address of I, therefore, the executable code generated by the compiler will re-read data from the I address and put it in K. The optimization method is that because the compiler finds that the code between the two data reads from I has not performed any operations on I, it will automatically put the data that was last read in K. Instead of reading from I again. In this way, if I is a register variable or indicates that data on a port is prone to errors, volatile can ensure stable access to special addresses without errors.

/**********************

A variable defined as volatile means that this variable may be unexpectedly changed, so that the compiler will not assume the value of this variable. Precisely, the optimizer must carefully re-read the value of this variable every time when using this variable, rather than using the backup stored in the register. The following are examples of volatile variables: 1) Hardware registers of parallel devices (for example, Status Registers) 2) non-automatic variables (non-automatic variables) 3) that will be accessed in an interrupt service subroutine) the variables shared by several tasks in multi-threaded applications cannot answer this question. I think this is the most basic problem to distinguish between C programmers and embedded system programmers. Embedded people often deal with hardware, interruptions, RTOS, etc. All of these require volatile variables. If you do not know volatile content, it will lead to disasters. If the subject correctly answers this question (well, I suspect it will be the case), I will go a little deeper to see if this guy understands the full importance of volatile. 1) can a parameter be const or volatile? Explain why. 2) can a pointer be volatile? Explain why. 3); what is the error in the following function: int square (volatile int * PTR) {return * PTR ** PTR;} The following is the answer: 1) Yes. One example is read-only status registers. It is volatile because it may be unexpectedly changed. It is const because the program should not try to modify it. 2); yes. Although this is not very common. One example is when a service subroutine repairs a pointer to a buffer. 3) This code is a little abnormal. The purpose of this Code is to return the pointer * PTR points to the square of the value. However, since * PTR points to a volatile parameter, the compiler will generate code similar to the following: int square (volatile int * PTR) {int A, B; A = * PTR; B = * PTR; return a * B ;} * The value of * PTR may be unexpectedly changed, so a and B may be different. As a result, this Code may not return the expected square value! The correct code is as follows: Long square (volatile int * PTR) {int A; A = * PTR; return a * A;} bit operation (bit manipulation)

//*********************

The keyword volatile is often used in embedded programming. The usage of volatile can be summarized as follows:

I. Tell compiler not to perform any Optimization

For example, if you want to send two commands to an address: int * IP = ...; // device address * IP = 1; // The First Command * IP = 2; // The Compiler program above the second command may be optimized to: int * IP = ...; * IP = 2; the First Command is lost. If volatile is used, compiler will not allow any optimization, so as to ensure the program's original intention: Volatile int * IP = ...; * IP = 1; * IP = 2; even if you want compiler to optimize, it will not convert the two value payment statements into one. It can only perform other optimizations. This is useful to device driver programmers.

2: variables defined with volatile will be changed outside the program. Each time they are read from the memory, they cannot be reused in the cache or register.

For example, volatile char A; A = 0; while (! A) {// do some things;} doother (); if there is no volatile doother (), it will not be executed