/*
 * Copyright (c) 2004-2006 Voltaire, Inc. All rights reserved.
 * Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved.
 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

/*
 * Abstract:
 *	Implementation of the grow pools.  The grow pools manage a pool of objects.
 *	The pools can grow to meet demand, limited only by system memory.
 *
 */

#if HAVE_CONFIG_H
#  include <config.h>
#endif				/* HAVE_CONFIG_H */

#include <stdlib.h>
#include <string.h>
#include <complib/cl_qcomppool.h>
#include <complib/cl_comppool.h>
#include <complib/cl_qpool.h>
#include <complib/cl_pool.h>
#include <complib/cl_math.h>

/*
 * IMPLEMENTATION OF QUICK COMPOSITE POOL
 */
void cl_qcpool_construct(IN cl_qcpool_t * const p_pool)
{
	CL_ASSERT(p_pool);

	memset(p_pool, 0, sizeof(cl_qcpool_t));

	p_pool->state = CL_UNINITIALIZED;
}

cl_status_t
cl_qcpool_init(IN cl_qcpool_t * const p_pool,
	       IN const size_t min_size,
	       IN const size_t max_size,
	       IN const size_t grow_size,
	       IN const size_t * const component_sizes,
	       IN const uint32_t num_components,
	       IN cl_pfn_qcpool_init_t pfn_initializer OPTIONAL,
	       IN cl_pfn_qcpool_dtor_t pfn_destructor OPTIONAL,
	       IN const void *const context)
{
	cl_status_t status;
	uint32_t i;

	CL_ASSERT(p_pool);
	/* Must have a minimum of 1 component. */
	CL_ASSERT(num_components);
	/* A component size array is required. */
	CL_ASSERT(component_sizes);
	/*
	 * If no initializer is provided, the first component must be large
	 * enough to hold a pool item.
	 */
	CL_ASSERT(pfn_initializer ||
		  (component_sizes[0] >= sizeof(cl_pool_item_t)));

	cl_qcpool_construct(p_pool);

	if (num_components > 1 && !pfn_initializer)
		return (CL_INVALID_SETTING);

	if (max_size && max_size < min_size)
		return (CL_INVALID_SETTING);

	/*
	 * Allocate the array of component sizes and component pointers all
	 * in one allocation.
	 */
	p_pool->component_sizes = (size_t *) malloc((sizeof(size_t) +
						     sizeof(void *)) *
						    num_components);

	if (!p_pool->component_sizes)
		return (CL_INSUFFICIENT_MEMORY);
	else
		memset(p_pool->component_sizes, 0,
		       (sizeof(size_t) + sizeof(void *)) * num_components);

	/* Calculate the pointer to the array of pointers, used for callbacks. */
	p_pool->p_components =
	    (void **)(p_pool->component_sizes + num_components);

	/* Copy the user's sizes into our array for future use. */
	memcpy(p_pool->component_sizes, component_sizes,
	       sizeof(component_sizes[0]) * num_components);

	/* Store the number of components per object. */
	p_pool->num_components = num_components;

	/* Round up and store the size of the components. */
	for (i = 0; i < num_components; i++) {
		/*
		 * We roundup each component size so that all components
		 * are aligned on a natural boundary.
		 */
		p_pool->component_sizes[i] =
		    ROUNDUP(p_pool->component_sizes[i], sizeof(uintn_t));
	}

	p_pool->max_objects = max_size ? max_size : ~(size_t) 0;
	p_pool->grow_size = grow_size;

	/* Store callback function pointers. */
	p_pool->pfn_init = pfn_initializer;	/* may be NULL */
	p_pool->pfn_dtor = pfn_destructor;	/* may be NULL */
	p_pool->context = context;

	cl_qlist_init(&p_pool->alloc_list);

	cl_qlist_init(&p_pool->free_list);

	/*
	 * We are now initialized.  We change the initialized flag before
	 * growing since the grow function asserts that we are initialized.
	 */
	p_pool->state = CL_INITIALIZED;

	/* Allocate the minimum number of objects as requested. */
	if (!min_size)
		return (CL_SUCCESS);

	status = cl_qcpool_grow(p_pool, min_size);
	/* Trap for error and cleanup if necessary. */
	if (status != CL_SUCCESS)
		cl_qcpool_destroy(p_pool);

	return (status);
}

