timer.cc

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1998 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/mpi.h>
#include <deal.II/base/mpi.templates.h>
#include <deal.II/base/signaling_nan.h>
#include <deal.II/base/timer.h>
#include <deal.II/base/utilities.h>
 
#include <boost/io/ios_state.hpp>
 
#include <algorithm>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <optional>
#include <sstream>
#include <string>
#include <type_traits>
 
#ifdef DEAL_II_HAVE_SYS_RESOURCE_H
#  include <sys/resource.h>
#endif
 
#ifdef DEAL_II_MSVC
#  include <windows.h>
#endif
 
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace internal
{
  namespace TimerImplementation
  {
    namespace
    {
      template <typename T>
      struct is_duration : std::false_type
      {};
 
      template <typename Rep, typename Period>
      struct is_duration<std::chrono::duration<Rep, Period>> : std::true_type
      {};
 
      template <typename T>
      T
      from_seconds(const double time)
      {
        static_assert(is_duration<T>::value,
                      "The template type should be a duration type.");
        return T(std::lround(T::period::den * (time / T::period::num)));
      }
 
      template <typename Rep, typename Period>
      double
      to_seconds(const std::chrono::duration<Rep, Period> duration)
      {
        return Period::num * double(duration.count()) / Period::den;
      }
 
      void
      clear_timing_data(Utilities::MPI::MinMaxAvg &data)
      {
        data.sum       = numbers::signaling_nan<double>();
        data.min       = numbers::signaling_nan<double>();
        data.max       = numbers::signaling_nan<double>();
        data.avg       = numbers::signaling_nan<double>();
        data.min_index = numbers::invalid_unsigned_int;
        data.max_index = numbers::invalid_unsigned_int;
      }
    } // namespace
  }   // namespace TimerImplementation
} // namespace internal
 
 
 
CPUClock::time_point
CPUClock::now() noexcept
{
  double system_cpu_duration = 0.0;
#ifdef DEAL_II_MSVC
  FILETIME   cpuTime, sysTime, createTime, exitTime;
  const auto succeeded = GetProcessTimes(
    GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime);
  if (succeeded)
    {
      system_cpu_duration =
        (double)(((unsigned long long)cpuTime.dwHighDateTime << 32) |
                 cpuTime.dwLowDateTime) /
        1e7;
    }
    // keep the zero value if GetProcessTimes didn't work
#elif defined(DEAL_II_HAVE_SYS_RESOURCE_H)
  rusage usage;
  getrusage(RUSAGE_SELF, &usage);
  system_cpu_duration = usage.ru_utime.tv_sec + 1.e-6 * usage.ru_utime.tv_usec;
#else
  DEAL_II_WARNING("Unsupported platform. Porting not finished.")
#endif
  return time_point(
    internal::TimerImplementation::from_seconds<duration>(system_cpu_duration));
}
 
 
 
template <typename clock_type_>
Timer::ClockMeasurements<clock_type_>::ClockMeasurements()
  : current_lap_start_time(clock_type::now())
  , accumulated_time(duration_type::zero())
  , last_lap_time(duration_type::zero())
{}
 
 
 
template <typename clock_type_>
void
Timer::ClockMeasurements<clock_type_>::reset()
{
  current_lap_start_time = clock_type::now();
  accumulated_time       = duration_type::zero();
  last_lap_time          = duration_type::zero();
}
 
 
 
Timer::Timer()
  : Timer(MPI_COMM_SELF, /*sync_lap_times=*/false)
{}
 
 
 
Timer::Timer(const MPI_Comm mpi_communicator, const bool sync_lap_times_)
  : running(false)
  , is_synchronized(true)
  , mpi_communicator(mpi_communicator)
  , sync_lap_times(sync_lap_times_)
{
  reset();
  start();
}
 
 
 
void
Timer::start()
{
  // If the data of the last lap has not been synchronized so far,
  // synchronize now, before starting to measure a new lap.
  if (is_running() == false)
    synchronize_and_update();
 
  // Make sure only one thread at a time starts or resets the timer
  // Note that the location of this line, after the call to
  // synchronize_and_update(), but before the number of laps is increased
  // is critical, since the same mutex is locked inside
  // synchronize_and_update().
  std::scoped_lock lock(mutex);
 
  if (is_running() == false)
    {
      ++n_timed_laps;
      running = true;
    }
 
#ifdef DEAL_II_WITH_MPI
  if (sync_lap_times)
    {
      const int ierr = MPI_Barrier(mpi_communicator);
      AssertThrowMPI(ierr);
    }
#endif
  wall_times.current_lap_start_time = wall_clock_type::now();
  cpu_times.current_lap_start_time  = cpu_clock_type::now();
}
 
 
 
