InterlockedIncrement and other Interlocked operations declare their arguments as volatile. Why? What is the intention and effect of this?
A:
The volatile argument prevents the compiler from making optimizations that prevent the read to memory. A compiler can make whatever optimizations it likes as long as the visible effects of the code are the same, but those effects aren't considered in multiple thread scenarios, only from a single thread. The volatile keyword tells the compiler that this variable may be modified or read from external, unknowable sources and the compiler cannot get rid of it or ellide memory accesses to it.
DeadMG
2010-09-14 10:55:31
This is true in general about volatile, but this is not applicable in this particular case. For the caller of the function, there is no difference if the function is handling the argument as volatile internally or not.
Suma
2010-09-14 11:10:46
Because the called never had to compile their code.
DeadMG
2010-09-14 12:41:31
A:
In short, volatile means "this variable might be modified outside this program".
In a bit more words, it means that a variable's value can change without any related instructions in your code. It's often used in low-level I/O for instance, where the value of a register or buffer can be set by the hardware.
jv42
2010-09-14 10:59:01
Does not seem applicable in this case. The compiler is not compiling the InterlockedIncrement function, and marking the variable as volatile has no effect outside of the function.
Suma
2010-09-14 11:11:44
This have something to do with telling the compiler not to optimize the access to the variable, even inside the function. I'm not sure about why it is needed in the prototype, except to tell you how your parameters will be treated though.
jv42
2010-09-14 11:16:10
+2
A:
The only possible reason I was able to come with is this:
This is done so that the function can be called both on normal variables and on volatile variables. You cannot pass a volatile variable into a function which is not expecting a volatile argument. The following code does not compile (tested with Visual Studio 2005 C++ compiler):
void TestV(int *a)
{
*a = 1;
}
void Test()
{
volatile int a = 0;
TestV(&a);
}
With the declaration being what it is, you can do following:
volatile LONG a = 0;
InterlockedIncrement(&a);
As it most likely has a sense to call InterlockedIncrement on volatile variables, it seems sensible to have it declared as such.
Suma
2010-09-14 11:12:58
+4
A:
The probable effect is very minimal. The most likely intent is to allow users to pass volatile-qualified variables to these functions without the need for a typecast.
Bart van Ingen Schenau
2010-09-14 11:16:26