void cl_qcpool_destroy(IN cl_qcpool_t * const p_pool)
{
	/* CL_ASSERT that a non-NULL pointer was provided. */
	CL_ASSERT(p_pool);
	/* CL_ASSERT that we are in a valid state (not uninitialized memory). */
	CL_ASSERT(cl_is_state_valid(p_pool->state));

	if (p_pool->state == CL_INITIALIZED) {
		/*
		 * Assert if the user hasn't put everything back in the pool
		 * before destroying it
		 * if they haven't, then most likely they are still using memory
		 * that will be freed, and the destructor will not be called!
		 */
#ifdef _DEBUG_
		/* but we do not want "free" version to assert on this one */
		CL_ASSERT(cl_qcpool_count(p_pool) == p_pool->num_objects);
#endif
		/* call the user's destructor for each object in the pool */
		if (p_pool->pfn_dtor) {
			while (!cl_is_qlist_empty(&p_pool->free_list)) {
				p_pool->pfn_dtor((cl_pool_item_t *)
						 cl_qlist_remove_head(&p_pool->
								      free_list),
						 (void *)p_pool->context);
			}
		} else {
			cl_qlist_remove_all(&p_pool->free_list);
		}

		/* Free all allocated memory blocks. */
		while (!cl_is_qlist_empty(&p_pool->alloc_list))
			free(cl_qlist_remove_head(&p_pool->alloc_list));

		if (p_pool->component_sizes) {
			free(p_pool->component_sizes);
			p_pool->component_sizes = NULL;
		}
	}

	p_pool->state = CL_UNINITIALIZED;
}

cl_status_t cl_qcpool_grow(IN cl_qcpool_t * const p_pool, IN size_t obj_count)
{
	cl_status_t status = CL_SUCCESS;
	uint8_t *p_objects;
	cl_pool_item_t *p_pool_item;
	uint32_t i;
	size_t obj_size;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->state == CL_INITIALIZED);
	CL_ASSERT(obj_count);

	/* Validate that growth is possible. */
	if (p_pool->num_objects == p_pool->max_objects)
		return (CL_INSUFFICIENT_MEMORY);

	/* Cap the growth to the desired maximum. */
	if (obj_count > (p_pool->max_objects - p_pool->num_objects))
		obj_count = p_pool->max_objects - p_pool->num_objects;

	/* Calculate the size of an object. */
	obj_size = 0;
	for (i = 0; i < p_pool->num_components; i++)
		obj_size += p_pool->component_sizes[i];

	/* Allocate the buffer for the new objects. */
	p_objects = (uint8_t *)
	    malloc(sizeof(cl_list_item_t) + (obj_size * obj_count));

	/* Make sure the allocation succeeded. */
	if (!p_objects)
		return (CL_INSUFFICIENT_MEMORY);
	else
		memset(p_objects, 0,
		       sizeof(cl_list_item_t) + (obj_size * obj_count));

	/* Insert the allocation in our list. */
	cl_qlist_insert_tail(&p_pool->alloc_list, (cl_list_item_t *) p_objects);
	p_objects += sizeof(cl_list_item_t);

	/* initialize the new elements and add them to the free list */
	while (obj_count--) {
		/* Setup the array of components for the current object. */
		p_pool->p_components[0] = p_objects;
		for (i = 1; i < p_pool->num_components; i++) {
			/* Calculate the pointer to the next component. */
			p_pool->p_components[i] =
			    (uint8_t *) p_pool->p_components[i - 1] +
			    p_pool->component_sizes[i - 1];
		}

		/*
		 * call the user's initializer
		 * this can fail!
		 */
		if (p_pool->pfn_init) {
			p_pool_item = NULL;
			status = p_pool->pfn_init(p_pool->p_components,
						  p_pool->num_components,
						  (void *)p_pool->context,
						  &p_pool_item);
			if (status != CL_SUCCESS) {
				/*
				 * User initialization failed
				 * we may have only grown the pool by some partial amount
				 * Invoke the destructor for the object that failed
				 * initialization.
				 */
				if (p_pool->pfn_dtor)
					p_pool->pfn_dtor(p_pool_item,
							 (void *)p_pool->
							 context);

				/* Return the user's status. */
				return (status);
			}
			CL_ASSERT(p_pool_item);
		} else {
			/*
			 * If no initializer is provided, assume that the pool item
			 * is stored at the beginning of the first component.
			 */
			p_pool_item =
			    (cl_pool_item_t *) p_pool->p_components[0];
		}

#ifdef _DEBUG_
		/*
		 * Set the pool item's pool pointer to this pool so that we can
		 * check that items get returned to the correct pool.
		 */
		p_pool_item->p_pool = p_pool;
#endif

		/* Insert the new item in the free list, traping for failure. */
		cl_qlist_insert_head(&p_pool->free_list,
				     &p_pool_item->list_item);

		p_pool->num_objects++;

		/* move the pointer to the next item */
		p_objects += obj_size;
	}

	return (status);
}