void
Timer::stop()
{
  // Make sure only one thread at a time stops the timer
  std::scoped_lock lock(mutex);
 
  AssertThrow(is_running() == true,
              ExcMessage(
                "This timer is not running and hence cannot be stopped."));
 
  running         = false;
  is_synchronized = false;
 
  wall_times.last_lap_time =
    wall_clock_type::now() - wall_times.current_lap_start_time;
  cpu_times.last_lap_time =
    cpu_clock_type::now() - cpu_times.current_lap_start_time;
}
 
 
 
bool
Timer::is_running() const
{
  return running;
}
 
 
 
double
Timer::cpu_time() const
{
  if (is_running())
    {
      const double running_time = internal::TimerImplementation::to_seconds(
        cpu_clock_type::now() - cpu_times.current_lap_start_time +
        cpu_times.accumulated_time);
      return Utilities::MPI::sum(running_time, mpi_communicator);
    }
  else
    {
      synchronize_and_update();
 
      return Utilities::MPI::sum(internal::TimerImplementation::to_seconds(
                                   cpu_times.accumulated_time),
                                 mpi_communicator);
    }
}
 
 
 
double
Timer::last_cpu_time() const
{
  if (running == false)
    synchronize_and_update();
 
  return internal::TimerImplementation::to_seconds(cpu_times.last_lap_time);
}
 
 
 
double
Timer::wall_time() const
{
  wall_clock_type::duration current_elapsed_wall_time;
  if (is_running())
    {
      current_elapsed_wall_time = wall_clock_type::now() -
                                  wall_times.current_lap_start_time +
                                  wall_times.accumulated_time;
    }
  else
    {
      synchronize_and_update();
 
      current_elapsed_wall_time = wall_times.accumulated_time;
    }
 
  return internal::TimerImplementation::to_seconds(current_elapsed_wall_time);
}
 
 
 
double
Timer::last_wall_time() const
{
  if (running == false)
    synchronize_and_update();
 
  return internal::TimerImplementation::to_seconds(wall_times.last_lap_time);
}
 
 
 
void
Timer::synchronize_and_update() const
{
  Assert(
    running == false,
    ExcMessage(
      "Timer::synchronize_and_update() should not be called while the timer is running."));
 
  // Make sure only one thread synchronizes the shared state
  // and all other threads wait until synchronization is done.
  std::scoped_lock lock(mutex);
 
  if (is_synchronized == false)
    {
      last_lap_wall_time_data =
        Utilities::MPI::min_max_avg(internal::TimerImplementation::to_seconds(
                                      wall_times.last_lap_time),
                                    mpi_communicator);
 
      const Utilities::MPI::MinMaxAvg last_lap_cpu_time_data =
        Utilities::MPI::min_max_avg(internal::TimerImplementation::to_seconds(
                                      cpu_times.last_lap_time),
                                    mpi_communicator);
 
      if (sync_lap_times)
        {
          wall_times.last_lap_time =
            internal::TimerImplementation::from_seconds<
              decltype(wall_times)::duration_type>(last_lap_wall_time_data.max);
 
          cpu_times.last_lap_time = internal::TimerImplementation::from_seconds<
            decltype(cpu_times)::duration_type>(last_lap_cpu_time_data.max);
        }
 
      // This looks like we should set last_lap_time to 0 after
      // updating the accumulated time but both numbers may
      // be requested after the update. We therefore instead ensure
      // that synchronize_and_update() is only executed once after
      // each lap, by setting is_synchronized to true below.
      wall_times.accumulated_time += wall_times.last_lap_time;
      cpu_times.accumulated_time += cpu_times.last_lap_time;
 
      accumulated_wall_time_data =
        Utilities::MPI::min_max_avg(internal::TimerImplementation::to_seconds(
                                      wall_times.accumulated_time),
                                    mpi_communicator);
 
      is_synchronized = true;
    }
}
 
 
 
void
Timer::reset()
{
  wall_times.reset();
  cpu_times.reset();
  running         = false;
  n_timed_laps    = 0;
  is_synchronized = true;
  internal::TimerImplementation::clear_timing_data(last_lap_wall_time_data);
  internal::TimerImplementation::clear_timing_data(accumulated_wall_time_data);
}
 
 
 
