ObjectPool.c

 
#include <winpr/config.h>
 
#include <winpr/crt.h>
#include <winpr/assert.h>
 
#include <winpr/collections.h>
 
struct s_wObjectPool
{
  size_t size;
  size_t capacity;
  void** array;
  CRITICAL_SECTION lock;
  wObject object;
  BOOL synchronized;
};
 
static void ObjectPool_Lock(wObjectPool* pool)
{
  WINPR_ASSERT(pool);
  if (pool->synchronized)
    EnterCriticalSection(&pool->lock);
}
 
static void ObjectPool_Unlock(wObjectPool* pool)
{
  WINPR_ASSERT(pool);
  if (pool->synchronized)
    LeaveCriticalSection(&pool->lock);
}
 
void* ObjectPool_Take(wObjectPool* pool)
{
  void* obj = nullptr;
 
  ObjectPool_Lock(pool);
 
  if (pool->size > 0)
    obj = pool->array[--(pool->size)];
 
  if (!obj)
  {
    if (pool->object.fnObjectNew)
      obj = pool->object.fnObjectNew(nullptr);
  }
 
  if (pool->object.fnObjectInit)
    pool->object.fnObjectInit(obj);
 
  ObjectPool_Unlock(pool);
 
  return obj;
}
 
static BOOL ObjectPool_EnsureCapacity(wObjectPool* pool, size_t add)
{
  WINPR_ASSERT(pool->size < SIZE_MAX - add);
 
  const size_t blocksize = 128ull;
  const size_t required = pool->size + add;
  if (required >= pool->capacity)
  {
    const size_t new_cap = required + blocksize - required % blocksize;
 
    void** new_arr = (void**)realloc((void*)pool->array, sizeof(void*) * new_cap);
    if (!new_arr)
      return FALSE;
 
    pool->array = new_arr;
    pool->capacity = new_cap;
  }
  return TRUE;
}
 
void ObjectPool_Return(wObjectPool* pool, void* obj)
{
  ObjectPool_Lock(pool);
 
  if (!ObjectPool_EnsureCapacity(pool, 1))
    goto out;
 
  pool->array[(pool->size)++] = obj;
 
  if (pool->object.fnObjectUninit)
    pool->object.fnObjectUninit(obj);
 
out:
  ObjectPool_Unlock(pool);
}
 
wObject* ObjectPool_Object(wObjectPool* pool)
{
  WINPR_ASSERT(pool);
  return &pool->object;
}
 
void ObjectPool_Clear(wObjectPool* pool)
{
  ObjectPool_Lock(pool);
 
  while (pool->size > 0)
  {
    (pool->size)--;
 
    if (pool->object.fnObjectFree)
      pool->object.fnObjectFree(pool->array[pool->size]);
  }
 
  ObjectPool_Unlock(pool);
}
 
wObjectPool* ObjectPool_New(BOOL synchronized)
{
  wObjectPool* pool = (wObjectPool*)calloc(1, sizeof(wObjectPool));
 
  if (!pool)
    goto fail;
 
  pool->synchronized = synchronized;
 
  if (pool->synchronized)
  {
    if (!InitializeCriticalSectionAndSpinCount(&pool->lock, 4000))
      goto fail;
  }
 
  if (!ObjectPool_EnsureCapacity(pool, 32))
    goto fail;
 
  return pool;
 
fail:
  ObjectPool_Free(pool);
  return nullptr;
}
 
void ObjectPool_Free(wObjectPool* pool)
{
  if (!pool)
    return;
 
  ObjectPool_Clear(pool);
 
  if (pool->synchronized)
    DeleteCriticalSection(&pool->lock);
 
  free((void*)pool->array);
 
  free(pool);
}