FreeRDP/winpr/libwinpr/synch/barrier.c

183 lines
4.3 KiB
C

/**
* WinPR: Windows Portable Runtime
* Synchronization Functions
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <winpr/synch.h>
#include "synch.h"
#include <winpr/crt.h>
#ifdef WINPR_SYNCHRONIZATION_BARRIER
#include <winpr/library.h>
#include <winpr/interlocked.h>
#ifdef _WIN32
static HMODULE g_Kernel32 = NULL;
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 = NULL;
static fnEnterSynchronizationBarrier pfnEnterSynchronizationBarrier = NULL;
static fnDeleteSynchronizationBarrier pfnDeleteSynchronizationBarrier = NULL;
static BOOL CALLBACK InitOnce_Barrier(PINIT_ONCE once, PVOID param, PVOID *context)
{
g_Kernel32 = LoadLibraryA("kernel32.dll");
if (!g_Kernel32)
return TRUE;
pfnInitializeSynchronizationBarrier = (fnInitializeSynchronizationBarrier)
GetProcAddress(g_Kernel32, "InitializeSynchronizationBarrier");
pfnEnterSynchronizationBarrier = (fnEnterSynchronizationBarrier)
GetProcAddress(g_Kernel32, "EnterSynchronizationBarrier");
pfnDeleteSynchronizationBarrier = (fnDeleteSynchronizationBarrier)
GetProcAddress(g_Kernel32, "DeleteSynchronizationBarrier");
if (pfnInitializeSynchronizationBarrier && pfnEnterSynchronizationBarrier
&& pfnDeleteSynchronizationBarrier)
{
g_NativeBarrier = TRUE;
}
return TRUE;
}
#endif
BOOL WINAPI InitializeSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier, LONG lTotalThreads, LONG lSpinCount)
{
WINPR_BARRIER* pBarrier;
#ifdef _WIN32
InitOnceExecuteOnce(&g_InitOnce, InitOnce_Barrier, NULL, NULL);
if (g_NativeBarrier)
return pfnInitializeSynchronizationBarrier(lpBarrier, lTotalThreads, lSpinCount);
#endif
if (!lpBarrier)
return FALSE;
ZeroMemory(lpBarrier, sizeof(SYNCHRONIZATION_BARRIER));
pBarrier = (WINPR_BARRIER*) calloc(1, sizeof(WINPR_BARRIER));
if (!pBarrier)
return FALSE;
if (lSpinCount < 0)
lSpinCount = 2000;
pBarrier->lTotalThreads = lTotalThreads;
pBarrier->lSpinCount = lSpinCount;
pBarrier->count = 0;
pBarrier->event = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!pBarrier->event)
{
free(pBarrier);
return FALSE;
}
lpBarrier->Reserved3[0] = (ULONG_PTR) pBarrier;
return TRUE;
}
BOOL WINAPI EnterSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier, DWORD dwFlags)
{
LONG count;
BOOL status = FALSE;
WINPR_BARRIER* pBarrier;
#ifdef _WIN32
if (g_NativeBarrier)
return pfnEnterSynchronizationBarrier(lpBarrier, dwFlags);
#endif
if (!lpBarrier)
return FALSE;
pBarrier = (WINPR_BARRIER*) lpBarrier->Reserved3[0];
if (!pBarrier)
return FALSE;
count = InterlockedIncrement(&(pBarrier->count));
if (count < pBarrier->lTotalThreads)
{
WaitForSingleObject(pBarrier->event, INFINITE);
}
else
{
SetEvent(pBarrier->event);
status = TRUE;
}
InterlockedDecrement(&(pBarrier->count));
return status;
}
BOOL WINAPI DeleteSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier)
{
WINPR_BARRIER* pBarrier;
#ifdef _WIN32
if (g_NativeBarrier)
return pfnDeleteSynchronizationBarrier(lpBarrier);
#endif
if (!lpBarrier)
return TRUE;
pBarrier = (WINPR_BARRIER*) lpBarrier->Reserved3[0];
if (!pBarrier)
return TRUE;
while (InterlockedCompareExchange(&pBarrier->count, 0, 0) != 0)
Sleep(100);
CloseHandle(pBarrier->event);
free(pBarrier);
ZeroMemory(lpBarrier, sizeof(SYNCHRONIZATION_BARRIER));
return TRUE;
}
#endif