TimerManager< TIMER > Class Template Reference

Manager creates timers and handle reports. More...

Inheritance diagram for TimerManager< TIMER >:

Collaboration diagram for TimerManager< TIMER >:

Classes
struct	FlatProfileData
struct	StackProfileData

Public Types
using	nameList_t = std::map< std::string, int >
using	timeList_t = std::vector< double >
using	callList_t = std::vector< long >
using	names_t = std::vector< std::string >

Public Member Functions
	TimerManager ()
TIMER *	createTimer (const std::string &myname, timer_levels mytimer=timer_level_fine)
	Create a new timer object registred in this manager. This call is thread-safe. More...
void	push_timer (TIMER *t)
void	pop_timer (TIMER *t)
TIMER *	current_timer ()
void	set_timer_threshold (const timer_levels threshold)
void	set_timer_threshold (const std::string &threshold)
std::string	get_timer_threshold_string () const
bool	maximum_number_of_timers_exceeded () const
void	reset ()
void	print (Communicate *comm)
void	collate_flat_profile (Communicate *comm, FlatProfileData &p)
void	collate_stack_profile (Communicate *comm, StackProfileData &p)
void	output_timing (Communicate *comm, Libxml2Document &doc, xmlNodePtr root)
void	get_stack_name_from_id (const StackKey &key, std::string &name)

Private Member Functions
void	initializeTimer (TIMER &t)
void	print_flat (Communicate *comm)
void	print_stack (Communicate *comm)

Private Attributes
std::vector< std::unique_ptr< TIMER > >	timer_storage_
	All the timers created by this manager. More...
std::mutex	timer_list_lock_
	mutex for TimerList More...
std::vector< TIMER * >	CurrentTimerStack
	The stack of nested active timers. More...
timer_levels	timer_threshold
	The threshold for active timers. More...
timer_id_t	max_timer_id
	The current maximal timer id. More...
bool	max_timers_exceeded
	status of maxmal timer id reached More...
std::map< timer_id_t, std::string >	timer_id_name
	timer id to name mapping More...
std::map< std::string, timer_id_t >	timer_name_to_id
	name to timer id mapping More...

Detailed Description

template<class TIMER>
class qmcplusplus::TimerManager< TIMER >

Manager creates timers and handle reports.

Template Parameters

TIMER

regular or fake timer

TimerManager is generally not thread-safe. Thread-safe functions are noted below.

Definition at line 40 of file NewTimer.h.

---

Class Documentation

qmcplusplus::TimerManager::FlatProfileData

struct qmcplusplus::TimerManager::FlatProfileData

template<class TIMER>
struct qmcplusplus::TimerManager< TIMER >::FlatProfileData

Definition at line 113 of file TimerManager.h.

Collaboration diagram for TimerManager< TIMER >::FlatProfileData:

Class Members
callList_t	callList
nameList_t	nameList
timeList_t	timeList

qmcplusplus::TimerManager::StackProfileData

struct qmcplusplus::TimerManager::StackProfileData

template<class TIMER>
struct qmcplusplus::TimerManager< TIMER >::StackProfileData

Definition at line 120 of file TimerManager.h.

Collaboration diagram for TimerManager< TIMER >::StackProfileData:

Class Members
callList_t	callList
nameList_t	nameList
names_t	names
timeList_t	timeExclList
timeList_t	timeList

Member Typedef Documentation

callList_t

using callList_t = std::vector<long>

Definition at line 110 of file TimerManager.h.

nameList_t

using nameList_t = std::map<std::string, int>

Definition at line 108 of file TimerManager.h.

names_t

using names_t = std::vector<std::string>

Definition at line 111 of file TimerManager.h.

timeList_t

using timeList_t = std::vector<double>

Definition at line 109 of file TimerManager.h.

Constructor & Destructor Documentation

TimerManager()

TimerManager ( )

inline

Definition at line 76 of file TimerManager.h.

                 : timer_threshold(timer_level_coarse), max_timer_id(1), max_timers_exceeded(false)
  {
#ifdef USE_VTUNE_TASKS
    task_domain = __itt_domain_create("QMCPACK");
#endif
  }

