Hosam Aly Mahmoud

//
//
//  Time slip test program which demonstrates an issue with multimedia timers
//  on multiprocessor kernel Windows 2000.  This program creates several threads which
//  are all creating and destroying a Win32 Multimedia Timer.  After running
//  for some time (its better to just leave the computer alone, no mouse moves, etc.)
//  the Windows clock will have drifted FORWARD in time.  This can be checked
//  by doing a sync with an "atomic clock" program before and maybe 15 minutes into
//  the run.
//
//

// link with win multimedia
#pragma comment( lib, "Winmm.lib" )


#include <process.h>
#include <windows.h>
#include <stdio.h>

// Sleep time
const UINT kSleepyTimeMilliseconds = 300;

// Empty timer callback proc
void CALLBACK    Win32MultiMediaTimerProc(UINT wTimerID, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2)
{
}

// Thread proc to test multimedia timer
//==================================================================================================
unsigned __stdcall    Win32_MyThreadProcStdC(void* threadInput_i)
{
    while( TRUE )
    {
        MMRESULT    result;

        // get the capabilities of the multimedia device
        TIMECAPS timeCapabilities;
        result = ::timeGetDevCaps(&timeCapabilities,sizeof(timeCapabilities));
        if (result != TIMERR_NOERROR)
            return 0;

        // set the minimum resolution of the timer
        //
        //    NOTE: We want to be capable of 1 millisecond resolution.
        //
        UINT myWin32TimerResolution = timeCapabilities.wPeriodMin;
        if (timeCapabilities.wPeriodMax < myWin32TimerResolution)
            myWin32TimerResolution = timeCapabilities.wPeriodMax;
        if (myWin32TimerResolution < 1)
            myWin32TimerResolution = 1;

        // Begin the timer
        result = ::timeBeginPeriod(myWin32TimerResolution);

        // define the timer options
        register UINT timerOptions = TIME_CALLBACK_FUNCTION
                                   | TIME_PERIODIC;

        // create the timer
        MMRESULT myWin32MultiMediaTimerID = ::timeSetEvent(
                                                  (UINT)500,                    // delay
                                                  myWin32TimerResolution,        // timer resolution
                                                  Win32MultiMediaTimerProc,        // callback
                                                  (DWORD)0,                        // user data
                                                  timerOptions                    // options
                                                 );

        DWORD lastWin32Error    = ::GetLastError();
        
        // I'm not sure if this I/O is necessary to produce the time slip, but here it is anyway
        FILE* f = fopen( "trashFile","w");
        if( f )
        {
            fprintf(f, "trash\n" );
            fclose(f);
        }

        // Sleep for a while, maybe to let the clock drift happen?
        ::Sleep( kSleepyTimeMilliseconds );
        
        for( UINT i = 0; i < kSleepyTimeMilliseconds; i++ )
        {
            ::Sleep( 0 );
        }

        result            = ::timeKillEvent( myWin32MultiMediaTimerID );
        lastWin32Error    = ::GetLastError();
        UINT    killRetryCount    = 3;

        // Since we are specifying that we are using TIME_KILL_SYNCHRONOUS, we should
        // not have to do this work, but it is here for additional safety.
        // If we have an error, we will try a number of times to 
        // shut down the timer
        while(        ( result != TIMERR_NOERROR )
                &&  ( killRetryCount > 0 ) )
        {
            // Yield the CPU to allow the thread that may be holding this timer resource
            ::Sleep(0);

            result            = ::timeKillEvent( myWin32MultiMediaTimerID );
            lastWin32Error    = ::GetLastError();

            // If we received something other than "no error", and the last error
            // is that we have somehow already terminated the timer, set
            // our success state to TIMERR_NOERROR
            if(        ( result != TIMERR_NOERROR )
                &&  ( lastWin32Error == ERROR_ALREADY_EXISTS ) )
            {
                result            = TIMERR_NOERROR;
                lastWin32Error    = 0;
            }

            // Decrement our retry count until we have exhausted all retries
            killRetryCount--;
        }

        switch (result)
        {
            case TIMERR_NOERROR:
                // nothing to do here...
                break;

            case MMSYSERR_INVALPARAM:
                // return a failure
                return 0;

            case TIMERR_NOCANDO:
                break;
                
            default:
                // we didn't expect this
                break;
        }

        // terminate the time services
        result = ::timeEndPeriod(myWin32TimerResolution);

        ::Sleep( kSleepyTimeMilliseconds );
    }

}

// Creates a number of threads to test the Win32 MultiMedia clock drift problem.
void ThreadTest()
{
    const UINT kNumberThreads = 10;

    // Create a bunch of threads that will create and destroy a lot of timers
    for( UINT i = 0; i < kNumberThreads; i++ )
    {

        // create the thread
        unsigned threadID;
        const unsigned long threadResult = _beginthreadex(
                                                          NULL,                        // security (NULL ==> default)
                                                          0,                        // stack size
                                                          Win32_MyThreadProcStdC,    // start address
                                                          NULL,                        // argument list
                                                          0,                        // init flags
                                                          &threadID                    // resultant thread ID
                                                         );
    }
    
    // Once the threads are going we will quietly wait for the program to be killed.
    while( TRUE )
    {
        ::Sleep( 1000 );
    }
}

//==================================================================================================
int    main(int               argumentCount_i,
         const char* const argumentValueArray_i[])
{
    ThreadTest();

    // return a success
    return 0;
}