A
aruna
What are the advantages of using volatile? What are
the practical situations where you use volatile specifier?
the practical situations where you use volatile specifier?
E
Eric Sosman
aruna said:
Aruna, have you done any research on these questions before
posting them? Have you read a C textbook or tutorial? Have
you read the comp.lang.c Frequently Asked Questions document?
If so and if you are confused by what these sources have told
you, *then* take your question to comp.lang.c, and explain
the nature of your confusion.
Do not try to treat comp.lang.c or any other forum as a
substitute for study. Usenet is an ineffective vehicle for
basic instruction.
T
Tim Prince
Did you read any FAQs about this? What are your specific questions? Iaruna said:
won't mention my personal reasons for using it, as they aren't likely to
intersect with the interests of 98% of the readers of this NG, and don't
conform to Standard C.
C
Christopher Benson-Manica
aruna said:
1) It's a "qualifier", not a "specifier".
2) Read a C book. Or the comp.lang.c FAQ. Or its archives.
T
Thomas Matthews
Here are some:aruna said:
1. The compiler does not "optimize-out" the variable that
is declared as volatile.
2. The compiler refreshes variables marked as volatile
before using them.
My experience, in embedded systems, is to use volatile
when the hardware can change the value of a memory
location without the program's consent or knowledge.
I/O devices, such as a UART, is one example. The
value in the Receive Register depends on the other
end of the connection. A host computer could send
a character over and it resides in the Receive
Register, without the knowledge of the executing
program.
Sensors and triggers are also another example.
The sensor could be triggered without the program's
knowledge.
Message queues are another one. Your program could
receive a message from another task without any
prior knowledge and at unexpected times.
Memory locations that are shared by your program
and either a hardware device or another task.
Stuff could be placed into the shared memory
without your program knowing about it.
See also:
mutex
lock
semaphore
signal
I've seen replies about volatile being used for
multi-threading, but that is outside my knowledge
base.
--
Thomas Matthews
C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book
K
Karthik
Thomas said:I've seen replies about volatile being used for
multi-threading, but that is outside my knowledge
base.
The fundamental concept remains the same there still. If multiple
threads are accessing a variable, it is important that the thread (when
it sees a variable x ) , actually gets the most recent value of x. This
would be taken care by the compiler to make sure that it refreshes
before fetching the value for the current thread, without doing any
optimization, thereby preserving the semantics of the multi-threaded
program.
- Karthik.