8cc6582044
* Unified enum/struct definitions, fixed include issues * Fixed mac compilation issues * Added missing include * Fixed windows server build warnings * Fixed VS2010 build issue * Removed unnecessary library linking * Fixed ThreadPool WinXP compatibility * Fixed pr review remarks
188 lines
4.9 KiB
C
188 lines
4.9 KiB
C
/**
|
|
* WinPR: Windows Portable Runtime
|
|
* Thread Pool API (Work)
|
|
*
|
|
* 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/crt.h>
|
|
#include <winpr/pool.h>
|
|
#include <winpr/library.h>
|
|
|
|
#include "pool.h"
|
|
#include "../log.h"
|
|
#define TAG WINPR_TAG("pool")
|
|
|
|
#ifdef WINPR_THREAD_POOL
|
|
|
|
#ifdef _WIN32
|
|
static INIT_ONCE init_once_module = INIT_ONCE_STATIC_INIT;
|
|
static PTP_WORK(WINAPI* pCreateThreadpoolWork)(PTP_WORK_CALLBACK pfnwk, PVOID pv,
|
|
PTP_CALLBACK_ENVIRON pcbe);
|
|
static VOID(WINAPI* pCloseThreadpoolWork)(PTP_WORK pwk);
|
|
static VOID(WINAPI* pSubmitThreadpoolWork)(PTP_WORK pwk);
|
|
static BOOL(WINAPI* pTrySubmitThreadpoolCallback)(PTP_SIMPLE_CALLBACK pfns, PVOID pv,
|
|
PTP_CALLBACK_ENVIRON pcbe);
|
|
static VOID(WINAPI* pWaitForThreadpoolWorkCallbacks)(PTP_WORK pwk, BOOL fCancelPendingCallbacks);
|
|
|
|
static BOOL CALLBACK init_module(PINIT_ONCE once, PVOID param, PVOID* context)
|
|
{
|
|
HMODULE kernel32 = LoadLibraryA("kernel32.dll");
|
|
|
|
if (kernel32)
|
|
{
|
|
pCreateThreadpoolWork = (void*)GetProcAddress(kernel32, "CreateThreadpoolWork");
|
|
pCloseThreadpoolWork = (void*)GetProcAddress(kernel32, "CloseThreadpoolWork");
|
|
pSubmitThreadpoolWork = (void*)GetProcAddress(kernel32, "SubmitThreadpoolWork");
|
|
pTrySubmitThreadpoolCallback =
|
|
(void*)GetProcAddress(kernel32, "TrySubmitThreadpoolCallback");
|
|
pWaitForThreadpoolWorkCallbacks =
|
|
(void*)GetProcAddress(kernel32, "WaitForThreadpoolWorkCallbacks");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
static TP_CALLBACK_ENVIRON DEFAULT_CALLBACK_ENVIRONMENT = {
|
|
1, /* Version */
|
|
NULL, /* Pool */
|
|
NULL, /* CleanupGroup */
|
|
NULL, /* CleanupGroupCancelCallback */
|
|
NULL, /* RaceDll */
|
|
NULL, /* FinalizationCallback */
|
|
{ 0 } /* Flags */
|
|
};
|
|
|
|
PTP_WORK winpr_CreateThreadpoolWork(PTP_WORK_CALLBACK pfnwk, PVOID pv, PTP_CALLBACK_ENVIRON pcbe)
|
|
{
|
|
PTP_WORK work = NULL;
|
|
#ifdef _WIN32
|
|
InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
|
|
|
|
if (pCreateThreadpoolWork)
|
|
return pCreateThreadpoolWork(pfnwk, pv, pcbe);
|
|
|
|
#endif
|
|
work = (PTP_WORK)calloc(1, sizeof(TP_WORK));
|
|
|
|
if (work)
|
|
{
|
|
if (!pcbe)
|
|
{
|
|
pcbe = &DEFAULT_CALLBACK_ENVIRONMENT;
|
|
pcbe->Pool = GetDefaultThreadpool();
|
|
}
|
|
|
|
work->CallbackEnvironment = pcbe;
|
|
work->WorkCallback = pfnwk;
|
|
work->CallbackParameter = pv;
|
|
#ifndef _WIN32
|
|
|
|
if (pcbe->CleanupGroup)
|
|
ArrayList_Append(pcbe->CleanupGroup->groups, work);
|
|
|
|
#endif
|
|
}
|
|
|
|
return work;
|
|
}
|
|
|
|
VOID winpr_CloseThreadpoolWork(PTP_WORK pwk)
|
|
{
|
|
#ifdef _WIN32
|
|
InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
|
|
|
|
if (pCloseThreadpoolWork)
|
|
{
|
|
pCloseThreadpoolWork(pwk);
|
|
return;
|
|
}
|
|
|
|
#else
|
|
|
|
if (pwk->CallbackEnvironment->CleanupGroup)
|
|
ArrayList_Remove(pwk->CallbackEnvironment->CleanupGroup->groups, pwk);
|
|
|
|
#endif
|
|
free(pwk);
|
|
}
|
|
|
|
VOID winpr_SubmitThreadpoolWork(PTP_WORK pwk)
|
|
{
|
|
PTP_POOL pool;
|
|
PTP_CALLBACK_INSTANCE callbackInstance;
|
|
#ifdef _WIN32
|
|
InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
|
|
|
|
if (pSubmitThreadpoolWork)
|
|
{
|
|
pSubmitThreadpoolWork(pwk);
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
pool = pwk->CallbackEnvironment->Pool;
|
|
callbackInstance = (PTP_CALLBACK_INSTANCE)calloc(1, sizeof(TP_CALLBACK_INSTANCE));
|
|
|
|
if (callbackInstance)
|
|
{
|
|
callbackInstance->Work = pwk;
|
|
CountdownEvent_AddCount(pool->WorkComplete, 1);
|
|
Queue_Enqueue(pool->PendingQueue, callbackInstance);
|
|
}
|
|
}
|
|
|
|
BOOL winpr_TrySubmitThreadpoolCallback(PTP_SIMPLE_CALLBACK pfns, PVOID pv,
|
|
PTP_CALLBACK_ENVIRON pcbe)
|
|
{
|
|
#ifdef _WIN32
|
|
InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
|
|
|
|
if (pTrySubmitThreadpoolCallback)
|
|
return pTrySubmitThreadpoolCallback(pfns, pv, pcbe);
|
|
|
|
#endif
|
|
WLog_ERR(TAG, "TrySubmitThreadpoolCallback is not implemented");
|
|
return FALSE;
|
|
}
|
|
|
|
VOID winpr_WaitForThreadpoolWorkCallbacks(PTP_WORK pwk, BOOL fCancelPendingCallbacks)
|
|
{
|
|
HANDLE event;
|
|
PTP_POOL pool;
|
|
#ifdef _WIN32
|
|
InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
|
|
|
|
if (pWaitForThreadpoolWorkCallbacks)
|
|
{
|
|
pWaitForThreadpoolWorkCallbacks(pwk, fCancelPendingCallbacks);
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
pool = pwk->CallbackEnvironment->Pool;
|
|
event = CountdownEvent_WaitHandle(pool->WorkComplete);
|
|
|
|
if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0)
|
|
WLog_ERR(TAG, "error waiting on work completion");
|
|
}
|
|
|
|
#endif /* WINPR_THREAD_POOL defined */
|