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
 RCS:           $Id$
________________________________________________________________________
 
*/
 
#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();
 
    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=nullptr);
                                Thread(const CallBack&,const char* nm=nullptr);
    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