Differential D8762 Diff 28333 extern/bullet2/src/BulletCollision/Gimpact/btGenericPoolAllocator.h

Changeset View

Standalone View

extern/bullet2/src/BulletCollision/Gimpact/btGenericPoolAllocator.h

	Show All 23 Lines
	#include <limits.h>			#include <limits.h>
	#include <stdio.h>			#include <stdio.h>
	#include <string.h>			#include <string.h>
	#include "LinearMath/btAlignedAllocator.h"			#include "LinearMath/btAlignedAllocator.h"

	#define BT_UINT_MAX UINT_MAX			#define BT_UINT_MAX UINT_MAX
	#define BT_DEFAULT_MAX_POOLS 16			#define BT_DEFAULT_MAX_POOLS 16


	//! Generic Pool class			//! Generic Pool class
	class btGenericMemoryPool			class btGenericMemoryPool
	{			{
	public:			public:
	unsigned char * m_pool; //[m_element_size*m_max_element_count];			unsigned char m_pool; //[m_element_sizem_max_element_count];
	size_t * m_free_nodes; //[m_max_element_count];//! free nodes			size_t *m_free_nodes; //[m_max_element_count];//! free nodes
	size_t * m_allocated_sizes;//[m_max_element_count];//! Number of elements allocated per node			size_t *m_allocated_sizes; //[m_max_element_count];//! Number of elements allocated per node
	size_t m_allocated_count;			size_t m_allocated_count;
	size_t m_free_nodes_count;			size_t m_free_nodes_count;

	protected:			protected:
	size_t m_element_size;			size_t m_element_size;
	size_t m_max_element_count;			size_t m_max_element_count;

	size_t allocate_from_free_nodes(size_t num_elements);			size_t allocate_from_free_nodes(size_t num_elements);
	size_t allocate_from_pool(size_t num_elements);			size_t allocate_from_pool(size_t num_elements);

	public:			public:

	void init_pool(size_t element_size, size_t element_count);			void init_pool(size_t element_size, size_t element_count);

	void end_pool();			void end_pool();


	btGenericMemoryPool(size_t element_size, size_t element_count)			btGenericMemoryPool(size_t element_size, size_t element_count)
	{			{
	init_pool(element_size, element_count);			init_pool(element_size, element_count);
	}			}

	~btGenericMemoryPool()			~btGenericMemoryPool()
	{			{
	end_pool();			end_pool();
	}			}


	inline size_t get_pool_capacity()			inline size_t get_pool_capacity()
	{			{
	return m_element_size*m_max_element_count;			return m_element_size * m_max_element_count;
	}			}

	inline size_t gem_element_size()			inline size_t gem_element_size()
	{			{
	return m_element_size;			return m_element_size;
	}			}

	inline size_t get_max_element_count()			inline size_t get_max_element_count()
	{			{
	return m_max_element_count;			return m_max_element_count;
	}			}

	inline size_t get_allocated_count()			inline size_t get_allocated_count()
	{			{
	return m_allocated_count;			return m_allocated_count;
	}			}

	inline size_t get_free_positions_count()			inline size_t get_free_positions_count()
	{			{
	return m_free_nodes_count;			return m_free_nodes_count;
	}			}

	inline void * get_element_data(size_t element_index)			inline void *get_element_data(size_t element_index)
	{			{
	return &m_pool[element_index*m_element_size];			return &m_pool[element_index * m_element_size];
	}			}

	//! Allocates memory in pool			//! Allocates memory in pool
	/*!			/*!
	\param size_bytes size in bytes of the buffer			\param size_bytes size in bytes of the buffer
	*/			*/
	void * allocate(size_t size_bytes);			void *allocate(size_t size_bytes);

	bool freeMemory(void * pointer);			bool freeMemory(void *pointer);
	};			};




	//! Generic Allocator with pools			//! Generic Allocator with pools
	/*!			/*!
	General purpose Allocator which can create Memory Pools dynamiacally as needed.			General purpose Allocator which can create Memory Pools dynamiacally as needed.
	*/			*/
	class btGenericPoolAllocator			class btGenericPoolAllocator
	{			{
	protected:			protected:
	size_t m_pool_element_size;			size_t m_pool_element_size;
	size_t m_pool_element_count;			size_t m_pool_element_count;

	public:			public:
	btGenericMemoryPool * m_pools[BT_DEFAULT_MAX_POOLS];			btGenericMemoryPool *m_pools[BT_DEFAULT_MAX_POOLS];
	size_t m_pool_count;			size_t m_pool_count;


	inline size_t get_pool_capacity()			inline size_t get_pool_capacity()
	{			{
	return m_pool_element_size*m_pool_element_count;			return m_pool_element_size * m_pool_element_count;
	}			}


	protected:			protected:
	// creates a pool			// creates a pool
	btGenericMemoryPool * push_new_pool();			btGenericMemoryPool *push_new_pool();

	void * failback_alloc(size_t size_bytes);			void *failback_alloc(size_t size_bytes);

	bool failback_free(void * pointer);			bool failback_free(void *pointer);
	public:

				public:
	btGenericPoolAllocator(size_t pool_element_size, size_t pool_element_count)			btGenericPoolAllocator(size_t pool_element_size, size_t pool_element_count)
	{			{
	m_pool_count = 0;			m_pool_count = 0;
	m_pool_element_size = pool_element_size;			m_pool_element_size = pool_element_size;
	m_pool_element_count = pool_element_count;			m_pool_element_count = pool_element_count;
	}			}

	virtual ~btGenericPoolAllocator();			virtual ~btGenericPoolAllocator();

	//! Allocates memory in pool			//! Allocates memory in pool
	/*!			/*!
	\param size_bytes size in bytes of the buffer			\param size_bytes size in bytes of the buffer
	*/			*/
	void * allocate(size_t size_bytes);			void *allocate(size_t size_bytes);

	bool freeMemory(void * pointer);			bool freeMemory(void *pointer);
	};			};



	void * btPoolAlloc(size_t size);			void *btPoolAlloc(size_t size);
	void * btPoolRealloc(void *ptr, size_t oldsize, size_t newsize);			void btPoolRealloc(void ptr, size_t oldsize, size_t newsize);
	void btPoolFree(void *ptr);			void btPoolFree(void *ptr);


	#endif			#endif