Member Function Documentation

collate_flat_profile()

void collate_flat_profile	(	Communicate *	comm,
		FlatProfileData &	p
	)

Definition at line 168 of file TimerManager.cpp.

Referenced by qmcplusplus::TEST_CASE().

{
  for (int i = 0; i < timer_storage_.size(); ++i)
  {
    TIMER& timer = *timer_storage_[i];
    nameList_t::iterator it(p.nameList.find(timer.get_name()));
    if (it == p.nameList.end())
    {
      int ind                      = p.nameList.size();
      p.nameList[timer.get_name()] = ind;
      p.timeList.push_back(timer.get_total());
      p.callList.push_back(timer.get_num_calls());
    }
    else
    {
      int ind = (*it).second;
      p.timeList[ind] += timer.get_total();
      p.callList[ind] += timer.get_num_calls();
    }
  }

  if (comm)
  {
    comm->allreduce(p.timeList);
    comm->allreduce(p.callList);
  }
}

collate_stack_profile()

void collate_stack_profile	(	Communicate *	comm,
		StackProfileData &	p
	)

Definition at line 244 of file TimerManager.cpp.

Referenced by qmcplusplus::TEST_CASE().

{
#ifdef USE_STACK_TIMERS
  // Put stacks from all timers into one data structure
  // By naming the timer stacks as 'timer1/timer2', etc, the ordering done by the
  // map's keys will also place the stacks in depth-first order.
  // The order in which sibling timers are encountered in the code is not
  // preserved. They will be ordered alphabetically instead.
  std::map<std::string, ProfileData> all_stacks;
  for (int i = 0; i < timer_storage_.size(); ++i)
  {
    TIMER& timer = *timer_storage_[i];
    for (const auto& [key, time] : timer.get_per_stack_total_time())
    {
      ProfileData pd;
      std::string stack_name;
      get_stack_name_from_id(key, stack_name);
      pd.time  = timer.get_total(key);
      pd.calls = timer.get_num_calls(key);

      all_stacks[stack_name] += pd;
    }
  }

  // Fill in the output data structure (but don't compute exclusive time yet)
  int idx = 0;
  for (const auto& [stack_name, data] : all_stacks)
  {
    p.nameList[stack_name] = idx;
    p.names.push_back(stack_name);
    p.timeList.push_back(data.time);
    p.timeExclList.push_back(data.time);
    p.callList.push_back(data.calls);
    idx++;
  }

  // Subtract times of immediate children to get exclusive time
  for (idx = 0; idx < p.timeList.size(); idx++)
  {
    int start_level = get_level(p.names[idx]);
    for (int i = idx + 1; i < p.timeList.size(); i++)
    {
      int level = get_level(p.names[i]);
      if (level == start_level + 1)
        p.timeExclList[idx] -= p.timeExclList[i];

      if (level == start_level)
        break;
    }
  }
#endif
}

createTimer()

TIMER * createTimer	(	const std::string &	myname,
		timer_levels	mytimer = timer_level_fine
	)

Create a new timer object registred in this manager. This call is thread-safe.

Definition at line 84 of file TimerManager.cpp.

Referenced by qmcplusplus::TEST_CASE().

{
  TIMER* t = nullptr;
  {
    const std::lock_guard<std::mutex> lock(timer_list_lock_);
    timer_storage_.push_back(std::make_unique<TIMER>(myname, this, mytimer));
    t = timer_storage_.back().get();
    initializeTimer(*t);
  }
  return t;
}

current_timer()

TIMER* current_timer ( )

inline

Definition at line 90 of file TimerManager.h.

Referenced by qmcplusplus::TEST_CASE().

  {
    TIMER* current = nullptr;
    if (CurrentTimerStack.size() > 0)
      current = CurrentTimerStack.back();

    return current;
  }

get_stack_name_from_id()

void get_stack_name_from_id	(	const StackKey &	key,
		std::string &	name
	)

