#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=0)
	Print elapsed time and call count for each region. More...

Private Attributes
CounterType	m_start = CounterType()

CounterType	m_end = CounterType()

bool	m_isactive = false

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

Detailed Description

Definition at line 51 of file Timer.h.

Member Typedef Documentation

◆ Clock

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

Definition at line 54 of file Timer.h.

◆ CounterType

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

Definition at line 55 of file Timer.h.

◆ Seconds

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

Definition at line 56 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 72 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)});
    }
    else
    {
        std::get<0>(search->second) += this->Elapsed();
        std::get<1>(search->second) += 1;
    }
}

References Elapsed(), and m_elapsedRegion.

◆ Elapsed()

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

Definition at line 60 of file Timer.cpp.

{
    ASSERTL0(!m_isactive,
             "Call to Timer::Elapsed() done before Timer::Stop().");
    return std::chrono::duration_cast<Seconds>(m_end - m_start);
}

References ASSERTL0, m_end, m_isactive, and m_start.

◆ 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 88 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);
 
    delete[] argv;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and PrintElapsedRegions().

Referenced by Nektar::TriCollectionTests::BOOST_AUTO_TEST_CASE(), and PrintElapsedRegions().

◆ PrintElapsedRegions() [2/2]

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

static

Print elapsed time and call count for each region.

Definition at line 101 of file Timer.cpp.

{
    // Return if there is nothing to write, or the user has disabled printing
    if (m_elapsedRegion.begin() == m_elapsedRegion.end() || iolevel < 0)
    {
        return;
    }
 
    // Define content of each column that will be written
    std::vector<std::string> labels{"Region",  "Elapsed time Avg (s)",
                                    "Min (s)", "Max (s)",
                                    "Count",   "IO Level"};
 
    // Set width of each column (minimum 14 characters)
    std::vector<size_t> widths;
    for (const auto &label : labels)
    {
        widths.push_back(std::max<size_t>(label.size() + 2, 14));
    }
 
    // Make sure that names for each "Region" fits
    for (const auto &entry : m_elapsedRegion)
    {
        widths[0] = std::max<size_t>(entry.first.size() + 2, widths[0]);
    }
 
    // Print header
    if (comm->GetRank() == 0)
    {
        o << "-------------------------------------------\n";
        for (int i = 0; i < labels.size(); ++i)
        {
            o << std::setw(widths[i]) << labels[i];
        }
        o << '\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(widths[0]) << item->first << std::setw(widths[1])
              << elapsedAve << std::setw(widths[2]) << elapsedMin
              << std::setw(widths[3]) << elapsedMax << std::setw(widths[4])
              << std::get<1>(item->second) << std::setw(widths[5])
              << std::get<2>(item->second) << '\n';
        }
    }
 
    // Write all remaining timers, grouped by their IO Level
    for (int i = 0; i <= iolevel; i++)
    {
        // Add a newline between each IO Level group
        if (comm->GetRank() == 0)
            o << "\n";
 
        for (auto item = m_elapsedRegion.begin(); item != m_elapsedRegion.end();
             ++item)
        {
            // Avoid writing the "Execute" timer twice
            if (boost::iequals(item->first, "Execute"))
            {
                continue;
            }
 
            // Check if this timer has the correct IO Level
            if (std::get<2>(item->second) == i)
            {
 
                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(widths[0]) << item->first
                      << std::setw(widths[1]) << elapsedAve
                      << std::setw(widths[2]) << elapsedMin
                      << std::setw(widths[3]) << elapsedMax
                      << std::setw(widths[4]) << std::get<1>(item->second)
                      << std::setw(widths[5]) << std::get<2>(item->second)
                      << '\n';
                }
            }
        }
    }
}

References CG_Iterations::label, m_elapsedRegion, Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceMin, and Nektar::LibUtilities::ReduceSum.

◆ Start()

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

Definition at line 46 of file Timer.cpp.

{
    ASSERTL0(!m_isactive, "Call to Timer::Start() done when timer is active.");
    m_isactive = true;
    m_start    = Clock::now();
}

References ASSERTL0, m_isactive, and m_start.

◆ Stop()

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

Definition at line 53 of file Timer.cpp.

{
    m_end = Clock::now();
    ASSERTL0(m_isactive, "Call to Timer::Stop() done when timer is inactive.");
    m_isactive = false;
}

References ASSERTL0, m_end, and m_isactive.

◆ TimePerTest()

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

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

Definition at line 67 of file Timer.cpp.

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

References Elapsed().

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 = CounterType()

private

Definition at line 87 of file Timer.h.

Referenced by Elapsed(), and Stop().

◆ m_isactive

bool Nektar::LibUtilities::Timer::m_isactive = false

private

Definition at line 88 of file Timer.h.

Referenced by Elapsed(), Start(), and Stop().

◆ m_start

CounterType Nektar::LibUtilities::Timer::m_start = CounterType()

private

Definition at line 86 of file Timer.h.

Referenced by Elapsed(), and Start().

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ Clock

◆ CounterType

◆ Seconds

Constructor & Destructor Documentation

◆ Timer() [1/2]

◆ ~Timer()

◆ Timer() [2/2]

Member Function Documentation

◆ AccumulateRegion()

◆ Elapsed()

◆ operator=()

◆ PrintElapsedRegions() [1/2]

◆ PrintElapsedRegions() [2/2]

◆ Start()

◆ Stop()

◆ TimePerTest()

Member Data Documentation

◆ m_elapsedRegion

◆ m_end

◆ m_isactive

◆ m_start