FreeRDP/winpr/libwinpr/utils/collections/ObjectPool.c

/**
 * WinPR: Windows Portable Runtime
 * Object 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/assert.h>

#include <winpr/collections.h>

struct s_wObjectPool
{
	size_t size;
	size_t capacity;
	void** array;
	CRITICAL_SECTION lock;
	wObject object;
	BOOL synchronized;
};

/**
 * C Object Pool similar to C# BufferManager Class:
 * http://msdn.microsoft.com/en-us/library/ms405814.aspx
 */

/**
 * Methods
 */

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);
}

/**
 * Gets an object from the pool.
 */

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;
}

/**
 * Returns an object to the pool.
 */

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;
}

/**
 * Releases the buffers currently cached in the pool.
 */

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);
}

/**
 * Construction, Destruction
 */

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);
}