Definition at line 229 of file TimerManager.cpp.

{
  for (int i = 0; i < StackKey::max_level; i++)
  {
    std::string& timer_name = timer_id_name[key.get_id(i)];
    if (key.get_id(i) == 0)
      break;
    if (i > 0)
      stack_name += TIMER_STACK_SEPARATOR;

    stack_name += timer_name;
  }
}

get_timer_threshold_string()

std::string get_timer_threshold_string

(

)

const

Definition at line 161 of file TimerManager.cpp.

{
  return timer_level_names[timer_threshold];
}

initializeTimer()

void initializeTimer ( TIMER &  t )

private

Definition at line 57 of file TimerManager.cpp.

{
  if (t.get_name().find(TIMER_STACK_SEPARATOR) != std::string::npos)
    app_log() << "Warning: Timer name (" << t.get_name() << ") should not contain the character "
              << TIMER_STACK_SEPARATOR << std::endl;

  if (timer_name_to_id.find(t.get_name()) == timer_name_to_id.end())
  {
    t.set_id(max_timer_id);
    timer_id_name[t.get_id()]      = t.get_name();
    timer_name_to_id[t.get_name()] = t.get_id();
    if (max_timer_id >= std::numeric_limits<timer_id_t>::max())
    {
      max_timers_exceeded = true;
      app_log() << "Number of timers exceeds limit (" << static_cast<int>(std::numeric_limits<timer_id_t>::max())
                << ").   Adjust timer_id_t in NewTimer.h and recompile." << std::endl;
    }
    else
      max_timer_id++;
  }
  else
    t.set_id(timer_name_to_id[t.get_name()]);

  t.set_active_by_timer_threshold(timer_threshold);
}

maximum_number_of_timers_exceeded()

bool maximum_number_of_timers_exceeded ( ) const

inline

Definition at line 103 of file TimerManager.h.

{ return max_timers_exceeded; }

output_timing()

void output_timing	(	Communicate *	comm,
		Libxml2Document &	doc,
		xmlNodePtr	root
	)

Definition at line 419 of file TimerManager.cpp.

Referenced by qmcplusplus::TEST_CASE().

{
#if defined(ENABLE_TIMERS) && defined(USE_STACK_TIMERS)
  StackProfileData p;

  collate_stack_profile(comm, p);

  if (comm == nullptr || comm->rank() == 0)
  {
    xmlNodePtr timing_root = doc.addChild(root, "timing");
    doc.addChild(timing_root, "max_stack_level_exceeded", timer_max_level_exceeded ? "yes" : "no");
    doc.addChild(timing_root, "max_timers_exceeded", max_timers_exceeded ? "yes" : "no");
    std::vector<xmlNodePtr> node_stack;
    node_stack.push_back(timing_root);
    xmlNodePtr current_root = timing_root;

    for (int i = 0; i < p.names.size(); i++)
    {
      std::string stack_name = p.names[i];
      int level              = get_level(stack_name);
      std::string name       = get_leaf_name(stack_name);

      std::string indent_str(2 * level, ' ');

      xmlNodePtr timer = doc.addChild(current_root, "timer");
      doc.addChild(timer, "name", name);
      doc.addChild(timer, "time_incl", p.timeList[i]);
      doc.addChild(timer, "time_excl", p.timeExclList[i]);
      doc.addChild(timer, "calls", p.callList[i]);

      int next_level = level;
      if (i + 1 < p.names.size())
        next_level = get_level(p.names[i + 1]);

      if (next_level > level)
      {
        xmlNodePtr next_node = doc.addChild(timer, "includes");
        node_stack.push_back(next_node);
        current_root = next_node;
      }
      if (next_level < level)
        for (int j = 0; j < level - next_level; j++)
        {
          node_stack.pop_back();
          current_root = node_stack.back();
        }
    }
  }

#endif
}

pop_timer()

void pop_timer

(

TIMER *

t

)

Definition at line 113 of file TimerManager.cpp.

