Hi,

I trying to get a proof of concept to use Eigen 2 to substitute a number of very ugly hand writen linear algebra functions we have in a library. The function I've focused on does the following in Eigen:

nMatRows = 118
nMatCols = 1299

Map<MatrixXd> eMatrix = Map<MatrixXd>(pMatrix,nMatRows,nMatCols);
Map<MatrixXd> eVector = Map<MatrixXd>(pVect,1,nMatCols);
Map<MatrixXd> eResults = Map<MatrixXd>(m_RealData,1,nMatRows);

eResults += eVector * eMatrix.transpose() ;

This code produces the expected results but it's much slower than the equivalent implementation in plain C. As a test, I call this code in a loop 10 times with some fix data and I get 3ms from the plain C function and 20ms with the equivalent Eigen one.

When I look at the assembly code for the Eigen bit I can't see any sse2 instructions, so I think MSVC is not vectorizing the code.

I have set the project to use Streaming SIMD Extensions 2 (/arch:SSE2) I have defined the EIGEN_VECTORIZE, I've tried a 32 and 64 builds too but the code still works slower with Eigen.
I also read that as I'm using dynamic matrixes of the size I use I should not worry with alignment, and I can still get the benefit of sse2.

what can I do? I running out of time for the proof of concept.

Thanks for any help,
M

Ah! just to add that I'm using eigen-2.0.12 for the test

We don't do SSE on MSVC 2005 because it lack certain important SSE intrinsics, in other words, its SSE support is incomplete.

Use MSVC 2008 or 2010 for SSE support.

As explained on the main page of the wiki.

Hi bjacob,

Thanks for your advice.
I have installed MSVC2008 and tried again the eigen code above, but it's still working slower than the hand writen code. When I arrive to that part of the code I look a the assembler view and I don't see sse instructions, so is still not vectorizing!

Any further advice?

M.

Did you enable SSE2 in your MSVC project? Note: SSE2 required, Eigen won't be able to use just SSE1.

If yes, can you paste here the relevant source code snippet and the corresponding assembly.

Note:
http://eigen.tuxfamily.org/index.php?ti ... ual_Studio

Yes "Streaming SIMD Extensions 2 (/arch:SSE2)" is enabled in all the projects in my solution. I have defined too:
#define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_SSE
#define EIGEN_VECTORIZE_SSE2
before the
#include <Eigen/Core>
#include <Eigen/Array>

The Eigen code is:

Map<MatrixXd> eMatrix = Map<MatrixXd>(pMatrix,nMatRows,nMatCols);
Map<MatrixXd> eVector = Map<MatrixXd>(pVect,1,nMatCols);
Map<MatrixXd> eResults = Map<MatrixXd>(m_RealData,1,nMatRows);
eResults += eVector * eMatrix.transpose();




The resulting assembly code is:

Map<MatrixXd> eMatrix = Map<MatrixXd>(pMatrix,nMatRows,nMatCols);
00836030 mov ecx,dword ptr [esi+10h]
Map<MatrixXd> eVector = Map<MatrixXd>(pVect,1,nMatCols);
00836033 mov edx,dword ptr [esp+40h]
00836037 mov dword ptr [esp+0Ch],ecx
0083603B mov ecx,dword ptr [edx+10h]
Map<MatrixXd> eResults = Map<MatrixXd>(m_RealData,1,nMatRows);
0083603E mov edx,dword ptr [ebx+10h]
00836041 mov dword ptr [esp+18h],ecx
00836045 mov dword ptr [esp+14h],eax
00836049 mov ecx,1
0083604E mov dword ptr [esp+20h],eax
00836052 mov dword ptr [esp+1Ch],ecx
00836056 mov dword ptr [esp+28h],ecx

eResults += eVector * eMatrix.transpose();
0083605A lea eax,[esp+0Ch]
0083605E mov dword ptr [esp+44h],eax
00836062 lea ecx,[esp+18h]
00836066 mov dword ptr [esp+24h],edx
0083606A lea eax,[esp+31h]
0083606E mov dword ptr [esp+34h],ecx
00836072 lea edx,[esp+44h]
00836076 push eax
00836077 lea ecx,[esp+28h]
0083607B mov dword ptr [esp+14h],edi
0083607F mov dword ptr [esp+30h],edi
00836083 mov dword ptr [esp+3Ch],edx
00836087 call Eigen::MapBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,1> >::operator+=<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,1> const &,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,1> > const &,1> > (836DD0h)
0083608C pop edi
0083608D pop esi
0083608E pop ebx

if I go inside the call Eigen::MapBase all the assembly instructions are standard too, not sse.

