UT/UT_LockUtil.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_LockUtil.h ( UT Library, C++)
 *
 * COMMENTS:    Templates for special types of thread locks
 */

#ifndef UT_LOCKUTILS_H
#define UT_LOCKUTILS_H

#include "UT_API.h"
#include "UT_PtrArray.h"
#include <stdio.h>

// An empty implementation of the lock interface (for easily removing all
// locks from an application).
class UT_NullLock {
public:
    explicit UT_NullLock(int /*lockstate*/ = 0, bool /*threadlock*/ = false) {}

    bool        lock(int) { return true; }
    bool        lockLW(int) { return true; }
    bool        lockNap(int) { return true; }
    void        lock() {}
    void        lockLW() {}
    void        lockNap() {}
    void        unlock() {}
    bool        isLocked() { return false; }
};


// A simple class to lock a lock and ensure that it is unlocked when it
// goes out of scope. It locks with a lightweight lock (which is the most 
// common type used). This works with both normal and threadlock types.
// 
template <class Lock>
class UT_AutoLockType
{
public:
     UT_AutoLockType(Lock &lock)
         : myLock(lock)
        { lock.lockLW(); }
    
    ~UT_AutoLockType() { myLock.unlock(); }
    
private:
    Lock        &myLock;
};

template <class Lock>
class UT_DebugLockType
{
public:
     UT_DebugLockType(const char *name, int lockstate=0, bool threadlock=false)
         : myLock(lockstate, threadlock),
           myName(name)
     { }
     UT_DebugLockType(const UT_DebugLockType &rhs)
         : myLock(rhs.myLock),
           myName(rhs.myName)
     { }
    ~UT_DebugLockType()
    {
        fprintf(stderr, "Lock[%s]: %d collisions\n",
                myName, myLock.getCollisions());
    }

    bool        lock(int ntrials)       { return myLock.lock(ntrials); }
    bool        lockLW(int ntrials)     { return myLock.lockLW(ntrials); }
    bool        lockNap(int ntrials)    { return myLock.lockNap(ntrials); }

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

    void        unlock()        { myLock.unlock(); }

    bool        isLocked()      { return myLock.isLocked(); }
private:
    Lock         myLock;
    const char  *myName;
};

// A data-bound lock.  The lock excludes access to the given object only,
// while allowing other threads to lock different objects.
template <class Lock>
class UT_ObjLockType {
public:
    UT_ObjLockType(int capacity = 256)
    {
        setCapacity(capacity);
    }
    ~UT_ObjLockType()
    {
        clear();
    }

    void setCapacity(int capacity)
    {
        if (myObjs.entries() < capacity)
        {
            myCapacity = capacity;
            myObjs.resize(myCapacity);
        }
    }
    int lock(void *obj)
    {
        int     ident = -1;
        int     i;

        myAccessLock.lock();
        for (i = 0; i < myObjs.entries(); i++)
        {
            if (myObjs(i)->myObj == obj)
            {
                ident = i;
                break;
            }
            if (!myObjs(i)->myRefCount)
                ident = i;
        }
        if (ident < 0)
        {
            UT_ASSERT(myObjs.entries() < myCapacity);
            myObjs.append(new ut_ObjLockEntry());
            ident = myObjs.entries()-1;
        }

        // Either we found the object or there is an empty slot.
        myObjs(ident)->myObj = obj;
        myObjs(ident)->myRefCount++;
        myAccessLock.unlock();
        myObjs(ident)->myLock.lock();
        return ident;
    }

    void unlock(void *obj, int ident)
    {
        // We found the object
        myObjs(ident)->myLock.unlock();
        myAccessLock.lock();
        UT_ASSERT(myObjs(ident)->myObj == obj);
        myObjs(ident)->myRefCount--;
        if (!myObjs(ident)->myRefCount)
            myObjs(ident)->myObj = 0;
        myAccessLock.unlock();
    }

private:
    void clear()
    {
        int             i;

        for (i = 0; i < myObjs.entries(); i++)
            delete myObjs(i);
        myObjs.entries(0);
    }

    class ut_ObjLockEntry
    {
    public:
        ut_ObjLockEntry()
        {
            myObj = 0;
            myRefCount = 0;
        }

        Lock            myLock;
        void            *myObj;
        int              myRefCount;
    };

public:
    Lock                                 myAccessLock;
    UT_PtrArray<ut_ObjLockEntry *>       myObjs;
    int                                  myCapacity;
};
    
template <class Lock>
class UT_AutoObjLockType
{
public:
     UT_AutoObjLockType(UT_ObjLockType<Lock> &lock, void *obj)
         : myLock(lock)
         , myObj(obj)
        { myId = lock.lock(myObj); }
    
    ~UT_AutoObjLockType() { myLock.unlock(myObj, myId); }
    
private:
    UT_ObjLockType<Lock>        &myLock;
    void                        *myObj;
    int                          myId;
};

#endif

---