Question

为什么矩阵加法比矩阵矢量乘法要花费更长的时间？

Matrix Add仅花费n ^ 2加，而Matrix-Vector乘法需要n *（n-1）加和n ^ 2乘法。

但是，在Eigen中，Matrix Add花费的时间是原来的两倍。矩阵向量乘法确实如此。是否有任何选项可以加快Eigen中的Matrix Add操作？

#include <eigen3/Eigen/Eigen>
#include <iostream>
#include <ctime>
#include <string>
#include <chrono>
#include <fstream>
#include <random>
#include <iomanip>

using namespace Eigen;
using namespace std;

int main()
{
const int l=100;
MatrixXf m=MatrixXf::Random(l,l);
MatrixXf n=MatrixXf::Random(l,l);
VectorXf v=VectorXf::Random(l,1);

MatrixXf qq=MatrixXf::Random(l,1);
MatrixXf pp=MatrixXf::Random(l,l);

auto start = chrono::steady_clock::now();
for(int j=0;j<10000;j++)
qq=m*v;
auto end = chrono::steady_clock::now();
double time_duration=chrono::duration_cast<chrono::milliseconds>(end - start).count();
std::cout << setprecision(6) << "Elapsed time in seconds : "<< time_duration/1000<< "s" << std::endl;
auto start1 = chrono::steady_clock::now();
for(int j=0;j<10000;j++)
pp=m+n;
auto end1 = chrono::steady_clock::now();
double time_duration1=chrono::duration_cast<chrono::milliseconds>(end1 - start1).count();
std::cout << setprecision(6) << "Elapsed time in seconds : "<< time_duration1/1000<< "s" << std::endl;
}

测试1：未经任何优化：

编译命令：g ++-8 -test.cpp -o test

运行命令：./test

经过的时间（秒）：0.323s

经过的时间（秒）：0.635s

测试2：使用-march =本地优化：

g ++-8 test.cpp -march =本机-o测试

运行命令：./test

经过的时间（以秒为单位）：0.21s

经过的时间（秒）：0.372s

测试3：使用-O3优化：

编译命令：g ++-8 -test.cpp -O3 -o测试

运行命令：./test

经过的时间（秒）：0.009s

经过的时间（秒）：0.016s

测试4：-march = native，-O3优化：

编译命令：g ++-8 -test.cpp -march = native -O3 -o test

运行命令：./test

经过的时间（秒）：0.008s

经过的时间（秒）：0.016s

==============

由于没有使用上一次迭代的结果，我注意到编译器可能会作弊。为了解决这个问题，我改为进行一次迭代，并使用较大的大小来获得稳定的时间统计信息。

#include <eigen3/Eigen/Eigen>
#include <iostream>
#include <ctime>
#include <string>
#include <chrono>
#include <fstream>
#include <random>
#include <iomanip>

using namespace Eigen;
using namespace std;

int main()
{
const int l=1000;
MatrixXf m=MatrixXf::Random(l,l);
MatrixXf n=MatrixXf::Random(l,l);
VectorXf v=VectorXf::Random(l,1);

MatrixXf qq=MatrixXf::Random(l,1);
MatrixXf pp=MatrixXf::Random(l,l);

auto start = chrono::steady_clock::now();
qq=m*v;
auto end = chrono::steady_clock::now();
double time_duration=chrono::duration_cast<chrono::microseconds>(end - start).count();

auto start1 = chrono::steady_clock::now();
pp=m+n;
auto end1 = chrono::steady_clock::now();
double time_duration1=chrono::duration_cast<chrono::microseconds>(end1 - start1).count();
std::cout << setprecision(6) << "Elapsed time in microseconds : "<< time_duration<< "us" << std::endl;
std::cout << setprecision(6) << "Elapsed time in microseconds : "<< time_duration1<< "us" << std::endl;
}

测试1：未经任何优化：

编译命令：g ++-8 -test.cpp -o test

运行命令：./test

经过的时间（以微秒为单位）：3125us

经过的时间（以微秒为单位）：6849us

测试2：使用-march =本地优化：

g ++-8 test.cpp -march =本机-o测试

运行命令：./test

经过的时间（以微秒为单位）：1776us

经过的时间（以微秒为单位）：3815us

测试3：使用-O3优化：

编译命令：g ++-8 -test.cpp -O3 -o测试

运行命令：./test

经过的时间（以微秒为单位）：449us

经过的时间（以微秒为单位）：760us

测试4：-march = native，-O3优化：

编译命令：g ++-8 -test.cpp -march = native -O3 -o test

运行命令：./test

经过的时间（以微秒为单位）：351us

经过的时间（以微秒为单位）：871us

Answer 1

简短的回答：您计算了操作数，但忽略了对内存访问的计数，在这种情况下，对于加法而言，内存访问的开销增加了近2倍。详细信息如下。

首先，两种操作的实际操作次数是相同的，因为现代CPU能够同时执行一个独立的加法和乘法。像x*y+z这样的两个连续mul / add甚至可以作为单个操作进行融合，其成本与1个加法或1个乘法相同。如果您的CPU支持FMA，-march=native会发生这种情况，但是我怀疑FMA在这里起什么作用。

第二，在计算上您忘了测量内存访问的数量。回想一下，除非数据已经在L1高速缓存中，否则一种内存负载要比一加或一mul昂贵得多。

添加起来很容易：我们有2*n^2个加载，其中有很多缓存未命中，还有n^2个存储。

对于具有以列为主的矩阵的矩阵向量乘积，输入向量仅读取一次，因此n^2+n会加载输入，并且由于这些列是一次由4列的块处理的，因此n^2/4对输出向量进行读写操作，但是由于高速缓存未命中L1缓存，因此几乎没有零缓存。因此，总的来说，相加的开销要比矩阵向量乘积的开销大将近x2，因此x2的速度因子并不是异常。

此外，通过显式循环剥离更主动地优化了矩阵矢量代码，尽管我怀疑这对基准测试有什么影响，因为您的矩阵根本不适合L1缓存。

为什么矩阵加法比本征矩阵向量乘法慢？

1 个答案: