Code: Select all

#include <Eigen/Eigen>
using namespace Eigen;
int main()
{
   // Create a buffer of doubles, that are not aligned to 8 bytes, but to 4
   char buf1[1024];
   char *b1(buf1);
   while ((int)b1 % 8 != 4) b1++;
   double *d1((double*)b1);

   // Create a buffer of doubles (may be aligned)
   double d2[100];
   for (int i=0;i<100;++i) d2[i]=i;

   // Create maps
   typedef Map<Matrix<double, Dynamic, Dynamic, RowMajor>, Unaligned > Map;
   Map map1(d1,10,10);
   Map map2(d2,10,10);
   
   // This line will crash
   map1 = map2;
   return 0;
}


Code: Select all

diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h
--- a/Eigen/src/Core/Assign.h
+++ b/Eigen/src/Core/Assign.h
@@ -434,29 +434,31 @@ struct assign_impl<Derived1, Derived2, L
 ***************************/
 
 template<typename Derived1, typename Derived2, int Version>
 struct assign_impl<Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling, Version>
 {
   typedef typename Derived1::Index Index;
   static inline void run(Derived1 &dst, const Derived2 &src)
   {
-    typedef packet_traits<typename Derived1::Scalar> PacketTraits;
+    typedef typename Derived1::Scalar Scalar;
+    typedef packet_traits<Scalar> PacketTraits;
     enum {
       packetSize = PacketTraits::size,
       alignable = PacketTraits::AlignedOnScalar,
       dstAlignment = alignable ? Aligned : int(assign_traits<Derived1,Derived2>::DstIsAligned) ,
       srcAlignment = assign_traits<Derived1,Derived2>::JointAlignment
     };
-    const Index packetAlignedMask = packetSize - 1;
+    const Scalar *dst_ptr = &dst.coeffRef(0,0);
+    const Index packetAlignedMask = (dstAlignment && ((Index(dst_ptr) % sizeof(Scalar))==0)) ? packetSize - 1 : ~Index(0);
     const Index innerSize = dst.innerSize();
     const Index outerSize = dst.outerSize();
     const Index alignedStep = alignable ? (packetSize - dst.outerStride() % packetSize) & packetAlignedMask : 0;
     Index alignedStart = ((!alignable) || assign_traits<Derived1,Derived2>::DstIsAligned) ? 0
-                       : internal::first_aligned(&dst.coeffRef(0,0), innerSize);
+                       : internal::first_aligned(dst_ptr, innerSize);
 
     for(Index outer = 0; outer < outerSize; ++outer)
     {
       const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
       // do the non-vectorizable part of the assignment
       for(Index inner = 0; inner<alignedStart ; ++inner)
         dst.copyCoeffByOuterInner(outer, inner, src);


Code: Select all

#include <iostream>
int main()
{
   double d;
   d=15.0;
   if ((long long)(&d) % 8) std::cout<<"not aligned";
}


Stack Alignment
On both of the 64-bit platforms, the top of each stackframe is 16-byte aligned. Although this uses more space than is needed, it guarantees that the compiler can place all data on the stack in a way that all elements are aligned.
The x86 compiler uses a different method for aligning the stack. By default, the stack is 4-byte aligned. Although this is space efficient, you can see that there are some data types that need to be 8-byte aligned, and that, in order to get good performance, 16-byte alignment is sometimes needed. The compiler can determine, on some occasions, that dynamic 8-byte stack alignment would be beneficial—notably when there are double values on the stack.
The compiler does this in two ways. First, the compiler can use link-time code generation (LTCG), when specified by the user at compile and link time, to generate the call-tree for the complete program. With this, it can determine regions of the call-tree where 8-byte stack alignment would be beneficial, and it determines call-sites where the dynamic stack alignment gets the best payoff. The second way is used when the function has doubles on the stack, but, for whatever reason, has not yet been 8-byte aligned. The compiler applies a heuristic (which improves with each iteration of the compiler) to determine whether the function should be dynamically 8-byte aligned.

Code: Select all

$ call "c:\Program Files\Microsoft Visual Studio 11.0\VC\vcvarsall.bat"
$ cd path/to/eigen/sources
$ mkdir build
$ cd build
$ cmake .. -DCMAKE_CXX_FLAGS="/MP2" -DEIGEN_TEST_NO_OPENGL=on -DEIGEN_ENABLE_LAPACK_TESTS=OFF  -DEIGEN_TEST_NOQT=ON
$ ctest -V -D Experimental