cheers.

First of all, a general c++ concern: you should rewrite this:

Code: Select all

Map<MatrixXd> eMatrix = Map<MatrixXd>(pMatrix,nMatRows,nMatCols);


as

Code: Select all

Map<MatrixXd> eMatrix(pMatrix,nMatRows,nMatCols);


Second, the code you showed here is just the construction of the Map objects: just copying sizes and pointers. It's normal it doesn't do SSE: it doesn't compute anything. Note that this typically vanishes when you enable optimization. The SSE stuff will be inside of the operator+= call you didn't paste.

If there's no SSE there, that's probably because you didn't tell Eigen that your arrays are aligned to 16 byte boundaries, which in this case can plausibly prevent any vectorization. For that, you need the development branch of Eigen (to become Eigen 3). You can then do:

Code: Select all

// first of all, make sure the pointers are aligned to 16 byte.
// you can use ei_aligned_malloc, ei_aligned_new, etc, see the file Memory.h
Map<MatrixXd, Aligned> eMatrix(pMatrix,nMatRows,nMatCols);
Map<MatrixXd, Aligned> eVector(pVect,1,nMatCols);
Map<MatrixXd, Aligned> eResults(m_RealData,1,nMatRows);
eResults += eVector * eMatrix.transpose();


Hi bjacob,

Thanks for your suggestion; I've rewritten the Map declaration as you say.
I've tried it in a 32bit built aligning the pMatrix, pVect,and m_RealData arrays to 16bits, but the eigen part is still slower than the hand written code. Then I tried the same on a 64bits built (not alignment needed I understand) and it's still slower again.

When you say the development branch is Eigen 2.0.12 ok then?

I add the assembly of what I think it's the part for the + call and the part for the = call of the += for the 64bit built:
I'm just copying what I see in the disassembly view with C++ intertwined, it seems to repeat some of the C++ statements,
all this assembler code it's a bit confusing for me. I'm sorry for posting so much code I don't really know what it's doing
or even if it's the right one. Now I see some instructions that use xmm registers so is that the sse code???
The resulting code is still slower than the hand written equivalent.