{
  TIMER* stack_top = current_timer();
  if (stack_top == nullptr)
  {
    std::cerr << "Timer stack pop failed on an empty stack! Requested \"" << t->get_name() << "\"." << std::endl;
    throw std::runtime_error("TimerManager pop_timer error!");
  }
  else if (t != stack_top)
  {
    std::cerr << "Timer stack pop not matching push! "
              << "Expecting \"" << t->get_name() << "\" but \"" << stack_top->get_name() << "\" is on the top."
              << std::endl;
    throw std::runtime_error("TimerManager pop_timer error!");
  }
  else
    CurrentTimerStack.pop_back();
}

print()

void print

(

Communicate *

comm

)

Definition at line 298 of file TimerManager.cpp.

{
  if (timer_threshold <= timer_level_none)
    return;
#ifdef ENABLE_TIMERS
  app_log() << std::endl;
  app_log() << "Use --enable-timers=<value> command line option to increase or decrease level of timing information"
            << std::endl;
#ifdef USE_STACK_TIMERS
  if (comm == nullptr || comm->rank() == 0)
    app_log() << "Stack timer profile" << std::endl;
  print_stack(comm);
#else
  if (comm == nullptr || comm->rank() == 0)
    app_log() << "\nFlat profile" << std::endl;
  print_flat(comm);
#endif
#endif
}

print_flat()

void print_flat ( Communicate *  comm )

private

Definition at line 319 of file TimerManager.cpp.

{
#ifdef ENABLE_TIMERS
  FlatProfileData p;

  collate_flat_profile(comm, p);

  if (comm == nullptr || comm->rank() == 0)
  {
#pragma omp master
    {
      std::array<char, 256> tmpout;
      std::map<std::string, int>::iterator it(p.nameList.begin()), it_end(p.nameList.end());
      while (it != it_end)
      {
        int i = (*it).second;
        int length =
            std::snprintf(tmpout.data(), tmpout.size(), "%-40s  %9.4f  %13ld  %16.9f  %12.6f TIMER\n",
                          (*it).first.c_str(), p.timeList[i], p.callList[i],
                          p.timeList[i] / (static_cast<double>(p.callList[i]) + std::numeric_limits<double>::epsilon()),
                          p.timeList[i] / static_cast<double>(omp_get_max_threads() * comm->size()));
        if (length < 0)
          throw std::runtime_error("Error generating timer string");
        app_log() << std::string_view(tmpout.data(), length);
        ++it;
      }
    }
  }
#endif
}

print_stack()

void print_stack ( Communicate *  comm )

private

Definition at line 360 of file TimerManager.cpp.

{
#ifdef ENABLE_TIMERS
  StackProfileData p;

  collate_stack_profile(comm, p);

  if (comm == nullptr || comm->rank() == 0)
  {
    if (timer_max_level_exceeded)
    {
      app_warning() << "Maximum stack level (" << StackKey::max_level << ") exceeded.  Results may be incorrect."
                    << std::endl;
      app_warning() << "Adjust StackKey in NewTimer.h and recompile." << std::endl;
    }

    int indent_len   = 2;
    int max_name_len = 0;
    for (int i = 0; i < p.names.size(); i++)
    {
      std::string stack_name = p.names[i];
      int level              = get_level(stack_name);
      std::string name       = get_leaf_name(stack_name);
      int name_len           = name.size() + indent_len * level;
      max_name_len           = std::max(name_len, max_name_len);
    }

    std::array<char, 256> tmpout;
    std::string timer_name;
    pad_string("Timer", timer_name, max_name_len);

    int length = std::snprintf(tmpout.data(), tmpout.size(), "%s  %-9s  %-9s  %-10s  %-13s\n", timer_name.c_str(),
                               "Inclusive_time", "Exclusive_time", "Calls", "Time_per_call");
    if (length < 0)
      throw std::runtime_error("Error generating timer string");
    app_log() << std::string_view(tmpout.data(), length);

    for (int i = 0; i < p.names.size(); i++)
    {
      std::string stack_name = p.names[i];
      int level              = get_level(stack_name);
      std::string name       = get_leaf_name(stack_name);
      std::string indent_str(indent_len * level, ' ');
      std::string indented_str = indent_str + name;
      std::string padded_name_str;
      pad_string(indented_str, padded_name_str, max_name_len);
      length =
          std::snprintf(tmpout.data(), tmpout.size(), "%s  %9.4f  %9.4f  %13ld  %16.9f\n", padded_name_str.c_str(),
                        p.timeList[i], p.timeExclList[i], p.callList[i],
                        p.timeList[i] / (static_cast<double>(p.callList[i]) + std::numeric_limits<double>::epsilon()));
      if (length < 0)
        throw std::runtime_error("Error generating timer string");
      app_log() << std::string_view(tmpout.data(), length);
    }
  }
#endif
}

