#include <Timer.h>

Public Types
using	Clock = std::chrono::steady_clock

using	CounterType = Clock::time_point

using	Seconds = std::chrono::duration< NekDouble >

Public Member Functions
	Timer ()=default

	~Timer ()=default

	Timer (const Timer &rhs)=delete

Timer &	operator= (const Timer &rhs)=delete

void	Start ()

void	Stop ()

Seconds	Elapsed ()

void	AccumulateRegion (std::string, int iolevel=0)
	Accumulate elapsed time for a region. More...

NekDouble	TimePerTest (unsigned int n)
	Returns amount of seconds per iteration in a test with n iterations. More...

Static Public Member Functions
static void	PrintElapsedRegions ()
	Print elapsed time and call count for each region with default serial communicator. More...

static void	PrintElapsedRegions (LibUtilities::CommSharedPtr comm, std::ostream &o=std::cout, int iolevel=1)
	Print elapsed time and call count for each region. More...

Private Attributes
CounterType	m_start

CounterType	m_end

Static Private Attributes
static std::map< std::string, std::tuple< Seconds, size_t, int > >	m_elapsedRegion {}

static unsigned short	m_maxStringWidth = 10

Detailed Description

Definition at line 52 of file Timer.h.

Member Typedef Documentation

◆ Clock

using Nektar::LibUtilities::Timer::Clock = std::chrono::steady_clock

Definition at line 55 of file Timer.h.

◆ CounterType

using Nektar::LibUtilities::Timer::CounterType = Clock::time_point

Definition at line 56 of file Timer.h.

◆ Seconds

using Nektar::LibUtilities::Timer::Seconds = std::chrono::duration<NekDouble>

Definition at line 57 of file Timer.h.

Constructor & Destructor Documentation

◆ Timer() [1/2]

Nektar::LibUtilities::Timer::Timer ( )

default

◆ ~Timer()

Nektar::LibUtilities::Timer::~Timer ( )

default

◆ Timer() [2/2]

Nektar::LibUtilities::Timer::Timer ( const Timer & rhs )

delete

Member Function Documentation

◆ AccumulateRegion()

void Nektar::LibUtilities::Timer::AccumulateRegion	(	std::string	region,
		int	iolevel = `0`
	)

Accumulate elapsed time for a region.

Definition at line 67 of file Timer.cpp.

 {
     // search for region
     auto search = m_elapsedRegion.find(region);
     if (search == m_elapsedRegion.end())
     {
         m_elapsedRegion.insert({region,
          std::make_tuple<Timer::Seconds, size_t>(this->Elapsed(),1, iolevel)});
         // update field width
         m_maxStringWidth = std::max(
             static_cast<decltype(m_maxStringWidth)>(region.size()),
             m_maxStringWidth);
     }
     else
     {
         std::get<0>(search->second) += this->Elapsed();
         std::get<1>(search->second) += 1;
     }
 }

References Elapsed(), m_elapsedRegion, and m_maxStringWidth.

