clock.c

Go to the documentation of this file.

/*
 * COPYRIGHT:       GPL - See COPYING in the top level directory
 * PROJECT:         ReactOS Virtual DOS Machine
 * FILE:            subsystems/mvdm/ntvdm/clock.c
 * PURPOSE:         Clock for VDM
 * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
 *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
 */

/* INCLUDES *******************************************************************/

#include "ntvdm.h"

#define NDEBUG
#include <debug.h>

#include "emulator.h"
#include "clock.h"

#include "cpu/cpu.h"
#include "hardware/cmos.h"
#include "hardware/ps2.h"
#include "hardware/pit.h"
#include "hardware/video/svga.h"
#include "hardware/mouse.h"

/* DEFINES ********************************************************************/

/*
 * Activate IPS_DISPLAY if you want to display the
 * number of instructions per second.
 */
// #define IPS_DISPLAY

/* Processor speed */
#define STEPS_PER_CYCLE 1024

/* VARIABLES ******************************************************************/

static LIST_ENTRY Timers;
static LARGE_INTEGER StartPerfCount, Frequency;
// static ULONG StartTickCount;
static LARGE_INTEGER Counter;
static ULONG CurrentTickCount;
static ULONGLONG LastCycles = 0ULL;
static PHARDWARE_TIMER IpsTimer;

ULONGLONG CurrentCycleCount = 0ULL;
ULONGLONG CurrentIps = 20000000ULL; // 20 MIPS is a good estimate

/* PRIVATE FUNCTIONS **********************************************************/

static VOID FASTCALL IpsCallback(ULONGLONG ElapsedTime)
{
#ifdef IPS_DISPLAY
    static INT NumCalls = 0;
#endif
    
    ULONGLONG NewIps = 10ULL * (CurrentCycleCount - LastCycles) / ElapsedTime;
    CurrentIps = (CurrentIps + NewIps) >> 1;

#ifdef IPS_DISPLAY
    NumCalls++;
    if (NumCalls == 10)
    {
        DPRINT1("NTVDM: %I64u Instructions Per Second\n", CurrentIps);
        NumCalls = 0;
    }
#endif

    LastCycles = CurrentCycleCount;
}

/* PUBLIC FUNCTIONS ***********************************************************/

VOID ClockUpdate(VOID)
{
    extern BOOLEAN CpuRunning;
    UINT i;
    PLIST_ENTRY Entry;
    PHARDWARE_TIMER Timer;

    while (VdmRunning && CpuRunning)
    {
        /* Get the current counters */
        CurrentTickCount = GetTickCount();
        NtQueryPerformanceCounter(&Counter, NULL);

        /* Continue CPU emulation */
        for (i = 0; VdmRunning && CpuRunning && (i < STEPS_PER_CYCLE); i++)
        {
            CpuStep();
            ++CurrentCycleCount;
        }

        Entry = Timers.Flink;
        while (Entry != &Timers)
        {
            ULONGLONG Ticks = (ULONGLONG)-1;

            Timer = CONTAINING_RECORD(Entry, HARDWARE_TIMER, Link);
            Entry = Entry->Flink;

            ASSERT((Timer->EnableCount > 0) && (Timer->Flags & HARDWARE_TIMER_ENABLED));

            if (Timer->Delay)
            {
                if (Timer->Flags & HARDWARE_TIMER_PRECISE)
                {
                    /* Use the performance counter for precise timers */
                    if (Counter.QuadPart <= Timer->LastTick.QuadPart) continue;
                    Ticks = (Counter.QuadPart - Timer->LastTick.QuadPart) / Timer->Delay;
                }
                else
                {
                    /* Use the regular tick count for normal timers */
                    if (CurrentTickCount <= Timer->LastTick.LowPart) continue;
                    Ticks = (CurrentTickCount - Timer->LastTick.LowPart) / (ULONG)Timer->Delay;
                }

                if (Ticks == 0) continue;
            }

            Timer->Callback(Ticks);

            if (Timer->Flags & HARDWARE_TIMER_ONESHOT)
            {
                /* Disable this timer */
                DisableHardwareTimer(Timer);
            }

            /* Update the time of the last timer tick */
            Timer->LastTick.QuadPart += Ticks * Timer->Delay;
        }

        /* Yield execution to other threads */
        // FIXME: Disabled because it causes timing issues (slowdowns).
        // NtYieldExecution();
    }
}

