threading.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef TY_THREADING
#define TY_THREADING
 
#include <queue>
#include <vector>
 
#include "Tympan/core/smartptr.h"
 
// Useful threading defines
#define TY_AUTO_MUTEX_NAME _mutex
 
// Activate QT threading support
#ifndef QT_THREAD_SUPPORT
    #define QT_THREAD_SUPPORT 1
#endif // QT_THREAD_SUPPORT
 
#include <QMutex>
#include <QWaitCondition>
#include <QThread>
 
class OSleeper : public QThread
{
public:
    static void sleep(unsigned long secs)
    {
        return QThread::sleep(secs);
    }
    static void msleep(unsigned long msecs)
    {
        return QThread::msleep(msecs);
    }
    static void usleep(unsigned long usecs)
    {
        return QThread::usleep(usecs);
    }
};
 
#define TY_AUTO_MUTEX mutable QMutex TY_AUTO_MUTEX_NAME;
#define TY_LOCK_AUTO_MUTEX TY_AUTO_MUTEX_NAME.lock();
#define TY_UNLOCK_AUTO_MUTEX TY_AUTO_MUTEX_NAME.unlock();
#define TY_OMUTEXLOCKER_AUTO_MUTEX OMutexLocker locker(TY_AUTO_MUTEX_NAME);
#define TY_MUTEX(name) mutable QMutex name;
#define TY_LOCK_MUTEX(name) name.lock();
#define TY_UNLOCK_MUTEX(name) name.unlock();
#define TY_OMUTEXLOCKER_MUTEX(name) OMutexLocker locker(name);
#define TY_STATIC_MUTEX(name) static QMutex name;
#define TY_STATIC_MUTEX_INSTANCE(name) QMutex name;
#define TY_AUTO_SHARED_MUTEX mutable QMutex* TY_AUTO_MUTEX_NAME;
#define TY_NEW_AUTO_SHARED_MUTEX TY_AUTO_MUTEX_NAME = new QMutex();
#define TY_DELETE_AUTO_SHARED_MUTEX delete TY_AUTO_MUTEX_NAME;
#define TY_LOCK_AUTO_SHARED_MUTEX TY_AUTO_MUTEX_NAME->lock();
#define TY_UNLOCK_AUTO_SHARED_MUTEX TY_AUTO_MUTEX_NAME->unlock();
#define TY_OMUTEXLOCKER_AUTO_SHARED_MUTEX OMutexLocker locker(*TY_AUTO_MUTEX_NAME);
#define TY_SHARED_MUTEX(name) mutable QMutex* name;
#define TY_NEW_SHARED_MUTEX(name) name = new QMutex();
#define TY_DELETE_SHARED_MUTEX(name) delete name;
#define TY_LOCK_SHARED_MUTEX(name) name->lock();
#define TY_UNLOCK_SHARED_MUTEX(name) name->unlock();
#define TY_OMUTEXLOCKER_SHARED_MUTEX(name) OMutexLocker locker(*name);
 
class OMutexLocker
{
public:
    OMutexLocker(QMutex& mutex);
    OMutexLocker(const QMutex& mutex);
 
    ~OMutexLocker();
 
private:
    QMutex* _mutex;
};
 
inline OMutexLocker::OMutexLocker(QMutex& mutex)
{
    _mutex = &mutex;
    TY_LOCK_SHARED_MUTEX(_mutex)
}
 
inline OMutexLocker::OMutexLocker(const QMutex& mutex)
{
    _mutex = const_cast<QMutex*>(&mutex);
    TY_LOCK_SHARED_MUTEX(_mutex)
}
 
inline OMutexLocker::~OMutexLocker()
{
    TY_UNLOCK_SHARED_MUTEX(_mutex)
}
 
class OThreadPool;
 
class OSlaveThread : public QThread
{
public:
    OSlaveThread(OThreadPool* pool);
 
    ~OSlaveThread();
 
    bool _bToEnd;
 
protected:
    OThreadPool* _pool;
 
    void run();
};
 
class OTask : public IRefCount, public QWaitCondition, public QMutex
{
public:
    OTask();
 
    virtual ~OTask();
 
    bool isRunning() const;
 
    bool isCompleted() const;
 
    bool isCanceled() const;
 
    virtual void main() = 0;
 
    void reset();
 
protected:
    bool _running;
 
    bool _completed;
 
    bool _canceled;
 
    friend class OSlaveThread;
    friend class OThreadPool;
};
 
typedef SmartPtr<OTask> LPOTask;
 
class OThreadPool : public std::vector<OSlaveThread*>, public QWaitCondition, public QMutex
{
public:
    OThreadPool(unsigned int slaves);
 
    virtual ~OThreadPool();
 
    virtual void push(OTask* task);
 
    unsigned int getTotalCount() const;
 
    unsigned int getCount() const;
 
    void begin(unsigned int count);
 
    void startPool();
 
    bool end();
 
protected:
    void stop();
 
    std::queue<LPOTask> _tasks;
 
    unsigned int _totalCount;
 
    unsigned int _counter;
 
    friend class OSlaveThread;
};
 
#endif // TY_THREADING