UT/UT_Lock.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:
 *      Luke Moore
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Lock.h ( UT Library, C++)
 *
 * COMMENTS:
 *      Locking class
 */

#ifndef __UT_Lock_h__
#define __UT_Lock_h__

#include "UT_API.h"
#include "UT_Assert.h"
#include "UT_LockUtil.h"

class UT_Condition;
class UT_ConditionLock;

#if defined(LINUX) || defined(MBSD)
#define HAVE_PLATFORM_LOCK
#include <pthread.h>
#elif defined(WIN32)
#define HAVE_PLATFORM_LOCK
struct ut_CriticalSection;
#endif

#ifdef HAVE_PLATFORM_LOCK
class UT_API UT_Lock
{
    friend class UT_Condition;
public:
    // thread_lock *must* be true
    explicit UT_Lock(bool initially_locked = false, bool thread_lock = true);
    ~UT_Lock();

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

    // lock(), lockLW(), and lockNap() all do the same thing.  There are
    // three versions of locking for backwards compatibility.
    
    // blocks until the lock is obtained.  lockLW() is inlined for speed.
#if defined(LINUX) || defined(MBSD)
    void        lockLW()
    {
    #if (UT_ASSERT_LEVEL > UT_ASSERT_LEVEL_NONE)
        int result = pthread_mutex_lock(&myLock);
        UT_ASSERT(result == 0);
    #else
        (void) pthread_mutex_lock(&myLock);
    #endif
    }
#elif defined(WIN32)
    void        lockLW();
#endif

    void        lock() { lockLW(); }
    void        lockNap() { lockLW(); }

    // tries N times to get the lock, returns true if the lock was obtained.
    bool        lockLW(int ntrials);
    bool        lock(int ntrials)       { return lockLW(ntrials); }
    bool        lockNap(int ntrials)    { return lockLW(ntrials); }

    // release the lock.  unlock() is inlined for speed.
#if defined(LINUX) || defined(MBSD)
    void        unlock()
    {
    #if (UT_ASSERT_LEVEL > UT_ASSERT_LEVEL_NONE)
        int result = pthread_mutex_unlock(&myLock);
        UT_ASSERT(result == 0);
    #else
        (void) pthread_mutex_unlock(&myLock);
    #endif
    }
#elif defined(WIN32)
    void        unlock();
#endif

    bool        isLocked();
    int         getCollisions() { return 0; }

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

#ifndef WIN32
    // UT_ConditionLock uses error check pthread locks, which Windows does not
    // support (it uses UT_SpinLock on Windows). This allows UT_ConditionLock to
    // use conditions on platforms that support them without asserting.
    explicit UT_Lock(UT_ConditionLock &);
    friend class UT_ConditionLock;
#endif

private:
#if defined(LINUX) || defined(MBSD)
    pthread_mutex_t      myLock;
    pthread_mutexattr_t  myLockAttributes;
#elif defined(WIN32)
    ut_CriticalSection *            myLock;
    int                             myThreadId;
    int                             myLockDepth;
#endif
};

#else

#include "UT_SpinLock.h"
typedef UT_SpinLock UT_Lock;

#endif

typedef UT_AutoLockType<UT_Lock>        UT_AutoLock;
typedef UT_DebugLockType<UT_Lock>       UT_DebugLock;
typedef UT_ObjLockType<UT_Lock>         UT_ObjLock;
typedef UT_AutoObjLockType<UT_Lock>     UT_AutoObjLock;

#endif

---