phTimeStamp.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission :
        Realtime Vision Processing System

    Copyright (C) 2003-2006 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics

    This file is part of Phission.

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

    Phission 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Phission; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 ---------------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
    #include <phissionconfig.h>
#endif

#if defined(WIN32)
    #include <windows.h>
    #define USE_CLOCK() 0
    #define USE_TIMEVAL() 0
#elif defined(__ADSPBLACKFIN__)
    #include <PhissionVDK.h>
    #define USE_CLOCK() 0
    #define USE_TIMEVAL() 0
#else
    #define USE_CLOCK() 0
    #define USE_TIMEVAL() 1
    #if defined(HAVE_SYS_TIME_H) && USE_TIMEVAL()
        #include <sys/time.h>
    #endif

    #if defined(HAVE_TIME_H) && USE_CLOCK()
        #include <time.h>
    #endif
#endif

#include <phStandard.h>

#include <phObject.h>
#include <phTimeStamp.h>

#include <phError.h>
#include <phMemory.h>
#include <phPrint.h>

/* ------------------------------------------------------------------------ */
phTimeStamp::phTimeStamp()
{
    phFUNCTION("phTimeStamp::phTimeStamp")
#if defined(WIN32)
    LARGE_INTEGER li;
    if (QueryPerformanceFrequency(&li))
        this->m_priv = li.QuadPart;
    else
#endif
        this->m_priv = 0;
    this->setName("phTimeStamp"); // comment this in when deriving from
                                  // phObject
    this->stamp();
}

/* ------------------------------------------------------------------------ */
phTimeStamp::phTimeStamp( const phTimeStamp &stamp )
{
    this->m_stamp_val = stamp.m_stamp_val;
    
}
/* ------------------------------------------------------------------------ */
phTimeStamp::~phTimeStamp()
{
}

/* ------------------------------------------------------------------------ */
double phTimeStamp::getStampValue() const 
{
    return this->m_stamp_val;
}

/* ------------------------------------------------------------------------ */
uint32_t phTimeStamp::getSeconds() const 
{
    return (uint32_t)(this->m_stamp_val / 1000000000.0);
}

/* ------------------------------------------------------------------------ */
uint32_t phTimeStamp::getMilliseconds() const
{
    return (uint32_t)(this->m_stamp_val / 1000000.0);
}

/* ------------------------------------------------------------------------ */
uint32_t phTimeStamp::getMicroseconds() const
{
    return (uint32_t)(this->m_stamp_val / 1000.0);
}

/* ------------------------------------------------------------------------ */
uintmax_t phTimeStamp::getNanoseconds() const
{
    return (uintmax_t)(this->m_stamp_val);
}

