TPZFront.h

Go to the documentation of this file.

#ifndef TPZFRONT_H
#define TPZFRONT_H

#include "pzmatrix.h"
#include "pzstack.h"
#include "pzvec.h"
#include "TPZThreadTools.h"

template<class TVar>
class TPZEqnArray;

template<class TVar>
class TPZFront : public TPZSavable {
                
public:
                
                //static void main();
                
                int64_t NElements();
    virtual ~TPZFront();
    TPZFront();
                TPZFront(
                                                 int64_t GlobalSize 
                                                 );
                
                TPZFront(const TPZFront<TVar> &cp);
                
    void SymbolicDecomposeEquations(int64_t mineq, int64_t maxeq);
                
                void SymbolicAddKel(TPZVec < int64_t > & destinationindex);

                int Work() {
                                return fWork;
                }
                
                void SetNumRigidBodyModes(int nrigid)
                {
                                fNextRigidBodyMode = fLocal.NElements()-nrigid;
                                
                                std::cout << " fNextRigidBody Mode neste ponto " << fNextRigidBodyMode<<std::endl;
                }
                
        public:
int ClassId() const override;
        
protected:
                int fWork;
private:    
                
    void FreeGlobal(int64_t global);
    
    int Local(int64_t global);
                
public:
                virtual         void ExtractFrontMatrix(TPZFMatrix<TVar> &front) {
                                std::cout << "TPZFront ExtractFrontMatrix should never be called\n";
                                DebugStop();
                }
                
    DecomposeType GetDecomposeType() const
    {
        return fDecomposeType;
    }
    
    virtual void SetDecomposeType(DecomposeType dectype) = 0;

                int NonNullFrontSize() const{
                                int maxeq = fLocal.NElements();
                                int mineq = 0;
                                for(mineq=0; mineq<maxeq; mineq++) if(fLocal[mineq] != -1) break;
                                int numeq = maxeq-mineq;
                                return numeq;
                }               
                
                virtual int64_t NFree();
                void Reset(int64_t GlobalSize=0);
                
                void Print(const char *name, std::ostream& out) const;
                void PrintGlobal(const char *name, std::ostream& out = std::cout);
                
                int FrontSize()
                {
                                return fFront;
                }

protected:
    
    int fMaxFront;

    TPZManVector <int64_t> fGlobal;
                
    TPZVec<int64_t> fLocal;
                
    int64_t fFront;
                
                int64_t fNextRigidBodyMode;
                
    TPZStack <int> fFree;
                
    TPZVec<TVar> fData;
    
    int fExpandRatio;

protected:
    
    DecomposeType fDecomposeType;
    

public:
                
                struct STensorProductMTData{
                                
                                typedef std::pair<int,STensorProductMTData * > STensorProductThreadData;
                                
                public:
                                
                                pz_semaphore_t fWorkDoneSem;
                                int fWorkDoneCount;
                                pz_critical_section_t fWorkDoneCS;
                                
                                TPZVec<pz_semaphore_t> fWorkSem;
                                
                                TPZVec< pz_thread_t > fThreads;
                                
                                TPZVec<TVar> * fAuxVecCol, * fAuxVecRow;
        
        TVar fDiagonal;
                                
                                int NThreads(){ return fThreads.NElements(); };
                                
                                //vec to storage
                                TPZVec<STensorProductThreadData*> fThreadData;  
                                
                                TPZFront<TVar> * fMat;
                                
                                bool fRunning;
                                
                                STensorProductMTData(int nthreads, TPZFront<TVar> * frontMat){
                                                if(!frontMat) DebugStop();
                                                this->fMat = frontMat;
                                                this->fRunning = true;
                                                
                                                fWorkSem.Resize(nthreads);
                                                for(int i = 0; i < nthreads; i++){
                                                                tht::InitializeSemaphore(fWorkSem[i]);
                                                }
                                                
                                                fThreads.Resize(nthreads);
                                                fThreadData.Resize(nthreads);
                                                for(int i = 0; i < nthreads; i++){
                                                                STensorProductThreadData * threadData = new STensorProductThreadData;
                                                                threadData->first = i;
                                                                threadData->second = this;
                                                                fThreadData[i] = threadData;
                                                                tht::CreateThread( fThreads[i], & Execute, threadData);
                                                }
                                                
                                                tht::InitializeSemaphore(fWorkDoneSem);
                                                tht::InitializeCriticalSection(fWorkDoneCS);
                                                
                                }
                                
                                ~STensorProductMTData(){
                                                
                                                this->fRunning = false;
                                                const int nthreads = fWorkSem.NElements();
                                                for(int i = 0; i < nthreads; i++){
                                                                tht::SemaphorePost(fWorkSem[i]);
                                                }
                                                for(int i = 0; i < nthreads; i++){
                                                                tht::ThreadWaitFor(fThreads[i]);
                                                                delete fThreadData[i];
                                                                fThreadData[i] = NULL;
                                                }
                                                
                                                for(int i = 0; i < fWorkSem.NElements(); i++){
                                                                tht::DeleteSemaphore( fWorkSem[i] );
                                                }
                                                tht::DeleteSemaphore( fWorkDoneSem );
                                                tht::DeleteCriticalSection(fWorkDoneCS);
                                                
                                }
                                
                                static void *Execute(void *data){
                                                STensorProductThreadData * mypair = static_cast< STensorProductThreadData * >(data);
                                                if(!mypair) DebugStop();
                                                TPZFront<TVar> * mat = mypair->second->fMat;
                                                if(!mat) DebugStop();
                                                mat->TensorProductIJ(mypair->first,mypair->second);
                                                return NULL;
                                }
                                
                                void WorkDone(){
                                                tht::EnterCriticalSection(fWorkDoneCS);
                                                fWorkDoneCount++;
                                                if(fWorkDoneCount == NThreads()){
                                                                tht::SemaphorePost(fWorkDoneSem);
                                                }
                                                tht::LeaveCriticalSection(fWorkDoneCS);
                                }
                                
                                void Run(TPZVec<TVar> &AuxVecCol, TPZVec<TVar> &AuxVecRow){
                                                this->fAuxVecCol = &AuxVecCol;
                                                this->fAuxVecRow = &AuxVecRow;
                                                this->fWorkDoneCount = 0;
                                                for(int i = 0; i < NThreads(); i++){
                                                                tht::SemaphorePost(fWorkSem[i]);
                                                }
                                                tht::SemaphoreWait( fWorkDoneSem );
                                }
                                
                };
                
protected:
                
                STensorProductMTData *fProductMTData;
                
public:
                
                void ProductTensorMTInitData(int nthreads){
                                fProductMTData = new STensorProductMTData(nthreads, this);
                }
                
                void ProductTensorMTFinish(){
                                delete this->fProductMTData;
                }
                
                void ProductTensorMT(TPZVec<TVar> &AuxVecCol, TPZVec<TVar> &AuxVecRow){
                                this->fProductMTData->Run(AuxVecCol,AuxVecRow);
                }
                
public:
                
                virtual void TensorProductIJ(int ithread,typename TPZFront<TVar>::STensorProductMTData *data);
};

template<class TVar>
int TPZFront<TVar>::ClassId() const {
    return Hash("TPZFront") ^ ClassIdOrHash<TVar>() << 1;
}
#endif //TPZFRONT_H