Re: re-ordering across a mutex

From:

Leigh Johnston <leigh@i42.co.uk>

Newsgroups:

comp.lang.c++.moderated

Date:

Wed, 24 Aug 2011 16:39:36 -0700 (PDT)

Message-ID:

<3bmdnaDbJOryZ9HTnZ2dnUVZ8oadnZ2d@giganews.com>

On 18/08/2011 10:32, darkknight.21@gmail.com wrote:

I have a follow-up question to my question on the double checked
locking problem

If I use a mutex of some kind like this
    acquire-mutex
    execute code/ modify shared variables
    release-mutex

For this to work, the compiler is not allowed to move code across the
acquire/release statements. Does the documentation for a mutex
usually say this?

Anyway, assuming the above is true, is not a simple solution to the
singleton problem something like this
         if (ptr == 0) // line1 - inexpensive
         {
             acquire-mutex1
             if (ptr == 0)
             {
                ptr1 =&singleton; // whatever
                acquire_mutex2;
                ptr = ptr1;
                release_mutex2;
             }
             release-mutex1
         }

At line1, if ptr is non-zero, we know for sure that the singleton
object has been fully constructed. No volatile anywhere. The mutexes
would also provide the needed memory barriers.

Would this work?

No, not on all systems. CPU read reordering could make non-null ptr
visible before the all of the singleton object is visible so you need a
barrier with acquire semantics after reading ptr. My singleton class
does the following:

    template <typename T>
    class singleton
    {
    public:
        static T& instance()
        {
            T* ret = sInstancePtr;
            memory_barrier_acquire_dependant();
            if (ret == 0)
            {
                lock theLock(sLock);
                static T sInstance;
                memory_barrier_release();
                sInstancePtr = &sInstance;
                ret = sInstancePtr;
            }
            return *ret;
        }
    private:
        static lockable sLock;
        static T* sInstancePtr;
    };

    template <typename T>
    lockable singleton<T>::sLock;
    template <typename T>
    T* singleton<T>::sInstancePtr;

HTH.

/Leigh

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