UT/UT_SpinLock.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Marks Alexander & Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_SpinLock.h ( UT Library, C++)
 *
 * COMMENTS:    Cross-platform Lock class for semaphoring.
 */

#ifndef UT_SPINLOCK_H
#define UT_SPINLOCK_H

#include "UT_API.h"
// Needed for ut_thread_id_t
#include "UT_Thread.h"
#include <SYS/SYS_AtomicInt.h>

class UT_API UT_SpinLock
{
public:
    // If threadlock is true, the locking thread is allowed to re-enter
    // code areas that it locked. The lock is incremented & decremented.
    
        explicit UT_SpinLock(int lockstate = 0, bool threadlock = false);
                ~UT_SpinLock();

    // tries the lock once, returns true if the lock was obtained.
    bool        tryLock();

    // lock(...)    does a CPU intensive lock (will use up 100% of a CPU until
    //              the lock is obtained. Use for VERY small critical sections
    //              where waiting must be minimized.
    // lockLW(...)  does a less CPU intensive lock, though not as responsive.
    // lockNap(...) Naps between each lock attempt for 10ms.
    
    // tries N times to get the lock, returns true if the lock was obtained.
    bool        lock(int ntrials);
    bool        lockLW(int ntrials);
    bool        lockNap(int ntrials);

    // blocks until the lock is obtained.
    void        lock();
    void        lockLW();
    void        lockNap();

    // release the lock.
    void        unlock();

    // trigger/wait on trigger methods. waitForTrigger will block until
    // trigger is called. Cannot be used with thread locks. 
    void        waitForTrigger();
    void        trigger();

    void        debugLock(bool debug);

    bool        isLocked() { return myIsThreadLock ? 
                                myLockCount : (int32)mySpinLock; }

    int         getCollisions() { return myCollisions; }

private:
    UT_SpinLock(const UT_SpinLock &copy);               // not allowed
    UT_SpinLock &operator=(const UT_SpinLock &copy);    // not allowed

private:
    SYS_AtomicInt32     mySpinLock;
    ut_thread_id_t      myLockedThread;
    int                 myLockCount;
    int                 myCollisions;   // Collision counter
    
    unsigned            myDebugThisLock : 1,
                        myIsThreadLock  : 1;
#ifdef UT_DEBUG
    bool                myIsActive;
#endif
};

// A spin lock with a default threadlock flag set to true.  This class can
// be safely substituted for UT_Lock.  If the default for threadlock in
// UT_SpinLock is changed to true, this class can be removed.
class UT_API UT_ReentrantSpinLock : public UT_SpinLock
{
public:
    explicit UT_ReentrantSpinLock(int lockstate = 0)
        : UT_SpinLock(lockstate, true) {}
};

#endif

---