Main MRPT website > C++ reference
MRPT logo
Classes | Namespaces | Defines | Functions

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
 

Applies the clock wise 2D rotation j to the set of 2D vectors of cordinates x and y: $ \left ( \begin{array}{cc} x \\ y \end{array} \right ) = J \left ( \begin{array}{cc} x \\ y \end{array} \right ) $


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)
 Frees a memory block reserved by aligned_malloc.
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)
 Frees a memory block reserved by aligned_malloc.
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 Scalar , typename Index >
static Index internal::first_aligned (const Scalar *array, Index 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)

Definition at line 446 of file Memory.h.

#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)

Definition at line 451 of file Memory.h.

Referenced by internal::product_selfadjoint_vector(), internal::triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor >::run(), internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor >::run(), internal::product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >::run(), internal::product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >::run(), internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 >::run(), internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor >::run(), internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor >::run(), internal::gemv_selector< OnTheRight, RowMajor, true >::run(), internal::gemv_selector< OnTheRight, ColMajor, true >::run(), internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, UpLo >::run(), and internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor >::run().

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

Definition at line 447 of file Memory.h.

#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

Definition at line 58 of file Memory.h.

#define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED   0

Definition at line 48 of file Memory.h.

#define EIGEN_HAS_MM_MALLOC   0

Definition at line 80 of file Memory.h.

#define EIGEN_HAS_POSIX_MEMALIGN   0

Definition at line 74 of file Memory.h.

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)

Definition at line 498 of file Memory.h.

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF (   NeedsToAlign)

Definition at line 495 of file Memory.h.

#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))

Definition at line 499 of file Memory.h.

#define EIGEN_MALLOC_ALREADY_ALIGNED   0

Definition at line 67 of file Memory.h.




Page generated by Doxygen 1.7.3 for MRPT 0.9.4 SVN: at Sat Mar 26 06:16:28 UTC 2011