Почему Eigen в 5 раз медленнее, чем ublas на следующем примере?

В версии Eigen я использую «настоящие» матрицы и векторы фиксированного размера, лучший алгоритм (LDLT по сравнению с LU в uBlas), он использует внутри SIMD-инструкции. Итак, почему он медленнее, чем uBlas на следующем примере?

Я уверен, что делаю что-то не так - Eigen ДОЛЖЕН быть быстрее или, по крайней мере, сопоставимым.

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include <boost/progress.hpp>
#include <Eigen/Dense>
#include <iostream>

using namespace boost;
using namespace std;
const int n=9;
const int total=100000;

void test_ublas()
{
    using namespace boost::numeric::ublas;
    cout << "Boost.ublas ";
    double r=1.0;
    {
        boost::progress_timer t;
        for(int j=0;j!=total;++j)
        {
            //symmetric_matrix< double,lower,row_major,bounded_array<double,(1+n)*n/2> > A(n,n);
            matrix<double,row_major,bounded_array<double,n*n> > A(n,n);
            permutation_matrix< unsigned char,bounded_array<unsigned char,n> > P(n);
            bounded_vector<double,n> v;
            for(int i=0;i!=n;++i)
                for(int k=0;k!=n;++k)
                    A(i,k)=0.0;
            for(int i=0;i!=n;++i)
            {
                A(i,i)=1.0+i;
                v[i]=i;
            }
            lu_factorize(A,P);
            lu_substitute(A,P,v);
            r+=inner_prod(v,v);
        }
    }
    cout << r << endl;
}

void test_eigen()
{
    using namespace Eigen;
    cout << "Eigen ";
    double r=1.0;
    {
        boost::progress_timer t;
        for(int j=0;j!=total;++j)
        {
            Matrix<double,n,n> A;
            Matrix<double,n,1> b;
            for(int i=0;i!=n;++i)
            {
                A(i,i)=1.0+i;
                b[i]=i;
            }
            Matrix<double,n,1> x=A.ldlt().solve(b);
            r+=x.dot(x);
        }
    }
    cout << r << endl;
}

int main()
{
    test_ublas();
    test_eigen();
}

Выход:

Boost.ublas 0.50 s

488184
Eigen 2.66 s

488184

(Выпуск Visual Studio 2010 x64)

ИЗМЕНИТЬ:

Для

const int n=4;
const int total=1000000;

Выход:

Boost.ublas 0.67 s

1.25695e+006
Eigen 0.40 s

5.4e+007

Я предполагаю, что такое поведение связано с тем, что версия uBlas вычисляет факторизацию на месте, а версия Eigen создает COPY матрицы (LDLT) - поэтому она хуже подходит для кеша.

Есть ли способ выполнить вычисления на месте в Eigen? Или, может быть, есть другие способы улучшить его?

ИЗМЕНИТЬ:

Следуя совету Февеза и используя LLT вместо LDLT, я получаю:

Eigen 0.16 s

488184

Это хорошо, но все еще делает ненужное выделение стека матриц:

sizeof(A.llt()) == 656

Я предпочитаю избегать этого - это должно быть еще быстрее.

ИЗМЕНИТЬ:

Я удалил выделение, создав подкласс из LDLT (его внутренняя матрица защищена) и заполнив его напрямую. Теперь результат для LDLT:

Eigen 0.26 s
488209

Это работает, но это обходной путь - не настоящее решение...

Наследование от LLT тоже работает, но не дает такого большого эффекта.