execution_timer.h

Go to the documentation of this file.

// Author(s): Jeroen Keiren
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_UTILITIES_EXECUTION_TIMER_H
#define MCRL2_UTILITIES_EXECUTION_TIMER_H
 
#include "mcrl2/utilities/exception.h"
 
#include <chrono>
#include <fstream>
#include <map>
#include <string>
 
namespace mcrl2
{
 
namespace utilities
{
 
class execution_timer
{
  protected:
 
    struct timing
    {
      std::chrono::steady_clock::time_point start;      
      std::chrono::steady_clock::time_point finish;
 
      clock_t start_user;      
      clock_t finish_user;
 
      timing() :
        start(),
        finish()
      {}
    };
 
    std::string m_tool_name; 
    std::string m_filename; 
    std::map<std::string, timing> m_timings; 
 
    void write_report(std::ostream& s)
    {
      std::ios::fmtflags oldflags = s.setf(std::ios::fixed, std::ios::floatfield);
      s.precision(3);
 
      s << "- tool: " << m_tool_name << std::endl
        << "  timing:" << std::endl;
 
      for (std::map<std::string, timing>::const_iterator i = m_timings.begin(); i != m_timings.end(); ++i)
      {
        if (i->second.finish == std::chrono::steady_clock::time_point())
        {
          s << "    " << i->first << ": did not finish. " << std::endl;
        }
        else if (i->second.start > i->second.finish)
        {
          throw mcrl2::runtime_error("Start of " + i->first + " occurred after finish.");
        }
        else
        {
          s << "    " << i->first << ": "
            << std::chrono::duration_cast<std::chrono::milliseconds>(i->second.finish - i->second.start).count() / 1000.0
            << "s (user: " << static_cast<double>(i->second.finish_user - i->second.start_user) / CLOCKS_PER_SEC << "s)"
            << std::endl;
        }
      }
      s.flags(oldflags);
    }
 
  public:
 
    execution_timer(const std::string& tool_name = "", std::string const& filename = "") :
      m_tool_name(tool_name),
      m_filename(filename)
    {}
 
    ~execution_timer()
    {}
 
    void start(const std::string& timing_name)
    {
      std::map<std::string, timing>::iterator t = m_timings.lower_bound(timing_name);
      if (t != m_timings.end() && t->first == timing_name)
      {
        throw mcrl2::runtime_error("Starting already known timing '" + timing_name + "'. This causes unreliable results.");
      }
      t = m_timings.insert(t, make_pair(timing_name, timing()));
 
      t->second.start = std::chrono::steady_clock::now();
      t->second.start_user = clock();
    }
 
    void finish(const std::string& timing_name)
    {
      std::chrono::steady_clock::time_point finish = std::chrono::steady_clock::now();
      const std::map<std::string, timing>::iterator t = m_timings.find(timing_name);
      if (t == m_timings.end())
      {
        throw mcrl2::runtime_error("Finishing timing '" + timing_name + "' that was not started.");
      }
      if (std::chrono::steady_clock::time_point() != t->second.finish)
      {
        throw mcrl2::runtime_error("Finishing timing '" + timing_name + "' for the second time.");
      }
 
      t->second.finish = finish;
      t->second.finish_user = clock();
    }
 
    void report()
    {
      if (m_filename.empty())
      {
        write_report(std::cerr);
      }
      else
      {
        std::ofstream out;
        out.open(m_filename.c_str(), std::ios::app);
        write_report(out);
        out.close();
      }
    }
 
};
 
} // namespace utilities
 
} // namespace mcrl2
 
#endif // MCRL2_UTILITIES_EXECUTION_TIMER_H