FMEThread.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Barrier.h>
#include <ogdf/basic/Thread.h>
#include <ogdf/energybased/fast_multipole_embedder/ArrayGraph.h>
#include <ogdf/energybased/fast_multipole_embedder/FastUtils.h>
#include <ogdf/energybased/fast_multipole_embedder/LinearQuadtree.h>
 
namespace ogdf {
namespace fast_multipole_embedder {
 
class FMEThreadPool;
 
class FMETask {
public:
    virtual ~FMETask() { }
 
    virtual void doWork() = 0;
};
 
template<typename FuncInvokerType>
class FMEFuncInvokerTask : public FMETask {
public:
    FMEFuncInvokerTask(FuncInvokerType f) : funcInvoker(f) { }
 
    void doWork() override { funcInvoker(); }
 
private:
    FuncInvokerType funcInvoker;
};
 
class FMEThread /*: public Thread*/
{
public:
    FMEThread(FMEThreadPool* pThreadPool, uint32_t threadNr);
 
    inline uint32_t threadNr() const { return m_threadNr; }
 
    inline uint32_t numThreads() const { return m_numThreads; }
 
    inline bool isMainThread() const { return m_threadNr == 0; }
 
    inline FMEThreadPool* threadPool() const { return m_pThreadPool; }
 
    void sync();
 
#ifdef OGDF_HAS_LINUX_CPU_MACROS
    void unixSetAffinity();
#else
    void unixSetAffinity() { }
#endif
 
    void operator()() {
        unixSetAffinity();
        m_pTask->doWork();
        delete m_pTask;
        m_pTask = nullptr;
    }
 
    void setTask(FMETask* pTask) { m_pTask = pTask; }
 
private:
    uint32_t m_threadNr;
 
    uint32_t m_numThreads;
 
    FMEThreadPool* m_pThreadPool;
 
    FMETask* m_pTask;
 
    FMEThread(const FMEThread&); // = delete
    FMEThread& operator=(const FMEThread&); // = delete
};
 
class FMEThreadPool {
public:
    explicit FMEThreadPool(uint32_t numThreads);
 
    ~FMEThreadPool();
 
    inline uint32_t numThreads() const { return m_numThreads; }
 
    inline FMEThread* thread(uint32_t threadNr) const { return m_pThreads[threadNr]; }
 
    inline Barrier* syncBarrier() const { return m_pSyncBarrier; }
 
    void runThreads();
 
    template<typename KernelType, typename ArgType1>
    void runKernel(ArgType1 arg1) {
        for (uint32_t i = 0; i < numThreads(); i++) {
            KernelType kernel(thread(i));
            FuncInvoker<KernelType, ArgType1> invoker(kernel, arg1);
            thread(i)->setTask(new FMEFuncInvokerTask<FuncInvoker<KernelType, ArgType1>>(invoker));
        }
        runThreads();
    }
 
private:
    void allocate();
 
    void deallocate();
 
    uint32_t m_numThreads;
 
    FMEThread** m_pThreads;
 
    Barrier* m_pSyncBarrier;
};
 
}
}