/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/ntk/geometry/Eigen/src/Core/util/Memory.h File Reference

Go to the source code of this file.

Classes
class	aligned_allocator< T >
	STL compatible allocator to use with with 16 byte aligned types. More...
struct	aligned_allocator< T >::rebind< U >
Namespaces
namespace	internal
Defines
#define	EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED   0
#define	EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED   0
#define	EIGEN_MALLOC_ALREADY_ALIGNED   0
#define	EIGEN_HAS_POSIX_MEMALIGN   0
#define	EIGEN_HAS_MM_MALLOC   0
#define	ei_aligned_stack_alloc(SIZE)   Eigen::internal::aligned_malloc(SIZE)
#define	ei_aligned_stack_free(PTR, SIZE)   Eigen::internal::aligned_free(PTR)
#define	ei_aligned_stack_new(TYPE, SIZE)   Eigen::internal::construct_elements_of_array(reinterpret_cast<TYPE*>(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE)
#define	ei_aligned_stack_delete(TYPE, PTR, SIZE)
#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Size)   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0))
Functions
void *	internal::handmade_aligned_malloc (size_t size)
void	internal::handmade_aligned_free (void *ptr)
void *	internal::handmade_aligned_realloc (void *ptr, size_t size, size_t=0)
void *	internal::aligned_malloc (size_t size)
void	internal::aligned_free (void *ptr)
void *	internal::generic_aligned_realloc (void *ptr, size_t size, size_t old_size)
void *	internal::aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<bool Align>
void *	internal::conditional_aligned_malloc (size_t size)
template<>
void *	internal::conditional_aligned_malloc< false > (size_t size)
template<bool Align>
void	internal::conditional_aligned_free (void *ptr)
template<>
void	internal::conditional_aligned_free< false > (void *ptr)
template<bool Align>
void *	internal::conditional_aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<>
void *	internal::conditional_aligned_realloc< false > (void *ptr, size_t new_size, size_t)
template<typename T >
T *	internal::construct_elements_of_array (T *ptr, size_t size)
template<typename T >
void	internal::destruct_elements_of_array (T *ptr, size_t size)
template<typename T >
T *	internal::aligned_new (size_t size)
template<typename T , bool Align>
T *	internal::conditional_aligned_new (size_t size)
template<typename T >
void	internal::aligned_delete (T *ptr, size_t size)
template<typename T , bool Align>
void	internal::conditional_aligned_delete (T *ptr, size_t size)
template<typename T , bool Align>
T *	internal::conditional_aligned_realloc_new (T *pts, size_t new_size, size_t old_size)
template<typename T , bool Align>
T *	internal::conditional_aligned_new_auto (size_t size)
template<typename T , bool Align>
T *	internal::conditional_aligned_realloc_new_auto (T *pts, size_t new_size, size_t old_size)
template<typename T , bool Align>
void	internal::conditional_aligned_delete_auto (T *ptr, size_t size)
void	internal::queryCacheSizes (int &l1, int &l2, int &l3)
int	internal::queryL1CacheSize ()
int	internal::queryTopLevelCacheSize ()

---

Define Documentation

#define ei_aligned_stack_alloc

(

SIZE

)

Eigen::internal::aligned_malloc(SIZE)

#define ei_aligned_stack_delete	(		TYPE,
			PTR,
			SIZE
	)

Value:

do {Eigen::internal::destruct_elements_of_array<TYPE>(PTR, SIZE); \
                                                   ei_aligned_stack_free(PTR,sizeof(TYPE)*SIZE);} while(0)

#define ei_aligned_stack_free	(		PTR,
			SIZE
	)			Eigen::internal::aligned_free(PTR)

#define ei_aligned_stack_new	(		TYPE,
			SIZE
	)			Eigen::internal::construct_elements_of_array(reinterpret_cast<TYPE*>(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE)

#define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED   0

#define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED   0

#define EIGEN_HAS_MM_MALLOC   0

#define EIGEN_HAS_POSIX_MEMALIGN   0

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF

(

NeedsToAlign

)

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE	(		Scalar,
			Size
	)			EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0))

#define EIGEN_MALLOC_ALREADY_ALIGNED   0