update

1 files changed, 38 insertions, 28 deletions

diff --git a/eigen/test/dynalloc.cpp b/eigen/test/dynalloc.cpp
index ef92c05..f1cc70b 100644
--- a/eigen/test/dynalloc.cpp
+++ b/eigen/test/dynalloc.cpp
@@ -9,18 +9,20 @@
 
 #include "main.h"
 
-#if EIGEN_ALIGN
-#define ALIGNMENT 16
+#if EIGEN_MAX_ALIGN_BYTES>0
+#define ALIGNMENT EIGEN_MAX_ALIGN_BYTES
 #else
 #define ALIGNMENT 1
 #endif
 
+typedef Matrix<float,8,1> Vector8f;
+
 void check_handmade_aligned_malloc()
 {
   for(int i = 1; i < 1000; i++)
   {
     char *p = (char*)internal::handmade_aligned_malloc(i);
-    VERIFY(size_t(p)%ALIGNMENT==0);
+    VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
     // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
     for(int j = 0; j < i; j++) p[j]=0;
     internal::handmade_aligned_free(p);
@@ -29,10 +31,10 @@ void check_handmade_aligned_malloc()
 
 void check_aligned_malloc()
 {
-  for(int i = 1; i < 1000; i++)
+  for(int i = ALIGNMENT; i < 1000; i++)
   {
     char *p = (char*)internal::aligned_malloc(i);
-    VERIFY(size_t(p)%ALIGNMENT==0);
+    VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
     // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
     for(int j = 0; j < i; j++) p[j]=0;
     internal::aligned_free(p);
@@ -41,10 +43,10 @@ void check_aligned_malloc()
 
 void check_aligned_new()
 {
-  for(int i = 1; i < 1000; i++)
+  for(int i = ALIGNMENT; i < 1000; i++)
   {
     float *p = internal::aligned_new<float>(i);
-    VERIFY(size_t(p)%ALIGNMENT==0);
+    VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
     // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
     for(int j = 0; j < i; j++) p[j]=0;
     internal::aligned_delete(p,i);
@@ -53,10 +55,10 @@ void check_aligned_new()
 
 void check_aligned_stack_alloc()
 {
-  for(int i = 1; i < 400; i++)
+  for(int i = ALIGNMENT; i < 400; i++)
   {
     ei_declare_aligned_stack_constructed_variable(float,p,i,0);
-    VERIFY(size_t(p)%ALIGNMENT==0);
+    VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
     // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
     for(int j = 0; j < i; j++) p[j]=0;
   }
@@ -68,7 +70,7 @@ struct MyStruct
 {
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
   char dummychar;
-  Vector4f avec;
+  Vector8f avec;
 };
 
 class MyClassA
@@ -76,15 +78,19 @@ class MyClassA
   public:
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
     char dummychar;
-    Vector4f avec;
+    Vector8f avec;
 };
 
 template<typename T> void check_dynaligned()
 {
-  T* obj = new T;
-  VERIFY(T::NeedsToAlign==1);
-  VERIFY(size_t(obj)%ALIGNMENT==0);
-  delete obj;
+  // TODO have to be updated once we support multiple alignment values
+  if(T::SizeAtCompileTime % ALIGNMENT == 0)
+  {
+    T* obj = new T;
+    VERIFY(T::NeedsToAlign==1);
+    VERIFY(internal::UIntPtr(obj)%ALIGNMENT==0);
+    delete obj;
+  }
 }
 
 template<typename T> void check_custom_new_delete()
@@ -100,7 +106,7 @@ template<typename T> void check_custom_new_delete()
     delete[] t;
   }
   
-#ifdef EIGEN_ALIGN
+#if EIGEN_MAX_ALIGN_BYTES>0
   {
     T* t = static_cast<T *>((T::operator new)(sizeof(T)));
     (T::operator delete)(t, sizeof(T));
@@ -120,9 +126,17 @@ void test_dynalloc()
   CALL_SUBTEST(check_aligned_malloc());
   CALL_SUBTEST(check_aligned_new());
   CALL_SUBTEST(check_aligned_stack_alloc());
+
+  for (int i=0; i<g_repeat*100; ++i)
+  {
+    CALL_SUBTEST( check_custom_new_delete<Vector4f>() );
+    CALL_SUBTEST( check_custom_new_delete<Vector2f>() );
+    CALL_SUBTEST( check_custom_new_delete<Matrix4f>() );
+    CALL_SUBTEST( check_custom_new_delete<MatrixXi>() );
+  }
   
   // check static allocation, who knows ?
-  #if EIGEN_ALIGN_STATICALLY
+  #if EIGEN_MAX_STATIC_ALIGN_BYTES
   for (int i=0; i<g_repeat*100; ++i)
   {
     CALL_SUBTEST(check_dynaligned<Vector4f>() );
@@ -130,23 +144,19 @@ void test_dynalloc()
     CALL_SUBTEST(check_dynaligned<Matrix4f>() );
     CALL_SUBTEST(check_dynaligned<Vector4d>() );
     CALL_SUBTEST(check_dynaligned<Vector4i>() );
-    
-    CALL_SUBTEST( check_custom_new_delete<Vector4f>() );
-    CALL_SUBTEST( check_custom_new_delete<Vector2f>() );
-    CALL_SUBTEST( check_custom_new_delete<Matrix4f>() );
-    CALL_SUBTEST( check_custom_new_delete<MatrixXi>() );
+    CALL_SUBTEST(check_dynaligned<Vector8f>() );
   }
 
   {
-    MyStruct foo0;  VERIFY(size_t(foo0.avec.data())%ALIGNMENT==0);
-    MyClassA fooA;  VERIFY(size_t(fooA.avec.data())%ALIGNMENT==0);
+    MyStruct foo0;  VERIFY(internal::UIntPtr(foo0.avec.data())%ALIGNMENT==0);
+    MyClassA fooA;  VERIFY(internal::UIntPtr(fooA.avec.data())%ALIGNMENT==0);
   }
   
   // dynamic allocation, single object
   for (int i=0; i<g_repeat*100; ++i)
   {
-    MyStruct *foo0 = new MyStruct();  VERIFY(size_t(foo0->avec.data())%ALIGNMENT==0);
-    MyClassA *fooA = new MyClassA();  VERIFY(size_t(fooA->avec.data())%ALIGNMENT==0);
+    MyStruct *foo0 = new MyStruct();  VERIFY(internal::UIntPtr(foo0->avec.data())%ALIGNMENT==0);
+    MyClassA *fooA = new MyClassA();  VERIFY(internal::UIntPtr(fooA->avec.data())%ALIGNMENT==0);
     delete foo0;
     delete fooA;
   }
@@ -155,8 +165,8 @@ void test_dynalloc()
   const int N = 10;
   for (int i=0; i<g_repeat*100; ++i)
   {
-    MyStruct *foo0 = new MyStruct[N];  VERIFY(size_t(foo0->avec.data())%ALIGNMENT==0);
-    MyClassA *fooA = new MyClassA[N];  VERIFY(size_t(fooA->avec.data())%ALIGNMENT==0);
+    MyStruct *foo0 = new MyStruct[N];  VERIFY(internal::UIntPtr(foo0->avec.data())%ALIGNMENT==0);
+    MyClassA *fooA = new MyClassA[N];  VERIFY(internal::UIntPtr(fooA->avec.data())%ALIGNMENT==0);
     delete[] foo0;
     delete[] fooA;
   }