Re: implementation of "Double-Checked Locking" Pattern in C++

From:

Joe <jgreer@nsisoftware.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Thu, 26 Apr 2007 16:10:56 CST

Message-ID:

<1177608949.291330.175380@t38g2000prd.googlegroups.com>

This is the point of view of the thread that is doing this.
Another thread might have a different opinion on the same subject. It is
still possible that another thread will see pInstance modified *before*
seeing the properly constructed object.

The question is about visibility of memory modifications and the above
code doesn't answer that.

There are issues about visibility with other threads, but pInstance is
either 0 or a pointer to an initialized object in any thread that can
possibly see it. (Assuming of course that the tmp pointer isn't
optimized away). The guard mutex should perform some sort of fencing,
so at worst different threads running on different cpu cores will
needlessly block once. What am I missing?

I think the one true portable answer isn't possible without the
compiler knowing about threading so that appropriate fences can be
added during the assignment. I am making the assumption that the
compiler's optimizer can be persuaded to not remove the temp variable
and I don't know if there is a portable way to do that. (There are
ways that will likely work, but someone can always make the hyper
intelligent linker with built-in code analyzer/global optimizer.)

joe

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]