tpzdohrprecond.h

Go to the documentation of this file.

#ifndef TPZDOHRPRECOND_H
#define TPZDOHRPRECOND_H

#include "pzmatrix.h"
#include "tpzautopointer.h"
#include "tpzdohrsubstruct.h"
#include "tpzdohrmatrix.h"
#include "tpzdohrassembly.h"
#include "tpzdohrassemblelist.h"

#include <list>
#include <semaphore.h>

#include "pz_pthread.h"

template <class TVar, class TSubStruct> 
class TPZDohrPrecond : public TPZMatrix<TVar>
{
                std::list<TPZAutoPointer<TSubStruct> > fGlobal;
                TPZStepSolver<TVar> * fCoarse; //K(c)

                int64_t fNumCoarse; //n(c)
                
                int fNumThreads;
                
                TPZAutoPointer<TPZDohrAssembly<TVar> > fAssemble;
                
    //
    
public:
    TPZDohrPrecond(TPZDohrMatrix<TVar, TSubStruct> &origin, TPZAutoPointer<TPZDohrAssembly<TVar> > assemble);
                TPZDohrPrecond(const TPZDohrPrecond &copy);
    TPZDohrPrecond();
                
    ~TPZDohrPrecond();
    
                // CLONEDEF(TPZDohrPrecond)
                virtual TPZMatrix<TVar>*Clone() const  override { return new TPZDohrPrecond(*this); }
    
                std::list<TPZAutoPointer<TSubStruct> > &Global()
    {
        return fGlobal;
    }
                
                void Initialize();
    
        void SetNumThreads(int numthreads)
        {
                  fNumThreads = numthreads;
        }

                virtual void MultAdd(const TPZFMatrix<TVar> &x,const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z, const TVar alpha,const TVar beta,const int opt) const override;
                
    virtual void MultAddTBB(const TPZFMatrix<TVar> &x,const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z, const TVar alpha,const TVar beta,const int opt) const;
    
                void SetSolver(TPZSolver<TVar> &solver);
                
                void ComputeV1(const TPZFMatrix<TVar> &x, TPZFMatrix<TVar> &v1) const;
                void ComputeV2(const TPZFMatrix<TVar> &x, TPZFMatrix<TVar> &v2) const;
    
                public:
int ClassId() const override;
                
                void Read(TPZStream &buf, void *context) override;
                void Write(TPZStream &buf, int withclassid) const override;

};

template <class TVar, class TSubStruct> 
int TPZDohrPrecond<TVar, TSubStruct>::ClassId() const{
    return Hash("TPZDohrPrecond") ^ TPZMatrix<TVar>::ClassId() << 1 ^ TSubStruct().ClassId() << 2;
}

#include <pthread.h>

template <class TVar, class TSubStruct> 
struct TPZDohrPrecondThreadV1Data {
                TPZDohrPrecondThreadV1Data() : fDohrMatrix(0), fInput(0), fOutput(0)
                {
                }
                TPZDohrPrecondThreadV1Data(const TPZDohrPrecond<TVar, TSubStruct> *ptr, const TPZFMatrix<TVar> &input, TPZFMatrix<TVar> &output) : fDohrMatrix(ptr),
                fInput(&input), fOutput(&output)
                {
                }
                const TPZDohrPrecond<TVar, TSubStruct> * fDohrMatrix;
                const TPZFMatrix<TVar> * fInput;
                TPZFMatrix<TVar> *fOutput;
                static void *ComputeV1(void *dataptr)
                {
                                TPZDohrPrecondThreadV1Data<TVar, TSubStruct> *ptr = (TPZDohrPrecondThreadV1Data<TVar, TSubStruct> *) dataptr;
                                ptr->fDohrMatrix->ComputeV1(*(ptr->fInput),*(ptr->fOutput));
                                return dataptr;
                }
};

template <class TVar, class TSubStruct> 
struct TPZDohrPrecondV2SubData {
                
                TPZDohrPrecondV2SubData() : fSubStructure(0), fInput_local(0), fv2_local(0)
                {
                }
                
                TPZDohrPrecondV2SubData(int subindex, const TPZAutoPointer<TSubStruct> &substruct, TPZAutoPointer<TPZFMatrix<TVar> > res_local) : fSubStructure(substruct),
                fInput_local(res_local)
                {
                                fv2_local = new TPZDohrAssembleItem<TVar>(subindex, res_local->Rows());
                }
                TPZDohrPrecondV2SubData(const TPZDohrPrecondV2SubData<TVar, TSubStruct> &copy) : fSubStructure(copy.fSubStructure), fInput_local(copy.fInput_local),
                fv2_local(copy.fv2_local)
                {
                }
                
                TPZDohrPrecondV2SubData &operator=(const TPZDohrPrecondV2SubData &copy)
                {
                                fSubStructure = copy.fSubStructure;
                                fInput_local = copy.fInput_local;
                                fv2_local = copy.fv2_local;
                                return *this;
                }
                
                bool IsValid()
                {
                                return fSubStructure;
                }
                
                ~TPZDohrPrecondV2SubData()
                {
                }
                
                TPZAutoPointer<TSubStruct> fSubStructure;
                TPZAutoPointer<TPZFMatrix<TVar> > fInput_local;
                TPZAutoPointer<TPZDohrAssembleItem<TVar> > fv2_local;
};

template<class TVar>
struct TPZDohrAssembleList;

template <class TVar, class TSubStruct> 
struct TPZDohrPrecondV2SubDataList {
                TPZDohrPrecondV2SubDataList(TPZAutoPointer<TPZDohrAssembleList<TVar> > &assemble) : fAssemblyStructure(assemble)
                {
                  PZ_PTHREAD_MUTEX_INIT(&fAccessLock, 0, "TPZDohrPrecondV2SubDataList::TPZDohrPrecondV2SubDataList()");
                }
                ~TPZDohrPrecondV2SubDataList()
                {
                  PZ_PTHREAD_MUTEX_DESTROY(&fAccessLock, "TPZDohrPrecondV2SubDataList::~TPZDohrPrecondV2SubDataList()");
                }
                
                pthread_mutex_t fAccessLock;
                
                std::list<TPZDohrPrecondV2SubData<TVar, TSubStruct> > fWork;
    
                void AddItem(TPZDohrPrecondV2SubData<TVar, TSubStruct> &data)
                {
                  PZ_PTHREAD_MUTEX_LOCK(&fAccessLock, "TPZDohrPrecondV2SubDataList::AddItem()");
                  fWork.push_back(data);
                  PZ_PTHREAD_MUTEX_UNLOCK(&fAccessLock, "TPZDohrPrecondV2SubDataList::AddItem()");
                }
                TPZDohrPrecondV2SubData<TVar, TSubStruct> PopItem()
                {
                                TPZDohrPrecondV2SubData<TVar, TSubStruct> result;
                                PZ_PTHREAD_MUTEX_LOCK(&fAccessLock, "TPZDohrPrecondV2SubDataList::PopItem()");
                                if (fWork.size()) {
                                                result = *fWork.begin();
                                                fWork.pop_front();
                                }
                                PZ_PTHREAD_MUTEX_UNLOCK(&fAccessLock, "TPZDohrPrecondV2SubDataList::PopItem()");
                                return result;
                }
                
                TPZAutoPointer<TPZDohrAssembleList<TVar> > fAssemblyStructure;
                
                static void *ThreadWork(void *voidptr);
                
};

#endif