template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
MatrixBase<Derived>::operator+(const MatrixBase<OtherDerived> &other) const
{
000000002A553A90 push rdi
000000002A553A92 sub rsp,30h
000000002A553A96 mov qword ptr [rsp+20h],0FFFFFFFFFFFFFFFEh
000000002A553A9F mov qword ptr [rsp+48h],rbx
000000002A553AA4 mov qword ptr [rsp+50h],rbp
000000002A553AA9 mov qword ptr [rsp+58h],rsi
000000002A553AAE mov rbp,rdx
000000002A553AB1 xor edi,edi
000000002A553AB3 mov dword ptr [this],edi
return CwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived());
000000002A553AB7 test r8,r8
000000002A553ABA je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+32h (2A553AC2h)
000000002A553ABC lea rbx,[r8-1]
000000002A553AC0 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+35h (2A553AC5h)
000000002A553AC2 mov rbx,rdi
000000002A553AC5 mov qword ptr [rdx+8],rcx
000000002A553AC9 test rbx,rbx
000000002A553ACC je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+43h (2A553AD3h)
000000002A553ACE inc rbx
000000002A553AD1 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+46h (2A553AD6h)
000000002A553AD3 mov rbx,rdi
000000002A553AD6 lea rsi,[rdx+10h]
000000002A553ADA mov qword ptr [this],rsi
000000002A553ADF test rbx,rbx
000000002A553AE2 je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+5Ah (2A553AEAh)
000000002A553AE4 lea rax,[rbx-1]
000000002A553AE8 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+5Dh (2A553AEDh)
000000002A553AEA mov rax,rdi
000000002A553AED mov rax,qword ptr [rax+10h]
000000002A553AF1 mov rcx,qword ptr [rax]
000000002A553AF4 mov r9d,dword ptr [rcx+8]
000000002A553AF8 test rbx,rbx
000000002A553AFB je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+73h (2A553B03h)
000000002A553AFD lea rax,[rbx-1]
000000002A553B01 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+76h (2A553B06h)
000000002A553B03 mov rax,rdi
000000002A553B06 mov rax,qword ptr [rax+8]
000000002A553B0A mov r10d,dword ptr [rax+8]
000000002A553B0E test rbx,rbx
000000002A553B11 je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+89h (2A553B19h)
000000002A553B13 lea rax,[rbx-1]
000000002A553B17 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+8Ch (2A553B1Ch)
000000002A553B19 mov rax,rdi
000000002A553B1C mov rax,qword ptr [rax+8]
000000002A553B20 mov r8d,dword ptr [rax+8]
000000002A553B24 test rbx,rbx
000000002A553B27 je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+9Fh (2A553B2Fh)
000000002A553B29 lea rax,[rbx-1]
000000002A553B2D jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+0A2h (2A553B32h)
000000002A553B2F mov rax,rdi
000000002A553B32 mov rax,qword ptr [rax+10h]
000000002A553B36 mov rcx,qword ptr [rax]
000000002A553B39 mov edx,dword ptr [rcx+8]
000000002A553B3C imul edx,r8d
000000002A553B40 mov r8d,r10d
000000002A553B43 mov rcx,rsi
000000002A553B46 call Eigen::ei_matrix_storage<double,10000,10000,10000,2>::ei_matrix_storage<double,10000,10000,10000,2> (2A552660h)
000000002A553B4B nop
000000002A553B4C test rbx,rbx
000000002A553B4F je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+0C7h (2A553B57h)
000000002A553B51 lea rax,[rbx-1]
000000002A553B55 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+0CAh (2A553B5Ah)
000000002A553B57 mov rax,rdi
000000002A553B5A mov rax,qword ptr [rax+10h]
000000002A553B5E mov rcx,qword ptr [rax]
000000002A553B61 mov r9d,dword ptr [rcx+8]
000000002A553B65 test rbx,rbx
000000002A553B68 je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+0E0h (2A553B70h)
000000002A553B6A lea rax,[rbx-1]
000000002A553B6E jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+0E3h (2A553B73h)
000000002A553B70 mov rax,rdi
000000002A553B73 mov rax,qword ptr [rax+8]
000000002A553B77 mov r8d,dword ptr [rax+8]
000000002A553B7B mov edx,r8d
000000002A553B7E imul edx,r9d
000000002A553B82 mov rcx,rsi
000000002A553B85 call Eigen::ei_matrix_storage<double,10000,10000,10000,2>::resize (2A551220h)
000000002A553B8A test rbx,rbx
000000002A553B8D je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+104h (2A553B94h)
000000002A553B8F dec rbx
000000002A553B92 jmp Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+107h (2A553B97h)
000000002A553B94 mov rbx,rdi
000000002A553B97 inc rbx
000000002A553B9A je Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> >::operator+<Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >+110h (2A553BA0h)
000000002A553B9C lea rdi,[rbx-1]
000000002A553BA0 mov rdx,rdi
000000002A553BA3 mov rcx,rsi
000000002A553BA6 call Eigen::MatrixBase<Eigen::Matrix<double,10000,10000,2,10000,10000> >::lazyAssign<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64> (2A5538A0h)
000000002A553BAB nop
000000002A553BAC mov rax,rbp
}
000000002A553BAF mov rbx,qword ptr [rsp+48h]
000000002A553BB4 mov rbp,qword ptr [rsp+50h]
000000002A553BB9 mov rsi,qword ptr [rsp+58h]
000000002A553BBE add rsp,30h
000000002A553BC2 pop rdi
000000002A553BC3 ret


And now the = part:



/***************************
*** Linear vectorization ***
***************************/

