currentTime Class Reference

Public Member Functions
	currentTime ()
	~currentTime ()
void	getCurrentTime (epicsTimeStamp &dest)
void	startPLL ()

Friends
unsigned __stdcall	_pllThreadEntry (void *pCurrentTimeIn)

Detailed Description

Definition at line 67 of file osdTime.cpp.

Constructor & Destructor Documentation

currentTime::currentTime

(

)

Definition at line 154 of file osdTime.cpp.

                          :
    lastPerfCounter ( 0 ),
    perfCounterFreq ( 0 ),
    epicsTimeLast ( 0 ),
    perfCounterFreqPLL ( 0 ),
    lastPerfCounterPLL ( 0 ),
    lastFileTimePLL ( 0 ),
    threadHandle ( 0 ),
    threadId ( 0 ),
    perfCtrPresent ( false ),
    threadShutdownCmd ( false ),
    threadHasExited ( false )
{
    InitializeCriticalSection ( & this->mutex );

    // avoid interruptions by briefly becoming a time critical thread
    int originalPriority = GetThreadPriority ( GetCurrentThread () );
    SetThreadPriority ( GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL );

    FILETIME ft;
    GetSystemTimeAsFileTime ( & ft );
    LARGE_INTEGER tmp;
    QueryPerformanceCounter ( & tmp );
    this->lastPerfCounter = tmp.QuadPart;
    // if no high resolution counters then default to low res file time
    if ( QueryPerformanceFrequency ( & tmp ) ) {
        this->perfCounterFreq = tmp.QuadPart;
        this->perfCtrPresent = true;
    }
    SetThreadPriority ( GetCurrentThread (), originalPriority );

    LARGE_INTEGER liFileTime;
    liFileTime.LowPart = ft.dwLowDateTime;
    liFileTime.HighPart = ft.dwHighDateTime;

    if ( liFileTime.QuadPart >= epicsEpochInFileTime ) {
        // the windows file time has a maximum resolution of 100 nS
        // and a nominal resolution of 10 mS - 16 mS
        this->epicsTimeLast =
            ( liFileTime.QuadPart - epicsEpochInFileTime ) *
            ET_TICKS_PER_FT_TICK;
    }
    else {
        errlogPrintf (
            "win32 osdTime.cpp init detected questionable "
            "system date prior to EPICS epoch, epics time will not advance\n" );
        this->epicsTimeLast = 0;
    }

    this->perfCounterFreqPLL = this->perfCounterFreq;
    this->lastPerfCounterPLL = this->lastPerfCounter;
    this->lastFileTimePLL = liFileTime.QuadPart;
}

currentTime::~currentTime

(

)

Definition at line 225 of file osdTime.cpp.

{
    EnterCriticalSection ( & this->mutex );
    this->threadShutdownCmd = true;
    while ( ! this->threadHasExited ) {
        LeaveCriticalSection ( & this->mutex );
        Sleep ( 250 /* mS */ );
        EnterCriticalSection ( & this->mutex );
    }
    LeaveCriticalSection ( & this->mutex );
    DeleteCriticalSection ( & this->mutex );
}

Member Function Documentation

void currentTime::getCurrentTime

(

epicsTimeStamp &

dest

)

Definition at line 238 of file osdTime.cpp.

{
    if ( this->perfCtrPresent ) {
        EnterCriticalSection ( & this->mutex );

        LARGE_INTEGER curPerfCounter;
        QueryPerformanceCounter ( & curPerfCounter );

        LONGLONG offset;
        if ( curPerfCounter.QuadPart >= this->lastPerfCounter ) {
            offset = curPerfCounter.QuadPart - this->lastPerfCounter;
        }
        else {
            //
            // must have been a timer roll-over event
            //
            // It takes 9.223372036855e+18/perf_freq sec to roll over this
            // counter. This is currently about 245118 years using the perf
            // counter freq value on my system (1193182). Nevertheless, I
            // have code for this situation because the performance
            // counter resolution will more than likely improve over time.
            //
            offset = ( MAXLONGLONG - this->lastPerfCounter )
                                + ( curPerfCounter.QuadPart - MINLONGLONG ) + 1;
        }
        if ( offset < MAXLONGLONG / EPICS_TIME_TICKS_PER_SEC ) {
            offset *= EPICS_TIME_TICKS_PER_SEC;
            offset /= this->perfCounterFreq;
        }
        else {
            double fpOffset = static_cast < double > ( offset );
            fpOffset *= EPICS_TIME_TICKS_PER_SEC;
            fpOffset /= static_cast < double > ( this->perfCounterFreq );
            offset = static_cast < LONGLONG > ( fpOffset );
        }
        LONGLONG epicsTimeCurrent = this->epicsTimeLast + offset;
        if ( this->epicsTimeLast > epicsTimeCurrent ) {
            double diff = static_cast < double >
                ( this->epicsTimeLast - epicsTimeCurrent ) / EPICS_TIME_TICKS_PER_SEC;
            errlogPrintf (
                "currentTime::getCurrentTime(): %f sec "
                "time discontinuity detected\n",
                diff );
        }
        this->epicsTimeLast = epicsTimeCurrent;
        this->lastPerfCounter = curPerfCounter.QuadPart;

        LeaveCriticalSection ( & this->mutex );

        dest.secPastEpoch = static_cast < epicsUInt32 >
            ( epicsTimeCurrent / EPICS_TIME_TICKS_PER_SEC );
        dest.nsec = static_cast < epicsUInt32 >
            ( epicsTimeCurrent % EPICS_TIME_TICKS_PER_SEC );
    }
    else {
        // if high resolution performance counters are not supported then
        // fall back to low res file time
        FILETIME ft;
        GetSystemTimeAsFileTime ( & ft );
        dest = epicsTime ( ft );
    }
}

void currentTime::startPLL

(

)

Definition at line 208 of file osdTime.cpp.

{
    // create frequency estimation thread when needed
    if ( this->perfCtrPresent && ! this->threadHandle ) {
        this->threadHandle = (HANDLE)
            _beginthreadex ( 0, 4096, _pllThreadEntry, this,
                CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION,
                & this->threadId );
        assert ( this->threadHandle );
        BOOL bstat = SetThreadPriority (
            this->threadHandle, THREAD_PRIORITY_HIGHEST );
        assert ( bstat );
        DWORD wstat =  ResumeThread ( this->threadHandle );
        assert ( wstat != 0xFFFFFFFF );
    }
}

Friends And Related Function Documentation

unsigned __stdcall _pllThreadEntry ( void *  pCurrentTimeIn )

friend

Definition at line 494 of file osdTime.cpp.

{
    currentTime * pCT =
        reinterpret_cast < currentTime * > ( pCurrentTimeIn );
    setThreadName ( pCT->threadId, "EPICS Time PLL" );
    while ( ! pCT->threadShutdownCmd ) {
        Sleep ( currentTime :: pllDelay * 1000 /* mS */ );
        pCT->updatePLL ();
    }
    EnterCriticalSection ( & pCT->mutex );
    pCT->threadHasExited = true;
    LeaveCriticalSection ( & pCT->mutex );
    return 1;
}

---

The documentation for this class was generated from the following file:

• modules/libcom/src/osi/os/WIN32/osdTime.cpp