Re: 32-bit memory accesses on dual-core dual-Xeon processors

From:

"peter koch" <peter.koch.larsen@gmail.com>

Newsgroups:

microsoft.public.vc.language

Date:

4 Jan 2007 02:52:00 -0800

Message-ID:

<1167907919.922634.174700@11g2000cwr.googlegroups.com>

DW skrev:

I'm not sure where the best place to post this is, but here's the question.

I have an implementation for a circular buffer (a fixed-sized queue of
pointers) where there is only one producer and one consumer, each running
independently in different threads. There is currently no protection
(locking) because there are no variables that can be written to by both
threads simultaneously. The head and/or tail could be read by one thread and
written by the other, but logically, there are no issues as long as whole
32-bit quantities can be accessed.

Is there anything wrong with the assumptions I've made, especially when the
code is run on dual-core dual-Xeon processors? Is memory on these 64-bit
processors accessed in such a way that there could be a memory corruption?

If you want to know whether this is safe on that particular CPU, you
should consult the documentation for the CPU, but it is an extremely
bad idea to assume that your code will "work" in the general sense. It
will not. Multithreading is tricky, and caching issues may cause writes
from one thread to be seen in an other order from other threads (as I
believe Igor wrote). Do not rely on informal testing to prove
otherwise, as quite probably it WILL prove otherwise until at some time
where you have forgot all about the dubious code or at some critical
point for your application.
Just take the advice and inmplement the proper syncronisation
primitives. If performance is critical, you can boil it down to one
simple instruction. (you might not need to issue that syncronising
instruction for each item you put into the buffer).

/Peter