ibrcommon/ibrcommon/TimeMeasurement.cpp

Go to the documentation of this file.

/*
 * TimeMeasurement.cpp
 *
 *  Created on: 20.01.2010
 *      Author: morgenro
 */

#include "ibrcommon/TimeMeasurement.h"
#include <iostream>
#include <iomanip>
#include <features.h>
#include <stdio.h>

namespace ibrcommon
{
        TimeMeasurement::TimeMeasurement()
        {
                start(); stop();
        }

        TimeMeasurement::~TimeMeasurement()
        {
        }

        void TimeMeasurement::start()
        {
                // set sending time
                clock_gettime(CLOCK_MONOTONIC, &_start);
        }

        void TimeMeasurement::stop()
        {
                //We are DOOOOMED
                //http://www.wand.net.nz/~smr26/wordpress/2009/01/19/monotonic-time-in-mac-os-x/
                // set receiving time
                clock_gettime(CLOCK_MONOTONIC, &_end);
        }

        float TimeMeasurement::getMilliseconds()
        {
                // calc difference
                u_int64_t timeElapsed = TimeMeasurement::timespecDiff(&_end, &_start);

                // make it readable
                float delay_ms = (float)timeElapsed / 1000000;

                return delay_ms;
        }

        float TimeMeasurement::getNanoseconds()
        {
                // calc difference
                return TimeMeasurement::timespecDiff(&_end, &_start);
        }

        float TimeMeasurement::getMicroseconds()
        {
                // calc difference
                u_int64_t timeElapsed = TimeMeasurement::timespecDiff(&_end, &_start);

                // make it readable
                float delay_m = (float)timeElapsed / 1000;

                return delay_m;
        }

        float TimeMeasurement::getSeconds()
        {
                return getMilliseconds() / 1000;
        }

        std::ostream& TimeMeasurement::format(std::ostream &stream, const float value)
        {
#ifdef __UCLIBC__
                char buf[32];
                snprintf(buf, 32, "%4.2f", value);
                stream << std::string(buf);
#else
                stream << std::setiosflags(std::ios::fixed) << std::setprecision(2) << value;
#endif
                return stream;
        }

        std::ostream &operator<<(std::ostream &stream, TimeMeasurement &measurement)
        {
                // calc difference
                u_int64_t timeElapsed = TimeMeasurement::timespecDiff(&(measurement._end), &(measurement._start));

                // make it readable
                float delay_ms = (float)timeElapsed / 1000000;
                float delay_sec = delay_ms / 1000;
                float delay_min = delay_sec / 60;
                float delay_h = delay_min / 60;

                if (delay_h > 1)
                {
                        TimeMeasurement::format(stream, delay_h); stream << " h";
                }
                else if (delay_min > 1)
                {
                        TimeMeasurement::format(stream, delay_min); stream << " m";
                }
                else if (delay_sec > 1)
                {
                        TimeMeasurement::format(stream, delay_sec); stream << " s";
                }
                else
                {
                        TimeMeasurement::format(stream, delay_ms); stream << " ms";
                }

                return stream;
        }

        int64_t TimeMeasurement::timespecDiff(struct timespec *timeA_p, struct timespec *timeB_p)
        {
                //Casting to 64Bit, otherwise it caps out at ~ 5 secs for 32bit machines
               return (   (  (int64_t)(timeA_p->tv_sec) * 1e9 + (int64_t)(timeA_p->tv_nsec)) -  ( (int64_t)(timeB_p->tv_sec) * 1e9 + (int64_t)(timeB_p->tv_nsec)) );
        }
}