pool.c

Lido PXA270平台开发板的最新BSP,包括源代码

/* -*- c-file-style: "img" -*-
<module>
* Name         : pool.c
* Title        : Object Pool Memory Allocator
* Author       : Marcus Shawcroft
* Created      : 14 May 2003
*
* Copyright    : 2003 by Imagination Technologies Limited.
*                All rights reserved.  No part of this software, either
*                material or conceptual may be copied or distributed,
*                transmitted, transcribed, stored in a retrieval system
*                or translated into any human or computer language in any
*                form by any means, electronic, mechanical, manual or
*                other-wise, or disclosed to third parties without the
*                express written permission of Imagination Technologies
*                Limited, Unit 8, HomePark Industrial Estate,
*                King's Langley, Hertfordshire, WD4 8LZ, U.K.
*
* Description :
*
*                Implements the object pool memory on Linux. Linux
*                kernel provides an object pool allocator directly,
*                the slab allocator, this module is a shim.
* 
* Platform     : linux
*
</module>
********************************************************************************/

#include <windows.h>
#include "img_types.h"
#include "services_headers.h"
#include "pool.h"
#include "trace.h"


struct _POOL_
{
  char *name;
  size_t size;
  unsigned grow;
  struct buffer *buffers;
  struct object *objects;
};

struct buffer
{
  struct buffer *next;
};

struct object
{
  struct object *next;
};

static void
allocate_buffer (POOL *pool)
{
	struct buffer *buf;
	int i;

	HostAllocMem( PVRSRV_HOST_NON_PAGEABLE_HEAP, 
					 pool->size * pool->grow + sizeof (struct buffer), 
					 &buf,  0);
	if (buf != NULL)
	{
		buf->next = pool->buffers;
		pool->buffers = buf;
		for (i=0; i<(int)pool->grow; i++)
		{
			struct object *obj;
			obj = (struct object *)(((unsigned char*)(buf+1)) + i * pool->size);
			obj->next = pool->objects;
			pool->objects = obj;
		}
	}
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   POOL_Create

	PURPOSE:
	            Create an object pool.
	                	
	PARAMETERS:	In:  name - name of object pool for diagnostic purposes.
	            In:  size - size of each object in the pool in bytes.
	RETURNS:	NULL or object pool handle.
</function>
-----------------------------------------------------------------------------*/
POOL *
POOL_Create (const char *name, IMG_SIZE_T size)
{
  POOL *pool;
	HostAllocMem( PVRSRV_HOST_NON_PAGEABLE_HEAP, 
					 sizeof (*pool), 
					 &pool,  0);
  if (pool==NULL)
    return NULL;
  pool->name = (char *)name;
  pool->size = size;
  pool->buffers = NULL;
  pool->objects = NULL;
  pool->grow = 32 /* grow */;
  return pool;
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   POOL_Delete

	PURPOSE:
	            Delete an object pool. All objects allocated from the pool must
	            be free'd with pool_free() before deleting the object pool.
	                	
	PARAMETERS:	In:  pool - object pool pointer.
	RETURNS:	None.
</function>
------------------------------------------------------------------------------*/
void
POOL_Delete (POOL *pool)
{

  if (!pool)
  {
  	return;
  }
	
  while (pool->buffers != NULL)
  {
  	struct buffer *buf;
  	
  	buf = pool->buffers;
  	pool->buffers = pool->buffers->next;
  	HostFreeMem(PVRSRV_HOST_NON_PAGEABLE_HEAP, buf);
  }

  HostFreeMem(PVRSRV_HOST_NON_PAGEABLE_HEAP, pool);
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   POOL_Alloc

	PURPOSE:
	            Allocate an object from an object pool.
	                	
	PARAMETERS:	In:  pool - object pool.
	RETURNS:	object pointer, or NULL.
</function>
------------------------------------------------------------------------------*/
void *
POOL_Alloc (POOL *pool)
{
  struct object *obj;
  ////////assert (pool!=NULL);
  if (pool->objects==NULL)
    allocate_buffer (pool);
  if (pool->objects==NULL)
    return NULL;
  obj = pool->objects;
  pool->objects = obj->next;
  return obj;
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   POOL_Free

	PURPOSE:
	            Free an object previously allocated from an object pool.
	                	
	PARAMETERS:	In:  pool - object pool pointer.
	            In:  obj - object pointer
	RETURNS:	None.
</function>
-----------------------------------------------------------------------------*/
void
POOL_Free (POOL *pool, void *o)
{
  struct object *obj;

  ////////assert (pool!=NULL);
  ////////assert (o!=NULL);
  obj = o;
  obj->next = pool->objects;
  pool->objects = obj;
}