sleep.c

 
#include <winpr/config.h>
 
#include <winpr/platform.h>
#include <winpr/windows.h>
 
#include <winpr/synch.h>
 
#include "../log.h"
#include "../thread/apc.h"
#include "../thread/thread.h"
#include "../synch/pollset.h"
 
#define TAG WINPR_TAG("synch.sleep")
 
#ifndef _WIN32
 
#include <time.h>
 
WINPR_PRAGMA_DIAG_PUSH
WINPR_PRAGMA_DIAG_IGNORED_RESERVED_ID_MACRO
WINPR_PRAGMA_DIAG_IGNORED_UNUSED_MACRO
 
#ifdef WINPR_HAVE_UNISTD_H
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 500 // NOLINT(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
#endif
#include <unistd.h>
#endif
 
WINPR_PRAGMA_DIAG_POP
 
VOID Sleep(DWORD dwMilliseconds)
{
  usleep(dwMilliseconds * 1000);
}
 
DWORD SleepEx(DWORD dwMilliseconds, BOOL bAlertable)
{
  WINPR_THREAD* thread = winpr_GetCurrentThread();
  WINPR_POLL_SET pollset;
  int status = 0;
  DWORD ret = WAIT_FAILED;
  BOOL autoSignalled = 0;
 
  if (thread)
  {
    /* treat re-entrancy if a completion is calling us */
    if (thread->apc.treatingCompletions)
      bAlertable = FALSE;
  }
  else
  {
    /* called from a non WinPR thread */
    bAlertable = FALSE;
  }
 
  if (!bAlertable || !thread->apc.length)
  {
    usleep(dwMilliseconds * 1000);
    return 0;
  }
 
  if (!pollset_init(&pollset, thread->apc.length))
  {
    WLog_ERR(TAG, "unable to initialize pollset");
    return WAIT_FAILED;
  }
 
  if (!apc_collectFds(thread, &pollset, &autoSignalled))
  {
    WLog_ERR(TAG, "unable to APC file descriptors");
    goto out;
  }
 
  if (!autoSignalled)
  {
    /* we poll and wait only if no APC member is ready */
    status = pollset_poll(&pollset, dwMilliseconds);
    if (status < 0)
    {
      WLog_ERR(TAG, "polling of apc fds failed");
      goto out;
    }
  }
 
  if (apc_executeCompletions(thread, &pollset, 0))
  {
    ret = WAIT_IO_COMPLETION;
  }
  else
  {
    /* according to the spec return value is 0 see
     * https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleepex*/
    ret = 0;
  }
out:
  pollset_uninit(&pollset);
  return ret;
}
 
#endif
 
VOID USleep(DWORD dwMicroseconds)
{
#ifndef _WIN32
  usleep(dwMicroseconds);
#else
  static LARGE_INTEGER freq = { 0 };
  LARGE_INTEGER t1 = { 0 };
  LARGE_INTEGER t2 = { 0 };
 
  QueryPerformanceCounter(&t1);
 
  if (freq.QuadPart == 0)
  {
    QueryPerformanceFrequency(&freq);
  }
 
  // in order to save cpu cycles we use Sleep() for the large share ...
  if (dwMicroseconds >= 1000)
  {
    Sleep(dwMicroseconds / 1000);
  }
  // ... and busy loop until all the requested micro seconds have passed
  do
  {
    QueryPerformanceCounter(&t2);
  } while (((t2.QuadPart - t1.QuadPart) * 1000000) / freq.QuadPart < dwMicroseconds);
#endif
}