waynepearlep

The compilation system tries to reduce code size and execution time on all machines翻譯社 by optimizing code. It is programmer responsibility to inform compilation system that certain code (or variable) should not be optimized. Many programmers do not understand when to use volatile to inform compilation system that certain code should not be optimized or what it does. Although (no doubt) their program work, they do not exploit the full power of the language.

A variable should be declared volatile whenever its value can be changed by something beyond the control of the program in which it appears, such as a concurrently executing thread. Volatile, can appear only once in a declaration with any type specifier; however, they cannot appear after the first comma in a multiple item declaration. For example, the following declarations are legal

volatile int p = 3;

declares and initializes an object with type volatile int whose value will be always read from memory.

Volatile T a =3;
T volatile a=3; 

The declaration declares and initializes an objet with type volatile T whose value will be always read from memory

T* volatile ptrv;

Use of volatile

- An object that is a memory-mapped I/O port
- An object variable that is shared between multiple concurrent processes
- An object that is modified by an interrupt service routine
- An automatic object declared in a function that calls setjmp and whose value is-changed between the call to setjmp and a corresponding call to longjmp

Conclusion

*ptr = 0;
while(*ptr){
     *ptr = 4 ;
     *ptr = 0 ;
}

*ptr = 0
while(0) {
}

*ptr is assigned 0 before value 4 is used ( and value of *ptr never changes ( same constant is always assigned to it)
volatile keyword is used to suppress these optimization the compiler assumes that the value can change any time 翻譯社 even if no explicit code modify it to suppress all optimization declare ptr as

 volatile char * const ptr = (volatile char*)0x16

this declaration say the object at which ptr points can change without notice , but that ptr itself is a constant whose value never change

/listing 3: difference between listing 1 and listing 3 ***/

< .file"vol.c"
---
> .file"wvol.c"
< movl$3翻譯社 -4(%ebp) 
< movl-4(%ebp)翻譯社 %eax
< pushl%eax
> pushl$3
< movl$5翻譯社 -4(%ebp) / * store in stack */

From above listing 3 it is clear that when you use setjmp and longjmp, the only automatic variables guaranteed to remain valid are those declared volatile.

/*Listing1: Assembly code fragment of above program
   Produced by cc compiler  when volatile is used*/



.file"vol.c"
main:
pushl%ebp
movl%esp, %ebp
subl$20翻譯社 %esp
movl$3, -4(%ebp)
pushl$buf
call_setjmp
addl$16, %esp
testl%eax, %eax
je.L18
subl$8, %esp
movl-4(%ebp), %eax
pushl%eax
pushl$.LC0
callprintf
movl$0, (%esp)
callexit
.p2align 2
.L18:
movl$5, -4(%ebp)
subl$8, %esp
pushl$1
pushl$buf
calllongjmp

#include <thread.h>
#include <stdio.h>
volatile int num ;
void* foo()
{
while(1) {
      ++num ;
      sleep(1000);
      }
}

main()
{
 int p ;
 void *targ =NULL ;
 thread_t id ;
 num = 0;
 p = thr_create((void*)NULL 翻譯社 0,foo,targ,0,&id);
 if(!p)  printf(" can not create thread ");

 while(1) 
 {
   printf("%d" , num ) ;
 }
}

the compiler may use a register to store the num variable in the main thread , so the change to the value by the second thread are ignored . The volatile modifier is a away of telling the compiler that no optimization applied to the variable its value be not placed in register and value may change outside influence during evaluation

# An automatic object declared in a function that calls setjmp and whose value is-changed between the call to setjmp and a corresponding call to longjmp

Variables local to functions that call setjmp is most often used. When an automatic object is declared in a function that calls setjmp, the compilation system knows that it has to produce code that exactly matches what the programmer wrote. Therefore, the most recent value for such an automatic object will always be in memory (not just in a register) and as such will be guaranteed to be up-to-date when longjmp is called. Without volatile variable is undefined by the standard whether the result one see differs with or without optimization simply reflects that fact Consider following code

 /*Listing 2:Assemply code fragment of  above program
   produced by cc compile witout volatile keword */

.file"wvol.c"
main:
pushl%ebp
movl%esp翻譯社 %ebp
subl$20翻譯社 %esp
pushl$buf
call_setjmp
addl$16, %esp
testl%eax, %eax
je.L18
subl$8, %esp
pushl$3
pushl$.LC0
callprintf
movl$0, (%esp)
callexit
.p2align 2
.L18:
subl$8翻譯社 %esp
pushl$1
pushl$buf
calllongjmp

char const ptr=(char*)0X15 ;

*ptr access the port consider following code fragment to set the third bit of the output port at periodic intervals

About the author

T i翻譯社 volatile vi ;

Volatile qualifiers can be used to change the behavior of a type. For example,

}

分別在偵錯版本和release版本運行程式，輸出都是：

i = 10
i = 32

這申明這個樞紐字發揮了它的感化！

　　volatile 指 出 i是隨時可能産生變化的，每次利用它的時候必需從i的位址中讀取，因而編譯器生成的組合說話程式碼會從新從i的位址讀取資料放在b中翻譯而最好化做法是，由 於編譯器發現兩次從i讀數據的程式碼之間的程式碼沒有對i進行過操作，它會自動把前次讀的資料放在b中。而不是重新從i裡面讀。如許以來，若是i是一個寄 存器變數或者默示一個埠資料就輕易出錯，所以說volatile可以保證對非凡位址的不亂存取。
　　注意，在vc6中，一般偵錯模式沒有進行程式碼最好化，所以這個環節字的感化看不出來翻譯下面經由過程插入組合語言程式碼，測試有沒有volatile關頭字，對程式終究程式碼的影響：
　　
　　起首，用classwizard建一個win32 console專案，插入一個voltest.cpp檔，輸入下面的程式碼：
　
#include <stdio.h>
void main()
{

...
//其他代碼，並未明確告知編譯器，對i進行過操作

Volatile T * ptr; 
T volatile * ptr; 

static lon int  num ;
void interrupt update(void)
{
++num ;
}
main()
{
long  val ;
val  = num ;
while(val !=num)
val = num ;
rturn val ;
}

}

}

Console.WriteLine("result = {0}"翻譯社 result);
return;