TimeStampCounter.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
/*
 *  Piece of code adapted for the FESA Framework.
 *  Original version references:
 *
 *  Portable Agile C++ Classes (PACC)
 *  Copyright (C) 2004 by Marc Parizeau
 *  http://manitou.gel.ulaval.ca/~parizeau/PACC
 *
 *  This library 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.1 of the License, or (at your option) any later version.
 *
 *  This library 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 this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact:
 *  Laboratoire de Vision et Systemes Numeriques
 *  Departement de genie electrique et de genie informatique
 *  Universite Laval, Quebec, Canada, G1K 7P4
 *  http://vision.gel.ulaval.ca
 *
 */
#include <iostream>
#include <fesa-core/Diagnostic/TimeStampCounter.h>

namespace fesa
{

    double TsCounter::mPeriod = 0;

    void TsCounter::calibrateCountPeriod(uint32_t inDelay/*ms*/, uint32_t inTimes)
    {

        if (mHardware)
        {
#if defined (__GNUG__) && (defined (__i386__) || defined (__PPC__))
            double lPeriod = 0;
            // calibrate by matching the time-stamps with the micro-seconds of gettimeofday
            for (uint32_t i = 0; i < inTimes; ++i)
            {
                timeval lStartTime, lTime;
                ::gettimeofday(&lStartTime, 0);
                uint64_t lStartCount = getCount();

                struct timespec theDelay, time_left_before_wakeup;
                int32_t sec = inDelay / 1000; // number of seconds since delay is expressed in ms
                int32_t nsec = 0;
                if ((nsec = inDelay % 1000)) // check remainder
                    nsec *= (int32_t) 1E6; // convert remainder into ns
                theDelay.tv_sec = sec;
                theDelay.tv_nsec = nsec;
                nanosleep(&theDelay, &time_left_before_wakeup);
                ::gettimeofday(&lTime, 0);
                uint64_t lCount = getCount() - lStartCount;
                lTime.tv_sec -= lStartTime.tv_sec;
                lTime.tv_usec -= lStartTime.tv_usec;
                // dismiss the first run of the loop
                if (i != 0)
                    lPeriod += (lTime.tv_sec + lTime.tv_usec * 0.000001) / lCount;
            }
            mPeriod = lPeriod / (inTimes - 1);
#else
            // use the microseconds of gettimeofday
            mPeriod = 0.000001;
#endif
        }
        else
        {
            // use the microseconds of gettimeofday
            mPeriod = 0.000001;
        }
    }

    uint64_t TsCounter::getCount(void) const
    {
        uint64_t lCount = 0;

        if (mHardware)
        {
#if defined (__GNUG__) && defined (__i386__)
            __asm__ volatile("rdtsc" : "=A" (lCount));
#else
#if defined (__GNUG__) && defined (__PPC__)
            register uint32_t lLow;
            register uint32_t lHigh1;
            register uint32_t lHigh2;
            do
            {
                // make sure that high bits have not changed
                __asm__ volatile ( "mftbu %0" : "=r" (lHigh1) );
                __asm__ volatile ( "mftb  %0" : "=r" (lLow) );
                __asm__ volatile ( "mftbu %0" : "=r" (lHigh2) );
            }while(lHigh1 != lHigh2);
            // transfer to lCount
            uint32_t *lPtr = (uint32_t*) &lCount;
            *lPtr++ = lHigh1; *lPtr = lLow;
#else
            timeval lCurrent;
            ::gettimeofday(&lCurrent, 0);
            lCount = (uint64_t)lCurrent.tv_sec*1000000 + lCurrent.tv_usec;
#endif
#endif
        }
        else
        {
            timeval lCurrent;
            ::gettimeofday(&lCurrent, 0);
            lCount = (uint64_t) lCurrent.tv_sec * 1000000 + lCurrent.tv_usec;
        }

        return lCount;
    }
}