push_timer()

void push_timer

(

TIMER *

t

)

Definition at line 97 of file TimerManager.cpp.

{
  // current_timer() can be nullptr when the stack was empty.
  if (t == current_timer())
  {
    std::cerr << "Timer " << t->get_name()
              << " instance is already at the top of the stack. "
                 "start() is being called again. This often happens when stop() is not paired properly with start(). "
              << "ScopedTimer uses RAII and manages timer start/stop more safely." << std::endl;
    throw std::runtime_error("TimerManager push_timer error!");
  }
  else
    CurrentTimerStack.push_back(t);
}

reset()

void reset

(

)

Definition at line 133 of file TimerManager.cpp.

{
  for (int i = 0; i < timer_storage_.size(); i++)
    timer_storage_[i]->reset();
}

set_timer_threshold() [1/2]

void set_timer_threshold

(

const timer_levels

threshold

)

Definition at line 140 of file TimerManager.cpp.

Referenced by qmcplusplus::TEST_CASE().

{
  timer_threshold = threshold;
  for (int i = 0; i < timer_storage_.size(); i++)
    timer_storage_[i]->set_active_by_timer_threshold(timer_threshold);
}

set_timer_threshold() [2/2]

void set_timer_threshold

(

const std::string &

threshold

)

Definition at line 148 of file TimerManager.cpp.

{
  const auto it = std::find(timer_level_names.begin(), timer_level_names.end(), threshold);
  if (it != timer_level_names.end())
    set_timer_threshold(static_cast<timer_levels>(std::distance(timer_level_names.begin(), it)));
  else
  {
    std::cerr << "Unknown timer level: " << threshold << " , current level: " << timer_level_names[timer_threshold]
              << std::endl;
  }
}

Member Data Documentation

CurrentTimerStack

std::vector<TIMER*> CurrentTimerStack

private

The stack of nested active timers.

Definition at line 54 of file TimerManager.h.

Referenced by TimerManager< qmcplusplus::TimerType< CLOCK > >::current_timer().

max_timer_id

timer_id_t max_timer_id

private

The current maximal timer id.

Definition at line 58 of file TimerManager.h.

max_timers_exceeded

bool max_timers_exceeded

private

status of maxmal timer id reached

Definition at line 60 of file TimerManager.h.

Referenced by TimerManager< qmcplusplus::TimerType< CLOCK > >::maximum_number_of_timers_exceeded().

timer_id_name

std::map<timer_id_t, std::string> timer_id_name

private

timer id to name mapping

Definition at line 62 of file TimerManager.h.

timer_list_lock_

std::mutex timer_list_lock_

private

mutex for TimerList

Definition at line 52 of file TimerManager.h.

timer_name_to_id

std::map<std::string, timer_id_t> timer_name_to_id

private

name to timer id mapping

Definition at line 64 of file TimerManager.h.

timer_storage_

std::vector<std::unique_ptr<TIMER> > timer_storage_

private

All the timers created by this manager.

Definition at line 50 of file TimerManager.h.

timer_threshold

timer_levels timer_threshold

private

The threshold for active timers.

Definition at line 56 of file TimerManager.h.

---

The documentation for this class was generated from the following files:

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Utilities/NewTimer.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Utilities/TimerManager.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Utilities/TimerManager.cpp