D:/WorkDir/SugoiProjects/SugoiTracer/src/timer.cpp

Go to the documentation of this file.

/* LICENSE_BEGIN
SutoiTracer library supply support profiling functions, class, or evet simple 
piece of code. It is part of the SugoiEngine project.
Copyright (C) 2006 Allusse Yannick (yannick dot allusse at laposte dot net)


This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
LICENSE_END
*/

#include "SugoiTracer\timer.h"


namespace SG_TRC{
CL_TimerVal::CL_TimerVal()
{
        Clear(); 
}

CL_TimerVal::CL_TimerVal(const CL_TimerVal &Time2)
{
        Clear();
        (*this) = Time2; 
}

CL_TimerVal::CL_TimerVal(const CL_Virtual_Record &Time2)
{
        Clear();
        //(*this) = *(CL_TimerVal*)Time2; 
}

CL_TimerVal::CL_TimerVal(const long T)
{
        Clear();
        (*this) = T; 
}

CL_TimerVal::CL_TimerVal(const timeval &_Timeval)
{ (*this) = _Timeval;}

void CL_TimerVal::Clear()
{
         SetToMin();
         succes = true;
         returnValue = 0;        
}
void CL_TimerVal:: SetToMax()
{
        tv_sec  = 999999;
        tv_usec = 999999;
}
void CL_TimerVal:: SetToMin()
{
        tv_sec  = 0;
        tv_usec = 0;
}
#if 1
CL_TimerVal& CL_TimerVal:: operator =( const CL_TimerVal& Time2)
{
        this->tv_sec = Time2.tv_sec;             
        this->tv_usec = Time2.tv_usec;
        return (*this);
}
/*
CL_TimerVal&   CL_TimerVal::operator  =( const CL_Virtual_Record *Time2)
{
        (*this)  = *(CL_TimerVal*)Time2;
        return (*this);
}
*/
CL_TimerVal&  CL_TimerVal:: operator =( const long T)
{
        this->tv_sec = T/1000000;
        this->tv_usec = T - this->tv_sec * 1000000;
        return (*this);
}

CL_TimerVal&  CL_TimerVal:: operator =( const ST_Timeval &_Timeval)
{
        tv_sec  = _Timeval.tv_sec;
        tv_usec = _Timeval.tv_usec;
        return (*this);
}

bool  CL_TimerVal::operator ==(const CL_TimerVal&  Time2)
{
        if ((tv_sec == Time2.tv_sec) && (tv_usec == Time2.tv_usec))
           return true;
        return false;
}
/*
bool  CL_TimerVal::operator ==(const CL_TimerVal&  T)
{
        if ((tv_sec == Time2.tv_sec) && (tv_usec == Time2.tv_usec))
           return true;
        return false;
}
*/
bool  CL_TimerVal::operator !=(const CL_TimerVal&  Time2)
{
        if ((tv_sec == Time2.tv_sec) && (tv_usec == Time2.tv_usec))
           return false;
        return true;
}
/*
bool  CL_TimerVal::operator !=(const CL_TimerVal&  T)
{
        if ((tv_sec == Time2.tv_sec) && (tv_usec == Time2.tv_usec))
           return true;
        return false;
}
*/
CL_TimerVal&   CL_TimerVal::operator +=( const CL_TimerVal  &Time2)
{
        //micro seconde test
        this->tv_usec += Time2.tv_usec;
        while (this->tv_usec > 1000000)
        {
                this->tv_sec ++;
                this->tv_usec -= 1000000;
        }
        //seconde test
        this->tv_sec += Time2.tv_sec;

        return (*this);
}

CL_TimerVal&   CL_TimerVal::operator -=( const CL_TimerVal &Time2)
{
        //micro seconde test
        this->tv_usec -= Time2.tv_usec;
        while (this->tv_usec < 0)
        {
                this->tv_sec --;
                this->tv_usec += 1000000;
        }
        //seconde test
        this->tv_sec -= Time2.tv_sec;

        return (*this);
}

CL_TimerVal&   CL_TimerVal::operator /=(const long T)
{
        SG_Assert(T, "Divide by 0 is not allowed!");
        long TempTime = GetValue();
        return (*this) = TempTime / T;
}

CL_TimerVal&   CL_TimerVal::operator *=(const long T)
{
        long TempTime = GetValue();
        return (*this) = TempTime * T;
}


CL_TimerVal CL_TimerVal::operator+(const CL_TimerVal &T2)const
{
        CL_TimerVal TempTime((*this));
        return TempTime += T2;
}

CL_TimerVal CL_TimerVal::operator-(const CL_TimerVal &T2)const
{
        CL_TimerVal TempTime((*this));
        return TempTime -= T2;
}

CL_TimerVal   CL_TimerVal::operator *(const long T)const
{
        CL_TimerVal TempTime((*this));
        return TempTime *= T;
}
        
CL_TimerVal   CL_TimerVal::operator /(const long T)const
{
        SG_Assert(T, "Divide by 0 is not allowed!");
        CL_TimerVal TempTime((*this));
        return TempTime /= T;
}

bool   CL_TimerVal::operator <(const CL_TimerVal &Time2)
{
        return !((*this) > Time2);
}

bool   CL_TimerVal::operator >(const CL_TimerVal &Time2)
{
        if (this->tv_sec > Time2.tv_sec )
                return true;
        else if (this->tv_sec < Time2.tv_sec)
                return false;
        else if(this->tv_usec > Time2.tv_usec)
                return true;
        else if(this->tv_usec < Time2.tv_usec)
                return false;
        return false;
}

long   CL_TimerVal::GetValue(void)
{  
        return (this->tv_sec * 1000000+this->tv_usec);
}

std::string CL_TimerVal::GetStr(bool _Apprixmimate/*=true*/)const
{
        std::string TempString="";
        char TempBuff[16];

        if (tv_sec > 0)
        {
                TempString = itoa(tv_sec, TempBuff, 10);
                TempString+= " s ";
        }

        long uSec = tv_usec;
        if (tv_usec > 1000)
        {
                TempString += itoa(tv_usec/1000, TempBuff, 10);
                uSec -= (tv_usec/1000) *1000;
                TempString+=" ms ";
        }

        if (uSec > 0)
        {
                TempString += itoa(uSec, TempBuff, 10);
                TempString+=" us";
        }
        return TempString;
}

void CL_TimerVal::Print()
{
     printf("%d'%6.d", tv_sec,tv_usec);
}

//the first time the run function is executed, we take the time, the second time(and more, we compare time)
void CL_TimerVal::Run(CL_TimerVal * StopTime/*=NULL*/)
{
        if (StopTime)
        {
                (*this)= (*StopTime)- (*this);
        }
        else
        {
                timeval TempTime;
                Ygettimeofday(&TempTime);
                CL_TimerVal Temp(TempTime);
                (*this)= Temp- (*this);
        }
}

#if _SG_TLS_XML

TiXmlElement* CL_TimerVal::XMLLoad(TiXmlElement* _XML_ROOT, std::string _Name/* =""*/)
{
        SG_Assert(_XML_ROOT, "CL_TimerVal::XMLLoad() => XML root element empty");
        SG_Assert(_Name!="", "XML tag name is empty.");

        Clear();//Init all positions values to default

        if (_Name!= "")
                SetMainTag(_Name);

        //TiXmlElement * XMLTimer = CL_XML_OBJ::XMLLoad(_XML_ROOT);
        TiXmlElement* XMLTimer = XMLGetElement(_XML_ROOT, _Name);
        if (!XMLTimer)
                return NULL;
        
        XMLReadVal (XMLTimer, "sec", this->tv_sec);
        XMLReadVal (XMLTimer, "usec", this->tv_usec);

        return XMLTimer;
}

TiXmlElement* CL_TimerVal::XMLSave(TiXmlElement* _XML_ROOT, std::string _Name/*=""*/)
{
        SG_Assert(_XML_ROOT, "CL_TimerVal::XMLSave() => XML root element empty");
        SG_Assert(_Name!="", "XML tag name is empty.");
        
        if (this->tv_sec == 0 && this->tv_usec == 0)
                return _XML_ROOT;
        else if (this->tv_sec == 999999 && this->tv_usec == 999999)
                return _XML_ROOT;

        if (_Name!= "")
                SetMainTag(_Name);


        TiXmlElement * XMLTimer = CL_XML_OBJ::XMLLoad(_XML_ROOT);
        if (!XMLTimer) 
        //CL_XML_OBJ::XMLSave(_XML_ROOT);
                XMLTimer = new TiXmlElement( _Name.data() );
        
        if (this->tv_sec != 0)
                XMLWriteVal (XMLTimer, "sec", this->tv_sec);
        if (this->tv_usec != 0)
                XMLWriteVal (XMLTimer, "usec", this->tv_usec);

        _XML_ROOT->InsertEndChild(*XMLTimer);

        return XMLTimer;
}
#endif //XML

int Ygettimeofday(struct timeval * tp)
{
        #if defined (_WIN32)
                LARGE_INTEGER ticksPerSecond;
                LARGE_INTEGER tick;   // A point in time
                LARGE_INTEGER time;   // For converting tick into real time

                // get the high resolution counter's accuracy
                QueryPerformanceFrequency(&ticksPerSecond);

                // what time is it?
                QueryPerformanceCounter(&tick);

                // convert the tick number into the number of seconds
                // since the system was started...
                time.QuadPart = tick.QuadPart/ticksPerSecond.QuadPart;
                tp->tv_sec = (long)time.QuadPart;

                //get the number of hours
                LONGLONG hours = time.QuadPart/3600;

                //get the number of minutes
                time.QuadPart = time.QuadPart - (hours * 3600);
                LONGLONG minutes = time.QuadPart/60;

                //get the number of seconds
                LONGLONG  seconds = time.QuadPart - (minutes * 60);
                
                tp->tv_usec = long(tick.QuadPart % ticksPerSecond.QuadPart / (float)ticksPerSecond.QuadPart * 1000000);

                return 0;//normal return
        #elif defined(__linux) || defined(__APPLE__)
                return gettimeofday(tp, NULL );
        #else
                return gettimeofday(tp );
        #endif  
}
#endif

};//namespace SG_TRC

---