/**

 * WinPR: Windows Portable Runtime

 * Thread Pool API (Pool)

 *

 * 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.

 */

#include <winpr/config.h>

#include <winpr/crt.h>

#include <winpr/sysinfo.h>

#include <winpr/pool.h>

#include <winpr/library.h>

#include "pool.h"

#ifdef WINPR_THREAD_POOL

#ifdef _WIN32

static INIT_ONCE init_once_module = INIT_ONCE_STATIC_INIT;

static PTP_POOL(WINAPI* pCreateThreadpool)(PVOID reserved);

static VOID(WINAPI* pCloseThreadpool)(PTP_POOL ptpp);

static BOOL(WINAPI* pSetThreadpoolThreadMinimum)(PTP_POOL ptpp, DWORD cthrdMic);

static VOID(WINAPI* pSetThreadpoolThreadMaximum)(PTP_POOL ptpp, DWORD cthrdMost);

static BOOL CALLBACK init_module(PINIT_ONCE once, PVOID param, PVOID* context)

{

  HMODULE kernel32 = LoadLibraryA("kernel32.dll");

  if (kernel32)

  {

    pCreateThreadpool = GetProcAddressAs(kernel32, "CreateThreadpool", void*);

    pCloseThreadpool = GetProcAddressAs(kernel32, "CloseThreadpool", void*);

    pSetThreadpoolThreadMinimum =

        GetProcAddressAs(kernel32, "SetThreadpoolThreadMinimum", void*);

    pSetThreadpoolThreadMaximum =

        GetProcAddressAs(kernel32, "SetThreadpoolThreadMaximum", void*);

  }

  return TRUE;

}

#endif

static TP_POOL DEFAULT_POOL = {

  0,       /* DWORD Minimum */

  500,     /* DWORD Maximum */

  nullptr, /* wArrayList* Threads */

  nullptr, /* wQueue* PendingQueue */

  nullptr, /* HANDLE TerminateEvent */

  nullptr, /* wCountdownEvent* WorkComplete */

};

static DWORD WINAPI thread_pool_work_func(LPVOID arg)

{

  DWORD status = 0;

  PTP_POOL pool = nullptr;

  PTP_WORK work = nullptr;

  HANDLE events[2];

  PTP_CALLBACK_INSTANCE callbackInstance = nullptr;

  pool = (PTP_POOL)arg;

  events[0] = pool->TerminateEvent;

  events[1] = Queue_Event(pool->PendingQueue);

  while (1)

  {

    status = WaitForMultipleObjects(2, events, FALSE, INFINITE);

    if (status == WAIT_OBJECT_0)

      break;

    if (status != (WAIT_OBJECT_0 + 1))

      break;

    callbackInstance = (PTP_CALLBACK_INSTANCE)Queue_Dequeue(pool->PendingQueue);

    if (callbackInstance)

    {

      work = callbackInstance->Work;

      work->WorkCallback(callbackInstance, work->CallbackParameter, work);

      CountdownEvent_Signal(pool->WorkComplete, 1);

      free(callbackInstance);

    }

  }

  ExitThread(0);

  return 0;

}

static void threads_close(void* thread)

{

  (void)WaitForSingleObject(thread, INFINITE);

  (void)CloseHandle(thread);

}

static BOOL InitializeThreadpool(PTP_POOL pool)

{

  BOOL rc = FALSE;

  wObject* obj = nullptr;

  if (pool->Threads)

    return TRUE;

  if (!(pool->PendingQueue = Queue_New(TRUE, -1, -1)))

    goto fail;

  if (!(pool->WorkComplete = CountdownEvent_New(0)))

    goto fail;

  if (!(pool->TerminateEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))

    goto fail;

  if (!(pool->Threads = ArrayList_New(TRUE)))

    goto fail;

  obj = ArrayList_Object(pool->Threads);

  obj->fnObjectFree = threads_close;

#if !defined(WINPR_THREADPOOL_DEFAULT_MIN_COUNT)

#error "WINPR_THREADPOOL_DEFAULT_MIN_COUNT must be defined"

#endif

#if !defined(WINPR_THREADPOOL_DEFAULT_MAX_COUNT)

#error "WINPR_THREADPOOL_DEFAULT_MAX_COUNT must be defined"

#endif

  {

    SYSTEM_INFO info = WINPR_C_ARRAY_INIT;

    GetSystemInfo(&info);

    DWORD min = info.dwNumberOfProcessors;

    DWORD max = info.dwNumberOfProcessors;

    if (info.dwNumberOfProcessors < WINPR_THREADPOOL_DEFAULT_MIN_COUNT)

      min = WINPR_THREADPOOL_DEFAULT_MIN_COUNT;

    if (info.dwNumberOfProcessors > WINPR_THREADPOOL_DEFAULT_MAX_COUNT)

      max = WINPR_THREADPOOL_DEFAULT_MAX_COUNT;

    if (min > max)

      min = max;

    if (!SetThreadpoolThreadMinimum(pool, min))

      goto fail;

    SetThreadpoolThreadMaximum(pool, max);

  }

  rc = TRUE;

fail:

  return rc;

}

