/* BEGIN_ICS_COPYRIGHT3 ****************************************
Copyright (c) 2015, Intel Corporation
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.
* Neither the name of Intel Corporation nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
** END_ICS_COPYRIGHT3 ****************************************/
/* [ICS VERSION STRING: unknown] */
#ifndef _IBA_PUBLIC_IGROWPOOL_H_
#define _IBA_PUBLIC_IGROWPOOL_H_
#include "iba/public/datatypes.h"
#include "iba/public/iobjmgr.h"
#include "iba/public/ilist.h"
#ifdef __cplusplus
extern "C" {
#endif
/****************************************************************************
****************************************************************************
*********** **********
*********** DECLARATION OF QUICK COMPOSITE POOL **********
*********** **********
****************************************************************************
****************************************************************************/
typedef enum _POOL_STATE
{
PoolReset,
PoolInitError,
PoolReady
} POOL_STATE;
/****************************************************************************
* Quick composite pool callback
* function types.
*/
typedef LIST_ITEM* (*QCPOOL_CTOR_FUNC)(
IN void** const pCompArray,
IN uint32 NumComponents,
IN void* const Context );
typedef FSTATUS (*QCPOOL_INIT_FUNC)(
IN LIST_ITEM* const pListItem,
IN void* const Context );
typedef void (*QCPOOL_DTOR_FUNC)(
IN LIST_ITEM* const pListItem,
IN void* const Context );
/****************************************************************************
* Quick composite pool structure.
*/
typedef struct _QCOMP_POOL
{
/* These fields are private and should NOt be directly accessed */
/* Number of components that make up a composite object. */
uint32 m_NumComponents;
/* Array of sizes for components that make up a user object. */
uint32 *m_ComponentSizes;
/* Array of pointers to components, used for constructor callback. */
void **m_pComponents;
/* Number of objects in the pool */
uint32 m_NumObjects;
/* Number of objects to auto-grow */
uint32 m_GrowSize;
/* Pointer to object constructor */
QCPOOL_CTOR_FUNC m_pfnCtor;
/* Pointer to object initializer */
QCPOOL_INIT_FUNC m_pfnInit;
/* Pointer to object destructor */
QCPOOL_DTOR_FUNC m_pfnDtor;
/* Context to pass to callback functions. */
void *m_Context;
/* Stack of available objects */
QUICK_LIST m_FreeList;
/* Object manager holds allocations */
OBJECT_MGR m_ObjMgr;
POOL_STATE m_State;
} QCOMP_POOL;
/****************************************************************************
* Quick composite pool access methods.
*/
/*
* Initialize the state of a quick composite pool.
*/
void
QCompPoolInitState(
IN QCOMP_POOL* const pPool );
/*
* Initialize a quick composite pool.
*/
FSTATUS
QCompPoolInit(
IN QCOMP_POOL* const pPool,
IN const uint32 MinCount,
IN const uint32* const ComponentSizes,
IN const uint32 NumComponents,
IN const uint32 GrowSize,
IN QCPOOL_CTOR_FUNC pfnConstructor,
IN QCPOOL_INIT_FUNC pfnInitializer OPTIONAL,
IN QCPOOL_DTOR_FUNC pfnDestructor OPTIONAL,
IN void* const Context );
/*
* Destroy a quick composite pool.
*/
void
QCompPoolDestroy(
IN QCOMP_POOL* const pPool );
/*
* Returns the number of objects available in a quick composite pool.
*/
static __inline uint32
QCompPoolCount(
IN QCOMP_POOL* const pPool )
{
ASSERT( pPool );
return( QListCount( &pPool->m_FreeList ) );
}
/*
* Get an object from a quick composite pool.
*/
LIST_ITEM*
QCompPoolGet(
IN QCOMP_POOL* const pPool );
/*
* Puts an object back in a quick composite pool.
*/
static __inline void
QCompPoolPut(
IN QCOMP_POOL* const pPool,
IN LIST_ITEM* const pListItem )
{
/* return this lil' doggy to the pool */
QListInsertHead( &pPool->m_FreeList, pListItem );
/* check for funny-business */
ASSERT( QCompPoolCount(pPool) <= pPool->m_NumObjects );
}
/*
* Grows a quick composite pool by the specified number of objects.
*/
FSTATUS
QCompPoolGrow(
IN QCOMP_POOL* const pPool,
IN uint32 ObjCount );
/****************************************************************************
****************************************************************************
*********** **********
*********** DECLARATION OF QUICK GROW POOL **********
*********** **********
****************************************************************************
****************************************************************************/
/****************************************************************************
* Quick grow pool callback function types.
*/
typedef LIST_ITEM* (*QGPOOL_CTOR_FUNC)(
IN void* const pObject,
IN void* const Context );
typedef FSTATUS (*QGPOOL_INIT_FUNC)(
IN LIST_ITEM* const pListItem,
IN void* const Context );
typedef void (*QGPOOL_DTOR_FUNC)(
IN LIST_ITEM* const pListItem,
IN void* const Context );
/****************************************************************************
* Grow pool structure.
*/
typedef struct _QGROW_POOL
{
/* These fields are private and should NOT be directly accessed */
QCOMP_POOL m_QCPool;
QGPOOL_CTOR_FUNC m_pfnCtor;
QGPOOL_INIT_FUNC m_pfnInit;
QGPOOL_DTOR_FUNC m_pfnDtor;
void *m_Context;
} QGROW_POOL;
/****************************************************************************
* Quick grow pool access methods.
*/
/*
* Initializes the state of a quick grow pool.
*/
void
QGrowPoolInitState(
IN QGROW_POOL* const pPool );
/*
* Initializes a quick grow pool.
*/
FSTATUS
QGrowPoolInit(
IN QGROW_POOL* const pPool,
IN const uint32 MinCount,
IN const uint32 ObjectSize,
IN const uint32 GrowSize,
IN QGPOOL_CTOR_FUNC pfnConstructor OPTIONAL,
IN QGPOOL_INIT_FUNC pfnInitializer OPTIONAL,
IN QGPOOL_DTOR_FUNC pnfDestructor OPTIONAL,
IN void* const Context );
/*
* Destroy a quick grow pool.
*/
void
QGrowPoolDestroy(
IN QGROW_POOL* const pPool );
/*
* Gets an object from a quick grow pool.
*/
static __inline LIST_ITEM*
QGrowPoolGet(
IN QGROW_POOL* const pPool )
{
ASSERT( pPool );
return( QCompPoolGet( &pPool->m_QCPool ) );
}
/*
* Puts an object back in the pool.
*/
static __inline void
QGrowPoolPut(
IN QGROW_POOL* const pPool,
LIST_ITEM* const pListItem )
{
ASSERT( pPool );
QCompPoolPut( &pPool->m_QCPool, pListItem );
}
/*
* Grows a quick grow pool by the specified number of objects.
*/
static __inline FSTATUS
QGrowPoolGrow(
IN QGROW_POOL* const pPool,
IN const uint32 ObjCount )
{
ASSERT( pPool );
return( QCompPoolGrow( &pPool->m_QCPool, ObjCount ) );
}
/*
* Returns the number of objects available in a quick grow pool.
*/
static __inline uint32
QGrowPoolCount(
IN QGROW_POOL* const pPool )
{
ASSERT( pPool );
return( QCompPoolCount( &pPool->m_QCPool ) );
}
/****************************************************************************
****************************************************************************
*********** **********
*********** DECLARATION OF COMPOSITE POOL **********
*********** **********
****************************************************************************
****************************************************************************/
/****************************************************************************
* Composite pool callback function types.
*/
typedef void (*CPOOL_CTOR_FUNC)(
IN void** const pCompArray,
IN uint32 NumComponents,
IN void* const Context );
typedef FSTATUS (*CPOOL_INIT_FUNC)(
IN void* const pObject,
IN void* const Context );
typedef void (*CPOOL_DTOR_FUNC)(
IN void* const pObject,
IN void* const Context );
/****************************************************************************
* Composite pool structure.
*/
typedef struct _COMP_POOL
{
/* These fields are private and should NOT be directly accessed */
QCOMP_POOL m_QCPool;
/* Callback pointers. */
CPOOL_CTOR_FUNC m_pfnCtor;
CPOOL_INIT_FUNC m_pfnInit;
CPOOL_DTOR_FUNC m_pfnDtor;
/* Context to pass to callback functions. */
void *m_Context;
} COMP_POOL;
/****************************************************************************
* Composite pool access methods.
*/
/*
* Initializes the state of a composite pool.
*/
void
CompPoolInitState(
IN COMP_POOL* const pCPool );
/*
* Initializes a composite pool.
*/
FSTATUS
CompPoolInit(
IN COMP_POOL* const pCPool,
IN const uint32 MinCount,
IN const uint32* const ComponentSizes,
IN const uint32 NumComponents,
IN const uint32 GrowSize,
IN CPOOL_CTOR_FUNC pfnConstructor,
IN CPOOL_INIT_FUNC pfnInitializer OPTIONAL,
IN CPOOL_DTOR_FUNC pfnDestructor OPTIONAL,
IN void* const Context );
/*
* Destroys a composite pool.
*/
void
CompPoolDestroy(
IN COMP_POOL* const pCPool );
/*
* Gets an object from a composite pool.
*/
static __inline void*
CompPoolGet(
IN COMP_POOL* const pCPool )
{
LIST_ITEM *pListItem;
ASSERT( pCPool );
pListItem = QCompPoolGet( &pCPool->m_QCPool );
if( !pListItem )
return( NULL );
return( QListObj( pListItem ) );
}
/*
* Puts an object back in a composite pool.
*/
static __inline void
CompPoolPut(
IN COMP_POOL* const pCPool,
IN void* const pObject )
{
LIST_ITEM *pListItem;
ASSERT( pCPool );
ASSERT( pObject );
pListItem = (LIST_ITEM*)((uchar*)pObject - sizeof(LIST_ITEM));
/* good sanity check */
ASSERT( pListItem->pObject == pObject );
QCompPoolPut( &pCPool->m_QCPool, pListItem );
}
/*
* Grows a composite pool by the specified number of objects.
*/
static __inline FSTATUS
CompPoolGrow(
IN COMP_POOL* const pCPool,
IN uint32 ObjCount )
{
ASSERT( pCPool );
return( QCompPoolGrow( &pCPool->m_QCPool, ObjCount ) );
}
/*
* Returns the number of objects available in a composite pool.
*/
static __inline uint32
CompPoolCount(
IN COMP_POOL* const pCPool )
{
ASSERT( pCPool );
return( QCompPoolCount( &pCPool->m_QCPool ) );
}
/****************************************************************************
****************************************************************************
*********** **********
*********** DECLARATION OF GROW POOL **********
*********** **********
****************************************************************************
****************************************************************************/
/****************************************************************************
* Grow pool callback function types.
*/
typedef void (*GPOOL_CTOR_FUNC)(
IN void* const pObject,
IN void* const Context );
typedef FSTATUS (*GPOOL_INIT_FUNC)(
IN void* const pObject,
IN void* const Context );
typedef void (*GPOOL_DTOR_FUNC)(
IN void* const pObject,
IN void* const Context );
/****************************************************************************
* Grow pool structure.
*/
typedef struct _GROW_POOL
{
/* These fields are private and should NOT be directly accessed */
QCOMP_POOL m_QCPool;
GPOOL_CTOR_FUNC m_pfnCtor;
GPOOL_INIT_FUNC m_pfnInit;
GPOOL_DTOR_FUNC m_pfnDtor;
void *m_Context;
} GROW_POOL;
/****************************************************************************
* Grow pool access methods.
*/
/*
* Initializes the state of a grow pool.
*/
void
GrowPoolInitState(
IN GROW_POOL* const pGPool );
/*
* Initialize a grow pool.
*/
FSTATUS
GrowPoolInit(
IN GROW_POOL* const pGPool,
IN const uint32 MinCount,
IN uint32 ObjectSize,
IN const uint32 GrowSize,
IN GPOOL_CTOR_FUNC pfnConstructor OPTIONAL,
IN GPOOL_INIT_FUNC pfnInitializer OPTIONAL,
IN GPOOL_DTOR_FUNC pnfDestructor OPTIONAL,
IN void* const Context );
/*
* Destroy a grow pool.
*/
void
GrowPoolDestroy(
IN GROW_POOL* const pGPool );
/*
* Get an object from a grow pool.
*/
static __inline void*
GrowPoolGet(
IN GROW_POOL* const pGPool )
{
LIST_ITEM *pListItem;
ASSERT( pGPool );
pListItem = QCompPoolGet( &pGPool->m_QCPool );
if( !pListItem )
return( NULL );
ASSERT( QListObj( pListItem ) != NULL );
return( QListObj( pListItem ) );
}
/*
* Put an object back in a grow pool.
*/
static __inline void
GrowPoolPut(
IN GROW_POOL* const pGPool,
void* const pObject )
{
LIST_ITEM *pListItem;
ASSERT( pGPool );
ASSERT( pObject );
pListItem = (LIST_ITEM*)((uchar*)pObject - sizeof(LIST_ITEM));
/* good sanity check */
ASSERT( pListItem->pObject == pObject );
QCompPoolPut( &pGPool->m_QCPool, pListItem );
}
/*
* Grows the resource pool by the specified number of objects.
*/
static __inline FSTATUS
GrowPoolGrow(
IN GROW_POOL* const pGPool,
IN const uint32 ObjCount )
{
ASSERT( pGPool );
return( QCompPoolGrow( &pGPool->m_QCPool, ObjCount ) );
}
/*
* Returns the number of objects available in the free pool.
*/
static __inline uint32
GrowPoolCount(
IN GROW_POOL* const pGPool )
{
ASSERT( pGPool );
return( QCompPoolCount( &pGPool->m_QCPool ) );
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _IBA_PUBLIC_IGROWPOOL_H_ */