Commit 65360c31 authored by Vít Hanousek's avatar Vít Hanousek
Browse files

Improve of Distributed Grid Performance measurement application.

parent ea3df8b8

src/UnitTests/Mpi/DistributedGridTest_1D.cpp

+1 −10
Original line number Diff line number Diff line
@@ -78,16 +78,6 @@ void check_Inner_1D(int rank, int nproc, DofType dof, typename DofType::RealType 
		EXPECT_EQ( dof[i], expectedValue) << " "<< i;

};



template<typename DofType>

void print_dof_1D(int rank, DofType dof)

{

	std::stringstream sout;

	for(int i=0;i<dof.getSize();i++) //buď je vlevo hranice, nebo overlap

		sout<< dof[i] << " ";

	

	std::cout << rank << ":   " << sout.str() << std::endl;

};



/*

 * Light check of 1D distriover grid and its synchronization. 

 * Number of process is not limitated.
@@ -182,6 +172,7 @@ TEST_F(DistributedGirdTest_1D, evaluateAllEntities) 
	//All entities, witout overlap

	setDof_1D(*dof,-1);

	constFunctionEvaluator.evaluateAllEntities( meshFunctionptr , constFunctionPtr );

	//Printer<MeshType,DofType>::print_dof(rank,*gridptr,*dof);

	check_Boundary_1D(rank, nproc, *dof, rank);

	check_Overlap_1D(rank, nproc, *dof, -1);

	check_Inner_1D(rank, nproc, *dof, rank);

src/UnitTests/Mpi/DistributedGridTest_2D.cpp

+2 −14
Original line number Diff line number Diff line
@@ -343,20 +343,7 @@ void check_Inner_2D(int rank, GridType grid, DofType dof, typename DofType::Real 






template<typename GridType,typename DofType>

void print_dof_2D(int rank,GridType grid, DofType dof)

{

	int maxx=grid.getDimensions().x();

	int maxy=grid.getDimensions().y();

	std::stringstream sout;

	for(int j=0;j<maxy;j++)

	{

		for(int i=0;i<maxx;i++)

			sout<< dof[j*maxx+i] << " ";

		sout<<std::endl;

	}

	std::cout << rank << ":   " << sout.str() << std::endl;

};





/*

 * Light check of 2D distributed grid and its synchronization.
@@ -453,6 +440,7 @@ TEST_F(DistributedGirdTest_2D, evaluateAllEntities) 
	//All entities, witout overlap

	setDof_2D(*dof,-1);

	constFunctionEvaluator.evaluateAllEntities( meshFunctionptr , constFunctionPtr );

	//Printer<MeshType,DofType>::print_dof(rank,*gridptr,*dof);

	check_Boundary_2D(rank, *gridptr, *dof, rank);

	check_Overlap_2D(rank, *gridptr, *dof, -1);

	check_Inner_2D(rank, *gridptr, *dof, rank);

src/UnitTests/Mpi/DistributedGridTest_3D.cpp

+1 −29
Original line number Diff line number Diff line
@@ -589,33 +589,6 @@ void check_Inner_3D(int rank, GridType grid, DofType dof, typename DofType::Real 
}







template<typename GridType,typename DofType>

void print_dof_3D(int rank,GridType grid, DofType dof)

{

  //print local dof

  int maxx=grid.getDimensions().x();

  int maxy=grid.getDimensions().y();

  int maxz=grid.getDimensions().z();

  

  std::stringstream sout;

  for(int k=0;k<maxz;k++)

  {

	for(int j=0;j<maxy;j++)

	{

		for(int ii=0;ii<k;ii++)

			sout<<"  ";

		for(int i=0;i<maxx;i++)

		{

			sout <<dof[k*maxx*maxy+maxx*j+i]<<"  ";

		}

		sout << std::endl;

	}

  }

  std::cout << sout.str()<< std::endl<<std::endl;

}





/*

 * Light check of 3D distributed grid and its synchronization. 

 * expected 9 processors
@@ -713,7 +686,7 @@ TEST_F(DistributedGirdTest_3D, evaluateAllEntities) 
	//All entities, witout overlap

	setDof_3D(*dof,-1);

	constFunctionEvaluator.evaluateAllEntities( meshFunctionptr , constFunctionPtr );

	//print_dof_3D(rank,*gridptr,*dof);

	//Printer<MeshType,DofType>::print_dof(rank,*gridptr,*dof);

	check_Boundary_3D(rank, *gridptr, *dof, rank);

	check_Overlap_3D(rank, *gridptr, *dof, -1);

	check_Inner_3D(rank, *gridptr, *dof, rank);
@@ -724,7 +697,6 @@ TEST_F(DistributedGirdTest_3D, evaluateBoundaryEntities) 
	//Boundary entities, witout overlap

	setDof_3D(*dof,-1);

	constFunctionEvaluator.evaluateBoundaryEntities( meshFunctionptr , constFunctionPtr );

	//print_dof_2D(rank,*gridptr,dof);

	check_Boundary_3D(rank, *gridptr, *dof, rank);

	check_Overlap_3D(rank, *gridptr, *dof, -1);

	check_Inner_3D(rank, *gridptr, *dof, -1);

src/UnitTests/Mpi/Functions.h

+75 −1
Original line number Diff line number Diff line
@@ -8,11 +8,14 @@ 


#pragma once





#include <iostream>

#include <sstream>

#include <TNL/Functions/MeshFunction.h>





using namespace TNL;

using namespace TNL::Functions;

//=================================1D=====================================================



template <typename Real,

        int Dim>
@@ -23,6 +26,13 @@ template <typename Real, 
        int Dim>

class ConstFunction{};



template < typename GridType,

        typename DofType,

        int Dim=GridType::getMeshDimension()>

class Printer

{};



//=================================1D=====================================================

template <typename Real>

class LinearFunction<Real,1> : public Functions::Domain< 1, Functions::MeshDomain >

{
@@ -60,6 +70,20 @@ class ConstFunction<Real,1> : public Functions::Domain< 1, Functions::MeshDomain 
	  }

};



template<typename GridType, typename DofType>

class Printer< GridType,DofType,1>

{

    public:

    void static print_dof(int rank, GridType grid, DofType dof)

    {

	std::stringstream sout;

	for(int i=0;i<dof.getSize();i++) 

		sout<< dof[i] << " ";

	

	std::cout << rank << ":   " << sout.str() << std::endl;

    };

};



//=================================2D======================================================



template <typename Real>
@@ -99,6 +123,26 @@ class ConstFunction<Real,2> : public Functions::Domain< 2, Functions::MeshDomain 
	  }

};



template<typename GridType, typename DofType>

class Printer< GridType,DofType,2>

{

    public:

    void static print_dof(int rank,GridType grid, DofType dof)

    {

	int maxx=grid.getDimensions().x();

	int maxy=grid.getDimensions().y();

	std::stringstream sout;

        sout<< rank<<":" <<std::endl;

	for(int j=0;j<maxy;j++)

	{

		for(int i=0;i<maxx;i++)

			sout<< dof[j*maxx+i] << " ";

		sout<<std::endl;

	}

	std::cout << sout.str() << std::endl<< std::endl;

    };

};



//============================3D============================================================

template <typename Real>

class LinearFunction<Real,3> : public Functions::Domain< 3, Functions::MeshDomain >
@@ -136,3 +180,33 @@ class ConstFunction<Real,3> : public Functions::Domain< 3, Functions::MeshDomain 
		 

	  }

};



template<typename GridType, typename DofType>

class Printer< GridType,DofType,3>

{

    public:

    static void print_dof(int rank,GridType grid, DofType dof)

    {

      //print local dof

      int maxx=grid.getDimensions().x();

      int maxy=grid.getDimensions().y();

      int maxz=grid.getDimensions().z();



      std::stringstream sout;

      sout<< rank<<":"  <<std::endl;

      for(int k=0;k<maxz;k++)

      {

            for(int j=0;j<maxy;j++)

            {

                    for(int ii=0;ii<k;ii++)

                            sout<<"  ";

                    for(int i=0;i<maxx;i++)

                    {

                            sout <<dof[k*maxx*maxy+maxx*j+i]<<"  ";

                    }

                    sout << std::endl;

            }

      }

      std::cout << sout.str()<< std::endl<<std::endl;

    };

};

tests/mpi/MeshFunctionEvauateTest.cpp

+32 −66
Original line number Diff line number Diff line
@@ -24,7 +24,9 @@ using namespace std; 


#include <TNL/Timer.h>



#define OUTPUT 

#define DIMENSION 2

//#define OUTPUT 





#include "../../src/UnitTests/Mpi/Functions.h"
@@ -43,15 +45,18 @@ int main ( int argc, char *argv[]) 
	

  MPI::Init(argc,argv);

  

  //typedef Grid<1,double,Host,int> MeshType;

  //typedef Grid<2,double,Host,int> MeshType;

  typedef Grid<3,double,Host,int> MeshType;

  typedef Grid<DIMENSION,double,Host,int> MeshType;

  typedef MeshFunction<MeshType> MeshFunctionType;

  typedef Vector<double,Host,int> DofType;

  typedef typename MeshType::Cell Cell;

  typedef typename MeshType::IndexType IndexType; 

  typedef typename MeshType::PointType PointType; 

  

  typedef DistributedGrid<MeshType> DistributedGridType;

  

  typedef LinearFunction<double,DIMENSION> LinearFunctionType;

  typedef ConstFunction<double,DIMENSION> ConstFunctionType;

  

  int size=9;

  int cycles=1;

  if(argc==3)
@@ -65,108 +70,69 @@ int main ( int argc, char *argv[]) 
	setup.start();

  

 PointType globalOrigin;

 globalOrigin.x()=-0.5;

 globalOrigin.y()=-0.5;

 globalOrigin.z()=-0.5;

 globalOrigin.setValue(-0.5);

 

 PointType globalProportions;

 globalProportions.x()=size;

 globalProportions.y()=size;

 globalProportions.z()=size;

 globalProportions.setValue(size);

 

 

 MeshType globalGrid;

 //globalGrid.setDimensions(9);

 //globalGrid.setDimensions(size,size);

 globalGrid.setDimensions(size,size,size);

 globalGrid.setDimensions(globalProportions);

 globalGrid.setDomain(globalOrigin,globalProportions);

 

 int distr[3]={0,0,0}; 

 DistributedGrid<MeshType> distrgrid(globalGrid, distr); 

 

 //DistributedGrid<MeshType> distrgrid(globalGrid);

 int distr[DIMENSION];

 for(int i=0;i<DIMENSION;i++) 

	distr[i]=0;

 DistributedGridType distrgrid(globalGrid, distr); 

   

 SharedPointer<MeshType> gridptr;

 SharedPointer<MeshFunctionType> meshFunctionptr;

 MeshFunctionEvaluator< MeshFunctionType, LinearFunction<double,3> > linearFunctionEvaluator;

 MeshFunctionEvaluator< MeshFunctionType, ConstFunction<double,3> > constFunctionEvaluator;

 MeshFunctionEvaluator< MeshFunctionType, LinearFunctionType > linearFunctionEvaluator;

 MeshFunctionEvaluator< MeshFunctionType, ConstFunctionType > constFunctionEvaluator;

 

  distrgrid.SetupGrid(*gridptr);

  

  DofType dof(gridptr->template getEntitiesCount< Cell >());



  int maxx=gridptr->getDimensions().x();

  int maxy=gridptr->getDimensions().y();

  int maxz=gridptr->getDimensions().z();

  for(int k=0;k<maxz;k++)

	for(int j=0;j<maxy;j++)

		for(int i=0;i<maxx;i++)

			dof[k*maxx*maxy+maxx*j+i]=0;

  dof.setValue(0);

  

  meshFunctionptr->bind(gridptr,dof);  

  

  SharedPointer< LinearFunction<double,3>, Host > linearFunctionPtr;

  SharedPointer< ConstFunction<double,3>, Host > constFunctionPtr; 

  SharedPointer< LinearFunctionType, Host > linearFunctionPtr;

  SharedPointer< ConstFunctionType, Host > constFunctionPtr; 

   

  DistributedGridSynchronizer<DistributedGrid<MeshType>,MeshFunctionType,3> synchronizer(&distrgrid);

  DistributedGridSynchronizer<DistributedGridType,MeshFunctionType> synchronizer(&distrgrid);

  

  setup.stop();

  

  double sum=0.0;



  constFunctionPtr->Number=MPI::COMM_WORLD.Get_rank();

  

  for(int i=0;i<cycles;i++)

	{    

	    //zero->Number=MPI::COMM_WORLD.Get_rank();

	    

	    eval.start();

		/*zero->Number=-1;

		zeroevaluator.evaluateBoundaryEntities( meshFunctionptr , zero );*/

		constFunctionPtr->Number=MPI::COMM_WORLD.Get_rank();

		constFunctionEvaluator.evaluateAllEntities( meshFunctionptr , constFunctionPtr );

		//zero->Number=-1;

		/*zero->Number=MPI::COMM_WORLD.Get_rank();

		zeroevaluator.evaluateBoundaryEntities( meshFunctionptr , zero );*/

		

		//constFunctionEvaluator.evaluateBoundaryEntities( meshFunctionptr , constFunctionPtr );

		linearFunctionEvaluator.evaluateAllEntities(meshFunctionptr , linearFunctionPtr);

		MPI::COMM_WORLD.Barrier();

		eval.stop();





		sync.start();	

		synchronizer.Synchronize(*meshFunctionptr);

		MPI::COMM_WORLD.Barrier();

		sync.stop();



		sum+=dof[2*gridptr->getDimensions().y()]; //dummy acces to array	

		sum+=dof[gridptr->getDimensions().x()/2]; //dummy acces to array	

	}

  all.stop();

  

#ifdef OUTPUT	

  //print local dof

  maxx=gridptr->getDimensions().x();

  maxy=gridptr->getDimensions().y();

  maxz=gridptr->getDimensions().z();

  

  stringstream sout;

  distrgrid.printcoords(sout);

  for(int k=0;k<maxz;k++)

  {

	for(int j=0;j<maxy;j++)

	{

		for(int ii=0;ii<k;ii++)

			sout<<"  ";

		for(int i=0;i<maxx;i++)

		{

			sout <<dof[k*maxx*maxy+maxx*j+i]<<"  ";

		}

		sout << endl;

	}

  }

  cout << sout.str()<< endl<<endl;

  Printer<MeshType,DofType>::print_dof(MPI::COMM_WORLD.Get_rank(),*gridptr, dof);

#endif

  

  

  

  

  

  if(MPI::COMM_WORLD.Get_rank()==0)

  {

	cout << sum <<endl<<endl;