base_thread_lock.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#if COMPILE_THREADS
#ifndef BASE_THREAD_LOCK_HH
#define BASE_THREAD_LOCK_HH 1

#include "base_thread_common.hh"

namespace base {

// Method-level lock.  It applies to all instances however.
// (THREAD_AUTO_RUSH_LOCK omitted since usually it's wrong as a method-level lock.)
#define THREAD_AUTO_FAST_LOCK {{ PERSISTENT FastLock lock; FastLock::Auto autolock(&lock); }}
#define THREAD_AUTO_SLOW_LOCK {{ PERSISTENT SlowLock lock; SlowLock::Auto autolock(&lock); }}

#if CPU_X86
#define PAUSE_CPU() asm volatile ("rep;nop": : :"memory");  // Linux kernel 2.6
#else
#define PAUSE_CPU()
#endif

template<typename LOCK>
class AutoLock
{

public:
    AutoLock( LOCK* lock )
    :   mLock(lock)
    {
    ASSERT_STACK_OBJECT( this );        // AutoLock must be on call stack
    ASSERT_PERSISTENT_OBJECT( mLock );  // underlying Slow/FastLock must be persistent

        mLock->Lock();
    }

    ~AutoLock()
    {
        mLock->Unlock();
    }

private:
    LOCK*  mLock;  // pointer to underlying lock in PERSISTENT storage (accessible by any thread)
};

class RushLock : private Atomic
{

public:
    RushLock( void )
    :   mLock(false)
    {
        ASSERT_PERSISTENT_OBJECT( this );  // cannot be on stack
    }

    ~RushLock()
    {
        // NOP
    }

    inline void Lock( void )
    {
        // Not a while loop as compiler would unoptimally predict branch-taken.

        Spin: if ( UX(Atomic::Xchg(&mLock,true)) ) { PAUSE_CPU(); goto Spin; }
    }

    inline void Unlock( void )
    {
        Atomic::Set( &mLock, false );
    }

  //bool IfLocked( void ) // N/A since RushLock doesn't track ownership

    class Auto : public AutoLock<RushLock>
    {
    public:
        Auto( RushLock* lock ) : AutoLock<RushLock>(lock) { }
    };

private:
    volatile Atomic::Bool  mLock;
};

class FastLock : private Atomic
{

private:
    enum { UNLOCKED, LOCKED, BUSY };  

public:
    FastLock( void )
    :   mLock(UNLOCKED),
        mDepth(0),
        mOwner(0)  // 0 is ok even if mOwner's type is pthread_t
    {
        ASSERT_PERSISTENT_OBJECT( this );  // cannot be on stack
    }

    ~FastLock() { }

    // FastLock would severely impede system if it never yields CPU.
    #define FAST_LOCK_YIELD( i )                                                        \
    {                                                                                   \
        PAUSE_CPU();                                                                    \
        ++i;                                                                            \
        if ( UX( i > base::defs::FAST_LOCK_LOOP_YIELD ) )                               \
        {                                                                               \
            /* pragma: Thread depends on Lock so use THREAD_YIELD() macro. */           \
            i = 0;                                                                      \
            THREAD_YIELD();                                                             \
        }                                                                               \
    }


    void Lock( void )
    {
        uint i = 0;
        while ( true )
        {
            FAST_LOCK_YIELD(i);

            // BUSY means busy testing the lock.
            const int lock = Atomic::Xchg( &mLock, BUSY );  // ok returning to plain int
            if ( EX( lock == UNLOCKED ) )
            {
                // Was unlocked.  Take the lock.
                ASSERT( mDepth == 0 );
                Atomic::Set( &mDepth, 1 );
                Atomic::Set( &mOwner, THREAD_ATOMIC_TID() );
                Atomic::Set( &mLock, LOCKED );
                break;
            }
            else if ( UX( lock == LOCKED ) )
            {
                // Either this thread is the owner or a competitor.
                if ( THREAD_ATOMIC_TID_EQUAL( mOwner ) )
                {
                    // This thread owns the lock.  Increase lock depth.
                    Atomic::Add( &mDepth, +1 );
                    Atomic::Set( &mLock, LOCKED );
                    break;
                }
                else
                {
                    // This thread is a competitor.  Revert the lock.
                    Atomic::Set( &mLock, LOCKED );
                    continue;
                }
            }
            else  // lock == BUSY
            {
                PAUSE_CPU();
                continue;
            }
        }
    }

    void Unlock( void )
    {
    ASSERT( mLock != UNLOCKED );
    ASSERT( mDepth > 0 );
    ASSERT( THREAD_ATOMIC_TID_EQUAL( mOwner ) );

        // mLock == BUSY if another thread owns the lock.
        // This thread will spin by exchanging BUSY with BUSY
        // until the other thread has released the lock.

        uint i = 0;
        while ( true )
        {
            if ( EX( Atomic::Xchg(&mLock,BUSY) != BUSY ) )
            {
                // Relinquish lock only when depth falls to zero.
                const int depth = Atomic::Add( &mDepth, -1 );  // regular int ok and faster
                Atomic::Set( &mLock, (depth ? LOCKED : UNLOCKED) );
                break;
            }
            else  // BUSY
            {
                // Another thread is testing the lock.  Wait for it to restore ownership.
                FAST_LOCK_YIELD(i);
                continue;
            }
        }
    }

    bool IfLocked( void )
    {
        // mOwner might change inside this line but this thread won't be the owner (ok).

        return mLock && not THREAD_ATOMIC_TID_EQUAL(mOwner);
    }

    class Auto : public AutoLock<FastLock>
    {
    public:
        Auto( FastLock* lock ) : AutoLock<FastLock>(lock) { }
    };

private:
    // volatile is critical to prevent compiler reordering instructions.
    // gcc -O2 or -O3 enable -fschedule-insns2.
    // (Atomic typedefs are volatile too despite redundancy.)
    volatile Atomic::Int        mLock;   // true if locked, false if unlocked
    volatile Atomic::Int        mDepth;  // tracks recursion
    volatile Thread::AtomicTid  mOwner;  // initialized when first thread takes the lock
};

class SlowLock
{
  // critical
public:
            SlowLock( void );
            ~SlowLock();
    void    Lock( void );
    void    Unlock( void );
    bool    IfLocked( void );  // query only
    bool    TryLock( void );   // tries to take lock

    class Auto : public AutoLock<SlowLock>
    {
    public:
        Auto( SlowLock* lock ) : AutoLock<SlowLock>(lock) { }
    };

private:
    pthread_mutex_t mMutex;     
};

class NoLock
{

public:
    // This code is guaranteed to have no bugs ;-)

            NoLock( void ) { }
            ~NoLock() { }
    void    Lock( void ) { }
    void    Unlock( void ) { }

    class Auto
    {
    public:
        Auto( UNUSED NoLock* ) { }
        ~Auto() { }
    };
};

} // namespace base

#endif // BASE_THREAD_LOCK_HH
#endif // COMPILE_THREADS

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:07 2007