template<typename Derived1, typename Derived2>
struct ei_assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
{
inline static void run(Derived1 &dst, const Derived2 &src)
{
000000002A552990 mov qword ptr [rsp+10h],rbx
000000002A552995 mov qword ptr [rsp+20h],rbp
000000002A55299A push rsi
000000002A55299B push rdi
const int size = dst.size();
000000002A55299C mov edi,dword ptr [rcx+0Ch]
000000002A55299F mov r8,rdx
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
000000002A5529A2 mov rdx,qword ptr [rcx]
000000002A5529A5 mov r10,rcx
000000002A5529A8 imul edi,dword ptr [rcx+8]
000000002A5529AC mov dword ptr [dst],edi
000000002A5529B0 test dl,7
000000002A5529B3 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+29h (2A5529B9h)
000000002A5529B5 mov esi,edi
000000002A5529B7 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+48h (2A5529D8h)
000000002A5529B9 shr rdx,3
000000002A5529BD lea rax,[dst]
000000002A5529C2 lea rcx,[rsp+28h]
000000002A5529C7 neg edx
000000002A5529C9 and edx,1
000000002A5529CC cmp edi,edx
000000002A5529CE mov dword ptr [rsp+28h],edx
000000002A5529D2 cmovge rax,rcx
000000002A5529D6 mov esi,dword ptr [rax]
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
000000002A5529D8 mov eax,edi

for(int index = 0; index < alignedStart; ++index)
000000002A5529DA movsxd rbx,esi
000000002A5529DD sub eax,esi
000000002A5529DF cdq
000000002A5529E0 sub eax,edx
000000002A5529E2 xor edx,edx
000000002A5529E4 sar eax,1
000000002A5529E6 cmp rbx,4
000000002A5529EA lea ebp,[rsi+rax*2]
000000002A5529ED jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+14Dh (2A552ADDh)
000000002A5529F3 lea r11,[rbx-3]
/***************************
*** Linear vectorization ***
***************************/

template<typename Derived1, typename Derived2>
struct ei_assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
{
inline static void run(Derived1 &dst, const Derived2 &src)
{
const int size = dst.size();
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

for(int index = 0; index < alignedStart; ++index)
dst.copyCoeff(index, src);
000000002A5529F7 test r8,r8
000000002A5529FA je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+7Bh (2A552A0Bh)
000000002A5529FC lea rax,[r8+1]
000000002A552A00 test rax,rax
000000002A552A03 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+7Bh (2A552A0Bh)
000000002A552A05 lea r9,[rax-1]
000000002A552A09 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+7Eh (2A552A0Eh)
000000002A552A0B xor r9d,r9d
000000002A552A0E mov rax,qword ptr [r9+8]
000000002A552A12 mov rcx,qword ptr [rax]
000000002A552A15 mov rax,qword ptr [r9+10h]
000000002A552A19 movsd xmm0,mmword ptr [rcx+rdx*8]
000000002A552A1E addsd xmm0,mmword ptr [rax+rdx*8]
000000002A552A23 mov rax,qword ptr [r10]
000000002A552A26 movsd mmword ptr [rax+rdx*8],xmm0
000000002A552A2B test r8,r8
000000002A552A2E je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0AFh (2A552A3Fh)
000000002A552A30 lea rax,[r8+1]
000000002A552A34 test rax,rax
000000002A552A37 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0AFh (2A552A3Fh)
000000002A552A39 lea r9,[rax-1]
000000002A552A3D jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0B2h (2A552A42h)
000000002A552A3F xor r9d,r9d
000000002A552A42 mov rax,qword ptr [r9+8]
000000002A552A46 mov rcx,qword ptr [rax]
000000002A552A49 mov rax,qword ptr [r9+10h]
000000002A552A4D movsd xmm0,mmword ptr [rcx+rdx*8+8]
000000002A552A53 addsd xmm0,mmword ptr [rax+rdx*8+8]
000000002A552A59 mov rax,qword ptr [r10]
000000002A552A5C movsd mmword ptr [rax+rdx*8+8],xmm0
000000002A552A62 test r8,r8
000000002A552A65 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0E6h (2A552A76h)
000000002A552A67 lea rax,[r8+1]
000000002A552A6B test rax,rax
000000002A552A6E je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0E6h (2A552A76h)
000000002A552A70 lea r9,[rax-1]
000000002A552A74 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+0E9h (2A552A79h)
000000002A552A76 xor r9d,r9d
000000002A552A79 mov rax,qword ptr [r9+8]
000000002A552A7D mov rcx,qword ptr [rax]
000000002A552A80 mov rax,qword ptr [r9+10h]
000000002A552A84 movsd xmm0,mmword ptr [rcx+rdx*8+10h]
000000002A552A8A addsd xmm0,mmword ptr [rax+rdx*8+10h]
000000002A552A90 mov rax,qword ptr [r10]
000000002A552A93 movsd mmword ptr [rax+rdx*8+10h],xmm0
000000002A552A99 test r8,r8
000000002A552A9C je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+11Dh (2A552AADh)
000000002A552A9E lea rax,[r8+1]
000000002A552AA2 test rax,rax
000000002A552AA5 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+11Dh (2A552AADh)
000000002A552AA7 lea r9,[rax-1]
000000002A552AAB jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+120h (2A552AB0h)
000000002A552AAD xor r9d,r9d
000000002A552AB0 mov rax,qword ptr [r9+8]
000000002A552AB4 add rdx,4
inline static void run(Derived1 &dst, const Derived2 &src)
{
const int size = dst.size();
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

for(int index = 0; index < alignedStart; ++index)
dst.copyCoeff(index, src);

for(int index = alignedStart; index < alignedEnd; index += packetSize)
{
dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
}

for(int index = alignedEnd; index < size; ++index)
000000002A552AB8 cmp rdx,r11
000000002A552ABB mov rcx,qword ptr [rax]
000000002A552ABE mov rax,qword ptr [r9+10h]
000000002A552AC2 movsd xmm0,mmword ptr [rcx+rdx*8-8]
000000002A552AC8 addsd xmm0,mmword ptr [rax+rdx*8-8]
000000002A552ACE mov rax,qword ptr [r10]
000000002A552AD1 movsd mmword ptr [rax+rdx*8-8],xmm0
000000002A552AD7 jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+67h (2A5529F7h)

for(int index = 0; index < alignedStart; ++index)
000000002A552ADD cmp rdx,rbx
000000002A552AE0 jge Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+191h (2A552B21h)
dst.copyCoeff(index, src);
000000002A552AE2 test r8,r8
000000002A552AE5 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+166h (2A552AF6h)
000000002A552AE7 lea rax,[r8+1]
000000002A552AEB test rax,rax
000000002A552AEE je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+166h (2A552AF6h)
000000002A552AF0 lea r9,[rax-1]
000000002A552AF4 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+169h (2A552AF9h)
000000002A552AF6 xor r9d,r9d
000000002A552AF9 mov rax,qword ptr [r9+8]
inline static void run(Derived1 &dst, const Derived2 &src)
{
const int size = dst.size();
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

for(int index = 0; index < alignedStart; ++index)
dst.copyCoeff(index, src);

for(int index = alignedStart; index < alignedEnd; index += packetSize)
{
dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
}

for(int index = alignedEnd; index < size; ++index)
000000002A552AFD inc rdx
000000002A552B00 cmp rdx,rbx
000000002A552B03 mov rcx,qword ptr [rax]
000000002A552B06 mov rax,qword ptr [r9+10h]
000000002A552B0A movsd xmm0,mmword ptr [rcx+rdx*8-8]
000000002A552B10 addsd xmm0,mmword ptr [rax+rdx*8-8]
000000002A552B16 mov rax,qword ptr [r10]
000000002A552B19 movsd mmword ptr [rax+rdx*8-8],xmm0
000000002A552B1F jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+152h (2A552AE2h)

for(int index = alignedStart; index < alignedEnd; index += packetSize)
000000002A552B21 cmp esi,ebp
000000002A552B23 jge Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+1EFh (2A552B7Fh)
000000002A552B25 lea r11,[rbx*8]
000000002A552B2D mov ebx,ebp
000000002A552B2F sub ebx,esi
000000002A552B31 dec ebx
000000002A552B33 shr ebx,1
000000002A552B35 inc ebx
template<typename Derived1, typename Derived2>
struct ei_assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
{
inline static void run(Derived1 &dst, const Derived2 &src)
{
const int size = dst.size();
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

for(int index = 0; index < alignedStart; ++index)
dst.copyCoeff(index, src);

for(int index = alignedStart; index < alignedEnd; index += packetSize)
{
dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
000000002A552B37 test r8,r8
000000002A552B3A je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+1BBh (2A552B4Bh)
000000002A552B3C lea rax,[r8+1]
000000002A552B40 test rax,rax
000000002A552B43 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+1BBh (2A552B4Bh)
000000002A552B45 lea r9,[rax-1]
000000002A552B49 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+1BEh (2A552B4Eh)
000000002A552B4B xor r9d,r9d
000000002A552B4E mov rax,qword ptr [r9+8]
000000002A552B52 mov rdx,qword ptr [r10]
000000002A552B55 add r11,10h
000000002A552B59 sub rbx,1
000000002A552B5D mov rcx,qword ptr [rax]
000000002A552B60 mov rax,qword ptr [r9+10h]
000000002A552B64 movupd xmm0,xmmword ptr [r11+rax-10h]
000000002A552B6B movapd xmm1,xmmword ptr [r11+rcx-10h]
000000002A552B72 addpd xmm1,xmm0
000000002A552B76 movapd xmmword ptr [r11+rdx-10h],xmm1
000000002A552B7D jne Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+1A7h (2A552B37h)

for(int index = alignedStart; index < alignedEnd; index += packetSize)
000000002A552B7F movsxd rdx,ebp
}

for(int index = alignedEnd; index < size; ++index)
000000002A552B82 movsxd r11,edi
000000002A552B85 cmp rdx,r11
000000002A552B88 jge Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+338h (2A552CC8h)
000000002A552B8E mov rax,r11
000000002A552B91 sub rax,rdx
000000002A552B94 cmp rax,4
000000002A552B98 jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+2F5h (2A552C85h)
000000002A552B9E lea rbx,[r11-3]
{
const int size = dst.size();
const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
: ei_alignmentOffset(&dst.coeffRef(0), size);
const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

for(int index = 0; index < alignedStart; ++index)
dst.copyCoeff(index, src);

for(int index = alignedStart; index < alignedEnd; index += packetSize)
{
dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
}

for(int index = alignedEnd; index < size; ++index)
dst.copyCoeff(index, src);
000000002A552BA2 test r8,r8
000000002A552BA5 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+225h (2A552BB5h)
000000002A552BA7 lea r9,[r8+1]
000000002A552BAB test r9,r9
000000002A552BAE je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+225h (2A552BB5h)
000000002A552BB0 dec r9
000000002A552BB3 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+228h (2A552BB8h)
000000002A552BB5 xor r9d,r9d
000000002A552BB8 mov rax,qword ptr [r9+8]
000000002A552BBC mov rcx,qword ptr [rax]
000000002A552BBF mov rax,qword ptr [r9+10h]
000000002A552BC3 movsd xmm0,mmword ptr [rcx+rdx*8]
000000002A552BC8 addsd xmm0,mmword ptr [rax+rdx*8]
000000002A552BCD mov rax,qword ptr [r10]
000000002A552BD0 movsd mmword ptr [rax+rdx*8],xmm0
000000002A552BD5 test r8,r8
000000002A552BD8 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+258h (2A552BE8h)
000000002A552BDA lea r9,[r8+1]
000000002A552BDE test r9,r9
000000002A552BE1 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+258h (2A552BE8h)
000000002A552BE3 dec r9
000000002A552BE6 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+25Bh (2A552BEBh)
000000002A552BE8 xor r9d,r9d
000000002A552BEB mov rax,qword ptr [r9+8]
000000002A552BEF mov rcx,qword ptr [rax]
000000002A552BF2 mov rax,qword ptr [r9+10h]
000000002A552BF6 movsd xmm0,mmword ptr [rcx+rdx*8+8]
000000002A552BFC addsd xmm0,mmword ptr [rax+rdx*8+8]
000000002A552C02 mov rax,qword ptr [r10]
000000002A552C05 movsd mmword ptr [rax+rdx*8+8],xmm0
000000002A552C0B test r8,r8
000000002A552C0E je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+28Fh (2A552C1Fh)
000000002A552C10 lea rax,[r8+1]
000000002A552C14 test rax,rax
000000002A552C17 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+28Fh (2A552C1Fh)
000000002A552C19 lea r9,[rax-1]
000000002A552C1D jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+292h (2A552C22h)
000000002A552C1F xor r9d,r9d
000000002A552C22 mov rax,qword ptr [r9+8]
000000002A552C26 mov rcx,qword ptr [rax]
000000002A552C29 mov rax,qword ptr [r9+10h]
000000002A552C2D movsd xmm0,mmword ptr [rcx+rdx*8+10h]
000000002A552C33 addsd xmm0,mmword ptr [rax+rdx*8+10h]
000000002A552C39 mov rax,qword ptr [r10]
000000002A552C3C movsd mmword ptr [rax+rdx*8+10h],xmm0
000000002A552C42 test r8,r8
000000002A552C45 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+2C5h (2A552C55h)
000000002A552C47 lea r9,[r8+1]
000000002A552C4B test r9,r9
000000002A552C4E je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+2C5h (2A552C55h)
000000002A552C50 dec r9
000000002A552C53 jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+2C8h (2A552C58h)
000000002A552C55 xor r9d,r9d
000000002A552C58 mov rax,qword ptr [r9+8]
000000002A552C5C add rdx,4
000000002A552C60 cmp rdx,rbx
000000002A552C63 mov rcx,qword ptr [rax]
000000002A552C66 mov rax,qword ptr [r9+10h]
000000002A552C6A movsd xmm0,mmword ptr [rcx+rdx*8-8]
000000002A552C70 addsd xmm0,mmword ptr [rax+rdx*8-8]
000000002A552C76 mov rax,qword ptr [r10]
000000002A552C79 movsd mmword ptr [rax+rdx*8-8],xmm0
000000002A552C7F jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+212h (2A552BA2h)
}

for(int index = alignedEnd; index < size; ++index)
000000002A552C85 cmp rdx,r11
000000002A552C88 jge Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+338h (2A552CC8h)
dst.copyCoeff(index, src);
000000002A552C8A test r8,r8
000000002A552C8D je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+30Dh (2A552C9Dh)
000000002A552C8F lea r9,[r8+1]
000000002A552C93 test r9,r9
000000002A552C96 je Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+30Dh (2A552C9Dh)
000000002A552C98 dec r9
000000002A552C9B jmp Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+310h (2A552CA0h)
000000002A552C9D xor r9d,r9d
000000002A552CA0 mov rax,qword ptr [r9+8]
000000002A552CA4 inc rdx
000000002A552CA7 cmp rdx,r11
000000002A552CAA mov rcx,qword ptr [rax]
000000002A552CAD mov rax,qword ptr [r9+10h]
000000002A552CB1 movsd xmm0,mmword ptr [rcx+rdx*8-8]
000000002A552CB7 addsd xmm0,mmword ptr [rax+rdx*8-8]
000000002A552CBD mov rax,qword ptr [r10]
000000002A552CC0 movsd mmword ptr [rax+rdx*8-8],xmm0
000000002A552CC6 jl Eigen::ei_assign_impl<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::CwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0>,Eigen::Product<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> const & __ptr64,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,10000,10000,2,10000,10000>,0> > const & __ptr64,1> >,1,0>::run+2FAh (2A552C8Ah)
}
000000002A552CC8 mov rbx,qword ptr [rsp+20h]
000000002A552CCD mov rbp,qword ptr [rsp+30h]
000000002A552CD2 pop rdi
000000002A552CD3 pop rsi
000000002A552CD4 ret
--- No source file -------------------------------------------------------------
000000002A552CD5 int 3
000000002A552CD6 int 3
000000002A552CD7 int 3
000000002A552CD8 int 3
000000002A552CD9 int 3
000000002A552CDA int 3
000000002A552CDB int 3
000000002A552CDC int 3
000000002A552CDD int 3
000000002A552CDE int 3
000000002A552CDF int 3
--- c:\build2\thirdpartylibs\eigen-2.0.12\eigen\eigen\src\core\assign.h --------
};

When you say the development branch is Eigen 2.0.12 ok then?

No! The development branch is called 'default' in the mercurial repository. it's Eigen 3. See the wiki main page, it's explained.

That stuff is NOT working correctly in 2.0.12. That is, it won't understand it's aligned.

Also note I said 16 byte, not 16 bit. That's 128 bit. That's more than the default even on many 64 bit platforms.

And yes, the assembly that you posted does use SSE registers (XMM...), but only the instructions with 'p' are actually SIMD instructions. For example addsd is adding a single double (no SIMD), addpd is what you want (add a packet of doubles at once).

Hi bjacob,

Things got a bit better, thought not what I initially expected.

I used the development branch 'default'.
Now I can see in the disassembly some SIMD instructions, with ‘p’s, such as movupd, addpd, etc. It seems this code is working a tiny bit faster than before.

The code runs and does what I expect but still slower than the hand written (no SSEd) equivalent.

I run this piece of code in an image processing application where it gets called for each acquired frame. I timed the Eigen code and the hand written one. I use the BenchTimer to time both sections. I can see that the hand written code is from 6 to 12 times faster than the Eigen one. I post some of the recorded times for a few frames, first column is Eigen part and second is the hand written code.

0.0013388, 0.000202316
0.000217715, 1.83922e-005
0.000227552, 1.83927e-005
0.00125068, 0.000202317
0.000214293, 1.79647e-005
0.000216432, 1.83922e-005
0.0012494, 0.000201033
0.000213866, 1.79647e-005
0.000213866, 1.88202e-005
0.00125368, 0.000201461
0.00021686, 1.88202e-005
0.000214293, 1.83922e-005
0.00124812, 0.000200605
0.000214293, 1.83927e-005
0.000214293, 1.79643e-005
0.00124598, 0.000201461
0.000213866, 1.83922e-005
0.000214293, 1.83922e-005
0.00128704, 0.000201461
0.000214721, 1.88202e-005
0.000213866, 1.83922e-005
0.00124213, 0.000201033
0.000213866, 1.88202e-005
0.000213865, 1.83922e-005
0.0012524, 0.000201033
0.000213866, 1.83927e-005
0.000214293, 1.83922e-005
0.00125625, 0.000202316
0.000216859, 1.83927e-005
0.000219426, 1.83922e-005
0.00124726, 0.000203172
0.000213865, 1.83922e-005
0.000216432, 1.83922e-005
0.00124769, 0.00020916
etc

I would think that Eigen should be faster than a code that doesn’t use SSE.

I add the hand written code to compare:

for(int col = 0; col < nMatCols; ++col, ++pVect)
{
double *pResults = m_RealData;
for(int row = 0; row < nMatRows; ++row, ++pResults, ++pMatrix)
{
*pResults += *pVect * *pMatrix;
}
}

How can I make the Eigen part go faster?
I have tried to aligned my mapped arrays to 128bits, but there is no difference in speed.

We have lots of little add hoc pieces like this, and we keep creating new ones. I’d really like to use something as expressive as Eigen, but performance is more important in our case.

Any suggestions on how to improve the Eigen performance?

Thanks for your help.
Martin.

martinakos wrote:Hi bjacob,
Now I can see in the disassembly some SIMD instructions, with ‘p’s, such as movupd, addpd, etc

movupd? That means *unaligned* access. Are you sure you specified Aligned? Can you paste your source code again?

That can easily explain the bad performance.

Ah! that's true, I forgot to mention something. Before I tried the development branch I used the following code:

Map<MatrixXd, Aligned> eMatrix(pMatrix,nMatRows,nMatCols);
Map<MatrixXd, Aligned> eVector(pVect,1,nMatCols);
Map<MatrixXd, Aligned> eResults(m_RealData,1,nMatRows);
eResults += eVector * eMatrix.transpose();

And it worked well but slower than expected. When I switched to the development branch I would get an exception with the same code, I don't remember the exception as it got caught by a catch all exception in the existing code. I removed the 'Aligned' from the template parameter and it didn't produce the exception anymore, it produced the right results but still slower than expected. When I removed the 'Aligned' I still aligned pMatrix, pVect and m_RealData using aligned_malloc/aligned_free.

allocating the objects at aligned locations is one thing. Telling that to Eigen at compile time, enabling it to use aligned instructions, is another thing! In order to get good performance, you must use Aligned here. If you think that a bug / crash is preventing you from doing that, we can look into that.

Hi bjacob

I don't know if it's a bug or I'm doing something wrong.
What I see is that the code with the 'Aligned' as template parameter works well with eigen-2.0.12, but when I switch to use eigen-default I get an access violation reading location 0x0000000.

What can I send you to diagnose this?
I'll send you the line where the exception happens and the stack.


With maximize speed optimization the exception happens at the line:

const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs);

with stack:

DriverApp.exe!Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5>::scaleAndAddTo<Eigen::Matrix<double,33331,33331,0,33331,33331> >(Eigen::Matrix<double,33331,33331,0,33331,33331> & dst={...}, double alpha=1.0000000000000000) Line 269 + 0x77 bytes C++
DriverApp.exe!Eigen::ProductBase<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > > >::evalTo<Eigen::Matrix<double,33331,33331,0,33331,33331> >(Eigen::Matrix<double,33331,33331,0,33331,33331> & dst={...}) Line 107 + 0x9e bytes C++
DriverApp.exe!Eigen::DenseBase<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> >::eval() Line 454 C++


If I disable the optimization I get the same type of exception at the line:

template<> EIGEN_STRONG_INLINE Packet2d ei_pload<double>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }

and the relevant stack is:

DriverApp.exe!Eigen::ei_pload<double>(const double * from=0x05e6f008) Line 184 + 0x1c bytes C++
DriverApp.exe!Eigen::ei_ploadt<double,1>(const double * from=0x05e6f008) Line 244 + 0x9 bytes C++
DriverApp.exe!Eigen::MapBase<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >::packet<1>(int index=0) Line 128 + 0x1a bytes C++
DriverApp.exe!Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >::copyPacket<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,1>(int index=0, const Eigen::DenseBase<Eigen::Matrix<double,33331,33331,0,33331,33331> > & other={...}) Line 113 + 0x23 bytes C++
DriverApp.exe!Eigen::ei_assign_impl<Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,Eigen::Matrix<double,33331,33331,0,33331,33331>,3,0>::run(Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > > & dst={...}, const Eigen::Matrix<double,33331,33331,0,33331,33331> & src={...}) Line 399 C++
DriverApp.exe!Eigen::DenseBase<Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > > >::lazyAssign<Eigen::Matrix<double,33331,33331,0,33331,33331> >(const Eigen::DenseBase<Eigen::Matrix<double,33331,33331,0,33331,33331> > & other={...}) Line 472 + 0x17 bytes C++
DriverApp.exe!Eigen::ei_assign_selector<Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5>,1,0>::run(Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > > & dst={...}, const Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> & other={...}) Line 496 + 0x43 bytes C++
DriverApp.exe!Eigen::DenseBase<Eigen::SelfCwiseBinaryOp<Eigen::ei_scalar_sum_op<double>,Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > > >::operator=<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> >(const Eigen::DenseBase<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> > & other={...}) Line 511 + 0x17 bytes C++
DriverApp.exe!Eigen::MatrixBase<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >::operator+=<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> >(const Eigen::MatrixBase<Eigen::GeneralProduct<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> >,Eigen::Transpose<Eigen::Map<Eigen::Matrix<double,33331,33331,0,33331,33331>,1,Eigen::Stride<0,0> > >,5> > & other={...}) Line 216 C++