我使用的Eigen版本使用“true”固定大小的矩阵和向量,采用更好的算法(在uBlas中采用LDLT而不是LU),它在内部使用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版本创建矩阵的副本(LDLT)-因此它的缓存利用率较低。
有没有办法在Eigen中进行原地计算?或者也许有其他方法可以改进它?
编辑:
按照Fezvez的建议使用LLT而不是LDLT,我得到了:
Eigen 0.16 s
488184
虽然它不错,但仍会进行不必要的矩阵堆栈分配:
sizeof(A.llt()) == 656
我更倾向于避免它 - 这样应该会更快。
编辑:
我通过从LDLT进行子类化(其内部矩阵受保护)并直接填充来删除了分配。现在,LDLT的结果如下:
Eigen 0.26 s
488209
它能够工作,但这只是一种权宜之计,不是真正的解决方案...
从LLT进行子类化也可以工作,但效果没有那么好。