unsigned int
Timer::n_laps() const
{
  return n_timed_laps;
}
 
 
 
/* ---------------------------- TimerOutput -------------------------- */
 
TimerOutput::TimerOutput(std::ostream         &stream,
                         const OutputFrequency output_frequency,
                         const OutputType      output_type)
  : output_frequency(output_frequency)
  , output_type(output_type)
  , timer_all()
  , sections()
  , out_stream(stream, true)
  , output_is_enabled(true)
  , mpi_communicator_timing(std::nullopt)
{}
 
 
 
TimerOutput::TimerOutput(ConditionalOStream   &stream,
                         const OutputFrequency output_frequency,
                         const OutputType      output_type)
  : output_frequency(output_frequency)
  , output_type(output_type)
  , timer_all()
  , sections()
  , out_stream(stream)
  , output_is_enabled(true)
  , mpi_communicator_timing(std::nullopt)
{}
 
 
 
TimerOutput::TimerOutput(const MPI_Comm        mpi_communicator,
                         std::ostream         &stream,
                         const OutputFrequency output_frequency,
                         const OutputType      output_type)
  : output_frequency(output_frequency)
  , output_type(output_type)
  , timer_all(mpi_communicator, /* sync_lap_times */ false)
  , sections()
  , out_stream(stream, true)
  , output_is_enabled(true)
  , mpi_communicator_timing(mpi_communicator)
{}
 
 
 
TimerOutput::TimerOutput(const MPI_Comm        mpi_communicator,
                         ConditionalOStream   &stream,
                         const OutputFrequency output_frequency,
                         const OutputType      output_type)
  : output_frequency(output_frequency)
  , output_type(output_type)
  , timer_all(mpi_communicator, /* sync_lap_times */ false)
  , sections()
  , out_stream(stream)
  , output_is_enabled(true)
  , mpi_communicator_timing(mpi_communicator)
{}
 
 
 
TimerOutput::~TimerOutput()
{
  auto do_exit = [this]() {
    try
      {
        while (active_sections.size() > 0)
          leave_subsection();
        // don't print unless we leave all subsections
        if ((output_frequency == summary ||
             output_frequency == every_call_and_summary) &&
            output_is_enabled == true)
          print_summary();
      }
    catch (...)
      {}
  };
 
  // avoid communicating with other processes if there is an uncaught
  // exception
#ifdef DEAL_II_WITH_MPI
  if (std::uncaught_exceptions() > 0 && mpi_communicator_timing.has_value() &&
      Utilities::MPI::n_mpi_processes(*mpi_communicator_timing) > 1)
    {
      const unsigned int myid =
        Utilities::MPI::this_mpi_process(*mpi_communicator_timing);
      if (myid == 0)
        std::cerr
          << "---------------------------------------------------------\n"
          << "TimerOutput objects finalize timed values printed to the\n"
          << "screen by communicating over MPI in their destructors.\n"
          << "Since an exception is currently uncaught, this\n"
          << "synchronization (and subsequent output) will be skipped\n"
          << "to avoid a possible deadlock.\n"
          << "---------------------------------------------------------"
          << std::endl;
    }
  else
    {
      do_exit();
    }
#else
  do_exit();
#endif
}
 
 
 
void
TimerOutput::enter_subsection(const std::string &section_name)
{
  std::scoped_lock lock(mutex);
 
  Assert(section_name.empty() == false, ExcMessage("Section string is empty."));
 
  Assert(std::find(active_sections.begin(),
                   active_sections.end(),
                   section_name) == active_sections.end(),
         ExcMessage("Cannot enter the already active section <" + section_name +
                    ">."));
 
  if (sections.find(section_name) == sections.end())
    {
      // Ensure MPI operations only happen if an MPI communicator was
      // initialized. No need to call start() for the timers, since
      // the constructor already starts them.
      if (mpi_communicator_timing.has_value())
        sections[section_name] = Timer(*mpi_communicator_timing, true);
      else
        sections[section_name] = Timer(MPI_COMM_SELF, false);
    }
  else
    {
      Assert(sections[section_name].is_running() == false,
             ExcMessage("Cannot enter the already active section <" +
                        section_name + ">."));
 
      sections[section_name].start();
    }
 
  active_sections.push_back(section_name);
}
 
 
 
