barrier.c

 
#include <winpr/config.h>
 
#include <winpr/synch.h>
#include <winpr/assert.h>
 
#include "synch.h"
 
#include <winpr/crt.h>
 
#ifdef WINPR_SYNCHRONIZATION_BARRIER
 
#include <winpr/sysinfo.h>
#include <winpr/library.h>
#include <winpr/interlocked.h>
#include <winpr/thread.h>
 
#ifdef _WIN32
 
static HMODULE g_Kernel32 = nullptr;
static BOOL g_NativeBarrier = FALSE;
static INIT_ONCE g_InitOnce = INIT_ONCE_STATIC_INIT;
 
typedef BOOL(WINAPI* fnInitializeSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier,
                                                         LONG lTotalThreads, LONG lSpinCount);
typedef BOOL(WINAPI* fnEnterSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier,
                                                    DWORD dwFlags);
typedef BOOL(WINAPI* fnDeleteSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier);
 
static fnInitializeSynchronizationBarrier pfnInitializeSynchronizationBarrier = nullptr;
static fnEnterSynchronizationBarrier pfnEnterSynchronizationBarrier = nullptr;
static fnDeleteSynchronizationBarrier pfnDeleteSynchronizationBarrier = nullptr;
 
static BOOL CALLBACK InitOnce_Barrier(PINIT_ONCE once, PVOID param, PVOID* context)
{
  g_Kernel32 = LoadLibraryA("kernel32.dll");
 
  if (!g_Kernel32)
    return TRUE;
 
  pfnInitializeSynchronizationBarrier = GetProcAddressAs(
      g_Kernel32, "InitializeSynchronizationBarrier", fnInitializeSynchronizationBarrier);
 
  pfnEnterSynchronizationBarrier =
      GetProcAddressAs(g_Kernel32, "EnterSynchronizationBarrier", fnEnterSynchronizationBarrier);
  pfnDeleteSynchronizationBarrier = GetProcAddressAs(g_Kernel32, "DeleteSynchronizationBarrier",
                                                     fnDeleteSynchronizationBarrier);
 
  if (pfnInitializeSynchronizationBarrier && pfnEnterSynchronizationBarrier &&
      pfnDeleteSynchronizationBarrier)
  {
    g_NativeBarrier = TRUE;
  }
 
  return TRUE;
}
 
#endif
 
BOOL WINAPI winpr_InitializeSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier,
                                                   LONG lTotalThreads, LONG lSpinCount)
{
  SYSTEM_INFO sysinfo;
  HANDLE hEvent0 = nullptr;
  HANDLE hEvent1 = nullptr;
 
#ifdef _WIN32
  if (!InitOnceExecuteOnce(&g_InitOnce, InitOnce_Barrier, nullptr, nullptr))
    return FALSE;
 
  if (g_NativeBarrier)
    return pfnInitializeSynchronizationBarrier(lpBarrier, lTotalThreads, lSpinCount);
#endif
 
  if (!lpBarrier || lTotalThreads < 1 || lSpinCount < -1)
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
  }
 
  ZeroMemory(lpBarrier, sizeof(SYNCHRONIZATION_BARRIER));
 
  if (lSpinCount == -1)
    lSpinCount = 2000;
 
  if (!(hEvent0 = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
    return FALSE;
 
  if (!(hEvent1 = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
  {
    (void)CloseHandle(hEvent0);
    return FALSE;
  }
 
  GetNativeSystemInfo(&sysinfo);
 
  WINPR_ASSERT(lTotalThreads >= 0);
  lpBarrier->Reserved1 = (DWORD)lTotalThreads;
  lpBarrier->Reserved2 = (DWORD)lTotalThreads;
  lpBarrier->Reserved3[0] = (ULONG_PTR)hEvent0;
  lpBarrier->Reserved3[1] = (ULONG_PTR)hEvent1;
  lpBarrier->Reserved4 = sysinfo.dwNumberOfProcessors;
  WINPR_ASSERT(lSpinCount >= 0);
  lpBarrier->Reserved5 = (DWORD)lSpinCount;
 
  return TRUE;
}
 
BOOL WINAPI winpr_EnterSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier, DWORD dwFlags)
{
  LONG remainingThreads = 0;
  HANDLE hCurrentEvent = nullptr;
  HANDLE hDormantEvent = nullptr;
 
#ifdef _WIN32
  if (g_NativeBarrier)
    return pfnEnterSynchronizationBarrier(lpBarrier, dwFlags);
#endif
 
  if (!lpBarrier)
    return FALSE;
 
  hCurrentEvent = (HANDLE)lpBarrier->Reserved3[0];
  hDormantEvent = (HANDLE)lpBarrier->Reserved3[1];
 
  remainingThreads = InterlockedDecrement((LONG*)&lpBarrier->Reserved1);
 
  WINPR_ASSERT(remainingThreads >= 0);
 
  if (remainingThreads > 0)
  {
    DWORD dwProcessors = lpBarrier->Reserved4;
    BOOL spinOnly = (dwFlags & SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY) != 0;
    BOOL blockOnly = (dwFlags & SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY) != 0;
    BOOL block = TRUE;
 
    if (spinOnly || (((ULONG)remainingThreads < dwProcessors) && !blockOnly))
    {
      DWORD dwSpinCount = lpBarrier->Reserved5;
      DWORD sp = 0;
      volatile ULONG_PTR* cmp = &lpBarrier->Reserved3[0];
      /* we spin until the last thread _completed_ the event switch */
      while ((block = (*cmp == (ULONG_PTR)hCurrentEvent)))
        if (!spinOnly && ++sp > dwSpinCount)
          break;
    }
 
    if (block)
      (void)WaitForSingleObject(hCurrentEvent, INFINITE);
 
    return FALSE;
  }
 
  /* reset the dormant event first */
  (void)ResetEvent(hDormantEvent);
 
  /* reset the remaining counter */
  lpBarrier->Reserved1 = lpBarrier->Reserved2;
 
  /* switch events - this will also unblock the spinning threads */
  lpBarrier->Reserved3[1] = (ULONG_PTR)hCurrentEvent;
  lpBarrier->Reserved3[0] = (ULONG_PTR)hDormantEvent;
 
  /* signal the blocked threads */
  (void)SetEvent(hCurrentEvent);
 
  return TRUE;
}
 
BOOL WINAPI winpr_DeleteSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier)
{
#ifdef _WIN32
  if (g_NativeBarrier)
    return pfnDeleteSynchronizationBarrier(lpBarrier);
#endif
 
  if (!lpBarrier)
    return TRUE;
 
  while (lpBarrier->Reserved1 != lpBarrier->Reserved2)
    SwitchToThread();
 
  if (lpBarrier->Reserved3[0])
    (void)CloseHandle((HANDLE)lpBarrier->Reserved3[0]);
 
  if (lpBarrier->Reserved3[1])
    (void)CloseHandle((HANDLE)lpBarrier->Reserved3[1]);
 
  ZeroMemory(lpBarrier, sizeof(SYNCHRONIZATION_BARRIER));
 
  return TRUE;
}
 
#endif