From 175ed636ea3ac5b1b807642421a036f8a9a10f1f Mon Sep 17 00:00:00 2001
From: Gael Guennebaud <g.gael@free.fr>
Date: Wed, 29 Jul 2015 10:22:25 +0200
Subject: bug #973: update macro-level control of alignement by introducing
 user-controllable EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES
 macros. This changeset also removes EIGEN_ALIGN (replaced by
 EIGEN_MAX_ALIGN_BYTES>0), EIGEN_ALIGN_STATICALLY (replaced by
 EIGEN_MAX_STATIC_ALIGN_BYTES>0), EIGEN_USER_ALIGN*, EIGEN_ALIGN_DEFAULT
 (replaced by EIGEN_ALIGN_MAX).

---
 test/unalignedassert.cpp | 44 +++++++++++++++++++++++++++++---------------
 1 file changed, 29 insertions(+), 15 deletions(-)

(limited to 'test/unalignedassert.cpp')

diff --git a/test/unalignedassert.cpp b/test/unalignedassert.cpp
index 9c6f0bc8f..f53f167b4 100644
--- a/test/unalignedassert.cpp
+++ b/test/unalignedassert.cpp
@@ -2,11 +2,25 @@
 // for linear algebra.
 //
 // Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
 //
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+#if defined(EIGEN_TEST_PART_1)
+  // default
+#elif defined(EIGEN_TEST_PART_2)
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 16
+  #define EIGEN_MAX_ALIGN_BYTES 16
+#elif defined(EIGEN_TEST_PART_3)
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 32
+  #define EIGEN_MAX_ALIGN_BYTES 32
+#elif defined(EIGEN_TEST_PART_4)
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 64
+  #define EIGEN_MAX_ALIGN_BYTES 64
+#endif
+
 #include "main.h"
 
 typedef Matrix<float,  6,1> Vector6f;
@@ -48,7 +62,7 @@ struct TestNew4
 struct TestNew5
 {
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-  float f; // try the f at first -- the EIGEN_ALIGN16 attribute of m should make that still work
+  float f; // try the f at first -- the EIGEN_ALIGN_MAX attribute of m should make that still work
   Matrix4f m;
 };
 
@@ -75,13 +89,13 @@ void check_unalignedassert_good()
   delete[] y;
 }
 
-#if EIGEN_ALIGN_STATICALLY
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
 template<typename T>
 void construct_at_boundary(int boundary)
 {
   char buf[sizeof(T)+256];
   size_t _buf = reinterpret_cast<size_t>(buf);
-  _buf += (EIGEN_ALIGN_BYTES - (_buf % EIGEN_ALIGN_BYTES)); // make 16/32-byte aligned
+  _buf += (EIGEN_MAX_ALIGN_BYTES - (_buf % EIGEN_MAX_ALIGN_BYTES)); // make 16/32/...-byte aligned
   _buf += boundary; // make exact boundary-aligned
   T *x = ::new(reinterpret_cast<void*>(_buf)) T;
   x[0].setZero(); // just in order to silence warnings
@@ -91,34 +105,34 @@ void construct_at_boundary(int boundary)
 
 void unalignedassert()
 {
-#if EIGEN_ALIGN_STATICALLY
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
   construct_at_boundary<Vector2f>(4);
   construct_at_boundary<Vector3f>(4);
   construct_at_boundary<Vector4f>(16);
   construct_at_boundary<Vector6f>(4);
-  construct_at_boundary<Vector8f>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Vector8f>(EIGEN_MAX_ALIGN_BYTES);
   construct_at_boundary<Vector12f>(16);
   construct_at_boundary<Matrix2f>(16);
   construct_at_boundary<Matrix3f>(4);
-  construct_at_boundary<Matrix4f>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Matrix4f>(EIGEN_MAX_ALIGN_BYTES);
 
   construct_at_boundary<Vector2d>(16);
   construct_at_boundary<Vector3d>(4);
-  construct_at_boundary<Vector4d>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Vector4d>(EIGEN_MAX_ALIGN_BYTES);
   construct_at_boundary<Vector5d>(4);
   construct_at_boundary<Vector6d>(16);
   construct_at_boundary<Vector7d>(4);
-  construct_at_boundary<Vector8d>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Vector8d>(EIGEN_MAX_ALIGN_BYTES);
   construct_at_boundary<Vector9d>(4);
   construct_at_boundary<Vector10d>(16);
-  construct_at_boundary<Vector12d>(EIGEN_ALIGN_BYTES);
-  construct_at_boundary<Matrix2d>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Vector12d>(EIGEN_MAX_ALIGN_BYTES);
+  construct_at_boundary<Matrix2d>(EIGEN_MAX_ALIGN_BYTES);
   construct_at_boundary<Matrix3d>(4);
-  construct_at_boundary<Matrix4d>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Matrix4d>(EIGEN_MAX_ALIGN_BYTES);
 
   construct_at_boundary<Vector2cf>(16);
   construct_at_boundary<Vector3cf>(4);
-  construct_at_boundary<Vector2cd>(EIGEN_ALIGN_BYTES);
+  construct_at_boundary<Vector2cd>(EIGEN_MAX_ALIGN_BYTES);
   construct_at_boundary<Vector3cd>(16);
 #endif
 
@@ -131,8 +145,8 @@ void unalignedassert()
   check_unalignedassert_good<TestNew6>();
   check_unalignedassert_good<Depends<true> >();
 
-#if EIGEN_ALIGN_STATICALLY
-  if(EIGEN_ALIGN_BYTES>=16)
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+  if(EIGEN_MAX_ALIGN_BYTES>=16)
   {
     VERIFY_RAISES_ASSERT(construct_at_boundary<Vector4f>(8));
     VERIFY_RAISES_ASSERT(construct_at_boundary<Vector8f>(8));
@@ -146,7 +160,7 @@ void unalignedassert()
     VERIFY_RAISES_ASSERT(construct_at_boundary<Vector2cf>(8));
     VERIFY_RAISES_ASSERT(construct_at_boundary<Vector4i>(8));
   }
-  for(int b=8; b<EIGEN_ALIGN_BYTES; b+=8)
+  for(int b=8; b<EIGEN_MAX_ALIGN_BYTES; b+=8)
   {
     VERIFY_RAISES_ASSERT(construct_at_boundary<Vector8f>(b));
     VERIFY_RAISES_ASSERT(construct_at_boundary<Matrix4f>(b));
-- 
cgit v1.2.3