windows timers

#include <windows.h>
#include <stdio.h>
#include <uuids.h>
#include <dsound.h>
#include <math.h>
#include <strmif.h>

// compile as
// winegcc -g timers.cpp -lwinmm -lole32 -lstrmiids

static int totalTime = 5; // sec

 void wait(HANDLE object, int milliseconds)
 {
  LARGE_INTEGER frequency;
  QueryPerformanceFrequency(&frequency);
  double f = frequency.QuadPart;
  double period = 1000.0 / f; // in ms

  LONGLONG previous = 0L;
  double sum = 0.;
  double sum2 = 0.;

  int k = 0;
  do
  {
    WaitForSingleObject(object, INFINITE);
    ++k;

    LARGE_INTEGER t1;
    QueryPerformanceCounter(&t1);

    if (k > 1)
    {
      double thisGap = double(t1.QuadPart - previous) * period;
      sum += thisGap;
      sum2 += thisGap * thisGap;
    }
    previous = t1.QuadPart;
  }
  while (k < totalTime * 1000 / milliseconds); // number of waits for 10 seconds

  double average = double(sum) / double(k - 1);
  double average2 = double(sum2) / double(k - 1);
  double stddev = sqrt(average2 - average * average);

  printf("k: %d\n", k);
  printf("average: %g\n", average);
  printf("stddev: %g\n", stddev);
}

void main1(int milliseconds)
{
  HANDLE hTimer;
  LARGE_INTEGER liDueTime = { 0 };

  printf("CreateWaitableTimer\n");

  hTimer = CreateWaitableTimer (NULL, FALSE, NULL);
  SetWaitableTimer(hTimer, &liDueTime, milliseconds, NULL, NULL, 0);

  wait(hTimer, milliseconds);
}

void main2(int milliseconds)
{
  HANDLE g_hSemaphore;
  IReferenceClock *g_RefClock;
  DWORD_PTR g_dwAdviseToken;

  printf("IReferenceClock\n");

  g_hSemaphore = CreateSemaphore(NULL, 0, 1, NULL);
  CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
  CoCreateInstance(CLSID_SystemClock, NULL, CLSCTX_INPROC, IID_IReferenceClock, (LPVOID*)&g_RefClock);

  REFERENCE_TIME rtPeriod = (REFERENCE_TIME)(10000 * milliseconds);
  REFERENCE_TIME rtNow;

  g_RefClock->GetTime(&rtNow);

  // VS Build
#ifdef _MSC_VER
  g_RefClock->AdvisePeriodic(rtNow + rtPeriod, rtPeriod, g_hSemaphore, &g_dwAdviseToken);
#else
  g_RefClock->AdvisePeriodic(rtNow + rtPeriod, rtPeriod, (HSEMAPHORE)g_hSemaphore, &g_dwAdviseToken);
#endif

  wait(g_hSemaphore, milliseconds);
}

VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired)
{
  HANDLE & gDoneEvent = *(HANDLE*)lpParam;
  SetEvent(gDoneEvent);
}

void main3(int milliseconds)
{
  HANDLE hTimer;
  HANDLE hTimerQueue;
  HANDLE gDoneEvent;

  printf("CreateTimerQueueTimer\n");

  gDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  hTimerQueue = CreateTimerQueue();
  CreateTimerQueueTimer(&hTimer, hTimerQueue, (WAITORTIMERCALLBACK)TimerRoutine, &gDoneEvent, 0, milliseconds, 0);

  wait(gDoneEvent, milliseconds);
}

void main4(int milliseconds)
{
  HANDLE gDoneEvent;

  printf("timeSetEvent\n");

  gDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

  int resolution = 0;
  timeSetEvent(milliseconds, resolution, (LPTIMECALLBACK)gDoneEvent, 0, TIME_PERIODIC | TIME_CALLBACK_EVENT_SET);

  wait(gDoneEvent, milliseconds);
}

int main(int argc, char * argv[])
{
  if (argc == 3)
  {
    const char * mstr = argv[1];
    int milliseconds = atoi(mstr);

    printf("Waiting every %d milliseconds for %d seconds...\n", milliseconds, totalTime);

    char c = argv[2][0];
    switch (c)
    {
    case '1': main1(milliseconds); break;
    case '2': main2(milliseconds); break;
    case '3': main3(milliseconds); break;
    case '4': main4(milliseconds); break;
    }
  }
  return 0;
}