PTP_POOL GetDefaultThreadpool(void)

{

  PTP_POOL pool = &DEFAULT_POOL;

  if (!InitializeThreadpool(pool))

    return nullptr;

  return pool;

}

PTP_POOL winpr_CreateThreadpool(PVOID reserved)

{

  PTP_POOL pool = nullptr;

#ifdef _WIN32

  if (!InitOnceExecuteOnce(&init_once_module, init_module, nullptr, nullptr))

    return nullptr;

  if (pCreateThreadpool)

    return pCreateThreadpool(reserved);

#else

  WINPR_UNUSED(reserved);

#endif

  if (!(pool = (PTP_POOL)calloc(1, sizeof(TP_POOL))))

    return nullptr;

  if (!InitializeThreadpool(pool))

  {

    winpr_CloseThreadpool(pool);

    return nullptr;

  }

  return pool;

}

VOID winpr_CloseThreadpool(PTP_POOL ptpp)

{

#ifdef _WIN32

  if (!InitOnceExecuteOnce(&init_once_module, init_module, nullptr, nullptr))

    return;

  if (pCloseThreadpool)

  {

    pCloseThreadpool(ptpp);

    return;

  }

#endif

  (void)SetEvent(ptpp->TerminateEvent);

  ArrayList_Free(ptpp->Threads);

  Queue_Free(ptpp->PendingQueue);

  CountdownEvent_Free(ptpp->WorkComplete);

  (void)CloseHandle(ptpp->TerminateEvent);

  {

    TP_POOL empty = WINPR_C_ARRAY_INIT;

    *ptpp = empty;

  }

  if (ptpp != &DEFAULT_POOL)

    free(ptpp);

}

BOOL winpr_SetThreadpoolThreadMinimum(PTP_POOL ptpp, DWORD cthrdMic)

{

  BOOL rc = FALSE;

#ifdef _WIN32

  if (!InitOnceExecuteOnce(&init_once_module, init_module, nullptr, nullptr))

    return FALSE;

  if (pSetThreadpoolThreadMinimum)

    return pSetThreadpoolThreadMinimum(ptpp, cthrdMic);

#endif

  ptpp->Minimum = cthrdMic;

  ArrayList_Lock(ptpp->Threads);

  while (ArrayList_Count(ptpp->Threads) < ptpp->Minimum)

  {

    HANDLE thread = CreateThread(nullptr, 0, thread_pool_work_func, (void*)ptpp, 0, nullptr);

    if (!thread)

      goto fail;

    if (!ArrayList_Append(ptpp->Threads, thread))

    {

      (void)CloseHandle(thread);

      goto fail;

    }

  }

  rc = TRUE;

fail:

  ArrayList_Unlock(ptpp->Threads);

  return rc;

}

VOID winpr_SetThreadpoolThreadMaximum(PTP_POOL ptpp, DWORD cthrdMost)

{

#ifdef _WIN32

  if (!InitOnceExecuteOnce(&init_once_module, init_module, nullptr, nullptr))

    return;

  if (pSetThreadpoolThreadMaximum)

  {

    pSetThreadpoolThreadMaximum(ptpp, cthrdMost);

    return;

  }

#endif

  ptpp->Maximum = cthrdMost;

  ArrayList_Lock(ptpp->Threads);

  if (ArrayList_Count(ptpp->Threads) > ptpp->Maximum)

  {

    (void)SetEvent(ptpp->TerminateEvent);

    ArrayList_Clear(ptpp->Threads);

    (void)ResetEvent(ptpp->TerminateEvent);

  }

  ArrayList_Unlock(ptpp->Threads);

  winpr_SetThreadpoolThreadMinimum(ptpp, ptpp->Minimum);

}

#endif /* WINPR_THREAD_POOL defined */