void
TimerOutput::leave_subsection(const std::string &section_name)
{
  Assert(!active_sections.empty(),
         ExcMessage("Cannot exit any section because none has been entered!"));
 
  std::scoped_lock lock(mutex);
 
  if (!section_name.empty())
    {
      Assert(sections.find(section_name) != sections.end(),
             ExcMessage("Cannot delete a section that was never created."));
      Assert(std::find(active_sections.begin(),
                       active_sections.end(),
                       section_name) != active_sections.end(),
             ExcMessage("Cannot delete a section that has not been entered."));
    }
 
  // if no string is given, exit the last
  // active section.
  const std::string actual_section_name =
    (section_name.empty() ? active_sections.back() : section_name);
 
  Assert(sections[actual_section_name].is_running() == true,
         ExcMessage("Cannot leave section <" + actual_section_name +
                    ">, because it has not been entered."));
 
  sections[actual_section_name].stop();
 
  // In case we have to print out something, do that here,
  // but only if no exceptions are currently uncaught.
  // If there are uncaught exceptions we are currently in the
  // process of stack unwinding, and the code below would trigger
  // MPI communication, which leads to a deadlock if not all
  // processes threw the exception. Avoid this deadlock by not
  // writing output in this case.
  if ((output_frequency == every_call ||
       output_frequency == every_call_and_summary) &&
      output_is_enabled == true && std::uncaught_exceptions() == 0)
    {
      std::string        output_time;
      std::ostringstream cpu;
      cpu << sections[actual_section_name].last_cpu_time() << "s";
      std::ostringstream wall;
      wall << sections[actual_section_name].last_wall_time() << "s";
      if (output_type == cpu_times)
        output_time = ", CPU time: " + cpu.str();
      else if (output_type == wall_times)
        output_time = ", wall time: " + wall.str() + ".";
      else
        output_time =
          ", CPU/wall time: " + cpu.str() + " / " + wall.str() + ".";
 
      out_stream << actual_section_name << output_time << std::endl;
    }
 
  // delete the index from the list of
  // active ones
  active_sections.erase(std::find(active_sections.begin(),
                                  active_sections.end(),
                                  actual_section_name));
}
 
 
 
std::map<std::string, double>
TimerOutput::get_summary_data(const OutputData kind) const
{
  Assert(
    active_sections.empty(),
    ExcMessage(
      "Cannot access data from TimerOutput while inside a timed section."));
 
  std::map<std::string, double> output;
  for (const auto &section : sections)
    {
      switch (kind)
        {
          case TimerOutput::OutputData::total_cpu_time:
            output[section.first] = section.second.cpu_time();
            break;
          case TimerOutput::OutputData::total_wall_time:
            output[section.first] = section.second.wall_time();
            break;
          case TimerOutput::OutputData::n_calls:
            output[section.first] = section.second.n_laps();
            break;
          default:
            DEAL_II_NOT_IMPLEMENTED();
        }
    }
  return output;
}
 
 
 
