atomically thread-safe Meyers singleton impl...

Here is the FIXED version of my atomically thread-safe singleton
implementation using pthreads, x86, MSVC and the double-checked locking
pattern with some error checking omitted for brevity:
__________________________________________________________________
#include <cstdio>
#include <cassert>
#include <cstdlib>
#include <pthread.h>

#if ! defined(_MSC_VER)
# error MSVC REQUIRED FOR NOW!
#elif (_MSC_VER > 1300)
  using namespace std;
#endif

class mutex_guard {
  pthread_mutex_t* const m_mtx;

public:
  mutex_guard(pthread_mutex_t* const mtx)
    : m_mtx(mtx) {
    pthread_mutex_lock(m_mtx);
    printf("pthread_mutex_lock(%p);\n", (void*)m_mtx);
  }

  ~mutex_guard() throw() {
    printf("pthread_mutex_unlock(%p);\n", (void*)m_mtx);
    pthread_mutex_unlock(m_mtx);
  }
};

namespace atomic {
  __declspec(naked)
  static void*
  ldptr_acq(void* volatile*) {
    _asm {
      MOV EAX, [ESP + 4]
      MOV EAX, [EAX]
      RET
    }
  }

  __declspec(naked)
  static void*
  stptr_rel(void* volatile*, void* const) {
    _asm {
      MOV ECX, [ESP + 4]
      MOV EAX, [ESP + 8]
      MOV [ECX], EAX
      RET
    }
  }
}

#if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
  static pthread_mutex_t singleton_mtx =
    PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
#else
  static pthread_mutex_t* volatile singleton_mtx_ptr = NULL;
  static pthread_mutex_t singleton_mtx;

  static void
  singleton_mutex_static_init_destroy() {
    assert(singleton_mtx_ptr == &singleton_mtx);
    pthread_mutex_destroy(&singleton_mtx);
    printf("pthread_mutex_destroy(%p);\n", (void*)&singleton_mtx);
  }
#endif

static pthread_mutex_t*
singleton_mutex_static_init() {
  pthread_mutex_t* mtx;
  #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
    mtx = &singleton_mtx;
  #else
    mtx = (pthread_mutex_t*)atomic::ldptr_acq(
      (void* volatile*)&singleton_mtx_ptr
    );
    if (! mtx) {
      static pthread_mutex_t this_mtx_sentinel =
        PTHREAD_MUTEX_INITIALIZER;
      mutex_guard lock(&this_mtx_sentinel);
      if (! (mtx = singleton_mtx_ptr)) {
        pthread_mutexattr_t mattr;
        pthread_mutexattr_init(&mattr);
        pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&singleton_mtx, &mattr);
        pthread_mutexattr_destroy(&mattr);
        atexit(singleton_mutex_static_init_destroy);
        mtx = (pthread_mutex_t*)atomic::stptr_rel(
          (void* volatile*)&singleton_mtx_ptr, &singleton_mtx
        );
        printf("pthread_mutex_init(%p);\n", (void*)mtx);
      }
    }
  #endif
  assert(mtx);
  return mtx;
}

template<typename T>
struct singleton {
  static T* instance() {
    static T* volatile this_ptr = NULL;
    T* ptr = (T*)atomic::ldptr_acq((void* volatile*)&this_ptr);
    if (! ptr) {
      mutex_guard lock(singleton_mutex_static_init());
      if (! (ptr = this_ptr)) {
        static T this_instance;
        ptr = (T*)atomic::stptr_rel(
          (void* volatile*)&this_ptr, &this_instance
        );
      }
    }
    assert(ptr);
    return ptr;
  }
};

struct foo {
  foo() {
    printf("(%p)->foo::foo();\n", (void*)this);
  }

  ~foo() throw() {
    printf("(%p)->foo::~foo();\n", (void*)this);
  }
};

struct foo1 {
  foo1() {
    foo* ptr1 = singleton<foo>::instance();
    foo* ptr2 = singleton<foo>::instance();
    foo* ptr3 = singleton<foo>::instance();
    assert(ptr1 == ptr2 && ptr2 == ptr3);
    printf("(%p)->foo1::foo1();\n", (void*)this);
  }

  ~foo1() throw() {
    printf("(%p)->foo1::~foo1();\n", (void*)this);
  }
};

struct foo2 {
  foo2() {
    printf("(%p)->foo2::foo2();\n", (void*)this);
  }

  ~foo2() throw() {
    printf("(%p)->foo2::~foo2();\n", (void*)this);
  }
};

int main() {
  foo1* ptr1 = singleton<foo1>::instance();
  foo1* ptr2 = singleton<foo1>::instance();
  foo1* ptr3 = singleton<foo1>::instance();
  foo2* ptr11 = singleton<foo2>::instance();
  foo2* ptr22 = singleton<foo2>::instance();
  foo2* ptr33 = singleton<foo2>::instance();
  assert(ptr1 == ptr2 && ptr2 == ptr3);
  assert(ptr11 == ptr22 && ptr22 == ptr33);
  return 0;
}
__________________________________________________________________

I think this is about as good as I can do. It uses a single recursive mutex
as a guard for the singleton slow-path. This is needed because a singleton
can contain other singletons in there ctor's. The pthread-win32 library
features a `PTHREAD_RECURSIVE_MUTEX_INITIALIZER' definition which statically
initialized a recursive mutex. However, I don't think that this is standard.
Therefore, the code will automatically compensate for this if it is not
defined. This means that this singleton will work even if threads are
created before main. Also, it should be rather trivial to convert this over
to GCC and Linux. Alls you would need to do is create the atomic functions
in AT&T inline assembler syntax.

Any thoughts on this approach?

I think the only way to break this would be to do something extremely stupid
like:

struct foo {
  foo() {
    foo* f = singleton<foo>::instance();
  }
};

which would be analogous to doing:

struct foo {
  foo() {
    static foo f;
  }
};

For now, AFAICT this thread-safe singleton is looking fairly bullet-proof.
Humm...

P.S.

Here is the BROKEN version:

http://groups.google.com/group/comp.lang.c++.moderated/msg/270cd69180dbe8af
(damn it!)

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