MercuryTimer.cpp

Go to the documentation of this file.

#include "MercuryTimer.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"

#ifndef WIN32
#include <sys/time.h>
#else
#include <windows.h>
#endif

#define RESOLUTION 1000000

MercuryTimer::MercuryTimer()
{
    m_pTime = 0;
    m_paused = false;
    Touch();
}

MercuryTimer::~MercuryTimer()
{
}

double MercuryTimer::Peek()
{
    return (double(m_secs) + (double(m_usecs) / RESOLUTION)) - m_pTime;
}

double MercuryTimer::Age()
{
    MercuryTimer current;
    if (!m_paused)
        return (current - *this).Peek();
    else
    {
        m_pTime += (current - *this).Peek();
        return 0;
    }
}

void MercuryTimer::Touch()
{
    uint64_t usecs = GetTimeMicroseconds();
    //We should probably check for clock wraparound

    m_secs = unsigned(usecs / RESOLUTION);
    m_usecs = unsigned(usecs % RESOLUTION);
}

#ifndef WIN32
int64_t GetMicrosecondsSinceEpoch()
{
    #if !defined (_EE)
        struct timeval tv;
        gettimeofday( &tv, 0 );
    
        return int64_t(tv.tv_sec) * RESOLUTION + int64_t(tv.tv_usec);
    #else
        return 0;
    #endif
}
#endif

MercuryTimer MercuryTimer::operator-(const MercuryTimer& t)
{
    MercuryTimer tmp;
    tmp.m_secs = m_secs - t.m_secs;
    tmp.m_usecs = m_usecs - t.m_usecs;

    if (tmp.m_usecs < 0)
    {
        tmp.m_secs--;
        tmp.m_usecs += RESOLUTION;
    }

    return tmp;
}

MercuryTimer MercuryTimer::operator+(const MercuryTimer& t)
{
    MercuryTimer tmp;
    tmp.m_secs = m_secs + t.m_secs;
    tmp.m_usecs = m_usecs + t.m_usecs;

    if ((tmp.m_usecs/RESOLUTION) >= 1)
    {
        tmp.m_secs++;
        tmp.m_usecs -= RESOLUTION;
    }

    return tmp;
}
    
void MercuryTimer::operator=(const MercuryTimer& t)
{
    m_secs = t.m_secs;
    m_usecs = t.m_usecs;

    m_paused = t.m_paused;
    m_pTime = t.m_pTime;
}

uint64_t MercuryTimer::GetTimeMicroseconds()
{
#ifdef WIN32
    int64_t t = timeGetTime() * int64_t(1000);
    t = FixupTimeIfLooped(t);
    t = FixupTimeIfBackwards(t);
    return t;
#else
    return GetMicrosecondsSinceEpoch();
#endif
}


int64_t MercuryTimer::FixupTimeIfLooped( int64_t usecs )
{
    static int64_t last = 0;
    static int64_t offset_us = 0;

    /* The time has wrapped if the last time was very high and the current time is very low. */
    const int64_t i32BitMaxMs = uint64_t(1) << 32;
    const int64_t i32BitMaxUs = i32BitMaxMs*1000;
    const int64_t one_day = uint64_t(24*60*60)*1000000;
    if( last > (i32BitMaxUs-one_day) && usecs < one_day )
        offset_us += i32BitMaxUs;

    last = usecs;

    return usecs + offset_us;
}

int64_t MercuryTimer::FixupTimeIfBackwards( int64_t usecs )
{
    static int64_t last = 0;
    static int64_t offset_us = 0;

    if( usecs < last )
    {
        /* The time has moved backwards.  Increase the offset by the amount we moved. */
        offset_us += last - usecs;
    }

    last = usecs;

    return usecs + offset_us;
}

MercuryTimerBenchmark BENCHMARK;

void MercuryTimerBenchmark::Start( const MString & sName )
{
    m_mTotals[sName].tTimer.Touch();
}

void MercuryTimerBenchmark::End( const MString & sName )
{
    m_mTotals[sName].fTotalTime += float(m_mTotals[sName].tTimer.Age());
    m_mTotals[sName].iTimesRun++;
}

void MercuryTimerBenchmark::Print( )
{
    std::map< MString, BenchPoint >::iterator c;

    LOG.Info( "Name : Times Run : Total Time : Average Time (ms)" );
    for( c = m_mTotals.begin(); c != m_mTotals.end(); c++ )
    {
        //if ( (c->second).iTimesRun <= 0 )
        LOG.Info( ssprintf( "%s : %i : %f : %f", (c->first).c_str(), (c->second).iTimesRun, (c->second).fTotalTime, (c->second).fTotalTime/float((c->second).iTimesRun)*1000.0f ) );
    }
}

/*
 *Copyright (c) 2001-2003 Chris Danford, Glenn Maynard
 * (c) 2005 Joshua Allen
 * (c) 2006 Charles Lohr
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by