CUDA：如何使用推力进行矩阵乘法？

Question

我是CUDA和Thrust的新手，我正在尝试实现矩阵乘法，我想通过仅使用推力算法来实现这一点，因为我想避免手动调用内核。

有没有办法可以有效地实现这一目标？ （至少没有使用2个嵌套for循环）

或者我必须辞职并致电CUDA内核？

//My data
thrust::device_vector<float> data(n*m);
thrust::device_vector<float> other(m*r);
thrust::device_vector<float> result(n*r);

// To make indexing faster, not really needed
transpose(other);

// My current approach
for (int i = 0; i < n; ++i)
{
   for (int j = 0; j < r;++j)
   {
       result[i*r+ j] = thrust::inner_product(data.begin()+(i*m), data.begin()+((i+1)*m),other+(j*m), 0.0f);
   }
}

Answer 1

如果您对性能感兴趣（通常为什么人们使用GPU进行计算任务），则不应使用推力，也不应该调用或编写自己的CUDA内核。 您应该使用CUBLAS库。 对于学习练习，如果您想学习自己的CUDA内核，可以在共享内存部分的CUDA编程指南中参考第一级优化的CUDA版本 。 如果你真的想通过一次推力使用推力，那么它是可能的。

基本思想是使用像这里描述的push :: transform这样的元素操作。 使用由循环组成的仿函数计算每输出数组元素点积。

这是一个考虑3种方法的实例。 你原来的双嵌套循环方法（相对慢），单个推力调用方法（更快）和cublas方法（最快，当然对于更大的矩阵大小）。 下面的代码只运行方法1，矩阵边尺寸为200或更小，因为它太慢了。 以下是特斯拉P100的示例：

$ cat t463.cu
#include <thrust/device_vector.h>
#include <thrust/transform.h>
#include <thrust/inner_product.h>
#include <thrust/execution_policy.h>
#include <thrust/equal.h>
#include <thrust/iterator/constant_iterator.h>
#include <cublas_v2.h>
#include <iostream>
#include <time.h>
#include <sys/time.h>
#include <cstdlib>
#define USECPSEC 1000000ULL

long long dtime_usec(unsigned long long start){

  timeval tv;
  gettimeofday(&tv, 0);
  return ((tv.tv_sec*USECPSEC)+tv.tv_usec)-start;
}

struct dp
{
  float *A, *B;
  int m,n,r;
  dp(float *_A, float *_B, int _m, int _n, int _r): A(_A), B(_B), m(_m), n(_n), r(_r) {};
  __host__ __device__
  float operator()(size_t idx){
    float sum = 0.0f;
    int row = idx/r;
    int col = idx - (row*r); // cheaper modulo
    for (int i = 0; i < m; i++)
      sum += A[col + row*i] * B[col + row*i];
    return sum;}
};

const int dsd = 200;
int main(int argc, char *argv[]){
  int ds = dsd;
  if (argc > 1) ds = atoi(argv[1]);
  const int n = ds;
  const int m = ds;
  const int r = ds;
  // data setup
  thrust::device_vector<float> data(n*m,1);
  thrust::device_vector<float> other(m*r,1);
  thrust::device_vector<float> result(n*r,0);
  // method 1
  //let's pretend that other is (already) transposed for efficient memory access by thrust
  // therefore each dot-product is formed using a row of data and a row of other
  long long dt = dtime_usec(0);
    if (ds < 201){
    for (int i = 0; i < n; ++i)
    {
      for (int j = 0; j < r;++j)
      {
         result[i*r+ j] = thrust::inner_product(data.begin()+(i*m), data.begin()+((i+1)*m),other.begin()+(j*m), 0.0f);
      }
    }
    cudaDeviceSynchronize();
    dt = dtime_usec(dt);
    if (thrust::equal(result.begin(), result.end(), thrust::constant_iterator<float>(m)))
      std::cout << "method 1 time: " << dt/(float)USECPSEC << "s" << std::endl;
    else
      std::cout << "method 1 failure" << std::endl;
    }
  thrust::fill(result.begin(), result.end(), 0);
  cudaDeviceSynchronize();
// method 2
  //let's pretend that data is (already) transposed for efficient memory access by thrust
  // therefore each dot-product is formed using a column of data and a column of other
  dt = dtime_usec(0);
  thrust::transform(thrust::counting_iterator<int>(0), thrust::counting_iterator<int>(n*r), result.begin(), dp(thrust::raw_pointer_cast(data.data()), thrust::raw_pointer_cast(other.data()), m, n, r));
  cudaDeviceSynchronize();
  dt = dtime_usec(dt);
  if (thrust::equal(result.begin(), result.end(), thrust::constant_iterator<float>(m)))
    std::cout << "method 2 time: " << dt/(float)USECPSEC << "s" << std::endl;
  else
    std::cout << "method 2 failure" << std::endl;
// method 3
  // once again, let's pretend the data is ready to go for CUBLAS
  cublasHandle_t h;
  cublasCreate(&h);
  thrust::fill(result.begin(), result.end(), 0);
  float alpha = 1.0f;
  float beta = 0.0f;
  cudaDeviceSynchronize();
  dt = dtime_usec(0);
  cublasSgemm(h, CUBLAS_OP_T, CUBLAS_OP_T, n, r, m, &alpha, thrust::raw_pointer_cast(data.data()), n, thrust::raw_pointer_cast(other.data()), m, &beta, thrust::raw_pointer_cast(result.data()), n);
  cudaDeviceSynchronize();
  dt = dtime_usec(dt);
  if (thrust::equal(result.begin(), result.end(), thrust::constant_iterator<float>(m)))
    std::cout << "method 3 time: " << dt/(float)USECPSEC << "s" << std::endl;
  else
    std::cout << "method 3 failure" << std::endl;
}
$ nvcc -o t463 t463.cu -lcublas
$ ./t463
method 1 time: 20.1648s
method 2 time: 6.3e-05s
method 3 time: 5.7e-05s
$ ./t463 1024
method 2 time: 0.008063s
method 3 time: 0.000458s
$

对于默认尺寸200的情况，单推力调用和cublas方法相当接近，但比循环方法快得多。 对于1024的侧面尺寸，cublas方法比单推力调用方法快近20倍。

请注意，我为所有3种方法选择了“最佳”转置配置。 对于方法1，最佳情况时序是当inner_product使用来自每个输入矩阵的“行”时（实际上是第二输入矩阵的转置）。 对于方法2，最佳情况时序是当仿函数从每个输入矩阵遍历“列”时（实际上是第一输入矩阵的转置）。 对于方法3，两个输入矩阵的CUBLAS_OP_T选择似乎最快。 实际上，只有cublas方法可以灵活地用于各种具有良好性能的输入情况。