/home/mhx/git/github/libmoost/include/moost/utils/benchmark.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_UTILS_BENCHMARK_HPP__
#define MOOST_UTILS_BENCHMARK_HPP__

#include <iostream>
#include <string>
#include <vector>
#include <map>

#include <boost/thread.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include "foreach.hpp"
#include "histogram.hpp"

namespace moost { namespace utils {

class benchmark
{
private:
   typedef std::map< std::string, std::vector<float> > timings_type;

public:
   class timer
   {
   public:
      timer(benchmark& bm, const std::string& default_result = "error")
         : m_bm(bm)
         , m_default_result(default_result)
      {
         restart();
      }

      ~timer()
      {
         try
         {
            stop(m_default_result);
         }
         catch (...)
         {
         }
      }

      void restart()
      {
         m_running = true;
         m_start = boost::posix_time::microsec_clock::universal_time();
      }

      void stop(const std::string& result = "success")
      {
         if (m_running)
         {
            boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
            float seconds = 1e-6*(now - m_start).total_microseconds();
            m_bm.add_timing(result, seconds);
            m_running = false;
         }
      }

   private:
      benchmark& m_bm;
      bool m_running;
      boost::posix_time::ptime m_start;
      const std::string m_default_result;
   };

   benchmark(const std::string& name, size_t num_threads = 1)
      : m_name(name)
      , m_num_threads(num_threads)
   {
   }

   void add_timing(const std::string& timing, float time)
   {
      boost::mutex::scoped_lock lock(m_mutex);
      m_timings[timing].push_back(time);
   }

   void output(std::ostream& os, size_t bins = 120, size_t height = 25, float offset = 0.0f, float hi_cut = 0.02f) const
   {
      boost::mutex::scoped_lock lock(m_mutex);

      moost::utils::histogram<float> cumulative("s");
      cumulative.set_display_range(offset, 1.0f - hi_cut);

      os << std::endl << "=== " << m_name << " ===" << std::endl << std::endl;

      foreach (const timings_type::value_type& t, m_timings)
      {
         moost::utils::histogram<float> h("s", bins, height);
         h.set_display_range(offset, 1.0f - hi_cut);

         h.add(t.second.begin(), t.second.end(), t.first, "*");
         cumulative.add(t.second.begin(), t.second.end(), t.first, t.first.substr(0, 1));

         h.draw(os);

         os << std::endl;
      }

      cumulative.draw(os);
      os << std::endl;

      os << "requests per second: " << m_num_threads/cumulative.mean() << std::endl;
   }

private:
   mutable boost::mutex m_mutex;
   timings_type m_timings;
   const std::string m_name;
   const size_t m_num_threads;
};

}}

#endif