pzstrmatrixot.h

Go to the documentation of this file.

#ifndef TPZStructMatrixOT_H
#define TPZStructMatrixOT_H

#include <set>
#include <map>
#include <semaphore.h>
#include "pzvec.h"
#include "tpzautopointer.h"
#include "pzcmesh.h"
#include "pzelmat.h"
#include "TPZSemaphore.h"
#include "TPZEquationFilter.h"
#include "TPZGuiInterface.h"
#include "pzmatrix.h"
#include "pzfmatrix.h"

class TPZStructMatrixOT;
#include "TPZStructMatrixBase.h"

//#ifdef USING_TBB
//#include "tbb/tbb.h"
//#include "tbb/task_group.h"
//#endif

#ifdef USING_BOOST
#include <boost/atomic.hpp>
#endif

//void UniformRefine(int num, TPZGeoMesh &m);

class TPZStructMatrixOT : public TPZStructMatrixBase{
    
public:
    
    TPZStructMatrixOT(): TPZStructMatrixBase(){}
    
    TPZStructMatrixOT(TPZCompMesh *);
    
    TPZStructMatrixOT(TPZAutoPointer<TPZCompMesh> cmesh);
    
    TPZStructMatrixOT(const TPZStructMatrixOT &copy);
    
    virtual ~TPZStructMatrixOT(){};
        
    virtual TPZMatrix<STATE> * Create() override;
    
    virtual TPZMatrix<STATE> * CreateAssemble(TPZFMatrix<STATE> &rhs, TPZAutoPointer<TPZGuiInterface> guiInterface,
                                              unsigned numthreads_assemble, unsigned numthreads_decompose) {
        SetNumThreads(numthreads_assemble);
        return CreateAssemble(rhs, guiInterface);
    }
    
    virtual TPZMatrix<STATE> * CreateAssemble(TPZFMatrix<STATE> &rhs, TPZAutoPointer<TPZGuiInterface> guiInterface) override;
    
    virtual TPZStructMatrixOT * Clone() override;
    
    virtual void Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface) override;
    virtual void Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface,
                          unsigned numthreads_assemble, unsigned numthreads_decompose) {
        std::cout << "Nothing to do." << std::endl;
    }
    
    virtual void Assemble(TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface) override;
    
    public:
int ClassId() const override;
    void Read(TPZStream &buf, void *context) override;
    void Write(TPZStream &buf, int withclassid) const override;
    
protected:
    
    virtual void Serial_Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);
    
    virtual void Serial_Assemble(TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);
    
    virtual void MultiThread_Assemble(TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);
    
    virtual void MultiThread_Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);
    
public:
    
    static void OrderElement(TPZCompMesh *cmesh, TPZVec<int64_t> &ElementOrder);
    
    static void ElementColoring(TPZCompMesh *cmesh, TPZVec<int64_t> &elSequence, TPZVec<int64_t> &elSequenceColor, TPZVec<int64_t> &elBlocked, TPZVec<int64_t> &NumelColors);
    
    virtual void FilterEquations(TPZVec<int64_t> &origindex, TPZVec<int64_t> &destindex) const override;
    
    void SetMaterialIds(const std::set<int> &materialids) override;
    
    bool ShouldCompute(int matid) const override
    {
        const size_t size = fMaterialIds.size();
        return size == 0 || fMaterialIds.find(matid) != fMaterialIds.end();
    }
    const std::set<int> &MaterialIds() override
    {
        return fMaterialIds;
    }
    
protected:
    
    struct ThreadData
    {
        ThreadData(TPZStructMatrixOT *strmat,int seqnum, TPZMatrix<STATE> &mat, TPZFMatrix<STATE> &rhs, std::set<int> &MaterialIds, TPZAutoPointer<TPZGuiInterface> guiInterface);
        ThreadData(TPZStructMatrixOT *strmat, int seqnum, TPZFMatrix<STATE> &rhs, std::set<int> &MaterialIds, TPZAutoPointer<TPZGuiInterface> guiInterface);
        ~ThreadData();
        static void *ThreadWork(void *threaddata);
        bool ShouldCompute(int matid)
        {
            return fStruct->ShouldCompute(matid);
        }
        
        TPZStructMatrixOT *fStruct;
        TPZAutoPointer<TPZGuiInterface> fGuiInterface;
        TPZMatrix<STATE> *fGlobMatrix;
        TPZFMatrix<STATE> *fGlobRhs;
        
#ifdef USING_BOOST
        boost::atomic<int64_t> *fCurrentIndex;
#else
#endif

        int fThreadSeqNum;

        TPZVec<int64_t> *fComputedElements;
        pthread_mutex_t *fAccessElement;
        
        pthread_cond_t *fCondition;
        
        int *fSomeoneIsSleeping;
        
        TPZVec<int64_t> *fElBlocked, *fElSequenceColor;
        
        int64_t *fElementCompleted;
        
        static void *ThreadWorkResidual(void *datavoid);
    };
    
//#ifdef USING_TBB
//    struct WorkResidualTBB {
//        
//        int fElem;
//        ThreadData *data;
//        
//        WorkResidualTBB(int elem, ThreadData *data);
//        void operator()();
//    
//    };
//    
//#endif
    friend struct ThreadData;
protected:
    
    TPZVec<int64_t> fElBlocked, fElSequenceColor;
    
    TPZVec<int64_t> fElementsComputed;
    
    int64_t fElementCompleted;
    
    int fSomeoneIsSleeping;
    
#ifdef USING_BOOST
    boost::atomic<int64_t> fCurrentIndex;
#endif

    
    pthread_mutex_t fAccessElement;
    
    pthread_cond_t fCondition;
};

#endif