19 #ifndef EIGEN_MEMORY_H
20 #define EIGEN_MEMORY_H
22 #ifndef EIGEN_MALLOC_ALREADY_ALIGNED
33 #if defined(__GLIBC__) && ((__GLIBC__>=2 && __GLIBC_MINOR__ >= 8) || __GLIBC__>2) \
34 && defined(__LP64__) && ! defined( __SANITIZE_ADDRESS__ )
35 #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 1
37 #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0
44 #if defined(__FreeBSD__) && !defined(__arm__) && !defined(__mips__)
45 #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 1
47 #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0
50 #if defined(__APPLE__) \
52 || EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED \
53 || EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED
54 #define EIGEN_MALLOC_ALREADY_ALIGNED 1
56 #define EIGEN_MALLOC_ALREADY_ALIGNED 0
64 #if defined(__unix__) || defined(__unix)
66 #if ((defined __QNXNTO__) || (defined _GNU_SOURCE) || (defined __PGI) || ((defined _XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600))) && (defined _POSIX_ADVISORY_INFO) && (_POSIX_ADVISORY_INFO > 0)
67 #define EIGEN_HAS_POSIX_MEMALIGN 1
71 #ifndef EIGEN_HAS_POSIX_MEMALIGN
72 #define EIGEN_HAS_POSIX_MEMALIGN 0
75 #ifdef EIGEN_VECTORIZE_SSE
76 #define EIGEN_HAS_MM_MALLOC 1
78 #define EIGEN_HAS_MM_MALLOC 0
85 inline void throw_std_bad_alloc()
87 #ifdef EIGEN_EXCEPTIONS
88 throw std::bad_alloc();
90 std::size_t huge = -1;
104 inline void* handmade_aligned_malloc(std::size_t size)
106 void *original = std::malloc(size+16);
107 if (original == 0)
return 0;
108 void *aligned =
reinterpret_cast<void*
>((
reinterpret_cast<std::size_t
>(original) & ~(std::size_t(15))) + 16);
109 *(
reinterpret_cast<void**
>(aligned) - 1) = original;
114 inline void handmade_aligned_free(
void *ptr)
116 if (ptr) std::free(*(reinterpret_cast<void**>(ptr) - 1));
124 inline void* handmade_aligned_realloc(
void* ptr, std::size_t size, std::size_t = 0)
126 if (ptr == 0)
return handmade_aligned_malloc(size);
127 void *original = *(
reinterpret_cast<void**
>(ptr) - 1);
128 std::ptrdiff_t previous_offset =
static_cast<char *
>(ptr)-static_cast<char *>(original);
129 original = std::realloc(original,size+16);
130 if (original == 0)
return 0;
131 void *aligned =
reinterpret_cast<void*
>((
reinterpret_cast<std::size_t
>(original) & ~(std::size_t(15))) + 16);
132 void *previous_aligned =
static_cast<char *
>(original)+previous_offset;
133 if(aligned!=previous_aligned)
134 std::memmove(aligned, previous_aligned, size);
136 *(
reinterpret_cast<void**
>(aligned) - 1) = original;
144 void* aligned_malloc(std::size_t size);
145 void aligned_free(
void *ptr);
152 inline void* generic_aligned_realloc(
void* ptr,
size_t size,
size_t old_size)
155 return aligned_malloc(size);
163 void* newptr = aligned_malloc(size);
166 #ifdef EIGEN_HAS_ERRNO
174 std::memcpy(newptr, ptr, (std::min)(size,old_size));
185 #ifdef EIGEN_NO_MALLOC
186 inline void check_that_malloc_is_allowed()
188 eigen_assert(
false &&
"heap allocation is forbidden (EIGEN_NO_MALLOC is defined)");
190 #elif defined EIGEN_RUNTIME_NO_MALLOC
191 inline bool is_malloc_allowed_impl(
bool update,
bool new_value =
false)
193 static bool value =
true;
198 inline bool is_malloc_allowed() {
return is_malloc_allowed_impl(
false); }
199 inline bool set_is_malloc_allowed(
bool new_value) {
return is_malloc_allowed_impl(
true, new_value); }
200 inline void check_that_malloc_is_allowed()
202 eigen_assert(is_malloc_allowed() &&
"heap allocation is forbidden (EIGEN_RUNTIME_NO_MALLOC is defined and g_is_malloc_allowed is false)");
205 inline void check_that_malloc_is_allowed()
212 inline void* aligned_malloc(
size_t size)
214 check_that_malloc_is_allowed();
218 result = std::malloc(size);
219 #elif EIGEN_MALLOC_ALREADY_ALIGNED
220 result = std::malloc(size);
221 #elif EIGEN_HAS_POSIX_MEMALIGN
222 if(posix_memalign(&result, 16, size)) result = 0;
223 #elif EIGEN_HAS_MM_MALLOC
224 result = _mm_malloc(size, 16);
225 #elif defined(_MSC_VER) && (!defined(_WIN32_WCE))
226 result = _aligned_malloc(size, 16);
228 result = handmade_aligned_malloc(size);
232 throw_std_bad_alloc();
238 inline void aligned_free(
void *ptr)
242 #elif EIGEN_MALLOC_ALREADY_ALIGNED
244 #elif EIGEN_HAS_POSIX_MEMALIGN
246 #elif EIGEN_HAS_MM_MALLOC
248 #elif defined(_MSC_VER) && (!defined(_WIN32_WCE))
251 handmade_aligned_free(ptr);
260 inline void* aligned_realloc(
void *ptr,
size_t new_size,
size_t old_size)
262 EIGEN_UNUSED_VARIABLE(old_size);
266 result = std::realloc(ptr,new_size);
267 #elif EIGEN_MALLOC_ALREADY_ALIGNED
268 result = std::realloc(ptr,new_size);
269 #elif EIGEN_HAS_POSIX_MEMALIGN
270 result = generic_aligned_realloc(ptr,new_size,old_size);
271 #elif EIGEN_HAS_MM_MALLOC
275 #if defined(_MSC_VER) && (!defined(_WIN32_WCE)) && defined(_mm_free)
276 result = _aligned_realloc(ptr,new_size,16);
278 result = generic_aligned_realloc(ptr,new_size,old_size);
280 #elif defined(_MSC_VER) && (!defined(_WIN32_WCE))
281 result = _aligned_realloc(ptr,new_size,16);
283 result = handmade_aligned_realloc(ptr,new_size,old_size);
286 if (!result && new_size)
287 throw_std_bad_alloc();
299 template<
bool Align>
inline void* conditional_aligned_malloc(
size_t size)
301 return aligned_malloc(size);
304 template<>
inline void* conditional_aligned_malloc<false>(
size_t size)
306 check_that_malloc_is_allowed();
308 void *result = std::malloc(size);
310 throw_std_bad_alloc();
315 template<
bool Align>
inline void conditional_aligned_free(
void *ptr)
320 template<>
inline void conditional_aligned_free<false>(
void *ptr)
325 template<
bool Align>
inline void* conditional_aligned_realloc(
void* ptr,
size_t new_size,
size_t old_size)
327 return aligned_realloc(ptr, new_size, old_size);
330 template<>
inline void* conditional_aligned_realloc<false>(
void* ptr,
size_t new_size, size_t)
332 return std::realloc(ptr, new_size);
342 template<
typename T>
inline T* construct_elements_of_array(T *ptr,
size_t size)
344 for (
size_t i=0; i < size; ++i) ::
new (ptr + i) T;
351 template<
typename T>
inline void destruct_elements_of_array(T *ptr,
size_t size)
355 while(size) ptr[--size].~T();
363 EIGEN_ALWAYS_INLINE
void check_size_for_overflow(
size_t size)
365 if(size >
size_t(-1) /
sizeof(T))
366 throw_std_bad_alloc();
373 template<
typename T>
inline T* aligned_new(
size_t size)
375 check_size_for_overflow<T>(size);
376 T *result =
reinterpret_cast<T*
>(aligned_malloc(
sizeof(T)*size));
377 return construct_elements_of_array(result, size);
380 template<
typename T,
bool Align>
inline T* conditional_aligned_new(
size_t size)
382 check_size_for_overflow<T>(size);
383 T *result =
reinterpret_cast<T*
>(conditional_aligned_malloc<Align>(
sizeof(T)*size));
384 return construct_elements_of_array(result, size);
390 template<
typename T>
inline void aligned_delete(T *ptr,
size_t size)
392 destruct_elements_of_array<T>(ptr, size);
399 template<
typename T,
bool Align>
inline void conditional_aligned_delete(T *ptr,
size_t size)
401 destruct_elements_of_array<T>(ptr, size);
402 conditional_aligned_free<Align>(ptr);
405 template<
typename T,
bool Align>
inline T* conditional_aligned_realloc_new(T* pts,
size_t new_size,
size_t old_size)
407 check_size_for_overflow<T>(new_size);
408 check_size_for_overflow<T>(old_size);
409 if(new_size < old_size)
410 destruct_elements_of_array(pts+new_size, old_size-new_size);
411 T *result =
reinterpret_cast<T*
>(conditional_aligned_realloc<Align>(
reinterpret_cast<void*
>(pts),
sizeof(T)*new_size,
sizeof(T)*old_size));
412 if(new_size > old_size)
413 construct_elements_of_array(result+old_size, new_size-old_size);
418 template<
typename T,
bool Align>
inline T* conditional_aligned_new_auto(
size_t size)
422 check_size_for_overflow<T>(size);
423 T *result =
reinterpret_cast<T*
>(conditional_aligned_malloc<Align>(
sizeof(T)*size));
424 if(NumTraits<T>::RequireInitialization)
425 construct_elements_of_array(result, size);
429 template<
typename T,
bool Align>
inline T* conditional_aligned_realloc_new_auto(T* pts,
size_t new_size,
size_t old_size)
431 check_size_for_overflow<T>(new_size);
432 check_size_for_overflow<T>(old_size);
433 if(NumTraits<T>::RequireInitialization && (new_size < old_size))
434 destruct_elements_of_array(pts+new_size, old_size-new_size);
435 T *result =
reinterpret_cast<T*
>(conditional_aligned_realloc<Align>(
reinterpret_cast<void*
>(pts),
sizeof(T)*new_size,
sizeof(T)*old_size));
436 if(NumTraits<T>::RequireInitialization && (new_size > old_size))
437 construct_elements_of_array(result+old_size, new_size-old_size);
441 template<
typename T,
bool Align>
inline void conditional_aligned_delete_auto(T *ptr,
size_t size)
443 if(NumTraits<T>::RequireInitialization)
444 destruct_elements_of_array<T>(ptr, size);
445 conditional_aligned_free<Align>(ptr);
466 template<
typename Scalar,
typename Index>
467 static inline Index first_aligned(
const Scalar* array, Index size)
469 static const Index PacketSize = packet_traits<Scalar>::size;
470 static const Index PacketAlignedMask = PacketSize-1;
478 else if(
size_t(array) & (
sizeof(Scalar)-1))
486 return std::min<Index>( (PacketSize - (Index((
size_t(array)/
sizeof(Scalar))) & PacketAlignedMask))
487 & PacketAlignedMask, size);
493 template<
typename Index>
494 inline static Index first_multiple(Index size, Index base)
496 return ((size+base-1)/base)*base;
501 template<
typename T,
bool UseMemcpy>
struct smart_copy_helper;
503 template<
typename T>
void smart_copy(
const T* start,
const T* end, T* target)
505 smart_copy_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
508 template<
typename T>
struct smart_copy_helper<T,true> {
509 static inline void run(
const T* start,
const T* end, T* target)
511 std::ptrdiff_t size = std::ptrdiff_t(end)-std::ptrdiff_t(start);
513 eigen_internal_assert(start!=0 && end!=0 && target!=0);
514 memcpy(target, start, size);
518 template<
typename T>
struct smart_copy_helper<T,false> {
519 static inline void run(
const T* start,
const T* end, T* target)
520 { std::copy(start, end, target); }
530 #if (defined __linux__) || (defined __APPLE__) || (defined alloca)
531 #define EIGEN_ALLOCA alloca
532 #elif defined(_MSC_VER)
533 #define EIGEN_ALLOCA _alloca
539 template<
typename T>
class aligned_stack_memory_handler
548 aligned_stack_memory_handler(T* ptr,
size_t size,
bool dealloc)
549 : m_ptr(ptr), m_size(size), m_deallocate(dealloc)
551 if(NumTraits<T>::RequireInitialization && m_ptr)
552 Eigen::internal::construct_elements_of_array(m_ptr, size);
554 ~aligned_stack_memory_handler()
556 if(NumTraits<T>::RequireInitialization && m_ptr)
557 Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
559 Eigen::internal::aligned_free(m_ptr);
586 #if defined(__arm__) || defined(_WIN32)
587 #define EIGEN_ALIGNED_ALLOCA(SIZE) reinterpret_cast<void*>((reinterpret_cast<size_t>(EIGEN_ALLOCA(SIZE+16)) & ~(size_t(15))) + 16)
589 #define EIGEN_ALIGNED_ALLOCA EIGEN_ALLOCA
592 #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
593 Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
594 TYPE* NAME = (BUFFER)!=0 ? (BUFFER) \
595 : reinterpret_cast<TYPE*>( \
596 (sizeof(TYPE)*SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) ? EIGEN_ALIGNED_ALLOCA(sizeof(TYPE)*SIZE) \
597 : Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE) ); \
598 Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,sizeof(TYPE)*SIZE>EIGEN_STACK_ALLOCATION_LIMIT)
602 #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
603 Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
604 TYPE* NAME = (BUFFER)!=0 ? BUFFER : reinterpret_cast<TYPE*>(Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE)); \
605 Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,true)
615 #ifdef EIGEN_EXCEPTIONS
616 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
617 void* operator new(size_t size, const std::nothrow_t&) throw() { \
618 try { return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); } \
619 catch (...) { return 0; } \
622 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
623 void* operator new(size_t size, const std::nothrow_t&) throw() { \
624 return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
628 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \
629 void *operator new(size_t size) { \
630 return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
632 void *operator new[](size_t size) { \
633 return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
635 void operator delete(void * ptr) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
636 void operator delete[](void * ptr) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
637 void operator delete(void * ptr, std::size_t ) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
638 void operator delete[](void * ptr, std::size_t ) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
642 static void *operator new(size_t size, void *ptr) { return ::operator new(size,ptr); } \
643 static void *operator new[](size_t size, void* ptr) { return ::operator new[](size,ptr); } \
644 void operator delete(void * memory, void *ptr) throw() { return ::operator delete(memory,ptr); } \
645 void operator delete[](void * memory, void *ptr) throw() { return ::operator delete[](memory,ptr); } \
647 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
648 void operator delete(void *ptr, const std::nothrow_t&) throw() { \
649 Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); \
651 typedef void eigen_aligned_operator_new_marker_type;
653 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
656 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
657 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size) \
658 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0)))
683 typedef size_t size_type;
684 typedef std::ptrdiff_t difference_type;
686 typedef const T* const_pointer;
687 typedef T& reference;
688 typedef const T& const_reference;
689 typedef T value_type;
706 pointer allocate(size_type num,
const void* = 0)
708 internal::check_size_for_overflow<T>(num);
709 return static_cast<pointer
>( internal::aligned_malloc(num *
sizeof(T)) );
712 void deallocate(pointer p, size_type )
714 internal::aligned_free(p);
720 #if !defined(EIGEN_NO_CPUID)
721 # if defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
722 # if defined(__PIC__) && defined(__i386__)
724 # define EIGEN_CPUID(abcd,func,id) \
725 __asm__ __volatile__ ("xchgl %%ebx, %k1;cpuid; xchgl %%ebx,%k1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "a" (func), "c" (id));
726 # elif defined(__PIC__) && defined(__x86_64__)
729 # define EIGEN_CPUID(abcd,func,id) \
730 __asm__ __volatile__ ("xchg{q}\t{%%}rbx, %q1; cpuid; xchg{q}\t{%%}rbx, %q1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id));
733 # define EIGEN_CPUID(abcd,func,id) \
734 __asm__ __volatile__ ("cpuid": "=a" (abcd[0]), "=b" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id) );
736 # elif defined(_MSC_VER)
737 # if (_MSC_VER > 1500) && ( defined(_M_IX86) || defined(_M_X64) )
738 # define EIGEN_CPUID(abcd,func,id) __cpuidex((int*)abcd,func,id)
747 inline bool cpuid_is_vendor(
int abcd[4],
const int vendor[3])
749 return abcd[1]==vendor[0] && abcd[3]==vendor[1] && abcd[2]==vendor[2];
752 inline void queryCacheSizes_intel_direct(
int& l1,
int& l2,
int& l3)
759 abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
760 EIGEN_CPUID(abcd,0x4,cache_id);
761 cache_type = (abcd[0] & 0x0F) >> 0;
762 if(cache_type==1||cache_type==3)
764 int cache_level = (abcd[0] & 0xE0) >> 5;
765 int ways = (abcd[1] & 0xFFC00000) >> 22;
766 int partitions = (abcd[1] & 0x003FF000) >> 12;
767 int line_size = (abcd[1] & 0x00000FFF) >> 0;
768 int sets = (abcd[2]);
770 int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);
774 case 1: l1 = cache_size;
break;
775 case 2: l2 = cache_size;
break;
776 case 3: l3 = cache_size;
break;
781 }
while(cache_type>0 && cache_id<16);
784 inline void queryCacheSizes_intel_codes(
int& l1,
int& l2,
int& l3)
787 abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
789 EIGEN_CPUID(abcd,0x00000002,0);
790 unsigned char * bytes =
reinterpret_cast<unsigned char *
>(abcd)+2;
791 bool check_for_p2_core2 =
false;
792 for(
int i=0; i<14; ++i)
796 case 0x0A: l1 = 8;
break;
797 case 0x0C: l1 = 16;
break;
798 case 0x0E: l1 = 24;
break;
799 case 0x10: l1 = 16;
break;
800 case 0x15: l1 = 16;
break;
801 case 0x2C: l1 = 32;
break;
802 case 0x30: l1 = 32;
break;
803 case 0x60: l1 = 16;
break;
804 case 0x66: l1 = 8;
break;
805 case 0x67: l1 = 16;
break;
806 case 0x68: l1 = 32;
break;
807 case 0x1A: l2 = 96;
break;
808 case 0x22: l3 = 512;
break;
809 case 0x23: l3 = 1024;
break;
810 case 0x25: l3 = 2048;
break;
811 case 0x29: l3 = 4096;
break;
812 case 0x39: l2 = 128;
break;
813 case 0x3A: l2 = 192;
break;
814 case 0x3B: l2 = 128;
break;
815 case 0x3C: l2 = 256;
break;
816 case 0x3D: l2 = 384;
break;
817 case 0x3E: l2 = 512;
break;
818 case 0x40: l2 = 0;
break;
819 case 0x41: l2 = 128;
break;
820 case 0x42: l2 = 256;
break;
821 case 0x43: l2 = 512;
break;
822 case 0x44: l2 = 1024;
break;
823 case 0x45: l2 = 2048;
break;
824 case 0x46: l3 = 4096;
break;
825 case 0x47: l3 = 8192;
break;
826 case 0x48: l2 = 3072;
break;
827 case 0x49:
if(l2!=0) l3 = 4096;
else {check_for_p2_core2=
true; l3 = l2 = 4096;}
break;
828 case 0x4A: l3 = 6144;
break;
829 case 0x4B: l3 = 8192;
break;
830 case 0x4C: l3 = 12288;
break;
831 case 0x4D: l3 = 16384;
break;
832 case 0x4E: l2 = 6144;
break;
833 case 0x78: l2 = 1024;
break;
834 case 0x79: l2 = 128;
break;
835 case 0x7A: l2 = 256;
break;
836 case 0x7B: l2 = 512;
break;
837 case 0x7C: l2 = 1024;
break;
838 case 0x7D: l2 = 2048;
break;
839 case 0x7E: l2 = 256;
break;
840 case 0x7F: l2 = 512;
break;
841 case 0x80: l2 = 512;
break;
842 case 0x81: l2 = 128;
break;
843 case 0x82: l2 = 256;
break;
844 case 0x83: l2 = 512;
break;
845 case 0x84: l2 = 1024;
break;
846 case 0x85: l2 = 2048;
break;
847 case 0x86: l2 = 512;
break;
848 case 0x87: l2 = 1024;
break;
849 case 0x88: l3 = 2048;
break;
850 case 0x89: l3 = 4096;
break;
851 case 0x8A: l3 = 8192;
break;
852 case 0x8D: l3 = 3072;
break;
857 if(check_for_p2_core2 && l2 == l3)
864 inline void queryCacheSizes_intel(
int& l1,
int& l2,
int& l3,
int max_std_funcs)
867 queryCacheSizes_intel_direct(l1,l2,l3);
869 queryCacheSizes_intel_codes(l1,l2,l3);
872 inline void queryCacheSizes_amd(
int& l1,
int& l2,
int& l3)
875 abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
876 EIGEN_CPUID(abcd,0x80000005,0);
877 l1 = (abcd[2] >> 24) * 1024;
878 abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
879 EIGEN_CPUID(abcd,0x80000006,0);
880 l2 = (abcd[2] >> 16) * 1024;
881 l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024;
887 inline void queryCacheSizes(
int& l1,
int& l2,
int& l3)
891 const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
892 const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
893 const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574};
896 EIGEN_CPUID(abcd,0x0,0);
897 int max_std_funcs = abcd[1];
898 if(cpuid_is_vendor(abcd,GenuineIntel))
899 queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
900 else if(cpuid_is_vendor(abcd,AuthenticAMD) || cpuid_is_vendor(abcd,AMDisbetter_))
901 queryCacheSizes_amd(l1,l2,l3);
904 queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
924 inline int queryL1CacheSize()
927 queryCacheSizes(l1,l2,l3);
933 inline int queryTopLevelCacheSize()
935 int l1, l2(-1), l3(-1);
936 queryCacheSizes(l1,l2,l3);
937 return (std::max)(l2,l3);
944 #endif // EIGEN_MEMORY_H
STL compatible allocator to use with with 16 byte aligned types.
Definition: Memory.h:680