Differential D8762 Diff 28333 extern/bullet2/src/LinearMath/btAlignedAllocator.h

Changeset View

Standalone View

extern/bullet2/src/LinearMath/btAlignedAllocator.h

	Show All 15 Lines
	#ifndef BT_ALIGNED_ALLOCATOR			#ifndef BT_ALIGNED_ALLOCATOR
	#define BT_ALIGNED_ALLOCATOR			#define BT_ALIGNED_ALLOCATOR

	///we probably replace this with our own aligned memory allocator			///we probably replace this with our own aligned memory allocator
	///so we replace _aligned_malloc and _aligned_free with our own			///so we replace _aligned_malloc and _aligned_free with our own
	///that is better portable and more predictable			///that is better portable and more predictable

	#include "btScalar.h"			#include "btScalar.h"
	//#define BT_DEBUG_MEMORY_ALLOCATIONS 1
				///BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system
				///for regression tests to detect memory leaks
				///#define BT_DEBUG_MEMORY_ALLOCATIONS 1
	#ifdef BT_DEBUG_MEMORY_ALLOCATIONS			#ifdef BT_DEBUG_MEMORY_ALLOCATIONS

				int btDumpMemoryLeaks();

	#define btAlignedAlloc(a,b) \			#define btAlignedAlloc(a, b) \
	btAlignedAllocInternal(a,b,__LINE__,__FILE__)			btAlignedAllocInternal(a, b, __LINE__, __FILE__)

	#define btAlignedFree(ptr) \			#define btAlignedFree(ptr) \
	btAlignedFreeInternal(ptr,__LINE__,__FILE__)			btAlignedFreeInternal(ptr, __LINE__, __FILE__)

	void* btAlignedAllocInternal (size_t size, int alignment,int line,char* filename);			void* btAlignedAllocInternal(size_t size, int alignment, int line, const char* filename);

	void btAlignedFreeInternal (void* ptr,int line,char* filename);			void btAlignedFreeInternal(void* ptr, int line, const char* filename);

	#else			#else
	void* btAlignedAllocInternal (size_t size, int alignment);			void* btAlignedAllocInternal(size_t size, int alignment);
	void btAlignedFreeInternal (void* ptr);			void btAlignedFreeInternal(void* ptr);

	#define btAlignedAlloc(size,alignment) btAlignedAllocInternal(size,alignment)			#define btAlignedAlloc(size, alignment) btAlignedAllocInternal(size, alignment)
	#define btAlignedFree(ptr) btAlignedFreeInternal(ptr)			#define btAlignedFree(ptr) btAlignedFreeInternal(ptr)

	#endif			#endif
	typedef int size_type;			typedef int size_type;

	typedef void *(btAlignedAllocFunc)(size_t size, int alignment);			typedef void*(btAlignedAllocFunc)(size_t size, int alignment);
	typedef void (btAlignedFreeFunc)(void *memblock);			typedef void(btAlignedFreeFunc)(void* memblock);
	typedef void *(btAllocFunc)(size_t size);			typedef void*(btAllocFunc)(size_t size);
	typedef void (btFreeFunc)(void *memblock);			typedef void(btFreeFunc)(void* memblock);

	///The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom			///The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom
	void btAlignedAllocSetCustom(btAllocFunc allocFunc, btFreeFunc freeFunc);			void btAlignedAllocSetCustom(btAllocFunc* allocFunc, btFreeFunc* freeFunc);
	///If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it.			///If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it.
	void btAlignedAllocSetCustomAligned(btAlignedAllocFunc allocFunc, btAlignedFreeFunc freeFunc);			void btAlignedAllocSetCustomAligned(btAlignedAllocFunc* allocFunc, btAlignedFreeFunc* freeFunc);


	///The btAlignedAllocator is a portable class for aligned memory allocations.			///The btAlignedAllocator is a portable class for aligned memory allocations.
	///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned.			///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned.
	template < typename T , unsigned Alignment >			template <typename T, unsigned Alignment>
	class btAlignedAllocator {			class btAlignedAllocator
				{
	typedef btAlignedAllocator< T , Alignment > self_type;			typedef btAlignedAllocator<T, Alignment> self_type;

	public:			public:

	//just going down a list:			//just going down a list:
	btAlignedAllocator() {}			btAlignedAllocator() {}
	/*			/*
	btAlignedAllocator( const self_type & ) {}			btAlignedAllocator( const self_type & ) {}
	*/			*/

	template < typename Other >			template <typename Other>
	btAlignedAllocator( const btAlignedAllocator< Other , Alignment > & ) {}			btAlignedAllocator(const btAlignedAllocator<Other, Alignment>&)
				{
				}

	typedef const T* const_pointer;			typedef const T* const_pointer;
	typedef const T& const_reference;			typedef const T& const_reference;
	typedef T* pointer;			typedef T* pointer;
	typedef T& reference;			typedef T& reference;
	typedef T value_type;			typedef T value_type;

	pointer address ( reference ref ) const { return &ref; }			pointer address(reference ref) const { return &ref; }
	const_pointer address ( const_reference ref ) const { return &ref; }			const_pointer address(const_reference ref) const { return &ref; }
	pointer allocate ( size_type n , const_pointer * hint = 0 ) {			pointer allocate(size_type n, const_pointer* hint = 0)
				{
	(void)hint;			(void)hint;
	return reinterpret_cast< pointer >(btAlignedAlloc( sizeof(value_type) * n , Alignment ));			return reinterpret_cast<pointer>(btAlignedAlloc(sizeof(value_type) * n, Alignment));
	}			}
	void construct ( pointer ptr , const value_type & value ) { new (ptr) value_type( value ); }			void construct(pointer ptr, const value_type& value) { new (ptr) value_type(value); }
	void deallocate( pointer ptr ) {			void deallocate(pointer ptr)
				{
	btAlignedFree( reinterpret_cast< void * >( ptr ) );			btAlignedFree(reinterpret_cast<void*>(ptr));
	}			}
	void destroy ( pointer ptr ) { ptr->~value_type(); }			void destroy(pointer ptr) { ptr->~value_type(); }

				template <typename O>
	template < typename O > struct rebind {			struct rebind
				{
	typedef btAlignedAllocator< O , Alignment > other;			typedef btAlignedAllocator<O, Alignment> other;
	};			};
	template < typename O >			template <typename O>
	self_type & operator=( const btAlignedAllocator< O , Alignment > & ) { return *this; }			self_type& operator=(const btAlignedAllocator<O, Alignment>&)
				{
				return *this;
				}

	friend bool operator==( const self_type & , const self_type & ) { return true; }			friend bool operator==(const self_type&, const self_type&) { return true; }
	};			};



	#endif //BT_ALIGNED_ALLOCATOR			#endif //BT_ALIGNED_ALLOCATOR