void
TimerOutput::print_summary() const
{
  Assert(active_sections.empty(),
         ExcMessage(
           "Cannot print data from TimerOutput while inside a timed section."));
 
  // we are going to change the precision and width of output below. store the
  // old values so the get restored when exiting this function
  const boost::io::ios_base_all_saver restore_stream(out_stream.get_stream());
 
  // get the maximum width among all sections
  unsigned int max_width = 0;
  for (const auto &i : sections)
    max_width = std::max(max_width, static_cast<unsigned int>(i.first.size()));
 
  // 32 is the default width until | character
  max_width = std::max(max_width + 1, static_cast<unsigned int>(32));
  const std::string extra_dash  = std::string(max_width - 32, '-');
  const std::string extra_space = std::string(max_width - 32, ' ');
 
  if (output_type != cpu_and_wall_times_grouped)
    {
      // in case we want to write CPU times
      if (output_type != wall_times)
        {
          double total_cpu_time = timer_all.cpu_time();
 
          // check that the sum of all section times is less or equal than the
          // total time. otherwise, we might have generated a lot of overhead in
          // this function.
          double total_cpu_time_in_sections = 0.;
          for (const auto &i : sections)
            total_cpu_time_in_sections += i.second.cpu_time();
 
          const double section_overhead =
            total_cpu_time_in_sections - total_cpu_time;
          if (section_overhead > 0.0)
            total_cpu_time = total_cpu_time_in_sections;
 
          // generate a nice table
          out_stream << "\n\n"
                     << "+---------------------------------------------"
                     << extra_dash << "+------------"
                     << "+------------+\n"
                     << "| Total CPU time elapsed since start          "
                     << extra_space << "|";
          out_stream << std::setw(10) << std::setprecision(3) << std::right;
          out_stream << total_cpu_time << "s |            |\n";
          out_stream << "|                                             "
                     << extra_space << "|            "
                     << "|            |\n";
          out_stream << "| Section                         " << extra_space
                     << "| no. calls |";
          out_stream << std::setw(10);
          out_stream << std::setprecision(3);
          out_stream << "  CPU time "
                     << " | % of total |\n";
          out_stream << "+---------------------------------" << extra_dash
                     << "+-----------+------------"
                     << "+------------+";
          for (const auto &i : sections)
            {
              std::string name_out = i.first;
 
              // resize the array so that it is always of the same size
              unsigned int pos_non_space = name_out.find_first_not_of(' ');
              name_out.erase(0, pos_non_space);
              name_out.resize(max_width, ' ');
 
              const double section_cpu_time = i.second.cpu_time();
 
              out_stream << std::endl;
              out_stream << "| " << name_out;
              out_stream << "| ";
              out_stream << std::setw(9);
              out_stream << i.second.n_laps() << " |";
              out_stream << std::setw(10);
              out_stream << std::setprecision(3);
              out_stream << section_cpu_time << "s |";
              out_stream << std::setw(10);
              if (total_cpu_time != 0)
                {
                  // if run time was less than 0.1%, just print a zero to avoid
                  // printing silly things such as "2.45e-6%". otherwise print
                  // the actual percentage
                  const double fraction = section_cpu_time / total_cpu_time;
                  if (fraction > 0.001)
                    {
                      out_stream << std::setprecision(2);
                      out_stream << fraction * 100;
                    }
                  else
                    out_stream << 0.0;
 
                  out_stream << "% |";
                }
              else
                out_stream << 0.0 << "% |";
            }
          out_stream << std::endl
                     << "+---------------------------------" << extra_dash
                     << "+-----------+"
                     << "------------+------------+\n"
                     << std::endl;
 
          if (section_overhead > 0.0)
            out_stream
              << std::endl
              << "Note: The sum of section times is " << section_overhead
              << " seconds larger than the total time.\n"
              << "(Timer function may have introduced too much overhead, or different\n"
              << "section timers may have run at the same time.)" << std::endl;
        }
 
      // in case we want to write out wallclock times
      if (output_type != cpu_times)
        {
          const double total_wall_time = timer_all.wall_time();
 
          // now generate a nice table
          out_stream << "\n\n"
                     << "+---------------------------------------------"
                     << extra_dash << "+------------"
                     << "+------------+\n"
                     << "| Total wallclock time elapsed since start    "
                     << extra_space << "|";
          out_stream << std::setw(10) << std::setprecision(3) << std::right;
          out_stream << total_wall_time << "s |            |\n";
          out_stream << "|                                             "
                     << extra_space << "|            "
                     << "|            |\n";
          out_stream << "| Section                         " << extra_space
                     << "| no. calls |";
          out_stream << std::setw(10);
          out_stream << std::setprecision(3);
          out_stream << "  wall time | % of total |\n";
          out_stream << "+---------------------------------" << extra_dash
                     << "+-----------+------------"
                     << "+------------+";
          for (const auto &i : sections)
            {
              std::string name_out = i.first;
 
              // resize the array so that it is always of the same size
              unsigned int pos_non_space = name_out.find_first_not_of(' ');
              name_out.erase(0, pos_non_space);
              name_out.resize(max_width, ' ');
              out_stream << std::endl;
              out_stream << "| " << name_out;
              out_stream << "| ";
              out_stream << std::setw(9);
              out_stream << i.second.n_laps() << " |";
              out_stream << std::setw(10);
              out_stream << std::setprecision(3);
              out_stream << i.second.wall_time() << "s |";
              out_stream << std::setw(10);
 
              if (total_wall_time != 0)
                {
                  // if run time was less than 0.1%, just print a zero to avoid
                  // printing silly things such as "2.45e-6%". otherwise print
                  // the actual percentage
                  const double fraction =
                    i.second.wall_time() / total_wall_time;
                  if (fraction > 0.001)
                    {
                      out_stream << std::setprecision(2);
                      out_stream << fraction * 100;
                    }
                  else
                    out_stream << 0.0;
 
                  out_stream << "% |";
                }
              else
                out_stream << 0.0 << "% |";
            }
          out_stream << std::endl
                     << "+---------------------------------" << extra_dash
                     << "+-----------+"
                     << "------------+------------+\n"
                     << std::endl;
        }
    }
  else
    // output_type == cpu_and_wall_times_grouped
    {
      const double total_wall_time = timer_all.wall_time();
      double       total_cpu_time  = timer_all.cpu_time();
 
      // check that the sum of all times is less or equal than the total time.
      // otherwise, we might have generated a lot of overhead in this function.
      double total_cpu_time_in_sections = 0.;
      for (const auto &i : sections)
        total_cpu_time_in_sections += i.second.cpu_time();
 
      const double section_overhead =
        total_cpu_time_in_sections - total_cpu_time;
      if (section_overhead > 0.0)
        total_cpu_time = total_cpu_time_in_sections;
 
      // generate a nice table
      out_stream << "\n\n+---------------------------------------------"
                 << extra_dash << "+"
                 << "------------+------------+"
                 << "------------+------------+" << '\n'
                 << "| Total CPU/wall time elapsed since start     "
                 << extra_space << "|" << std::setw(10) << std::setprecision(3)
                 << std::right << total_cpu_time << "s |            "
                 << extra_space << "|" << std::setw(10) << std::setprecision(3)
                 << total_wall_time << "s |            |"
                 << "\n|                                             "
                 << extra_space << "|"
                 << "            |            |"
                 << "            |            |"
                 << "\n| Section                         " << extra_space
                 << "| no. calls |"
                 << "  CPU time  | % of total |"
                 << "  wall time | % of total |"
                 << "\n+---------------------------------" << extra_dash
                 << "+-----------+"
                 << "------------+------------+"
                 << "------------+------------+" << std::endl;
 
      for (const auto &i : sections)
        {
          std::string name_out = i.first;
 
          // resize the array so that it is always of the same size
          unsigned int pos_non_space = name_out.find_first_not_of(' ');
          name_out.erase(0, pos_non_space);
          name_out.resize(max_width, ' ');
          out_stream << "| " << name_out << "| ";
 
          out_stream << std::setw(9);
          out_stream << i.second.n_laps() << " |";
 
          if (output_type != wall_times)
            {
              const double section_cpu_time = i.second.cpu_time();
 
              out_stream << std::setw(10);
              out_stream << std::setprecision(3);
              out_stream << section_cpu_time << "s |";
              out_stream << std::setw(10);
              if (total_cpu_time != 0)
                {
                  // if run time was less than 0.1%, just print a zero to avoid
                  // printing silly things such as "2.45e-6%". otherwise print
                  // the actual percentage
                  const double fraction = section_cpu_time / total_cpu_time;
                  if (fraction > 0.001)
                    {
                      out_stream << std::setprecision(2);
                      out_stream << fraction * 100;
                    }
                  else
                    out_stream << 0.0;
 
                  out_stream << "% |";
                }
              else
                out_stream << 0.0 << "% |";
            }
 
          if (output_type != cpu_times)
            {
              out_stream << std::setw(10);
              out_stream << std::setprecision(3);
              out_stream << i.second.wall_time() << "s |";
              out_stream << std::setw(10);
 
              if (total_wall_time != 0)
                {
                  // if run time was less than 0.1%, just print a zero to avoid
                  // printing silly things such as "2.45e-6%". otherwise print
                  // the actual percentage
                  const double fraction =
                    i.second.wall_time() / total_wall_time;
                  if (fraction > 0.001)
                    {
                      out_stream << std::setprecision(2);
                      out_stream << fraction * 100;
                    }
                  else
                    out_stream << 0.0;
 
                  out_stream << "% |";
                }
              else
                out_stream << 0.0 << "% |";
            }
          out_stream << std::endl;
        }
 
      out_stream << "+---------------------------------" << extra_dash
                 << "+-----------+"
                 << "------------+------------+"
                 << "------------+------------+" << std::endl
                 << std::endl;
 
      if (output_type != wall_times && section_overhead > 0.0)
        out_stream
          << std::endl
          << "Note: The sum of section times is " << section_overhead
          << " seconds larger than the total time.\n"
          << "(Timer function may have introduced too much overhead, or different\n"
          << "section timers may have run at the same time.)" << std::endl;
    }
}
 
 
 