PHARDWARE_TIMER CreateHardwareTimer(ULONG Flags, ULONGLONG Delay, PHARDWARE_TIMER_PROC Callback)
{
    PHARDWARE_TIMER Timer;

    Timer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*Timer));
    if (Timer == NULL) return NULL;

    Timer->Flags = Flags & ~HARDWARE_TIMER_ENABLED;
    Timer->EnableCount = 0;
    Timer->Callback = Callback;
    Timer->LastTick.QuadPart = 0;
    SetHardwareTimerDelay(Timer, Delay);

    if (Flags & HARDWARE_TIMER_ENABLED) EnableHardwareTimer(Timer);
    return Timer;
}

VOID EnableHardwareTimer(PHARDWARE_TIMER Timer)
{
    /* Increment the count */
    Timer->EnableCount++;

    /* Check if the count is above 0 but the timer isn't enabled */
    if ((Timer->EnableCount > 0) && !(Timer->Flags & HARDWARE_TIMER_ENABLED))
    {
        if (Timer->Flags & HARDWARE_TIMER_PRECISE)
        {
            NtQueryPerformanceCounter(&Timer->LastTick, NULL);
        }
        else
        {
            Timer->LastTick.LowPart = GetTickCount();
        }

        Timer->Flags |= HARDWARE_TIMER_ENABLED;
        InsertTailList(&Timers, &Timer->Link);
    }
}

VOID DisableHardwareTimer(PHARDWARE_TIMER Timer)
{
    /* Decrement the count */
    Timer->EnableCount--;

    /* Check if the count is 0 or less but the timer is enabled */
    if ((Timer->EnableCount <= 0) && (Timer->Flags & HARDWARE_TIMER_ENABLED))
    {
        /* Disable the timer */
        Timer->Flags &= ~HARDWARE_TIMER_ENABLED;
        RemoveEntryList(&Timer->Link);
    }
}

VOID SetHardwareTimerDelay(PHARDWARE_TIMER Timer, ULONGLONG NewDelay)
{
    if (Timer->Flags & HARDWARE_TIMER_PRECISE)
    {
        /* Convert the delay from nanoseconds to performance counter ticks */
        Timer->Delay = (NewDelay * Frequency.QuadPart + 500000000ULL) / 1000000000ULL;
    }
    else
    {
        Timer->Delay = NewDelay / 1000000ULL;
    }
}

VOID DestroyHardwareTimer(PHARDWARE_TIMER Timer)
{
    if (Timer)
    {
        if (Timer->Flags & HARDWARE_TIMER_ENABLED) RemoveEntryList(&Timer->Link);
        RtlFreeHeap(RtlGetProcessHeap(), 0, Timer);
    }
}

BOOLEAN ClockInitialize(VOID)
{
    InitializeListHead(&Timers);

    /* Initialize the performance counter (needed for hardware timers) */
    /* Find the starting performance */
    NtQueryPerformanceCounter(&StartPerfCount, &Frequency);
    if (Frequency.QuadPart == 0)
    {
        wprintf(L"FATAL: Performance counter not available\n");
        return FALSE;
    }

    /* Find the starting tick count */
    // StartTickCount = GetTickCount();

    IpsTimer = CreateHardwareTimer(HARDWARE_TIMER_ENABLED, HZ_TO_NS(10), IpsCallback);
    if (IpsTimer == NULL)
    {
        wprintf(L"FATAL: Cannot create IPS timer.\n");
        return FALSE;
    }

    return TRUE;
}