TimeIntervalStats.cpp

Go to the documentation of this file.

 
#include "uhal/utilities/TimeIntervalStats.hpp"
 
 
#include <boost/chrono/duration.hpp>    // for operator/, operator<, operator>
#include <boost/chrono/time_point.hpp>  // for operator-
#include <boost/ratio/ratio.hpp>        // for ratio
#include <boost/ratio/ratio_fwd.hpp>    // for milli
 
#include <ostream>                      // for operator<<, ostream, basic_os...
 
 
namespace uhal {
 
TimeIntervalStats::TimeIntervalStats() :
  nMeasurements(0)
{
}
 
 
TimeIntervalStats::~TimeIntervalStats()
{
}
 
 
size_t TimeIntervalStats::size() const
{
  return nMeasurements;
}
 
 
const TimeIntervalStats::Clock_t::duration& TimeIntervalStats::min() const
{
  return mMin;
}
 
 
const TimeIntervalStats::Clock_t::duration& TimeIntervalStats::max() const
{
  return mMax;
}
 
 
TimeIntervalStats::Clock_t::duration TimeIntervalStats::mean() const
{
  return mSum / nMeasurements;
}
 
 
const std::queue<TimeIntervalStats::Clock_t::duration>& TimeIntervalStats::getLatestMeasurements() const
{
  return mLatestMeasurements;
}
 
 
void TimeIntervalStats::add(const Clock_t::time_point& aT1, const Clock_t::time_point& aT2)
{
  const Clock_t::duration lInterval = aT2 - aT1;
 
  if ((nMeasurements == 0) or (lInterval < mMin))
    mMin = lInterval;
  if ((nMeasurements == 0) or (lInterval > mMax))
    mMax = lInterval;
 
  mSum += lInterval;
  nMeasurements += 1;
 
  mLatestMeasurements.push(lInterval);
  if (mLatestMeasurements.size() > 5)
    mLatestMeasurements.pop();
}
 
 
void TimeIntervalStats::clear()
{
  for (size_t i = 0; i < nMeasurements; i++)
    mLatestMeasurements.pop();
  nMeasurements = 0;
}
 
 
std::ostream& operator<<(std::ostream& aStream, const TimeIntervalStats& aStats)
{
  if (aStats.size() == 0)
    aStream << "no values recorded";
  else {
    typedef boost::chrono::duration<float, boost::milli> MilliSec_t;
 
    aStream << "min / mean / max = " << MilliSec_t(aStats.min()).count() << " / " 
            << MilliSec_t(aStats.mean()).count() << " / " << MilliSec_t(aStats.max()).count() << " ms";
    std::queue<TimeIntervalStats::Clock_t::duration> lLatestMeasurements = aStats.getLatestMeasurements();
    aStream << ", last values ";
    while (lLatestMeasurements.size() > 0) {
      aStream << MilliSec_t(lLatestMeasurements.front()).count() << (lLatestMeasurements.size() > 1 ? ", " : " ms");
      lLatestMeasurements.pop();
    }
  }
 
  return aStream;
}
 
 
} // end ns uhal