c++矩阵计算性能对比:Eigen和GPU解读

目录生成随机矩阵计算矩阵点积使用显式循环计算使用Eigen库使用GPU结果分析总结生成随机矩阵生成随机矩阵有多种方式，直接了当的方式是使用显式循环的方式为矩阵的每个元素赋随机值。#includeio...

目录

生成随机矩阵

生成随机矩阵有多种方式，直接了当的方式是使用显式循环的方式为矩阵的每个元素赋随机值。

#include <IOStream>
#include <random>

using namespace std;

// 生成随机数
double GenerateRandomRealValue()
{
  std::random_device rd;
  std::default_random_engine eng(rd());
  std::uniform_real_distribution<double> distr(1, 10);
  return distr(eng);
}

int main()
{
  // 3d矩阵
  double a[3][3];
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < 3; ++j) {
      a[i][j] = GenerateRandomRealValue();
    }
  }

  return 0;
}

另一种方式是使用Eigen库，它提供了矩阵运算的库。

生成随机矩阵：

#include "Eigen/Dense"
#include <functional>

using namespace std;
using namespace Eigen;

MatrixXd Generate2DMatrixByEigen()
{
  // 直接使用内置的Random，产生均匀分布随机矩阵
  MatrixXd m = MatrixXd::Random(3,3);
 
  // 也可以调用自定义的随机数生成函数填充数据
  // MatrixXd m = MatrixXd::Zero(3,3).unaryExpr(std::bind(GenerateRandomRealValue));
  return m;
}

计算矩阵点积

使用显式循环计算

直接上代码：

void CalcMatrixDotForLoop(const vector<vector<double>>& a, const vector<vector<double>>& b)
{
  std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
  if (a[0].size() != b.size()) {
    cout << "error:" << a.size() << "," << b[0].size() << endl;
    return;
  }

  vector<vector<double>> c;
  vector<double> c_row(b[0].size());
  for (int i = 0; i < a.size(); ++i) {
    for (int j = 0; j < b[0].size(); ++j) {
      for (int k = 0; k < b.size(); ++k) {
        c_row[j] += a[i][k] * b[k][j];
      }
    }
    c.emplace_back(c_row);
  }
  std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> time_span = t2 - t1;
  std::cout << "Loop takes " << time_span.count() << " ms\n";

  // cout << "mjavascriptatrix c:\n";
  // for (int i = 0; i < c.size(); ++i) {
  //   for (int j = 0; j < c[0].size(); ++j) {
  //     cout << c[i][j] << ",";
  //   }
  //   cout << endl;
  // }
}

使用Eigen库

代码：

void ModeEigen(const int a_row, const int a_col, const int b_row, const int b_col)
{
  std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
  auto c = a * b;
  std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> time_span = t2 - t1;
  std::cout << "Eigen takes " << time_span.count() << " ms\n";
  // cout << "matrix c:\n" << c << endl;
}

使用GPU

代码片断：

auto t_begin = std::chrono::high_resolution_clock::now();

t1 = std::chrono::high_resolution_clock::now();
cudaMalloc((void**)&da,size);
cudaMalloc((void**)&db,size);
cudaMalloc((void**)&dc,size);
t2 = std::chrono::high_resolution_clock::now();
time_span = t2 - t1;
std::cout << "GPU malloc takes " << time_span.count() << " ms\n";

t1 = std::chrono::high_resolution_clock::now();
cudaMemcpy(da,a,size,cudaMemcpyHostToDevice);
cudaMemcpy(db,b,size,cudaMemcpyHostToDevice);
t2 = std::chrono::high_resolution_clock::now();
time_span = t2 - t1;
std::cout << "cudaMemcpy takes " << time_span.count() << " ms\n";

t1 = std::chrono::high_resolution_clock::now();
dim3 dg(32,32);
dim3 dbs((n+dg.x-1)/dg.x,(n+dg.y-1)/dg.y);
mextix<<<dbs,dg>>>(da,db,dc,n);
t2 = std::chrono::high_resolution_clock::now();
time_span = t2 - t1;
std::cout << "gpu takes " << time_span.count() << " ms\n";

t1 = std::chrono::high_resolution_clock::now();
cudaMemcpy(c,dc,size,cudaMemcpyDeviceToHost);
t2 = std::chrono::high_resolution_clock::now();
time_span = t2 - t1;
std::cout << "cudaMemcpy back takes " << time_span.count() << " ms\n";

cudaFree(da);
cudaFree(db);
cudaFree(dc);

auto t_end = std::chrono::high_resolution_clock::now();
time_span = t_end - t_begin;
std::cout << "GPU total takes " << time_span.count() << js" ms\n";

结果分析

经过测试，得到以下结论：

总之：

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。