cl_pool_item_t *cl_qcpool_get(IN cl_qcpool_t * const p_pool)
{
	cl_list_item_t *p_list_item;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->state == CL_INITIALIZED);

	if (cl_is_qlist_empty(&p_pool->free_list)) {
		/*
		 * No object is available.
		 * Return NULL if the user does not want automatic growth.
		 */
		if (!p_pool->grow_size)
			return (NULL);

		/* We ran out of elements.  Get more */
		cl_qcpool_grow(p_pool, p_pool->grow_size);
		/*
		 * We may not have gotten everything we wanted but we might have
		 * gotten something.
		 */
		if (cl_is_qlist_empty(&p_pool->free_list))
			return (NULL);
	}

	p_list_item = cl_qlist_remove_head(&p_pool->free_list);
	/* OK, at this point we have an object */
	CL_ASSERT(p_list_item != cl_qlist_end(&p_pool->free_list));
	return ((cl_pool_item_t *) p_list_item);
}

cl_pool_item_t *cl_qcpool_get_tail(IN cl_qcpool_t * const p_pool)
{
	cl_list_item_t *p_list_item;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->state == CL_INITIALIZED);

	if (cl_is_qlist_empty(&p_pool->free_list)) {
		/*
		 * No object is available.
		 * Return NULL if the user does not want automatic growth.
		 */
		if (!p_pool->grow_size)
			return (NULL);

		/* We ran out of elements.  Get more */
		cl_qcpool_grow(p_pool, p_pool->grow_size);
		/*
		 * We may not have gotten everything we wanted but we might have
		 * gotten something.
		 */
		if (cl_is_qlist_empty(&p_pool->free_list))
			return (NULL);
	}

	p_list_item = cl_qlist_remove_tail(&p_pool->free_list);
	/* OK, at this point we have an object */
	CL_ASSERT(p_list_item != cl_qlist_end(&p_pool->free_list));
	return ((cl_pool_item_t *) p_list_item);
}

/*
 * IMPLEMENTATION OF QUICK GROW POOL
 */

/*
 * Callback to translate quick composite to quick grow pool
 * initializer callback.
 */
static cl_status_t
__cl_qpool_init_cb(IN void **const p_comp_array,
		   IN const uint32_t num_components,
		   IN void *const context,
		   OUT cl_pool_item_t ** const pp_pool_item)
{
	cl_qpool_t *p_pool = (cl_qpool_t *) context;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->pfn_init);
	CL_ASSERT(num_components == 1);

	UNUSED_PARAM(num_components);

	return (p_pool->pfn_init(p_comp_array[0], (void *)p_pool->context,
				 pp_pool_item));
}

/*
 * Callback to translate quick composite to quick grow pool
 * destructor callback.
 */
static void
__cl_qpool_dtor_cb(IN const cl_pool_item_t * const p_pool_item,
		   IN void *const context)
{
	cl_qpool_t *p_pool = (cl_qpool_t *) context;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->pfn_dtor);

	p_pool->pfn_dtor(p_pool_item, (void *)p_pool->context);
}

