pzstrmatrixflowtbb.h

Go to the documentation of this file.

#ifndef TPZStructMatrixTBBFlow_H
#define TPZStructMatrixTBBFlow_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 TPZStructMatrixTBBFlow;
#include "TPZStructMatrixBase.h"
#ifdef USING_TBB
#include "tbb/tbb.h"
#include "tbb/flow_graph.h"
#endif


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

class TPZStructMatrixTBBFlow : public TPZStructMatrixBase
{
    
public:
    
    TPZStructMatrixTBBFlow(): TPZStructMatrixBase() {}
    
    TPZStructMatrixTBBFlow(TPZCompMesh *);
    
    TPZStructMatrixTBBFlow(TPZAutoPointer<TPZCompMesh> cmesh);
    
    TPZStructMatrixTBBFlow(const TPZStructMatrixTBBFlow &copy);
    
    virtual ~TPZStructMatrixTBBFlow();
    
    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 TPZStructMatrixTBBFlow * 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:
    
    //    /** @brief Assemble the global system of equations into the matrix which has already been created */
    //    virtual void Serial_Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);
    //
    //    /** @brief Assemble the global right hand side */
    //    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);
    
protected:
    
#ifdef USING_TBB
    
    class TPZFlowGraph {
    public:
        TPZFlowGraph(TPZStructMatrixTBBFlow *strmat);
        ~TPZFlowGraph();
        TPZFlowGraph(TPZFlowGraph const &copy);
        
        // vectors for mesh coloring
        TPZVec<int> fnextBlocked, felSequenceColor, felSequenceColorInv;
        TPZManVector<int> fElementOrder;
        
        TPZCompMesh *cmesh;
        
        tbb::flow::graph fGraph;
        tbb::flow::broadcast_node<tbb::flow::continue_msg> fStartNode;
        std::vector<tbb::flow::continue_node<tbb::flow::continue_msg>* > fNodes;
        
        void OrderElements();
        void ElementColoring();
        void CreateGraph();
        void ExecuteGraph(TPZFMatrix<STATE> *rhs, TPZMatrix<STATE> *matrix = 0);
        
        TPZStructMatrixTBBFlow *fStruct;
        TPZAutoPointer<TPZGuiInterface> fGuiInterface;
        TPZMatrix<STATE> *fGlobMatrix;
        TPZFMatrix<STATE> *fGlobRhs;
    };
    
    class TPZFlowNode {
    public:
        TPZFlowNode(TPZFlowGraph *graph, int el):
        myGraph(graph), iel(el) {};
        
        ~TPZFlowNode() {};
        
        void operator()(tbb::flow::continue_msg) const;
        
        TPZFlowGraph *myGraph;
        
        int iel;
        
        
    };
    
    
    struct TPZGraphThreadData {
        // copy constructor
        TPZGraphThreadData(TPZCompMesh *cmesh, TPZVec<int> &fnextBlocked, TPZVec<int> &felSequenceColor, TPZVec<int> &felSequenceColorInv);
        // destructor
        ~TPZGraphThreadData();
        // tbb tasks graph
        tbb::flow::graph fAssembleGraph;
        // initial node
        tbb::flow::broadcast_node<tbb::flow::continue_msg> fStart;
        // store all the nodes
        std::vector<tbb::flow::continue_node<tbb::flow::continue_msg>* > fGraphNodes;
        // vector for coloring mesh
        TPZVec<int> felSequenceColor;
        
        
        
        TPZStructMatrixTBBFlow *fStruct;
        TPZAutoPointer<TPZGuiInterface> fGuiInterface;
        TPZMatrix<STATE> *fGlobMatrix;
        TPZFMatrix<STATE> *fGlobRhs;
    };
    
    struct TPZGraphThreadNode {
        TPZGraphThreadData *data;
        int iel;
        TPZGraphThreadNode(TPZGraphThreadData *data, int el)
        : data(data), iel(el) {}
        void operator()(tbb::flow::continue_msg) const;
    };
    
#endif
    
    
protected:
    
    TPZCompMesh * fMesh;
    TPZAutoPointer<TPZCompMesh> fCompMesh;
    TPZEquationFilter fEquationFilter;
    
#ifdef USING_TBB
    TPZFlowGraph *fFlowGraph;
#endif
    
protected:
    
    std::set<int> fMaterialIds;
    
    int fNumThreads;
};

#endif