void
TimerOutput::print_wall_time_statistics(
  const MPI_Comm mpi_communicator_statistics,
  const double   quantile) const
{
  Assert(active_sections.empty(),
         ExcMessage(
           "Cannot print data from TimerOutput while inside a timed section."));
 
  Assert(quantile >= 0. && quantile <= 0.5,
         ExcMessage("The quantile must be between 0 and 0.5"));
 
#ifdef DEAL_II_WITH_MPI
  // calling wall_time() below requires global communication over
  // mpi_communicator_timing, if timers are constructed with an MPI
  // communicator
  // -> make sure the two communicators mpi_communicator_timing and
  // mpi_communicator_statistics contain the same ranks
  if (mpi_communicator_timing.has_value())
    {
      int       result;
      const int ierr = MPI_Comm_compare(mpi_communicator_statistics,
                                        *mpi_communicator_timing,
                                        &result);
      AssertThrowMPI(ierr);
 
      Assert(result == MPI_IDENT || result == MPI_CONGRUENT ||
               result == MPI_SIMILAR,
             ExcMessage(
               "The passed MPI communicator must contain the same processes as "
               "the one used to construct the TimerOutput."));
    }
#endif
 
  // we are going to change the precision and width of output below. store the
  // old values so the get restored when exiting this function
  const boost::io::ios_base_all_saver restore_stream(out_stream.get_stream());
 
  // Obtain the global list of all sections entered by the ranks within
  // mpi_communicator_statistics
  std::vector<std::string> my_section_names;
  my_section_names.reserve(sections.size());
  for (const auto &[section, timer] : sections)
    my_section_names.push_back(section);
 
  const std::vector<std::string> global_section_names =
    Utilities::MPI::compute_set_union(my_section_names,
                                      mpi_communicator_statistics);
 
  // get the maximum width among all sections
  unsigned int max_width = 0;
  for (const auto &i : global_section_names)
    max_width = std::max(max_width, static_cast<unsigned int>(i.size()));
 
  // 17 is the default width until | character
  max_width = std::max(max_width + 1, static_cast<unsigned int>(17));
  const std::string extra_dash  = std::string(max_width - 17, '-');
  const std::string extra_space = std::string(max_width - 17, ' ');
 
  // function to print data in a nice table
  const auto print_statistics = [&](const double given_time) {
    const unsigned int n_ranks =
      Utilities::MPI::n_mpi_processes(mpi_communicator_statistics);
    if (n_ranks == 1 || quantile == 0.)
      {
        Utilities::MPI::MinMaxAvg data =
          Utilities::MPI::min_max_avg(given_time, mpi_communicator_statistics);
 
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << data.min << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << data.min_index << (n_ranks > 99999 ? "" : " ") << "|";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << data.avg << "s |";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << data.max << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << data.max_index << (n_ranks > 99999 ? "" : " ") << "|\n";
      }
    else
      {
        const unsigned int my_rank =
          Utilities::MPI::this_mpi_process(mpi_communicator_statistics);
        std::vector<double> receive_data(my_rank == 0 ? n_ranks : 0);
        std::vector<double> result(9);
#ifdef DEAL_II_WITH_MPI
        int ierr = MPI_Gather(&given_time,
                              1,
                              MPI_DOUBLE,
                              receive_data.data(),
                              1,
                              MPI_DOUBLE,
                              0,
                              mpi_communicator_statistics);
        AssertThrowMPI(ierr);
        if (my_rank == 0)
          {
            // fill the received data in a pair and sort; on the way, also
            // compute the average
            std::vector<std::pair<double, unsigned int>> data_rank;
            data_rank.reserve(n_ranks);
            for (unsigned int i = 0; i < n_ranks; ++i)
              {
                data_rank.emplace_back(receive_data[i], i);
                result[4] += receive_data[i];
              }
            result[4] /= n_ranks;
            std::sort(data_rank.begin(), data_rank.end());
 
            const unsigned int quantile_index =
              static_cast<unsigned int>(std::round(quantile * n_ranks));
            AssertIndexRange(quantile_index, data_rank.size());
            result[0] = data_rank[0].first;
            result[1] = data_rank[0].second;
            result[2] = data_rank[quantile_index].first;
            result[3] = data_rank[quantile_index].second;
            result[5] = data_rank[n_ranks - 1 - quantile_index].first;
            result[6] = data_rank[n_ranks - 1 - quantile_index].second;
            result[7] = data_rank[n_ranks - 1].first;
            result[8] = data_rank[n_ranks - 1].second;
          }
        ierr = MPI_Bcast(
          result.data(), 9, MPI_DOUBLE, 0, mpi_communicator_statistics);
        AssertThrowMPI(ierr);
#endif
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << result[0] << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << static_cast<unsigned int>(result[1])
                   << (n_ranks > 99999 ? "" : " ") << "|";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << result[2] << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << static_cast<unsigned int>(result[3])
                   << (n_ranks > 99999 ? "" : " ") << "|";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << result[4] << "s |";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << result[5] << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << static_cast<unsigned int>(result[6])
                   << (n_ranks > 99999 ? "" : " ") << "|";
        out_stream << std::setw(10) << std::setprecision(4) << std::right;
        out_stream << result[7] << "s ";
        out_stream << std::setw(5) << std::right;
        out_stream << static_cast<unsigned int>(result[8])
                   << (n_ranks > 99999 ? "" : " ") << "|\n";
      }
  };
 
  // in case we want to write out wallclock times
  {
    const unsigned int n_ranks =
      Utilities::MPI::n_mpi_processes(mpi_communicator_statistics);
 
    const std::string time_rank_column = "------------------+";
    const std::string time_rank_space  = "                  |";
 
    // now generate a nice table
    out_stream << '\n'
               << "+------------------------------" << extra_dash << "+"
               << time_rank_column
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << "------------+"
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << time_rank_column << '\n'
               << "| Total wallclock time elapsed " << extra_space << "|";
 
    print_statistics(timer_all.wall_time());
 
    out_stream << "|                              " << extra_space << "|"
               << time_rank_space
               << (n_ranks > 1 && quantile > 0. ? time_rank_space : "")
               << "             "
               << (n_ranks > 1 && quantile > 0. ? time_rank_space : "")
               << time_rank_space << '\n';
    out_stream << "| Section          " << extra_space << "| no. calls "
               << "|   min time  rank |";
    if (n_ranks > 1 && quantile > 0.)
      out_stream << " " << std::setw(5) << std::setprecision(2) << std::right
                 << quantile << "-tile  rank |";
    out_stream << "   avg time |";
    if (n_ranks > 1 && quantile > 0.)
      out_stream << " " << std::setw(5) << std::setprecision(2) << std::right
                 << 1. - quantile << "-tile  rank |";
    out_stream << "   max time  rank |\n";
    out_stream << "+------------------------------" << extra_dash << "+"
               << time_rank_column
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << "------------+"
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << time_rank_column << '\n';
 
    for (const auto &global_section_name : global_section_names)
      {
        std::string name_out   = global_section_name;
        const auto  section_it = sections.find(global_section_name);
        const bool  entered_section_locally = (section_it != sections.end());
 
        // resize the array so that it is always of the same size
        unsigned int pos_non_space = name_out.find_first_not_of(' ');
        name_out.erase(0, pos_non_space);
        name_out.resize(max_width, ' ');
        out_stream << "| " << name_out;
        out_stream << "| ";
        out_stream << std::setw(9);
        const unsigned n_laps =
          entered_section_locally ? section_it->second.n_laps() : 0;
 
        out_stream << n_laps << " |";
 
        const double wall_time =
          entered_section_locally ? section_it->second.wall_time() : 0.0;
        print_statistics(wall_time);
      }
    out_stream << "+------------------------------" << extra_dash << "+"
               << time_rank_column
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << "------------+"
               << (n_ranks > 1 && quantile > 0. ? time_rank_column : "")
               << time_rank_column << '\n';
  }
}
 
 
 
void
TimerOutput::disable_output()
{
  output_is_enabled = false;
  out_stream.set_condition(false);
}
 
 
 
void
TimerOutput::enable_output()
{
  output_is_enabled = true;
  out_stream.set_condition(true);
}
 
 
 
void
TimerOutput::reset()
{
  std::scoped_lock lock(mutex);
  sections.clear();
  active_sections.clear();
  timer_all.restart();
}
 
 
 
TimerOutput::Scope::~Scope()
{
  try
    {
      stop();
    }
  catch (...)
    {}
}
 
 
DEAL_II_NAMESPACE_CLOSE