/* ------------------------------------------------------------------------ */
int phTimeStamp::setFromSeconds      (uint32_t sec)
{
    this->m_stamp_val = (double)(sec * 1000000000);
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phTimeStamp::setFromMilliseconds (uint32_t micro)
{
    this->m_stamp_val = (double)(micro * 1000000);
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phTimeStamp::setFromMicroseconds (uint32_t micro)
{
    this->m_stamp_val = (double)(micro * 1000);
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phTimeStamp::setFromNanoseconds  (uintmax_t nano )
{
    this->m_stamp_val = (double)nano;
    return phSUCCESS;
}
    
/* ------------------------------------------------------------------------ */
void phTimeStamp::stamp()
{
#if defined(WIN32)
    LARGE_INTEGER li;
    if ((this->m_priv) && (QueryPerformanceCounter(&li)))
        this->m_stamp_val = ((double)li.QuadPart / (double)(this->m_priv)) * 
                                                                1000000000.0;
    else
        this->m_stamp_val = (double)(GetTickCount()) * 1000000.0;
#elif defined(__ADSPBLACKFIN__)
    double tick_per = (double)VDK::GetTickPeriod();
    this->m_stamp_val = ((double)VDK::GetUptime()) * 
                        ((double)VDK::GetTickPeriod()) * 
                        1000000.0;
#else
    #if USE_TIMEVAL()
    double sec  = 0;
    double usec = 0;
    struct timeval tval;
    gettimeofday(&tval,NULL);
    sec = (double)tval.tv_sec;
    usec= (double)tval.tv_usec;
    this->m_stamp_val = (sec * 1000000.0 + usec) * 1000.0;
    #endif
    #if USE_CLOCK()
    this->m_stamp_val = ((double)clock() / CLOCKS_PER_SEC) * 1000000000.0;
    #endif
#endif
    /*phPRINT("%12.8lf\n",this->m_stamp_val);*/
}

/* ------------------------------------------------------------------------ */
void phTimeStamp::clear()
{
    this->m_stamp_val = 0.0;
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator ==( const phTimeStamp &right ) const
{
    bool retrc = false;

    if (this->m_stamp_val == right.m_stamp_val)
    {
        retrc = true;
    }

    return retrc;
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator <( const phTimeStamp &right ) const
{
    bool retrc = false;

    if (this->m_stamp_val < right.m_stamp_val)
    {
        retrc = true;
    }
    
    return retrc;
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator !=( const phTimeStamp &right ) const
{
    return !(*this == right);
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator <=( const phTimeStamp &right ) const
{
    return !(right < *this);
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator >( const phTimeStamp &right ) const
{
    return (right < *this);
}

/* ------------------------------------------------------------------------ */
bool phTimeStamp::operator >=( const phTimeStamp &right ) const
{
    return !(*this < right);
}

/* ------------------------------------------------------------------------ */
/* Assignment operator */
phTimeStamp &phTimeStamp::operator =( const phTimeStamp &right )
{
    if (&right != this)
    {
        this->m_stamp_val = right.m_stamp_val;
    }

    return *this;
}

/* ------------------------------------------------------------------------ */
/* Addition operators */
phTimeStamp &phTimeStamp::operator +=( const phTimeStamp &right )
{
    this->m_stamp_val += right.m_stamp_val;

    return *this;
}

/* ------------------------------------------------------------------------ */
phTimeStamp phTimeStamp::operator +( const phTimeStamp &right )
{
    phTimeStamp temp;
    temp.m_stamp_val = this->m_stamp_val + right.m_stamp_val;

    return temp;
}

/* ------------------------------------------------------------------------ */
/* Subtraction operators */
phTimeStamp &phTimeStamp::operator -=( const phTimeStamp &right )
{
    this->m_stamp_val -= right.m_stamp_val;

    return *this;
}

/* ------------------------------------------------------------------------ */
phTimeStamp phTimeStamp::operator -( const phTimeStamp &right ) 
{
    phFUNCTION("phTimeStamp::operator -");
    phTimeStamp temp;

    temp.m_stamp_val = this->m_stamp_val - right.m_stamp_val;

    return temp;
}

/* ------------------------------------------------------------------------ */
void phTimeStamp::report(char *label,
                         FILE *file_desc )
{
    phFUNCTION("phTimeStamp::report")

    double          sec     = 0;
    double          usec    = 0;
    double          nsec    = 0;
   
    if (file_desc == NULL) file_desc = stdout;
    
    sec = (unsigned long)(this->m_stamp_val / 1000000000.0);
    usec = (unsigned long)((this->m_stamp_val - (sec * 1000000000)) / 1000);
    nsec = (unsigned long)(this->m_stamp_val - 
                ((sec * 1000000000) + (usec * 1000)));
    
    if (label == NULL)
    {
        fprintf(file_desc,
                "Time - %12.lf [%4.lf(s) %6.lf(us) %6.lf(ns)]\n",
                this->m_stamp_val, sec, usec, nsec
                );
    }
    else
    {
        fprintf(file_desc,
                "(%s)Time - %12.lf [%4.lf(s) %6.lf(us) %6.lf(ns)]\n",
                label,
                this->m_stamp_val, sec, usec, nsec
                );
    }
    fflush(file_desc);
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---