void cl_qpool_construct(IN cl_qpool_t * const p_pool)
{
	memset(p_pool, 0, sizeof(cl_qpool_t));

	cl_qcpool_construct(&p_pool->qcpool);
}

cl_status_t
cl_qpool_init(IN cl_qpool_t * const p_pool,
	      IN const size_t min_size,
	      IN const size_t max_size,
	      IN const size_t grow_size,
	      IN const size_t object_size,
	      IN cl_pfn_qpool_init_t pfn_initializer OPTIONAL,
	      IN cl_pfn_qpool_dtor_t pfn_destructor OPTIONAL,
	      IN const void *const context)
{
	cl_status_t status;

	CL_ASSERT(p_pool);

	p_pool->pfn_init = pfn_initializer;	/* may be NULL */
	p_pool->pfn_dtor = pfn_destructor;	/* may be NULL */
	p_pool->context = context;

	status = cl_qcpool_init(&p_pool->qcpool, min_size, max_size, grow_size,
				&object_size, 1,
				pfn_initializer ? __cl_qpool_init_cb : NULL,
				pfn_destructor ? __cl_qpool_dtor_cb : NULL,
				p_pool);

	return (status);
}

/*
 * IMPLEMENTATION OF COMPOSITE POOL
 */

/*
 * Callback to translate quick composite to compsite pool
 * initializer callback.
 */
static cl_status_t
__cl_cpool_init_cb(IN void **const p_comp_array,
		   IN const uint32_t num_components,
		   IN void *const context,
		   OUT cl_pool_item_t ** const pp_pool_item)
{
	cl_cpool_t *p_pool = (cl_cpool_t *) context;
	cl_pool_obj_t *p_pool_obj;
	cl_status_t status = CL_SUCCESS;

	CL_ASSERT(p_pool);

	/*
	 * Set our pointer to the list item, which is stored at the beginning of
	 * the first component.
	 */
	p_pool_obj = (cl_pool_obj_t *) p_comp_array[0];
	/* Set the pool item pointer for the caller. */
	*pp_pool_item = &p_pool_obj->pool_item;

	/* Calculate the pointer to the user's first component. */
	p_comp_array[0] = ((uint8_t *) p_comp_array[0]) + sizeof(cl_pool_obj_t);

	/*
	 * Set the object pointer in the pool object to point to the first of the
	 * user's components.
	 */
	p_pool_obj->p_object = p_comp_array[0];

	/* Invoke the user's constructor callback. */
	if (p_pool->pfn_init) {
		status = p_pool->pfn_init(p_comp_array, num_components,
					  (void *)p_pool->context);
	}

	return (status);
}

/*
 * Callback to translate quick composite to composite pool
 * destructor callback.
 */
static void
__cl_cpool_dtor_cb(IN const cl_pool_item_t * const p_pool_item,
		   IN void *const context)
{
	cl_cpool_t *p_pool = (cl_cpool_t *) context;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->pfn_dtor);
	CL_ASSERT(((cl_pool_obj_t *) p_pool_item)->p_object);

	/* Invoke the user's destructor callback. */
	p_pool->pfn_dtor((void *)((cl_pool_obj_t *) p_pool_item)->p_object,
			 (void *)p_pool->context);
}

void cl_cpool_construct(IN cl_cpool_t * const p_pool)
{
	CL_ASSERT(p_pool);

	memset(p_pool, 0, sizeof(cl_cpool_t));

	cl_qcpool_construct(&p_pool->qcpool);
}

cl_status_t
cl_cpool_init(IN cl_cpool_t * const p_pool,
	      IN const size_t min_size,
	      IN const size_t max_size,
	      IN const size_t grow_size,
	      IN size_t * const component_sizes,
	      IN const uint32_t num_components,
	      IN cl_pfn_cpool_init_t pfn_initializer OPTIONAL,
	      IN cl_pfn_cpool_dtor_t pfn_destructor OPTIONAL,
	      IN const void *const context)
{
	cl_status_t status;

	CL_ASSERT(p_pool);
	CL_ASSERT(num_components);
	CL_ASSERT(component_sizes);

	/* Add the size of the pool object to the first component. */
	component_sizes[0] += sizeof(cl_pool_obj_t);

	/* Store callback function pointers. */
	p_pool->pfn_init = pfn_initializer;	/* may be NULL */
	p_pool->pfn_dtor = pfn_destructor;	/* may be NULL */
	p_pool->context = context;

	status = cl_qcpool_init(&p_pool->qcpool, min_size, max_size, grow_size,
				component_sizes, num_components,
				__cl_cpool_init_cb,
				pfn_destructor ? __cl_cpool_dtor_cb : NULL,
				p_pool);

	/* Restore the original value of the first component. */
	component_sizes[0] -= sizeof(cl_pool_obj_t);

	return (status);
}

