Re: C++ Threads, what's the status quo?
Pete Becker wrote:
Le Chaud Lapin wrote:
The mutex is simpler but slower:
Mutex counter_mutex; // global
void increment_counter ()
{
counter_mutex.acquire();
++count;
counter_mutex.release();
}
The increment has no visible side effects, so the compiler is not
obliged to sandwich it between the acquire and the release. How do you
ensure that the compiler won't do either of those?
I would take whatever recourse is available in all situations like
these. If I may answer with an example...
Consider a single-threaded program that has a function that aims a
missile at an adjacent country and launches it. Aiming is achieved by
incrementing an memory-mapped register. Launching is achieved by
setting a different memory mapped register to "true":
static unsigned int ®ister_azimuth = *reinterpret_cast<unsigned int
*>(0x12345678);
static bool ®ister_launch = *reinterpret_cast<bool *>(0x12345680);
void aim_and_launch_missile ()
{
register_azimuth += 75; // degrees
register_launch = true;
}
Technically, IIUC, the compiler has the right to reorder these two
statements, since they are visibly independent, thus launching the
missile at a potentially friendly neighboring country and subsequently
pointing the launch pad at the enemy.
So even in a single-threaded program, the programmer would be faced
with a dilemma of what to do about the optimizer. Certainly, one could
argue from this example that, if preventing such transpositions is
desirable for threading, then it would be something desirable in
general.
Another example where a programmer has written a piece of code that he
thought was portable that gives a rough idea of how fast 1,000,000
global memory references can be performed by the CPU:
static int x;
int main ()
{
Instant before = now();
unsigned int count = 1000000;
while (count--)
x = 0;
Instant after = now();
cout << count << " memory references in " << (after-before) << "
seconds." << endl;
return 0;
}
On some compilers, he finds that the while loop is not performed until
just before the "return" 0. On other compilers, he finds that the
while loop has been completely omitted, as it is obviously superfluous,
resulting in that machine counting to a 1,000,000 is almost 0 seconds.
-Le Chaud Lapin-
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]