Mac Forum / Programming / CodeWarrior / January 2004

In article
<martin.taylor-41ECD4.10433523012004@newstrial.btopenworld.com>,

Martin,

Howard is taking a skiing week, and he is the expert on this.  If you
can write me or write here again next Monday he'll be able to help.  I
believe there are some things we fixed with locking in CW 9 which may
have better performance too.

Ron

In article
<martin.taylor-41ECD4.10433523012004@newstrial.btopenworld.com>,

I will take you up on that offer! :-)

I took a look at boost/detail/lwm_gcc.hpp and I'm not convinced that it
is reliable, at least the scoped_lock constructor:

       explicit scoped_lock(lightweight_mutex & m): m_(m)
       {
           while( !__exchange_and_add(&m_.a_, -1) )
           {
               // m_.a_ == -1 !!!
               __atomic_add(&m_.a_, 1);
               sched_yield();
           }
       }

The design of this mutex is that a value of 0 is locked, and other
values are unlocked.  Say that the mutex is locked by thread A.  Thread
B executes __exchange_and_add which returns 0 but does succeed in
decrementing the mutex to -1.  Thread B enters the loop to wait as it
should.  But thread B gets interrupted by Thread C before it can
increment the mutex backed to its proper locked state (0).  Thread C
executes __exchange_and_add which decrements the mutex to -2 and returns
-1.  Thread C now believes that it has accquired the mutex.  Chaos
ensues.

Therefore instead of writing CodeWarrior PPC versions of
__exchange_and_add and __atomic_add as you requested, I've instead
written a CodeWarrior PPC version of lightweight_mutex based on the
lwarx/stwcx. assembly statements.  The code posted below appears to
execute aproximately 8 times faster than pthreads for an uncontested
lock/unlock cycle.

Please let us know if this works for you, and if not, perhaps we can fix
whatever went wrong.  I would also like to publicly thank Bob Campbell
of Metrowerks who helped me review the PPC assembly.

Hoping to see you over at boost soon! :-)

-Howard

Metrowerks

#include <sched.h>

namespace boost
{

namespace detail
{

class lightweight_mutex
{
private:

   volatile int a_;

   lightweight_mutex(lightweight_mutex const &);
   lightweight_mutex & operator=(lightweight_mutex const &);

public:

   lightweight_mutex(): a_(0)
   {
   }

   class scoped_lock;
   friend class scoped_lock;

   class scoped_lock
   {
   private:

       lightweight_mutex & m_;

       scoped_lock(scoped_lock const &);
       scoped_lock & operator=(scoped_lock const &);

   public:

       explicit scoped_lock(lightweight_mutex & m): m_(m)
       {
           register volatile int* p = &m_.a_;
           register int f;
           register int one = 1;
           asm
           {
           loop:
               lwarx  f, 0, p
               cmpwi  f, 0
               bne-   yield
               stwcx. one, 0, p
               beq+   done
           }
           yield:
           sched_yield();
           goto loop;
           done: ;
       }

       ~scoped_lock()
       {
           m_.a_ = 0;
       }
   };
};

}

}