/*
 * IMPLEMENTATION OF GROW POOL
 */

/*
 * Callback to translate quick composite to grow pool constructor callback.
 */
static cl_status_t
__cl_pool_init_cb(IN void **const pp_obj,
		  IN const uint32_t count,
		  IN void *const context,
		  OUT cl_pool_item_t ** const pp_pool_item)
{
	cl_pool_t *p_pool = (cl_pool_t *) context;
	cl_pool_obj_t *p_pool_obj;
	cl_status_t status = CL_SUCCESS;

	CL_ASSERT(p_pool);
	CL_ASSERT(pp_obj);
	CL_ASSERT(count == 1);

	UNUSED_PARAM(count);

	/*
	 * Set our pointer to the list item, which is stored at the beginning of
	 * the first component.
	 */
	p_pool_obj = (cl_pool_obj_t *) * pp_obj;
	*pp_pool_item = &p_pool_obj->pool_item;

	/* Calculate the pointer to the user's first component. */
	*pp_obj = ((uint8_t *) * pp_obj) + sizeof(cl_pool_obj_t);

	/*
	 * Set the object pointer in the pool item to point to the first of the
	 * user's components.
	 */
	p_pool_obj->p_object = *pp_obj;

	/* Invoke the user's constructor callback. */
	if (p_pool->pfn_init)
		status = p_pool->pfn_init(*pp_obj, (void *)p_pool->context);

	return (status);
}

/*
 * Callback to translate quick composite to grow pool destructor callback.
 */
static void
__cl_pool_dtor_cb(IN const cl_pool_item_t * const p_pool_item,
		  IN void *const context)
{
	cl_pool_t *p_pool = (cl_pool_t *) context;

	CL_ASSERT(p_pool);
	CL_ASSERT(p_pool->pfn_dtor);
	CL_ASSERT(((cl_pool_obj_t *) p_pool_item)->p_object);

	/* Invoke the user's destructor callback. */
	p_pool->pfn_dtor((void *)((cl_pool_obj_t *) p_pool_item)->p_object,
			 (void *)p_pool->context);
}

void cl_pool_construct(IN cl_pool_t * const p_pool)
{
	CL_ASSERT(p_pool);

	memset(p_pool, 0, sizeof(cl_pool_t));

	cl_qcpool_construct(&p_pool->qcpool);
}

cl_status_t
cl_pool_init(IN cl_pool_t * const p_pool,
	     IN const size_t min_size,
	     IN const size_t max_size,
	     IN const size_t grow_size,
	     IN const size_t object_size,
	     IN cl_pfn_pool_init_t pfn_initializer OPTIONAL,
	     IN cl_pfn_pool_dtor_t pfn_destructor OPTIONAL,
	     IN const void *const context)
{
	cl_status_t status;
	size_t total_size;

	CL_ASSERT(p_pool);

	/* Add the size of the list item to the first component. */
	total_size = object_size + sizeof(cl_pool_obj_t);

	/* Store callback function pointers. */
	p_pool->pfn_init = pfn_initializer;	/* may be NULL */
	p_pool->pfn_dtor = pfn_destructor;	/* may be NULL */
	p_pool->context = context;

	/*
	 * We need an initializer in all cases for quick composite pool, since
	 * the user pointer must be manipulated to hide the prefixed cl_pool_obj_t.
	 */
	status = cl_qcpool_init(&p_pool->qcpool, min_size, max_size, grow_size,
				&total_size, 1, __cl_pool_init_cb,
				pfn_destructor ? __cl_pool_dtor_cb : NULL,
				p_pool);

	return (status);
}