Referenced by Nektar::SolverUtils::DiffusionIP::CalcTraceNumFlux(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::MultiRegions::ExpList::IProductWRTDerivBase(), main(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Nektar::SolverUtils::AdvectionWeakDG::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::SolverUtils::AdvectionWeakDG::v_AdvectCoeffs(), Nektar::SolverUtils::AdvectionWeakDG::v_AdvectTraceFlux(), Nektar::MultiRegions::ExpList::v_BwdTrans_IterPerExp(), Nektar::SolverUtils::DiffusionIP::v_Diffuse(), Nektar::SolverUtils::DiffusionIP::v_DiffuseTraceFlux(), Nektar::SolverUtils::DiffusionIP::v_DiffuseVolumeFlux(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), and Nektar::MultiRegions::ExpList::v_PhysDeriv().

◆ Elapsed()

Timer::Seconds Nektar::LibUtilities::Timer::Elapsed ( )

Definition at line 57 of file Timer.cpp.

 {
     return std::chrono::duration_cast<Seconds>(m_end - m_start);
 }

References m_end, and m_start.

Referenced by AccumulateRegion(), and TimePerTest().

◆ operator=()

Timer& Nektar::LibUtilities::Timer::operator= ( const Timer & rhs )

delete

◆ PrintElapsedRegions() [1/2]

void Nektar::LibUtilities::Timer::PrintElapsedRegions ( )

static

Print elapsed time and call count for each region with default serial communicator.

Definition at line 87 of file Timer.cpp.

 {
     std::string  def("default");
     char *argv = new char [def.length()+1];
     std::strcpy(argv,def.c_str());
     LibUtilities::CommSharedPtr comm = 
         MemoryManager<LibUtilities::CommSerial>:: AllocateSharedPtr(1,&argv);
  
     PrintElapsedRegions(comm);
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

◆ PrintElapsedRegions() [2/2]

void Nektar::LibUtilities::Timer::PrintElapsedRegions	(	LibUtilities::CommSharedPtr	comm,
		std::ostream &	o = `std::cout`,
		int	iolevel = `1`
	)

static

Print elapsed time and call count for each region.

Definition at line 98 of file Timer.cpp.

 {
     std::vector<std::string> labels{
         "Region",
         "Elapsed time Avg (s)",
         "Min (s)",
         "Max (s)",
         "Count"};
  
  
     if (comm->GetRank() == 0 &&
         m_elapsedRegion.begin() != m_elapsedRegion.end())
     {
         o << "-------------------------------------------\n";
         o << std::setw(m_maxStringWidth+2) << labels[0] << '\t'
           << std::setw(10) << labels[1] << '\t'
           << std::setw(10) << labels[2] << '\t'
           << std::setw(10) << labels[3] << '\t'
           << std::setw(10) << labels[4] << '\n';
     }
     // first write out execute time
     auto item = m_elapsedRegion.find("Execute");
     if(item != m_elapsedRegion.end())
     {
         auto elapsedAve = std::get<0>(item->second).count();
         comm->AllReduce(elapsedAve, LibUtilities::ReduceSum);
         elapsedAve /= comm->GetSize();
         auto elapsedMin = std::get<0>(item->second).count();
         comm->AllReduce(elapsedMin, LibUtilities::ReduceMin);
         auto elapsedMax = std::get<0>(item->second).count();
         comm->AllReduce(elapsedMax, LibUtilities::ReduceMax);
         
         if (comm->GetRank() == 0)
         {
             o << std::setw(m_maxStringWidth+2) << item->first << '\t'
               << std::setw(10) << elapsedAve << '\t'
               << std::setw(10) << elapsedMin << '\t'
               << std::setw(10) << elapsedMax << '\t'
               << std::setw(10) << std::get<1>(item->second) << '\n';
         }
     }            
  
     // write out all other timings order alphabetically on string
     for (auto item = m_elapsedRegion.begin();
             item != m_elapsedRegion.end(); ++item)
     {
         if(std::get<2>(item->second) < iolevel)
         {
             if(boost::iequals(item->first,"Execute"))
             {
                 continue;
             }
  
             auto elapsedAve = std::get<0>(item->second).count();
             comm->AllReduce(elapsedAve, LibUtilities::ReduceSum);
             elapsedAve /= comm->GetSize();
             auto elapsedMin = std::get<0>(item->second).count();
             comm->AllReduce(elapsedMin, LibUtilities::ReduceMin);
             auto elapsedMax = std::get<0>(item->second).count();
             comm->AllReduce(elapsedMax, LibUtilities::ReduceMax);
  
             if (comm->GetRank() == 0)
             {
                 o << std::setw(m_maxStringWidth+2) << item->first << '\t'
                   << std::setw(10) << elapsedAve << '\t'
                   << std::setw(10) << elapsedMin << '\t'
                   << std::setw(10) << elapsedMax << '\t'
                   << std::setw(10) << std::get<1>(item->second) << '\n';
             }
         }
     }
 }

References m_elapsedRegion, m_maxStringWidth, Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceMin, and Nektar::LibUtilities::ReduceSum.

◆ Start()

void Nektar::LibUtilities::Timer::Start ( )

Definition at line 47 of file Timer.cpp.

 {
     m_start = Clock::now();
 }

References m_start.

◆ Stop()

void Nektar::LibUtilities::Timer::Stop ( )

Definition at line 52 of file Timer.cpp.

 {
     m_end = Clock::now();
 }

References m_end.

◆ TimePerTest()

NekDouble Nektar::LibUtilities::Timer::TimePerTest ( unsigned int n )

Returns amount of seconds per iteration in a test with n iterations.

Definition at line 62 of file Timer.cpp.

 {
     return Elapsed().count() / static_cast<NekDouble>(n);
 }

References Elapsed().

Referenced by Nektar::SolverUtils::DriverSteadyState::ConvergenceHistory(), Nektar::FieldUtils::Field::CreateExp(), Nektar::SolverUtils::CouplingCwipi::DumpRawFields(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvaluateAtPoint(), Nektar::SolverUtils::CouplingCwipi::ExtrapolateFields(), main(), Nektar::FieldUtils::InputXml::Process(), Nektar::FieldUtils::ProcessCreateExp::Process(), Nektar::FieldUtils::ProcessIsoContour::Process(), Nektar::SolverUtils::CouplingCwipi::ReceiveCwipi(), Nektar::SolverUtils::CouplingCwipi::ReceiveStart(), RunModule(), Nektar::SolverUtils::CouplingCwipi::SendComplete(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::Collections::CollectionOptimisation::SetWithTimings(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::MultiRegions::AssemblyCommDG::Timing(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::CoupledLinearNS::v_DoSolve(), Nektar::Dummy::v_PostIntegrate(), and Nektar::SolverUtils::CouplingCwipi::v_Send().

Member Data Documentation

◆ m_elapsedRegion

std::map< std::string, std::tuple< Timer::Seconds, size_t, int > > Nektar::LibUtilities::Timer::m_elapsedRegion {}

staticprivate

Definition at line 90 of file Timer.h.

Referenced by AccumulateRegion(), and PrintElapsedRegions().

◆ m_end

CounterType Nektar::LibUtilities::Timer::m_end

private

Definition at line 88 of file Timer.h.

Referenced by Elapsed(), and Stop().

◆ m_maxStringWidth

unsigned short Nektar::LibUtilities::Timer::m_maxStringWidth = 10