thread.h

Go to the documentation of this file.

#pragma once

/*
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          9-3-1999
________________________________________________________________________

*/

#include "basicmod.h"
#include "commondefs.h"
#include "plftypes.h"

mFDQtclass(QThread)
mFDQtclass(QMutex)
mFDQtclass(QWaitCondition)

class CallBack;

namespace Threads
{

typedef void* ThreadID;

mExpClass(Basic) Mutex
{
public:
                Mutex( bool recursive=false );
                /*\If recursive, mutex can be locked
                   multiple times from the same thread without deadlock.
                   It will be unlock when unLock has been called the same
                   number of times as lock(). */
                Mutex(const Mutex&);
    virtual     ~Mutex();

    void        lock();
    void        unLock();

    bool        tryLock();
protected:

    mQtclass(QMutex*)           qmutex_;

    ThreadID                    lockingthread_;
    int                         count_;
public:
    int                         getCount() const { return count_; }
};



mExpClass(Basic) ConditionVar : public Mutex
{
public:
                                ConditionVar();
                                ConditionVar(const ConditionVar&);
                                ~ConditionVar();

    void                        wait();
    bool                        wait(unsigned long timeout);
    void                        signal(bool all);
protected:

#ifndef OD_NO_QT
    mQtclass(QWaitCondition*)           cond_;
#endif
};


mExpClass(Basic) ReadWriteLock
{
public:
                        ReadWriteLock();
                        ReadWriteLock(const ReadWriteLock&);
    virtual             ~ReadWriteLock();

    bool                isLocked() const                { return status_ != 0;}
    bool                isLockedForWrite() const        { return status_ < 0; }
    bool                isLockedForRead() const         { return status_ > 0; }

    void                readLock();
    bool                tryReadLock();
    void                writeLock();
    bool                tryWriteLock();
    void                permissiveWriteLock();
    void                readUnLock();
    void                writeUnLock();
    void                permissiveWriteUnLock();

    bool                convReadToWriteLock();
    void                convWriteToReadLock();

    void                convPermissiveToWriteLock();
    void                convWriteToPermissive();

protected:
    int                 nrreaders_;
    char                status_;
                        //0 not writelocked, -2 write lock, -1 permissive lock
                        //>0, number of readers
    ConditionVar        statuscond_;
};


#define mLockerClassImpl( mod, clssnm, clss, lockfn, unlockfn, trylockfn ) \
mExpClass(mod) clssnm \
{ \
public: \
                clssnm( clss& thelock, bool wait=true ) \
                    : lock_( thelock ) \
                    , islocked_( true ) \
                { \
                    if ( wait ) thelock.lockfn; \
                    else islocked_ = thelock.trylockfn; \
                } \
 \
                ~clssnm() { if ( islocked_ ) lock_.unlockfn; } \
    bool        isLocked() const { return islocked_; } \
 \
    void        unLock() { islocked_ = false; lock_.unlockfn; } \
 \
    void        lock() { islocked_ = true; lock_.lockfn; } \
 \
 \
protected: \
 \
    clss&       lock_; \
    bool        islocked_; \
};

mLockerClassImpl( Basic, MutexLocker, Mutex, lock(), unLock(), tryLock() )
mLockerClassImpl( Basic, ReadLockLocker, ReadWriteLock,
                  readLock(), readUnLock(), tryReadLock() )
mLockerClassImpl( Basic, WriteLockLocker, ReadWriteLock,
                  writeLock(), writeUnLock(), tryWriteLock() )


mExpClass(Basic) Barrier
{
public:
                        Barrier(int nrthreads=-1,bool immediatrelease=true);
    void                setNrThreads(int);
    int                 nrThreads() const               { return nrthreads_; }

    bool                waitForAll(bool unlock=true);
    void                releaseAll();
    void                releaseAllNoLock();
    Mutex&              mutex()                         { return condvar_; }

protected:
    void                releaseAllInternal();

    ConditionVar        condvar_;
    int                 nrthreads_;
    int                 threadcount_;
    bool                dorelease_;

    bool                immediaterelease_;
};


mExpClass(Basic) Thread
{
public:

                                Thread(void (*)(void*),const char* nm);
                                Thread(const CallBack&,const char* nm);
    virtual                     ~Thread();

    ThreadID                    threadID() const;

    void                        waitForFinish();
    const char*                 getName() const;


protected:

    mQtclass(QThread*)                  thread_;
};

mGlobal(Basic) int getSystemNrProcessors();
mGlobal(Basic) int getNrProcessors();
mGlobal(Basic) ThreadID currentThread();
mGlobal(Basic) void setCurrentThreadProcessorAffinity( int cpu );
mGlobal(Basic) void sleep(double seconds);


} //namespace