堆棧內存溢出
  簡體   English   中英

使用Cuda進行並行尺寸縮減（3D到2D求和）

[英]Parallel dimension reduction (3D to 2D with sum) using Cuda

 原文  2017-12-27 14:25:33  0   2    c++/ cuda/ gpu

問題描述

在CUDA應用程序中，我有一個N x N x D矩陣，我想通過在整個第一（或第二）軸上求和來簡化為N x D xD。 我如何最有效地做到這一點？

通常，N大於10000，D為2或3。

使用atomicAdd的快速而簡單的解決方案如下： 

namespace kernel {
    __global__ void sumNND(float* devPtrIn, float* devPtrOut, const int N, const int D) {
        int index = blockIdx.x * blockDim.x + threadIdx.x;
        int stride = blockDim.x * gridDim.x;

        for (int id = index; id < N * N * D; id += stride) {
            const unsigned int d = id % D;
            const unsigned int i = (id - d) / D;
            const unsigned int n = i / N;
            const unsigned int m = i % N;

            atomicAdd(&devPtrOut[d + D * n], devPtrIn[d + D * n + N * m]);
        }
    }
}

void sumNND(const int numBlocks, const int blockSize, float* devPtrIn, float* devPtrOut, const int N, const int D) {
    HANDLE_ERROR(cudaMemset(devPtrOut, 0, N * D * sizeof(float)));
    kernel::sumNND<<<numBlocks, blockSize>>>(devPtrIn, devPtrOut, N, D);
    HANDLE_ERROR(cudaDeviceSynchronize());
}

在其中sumNND地方

loopSize = N * N * D ， blockSize = 768和numBlocks = (loopSize + blockSize - 1) / blockSize 。

這是我的時間軸上的瓶頸（不足為奇），但是我不知道如何有效地並行化降維。 有指針嗎？

2 個解決方案

解決方案1
 3 已采納  2017-12-27 16:58:01

任何CUDA程序員的前兩個優化優先級是：

  1. 使用很多線程
  2. 有效地使用內存

對於您的問題，您不會遇到第一個問題-它很容易分解為一系列獨立的問題，可以分配給許多並行線程。 然后，第二優先級是您要關注的地方。 關於全局內存，這意味着我們應該盡可能地爭取合並訪問。 我們應該特別注意閱讀內容。

我需要做一些假設。 我假設您的維度組織為ROW，COLUMN，DEPTH，並且您的數據存儲在通常的C樣式（即行為主的存儲）中。 然后，利用這些假設，請求（ 在整個第一（或第二）軸上求和）實際上是在整個行上求和或在整個列上求和。 如果您在此處在cuda標記上進行了一些搜索，則會找到兩者的有效示例（ 這里是一個這樣的示例）。 盡管它們不一定全部涵蓋3D情況，但它們應該提供一個很好的路線圖。 您會發現這兩種情況應該以不同的方式處理，着眼於合並的全局內存訪問 ，即已經提到的優化優先級。 行方向也是合並方向，因此，如果需要對行求和，則需要使用經典的並行約簡技術，以便可以讀取行並將元素求和在一起。 如果我們需要對列求和，那么高效的內核更容易編寫； 每個線程可以負責一列，並且可以只將一個運行中的總和保持在for循環中。

就您而言，您似乎正在對列求和（但請參見下面的注釋）。 下面是一個有效的示例，將您的方法與運行速度更快的column-sum方法進行了比較，並結合了訪問（相鄰線程讀取內存中的相鄰元素）： 

$ cat t1263.cu
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

const int my_N = 10000;
const int my_D = 3;
const int my_blockSize = 768;
const int my_loopSize = my_N*my_N*my_D;
const int my_numBlocks = (my_loopSize + my_blockSize -1)/my_blockSize;
const int bsize = 512;
const float TOL = 0.1f;

#define HANDLE_ERROR(x) x

#define cudaCheckErrors(msg) \
    do { \
        cudaError_t __err = cudaGetLastError(); \
        if (__err != cudaSuccess) { \
            fprintf(stderr, "Fatal error: %s (%s at %s:%d)\n", \
                msg, cudaGetErrorString(__err), \
                __FILE__, __LINE__); \
            fprintf(stderr, "*** FAILED - ABORTING\n"); \
            exit(1); \
        } \
    } while (0)

#include <time.h>
#include <sys/time.h>
#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;
}

namespace kernel {
    __global__ void sumNND(float* devPtrIn, float* devPtrOut, const int N, const int D) {
        int index = blockIdx.x * blockDim.x + threadIdx.x;
        int stride = blockDim.x * gridDim.x;

        for (int id = index; id < N * N * D; id += stride) {
            const unsigned int d = id % D;
            const unsigned int i = (id - d) / D;
            const unsigned int n = i / N;
            const unsigned int m = i % N;

            atomicAdd(&devPtrOut[d + D * n], devPtrIn[d + D * n + N * m]);
        }
    }
}

void sumNND(const int numBlocks, const int blockSize, float* devPtrIn, float* devPtrOut, const int N, const int D) {
    HANDLE_ERROR(cudaMemset(devPtrOut, 0, N * D * sizeof(float)));
    kernel::sumNND<<<numBlocks, blockSize>>>(devPtrIn, devPtrOut, N, D);
    HANDLE_ERROR(cudaDeviceSynchronize());
}

// kernel assumes 1 block assigned per row, use block-striding methodology
// assumes block size is a power of 2
__global__ void sum_rows_NND(const float * __restrict__  devPtrIn, float * __restrict__  devPtrOut, const int N, const int D) {
  __shared__ float sdata[bsize];
  sdata[threadIdx.x] = 0;
  for (int i = threadIdx.x; i < N; i += blockDim.x) // block-stride
    sdata[threadIdx.x] += devPtrIn[(blockIdx.x * N) + i];
  __syncthreads();
  for (int i = blockDim.x>>1; i > 0; i>>=1){
    if (threadIdx.x < i) sdata[threadIdx.x] += sdata[threadIdx.x+i];
    __syncthreads();}
  if (!threadIdx.x) devPtrOut[blockIdx.x] = sdata[0];
}



// kernel assumes one thread assigned per column sum
// launch N threads
 __global__ void sum_cols_NND(const float * __restrict__  devPtrIn, float * __restrict__  devPtrOut, const int N, const int D) {
  int idx = threadIdx.x+blockDim.x*blockIdx.x;
  int ido = idx;
  if (idx < N){
    for (int j = 0; j < D; j++){
      float temp = 0;
      for (int i = 0; i < N; i++) temp += devPtrIn[idx + (i*N)];
      devPtrOut[ido] = temp;
      ido += N;
      idx += N*N;}}
}

int main(){

  float *h_data, *d_data, *h_res1, *h_res2, *d_res;

  h_data = new float[my_loopSize];
  cudaMalloc(&d_data, my_loopSize*sizeof(d_data[0]));
  h_res1 = new float[my_N*my_D];
  h_res2 = new float[my_N*my_D];
  cudaMalloc(&d_res, my_N*my_D*sizeof(d_res[0]));
  for (int i = 0; i < my_loopSize; i++) h_data[i] = rand()/(float)RAND_MAX;
  cudaCheckErrors("CUDA failure");
  cudaMemcpy(d_data, h_data, my_loopSize*sizeof(d_data[0]), cudaMemcpyHostToDevice);
  // test original approach
  cudaMemset(d_res, 0, my_N*my_D*sizeof(d_res[0]));
  unsigned long long dt1 = dtime_usec(0);
  kernel::sumNND<<<my_numBlocks, my_blockSize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt1 = dtime_usec(dt1);
  cudaMemcpy(h_res1, d_res, my_N*my_D*sizeof(d_res[0]), cudaMemcpyDeviceToHost);

  //test columnwise reduction
  unsigned long long dt2 = dtime_usec(0);
  //sum_rows_NND<<<my_N*my_D, bsize>>>(d_data, d_res, my_N, my_D);
  sum_cols_NND<<<(my_N + bsize -1)/bsize, bsize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt2 = dtime_usec(dt2);
  cudaMemcpy(h_res2, d_res, my_N*my_D*sizeof(d_res[0]), cudaMemcpyDeviceToHost);

  // validate results
  for (int i = 0; i < my_N; i++)
    if (fabsf(h_res1[i] - h_res2[i]) > TOL) {printf("mismatch at %d, was %f, should be %f\n", i, h_res2[i], h_res1[i]); return -1;}
  cudaCheckErrors("program error");

  printf("results match,  kernel 1 time: %fs, kernel 2 time: %fs\n", dt1/(float)USECPSEC, dt2/(float)USECPSEC);
  // time row reduction kernel
  unsigned long long dt3 = dtime_usec(0);
  sum_rows_NND<<<my_N*my_D, bsize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt3 = dtime_usec(dt3);
  printf("row reduction kernel time: %fs\n", dt3/(float)USECPSEC);
  cudaCheckErrors("program error");
}
$ nvcc -arch=sm_52 -o t1263 t1263.cu
$ ./t1263
results match,  kernel 1 time: 0.459971s, kernel 2 time: 0.013678s
row reduction kernel time: 0.013724s
$

筆記：

  1. 經過優化的內核比您的朴素原子內核快30倍左右。 我懷疑其中很大一部分實際上不是原子的使用，而是未分批訪問。 新型GPU上的全局原子可能很快。

  2. 我的內核和您的內核之間元素列總和的第一個“頁面”（NxN）匹配（即，前N個結果匹配）。 第一頁之后（前N個結果），我們的結果有所不同。 我很確定我的索引編制是正確的，但是花了一段時間嘗試弄清您的索引編制之后，我放棄了。 如果您嘗試對列求和，我懷疑您的內核索引中有一個錯誤，並且所有上述假設都是正確的。

  3. 我還包括了行求和內核的時序測量，它看起來有很大不同，但是產生的時序幾乎相同。 這是可以預料的，因為針對這些類型問題的最佳內核將受到內存帶寬的限制，這在兩種情況下都是相同的。 最佳內核將以合並的方式一次加載所有數據。 之后，行和與列和機制對內核時間的影響相對較小。

  4. 通過對數據的初始化進行少量修改，我認為很容易證明您的內核沒有創建正確的索引，因此沒有在第一個“頁面”之后（即在前N結果之后）產生正確的行總和。 。 在對索引進行了更多研究之后，我對出了什么問題有了一些了解。 一個示例問題是，對於不能被D整除的N ，您的內核d變量在第一個“頁面”之后將不會重置為零，但這不是唯一的問題。

根據第4項，這是修改了數據初始化的代碼版本，並對所有N * D結果進行了全面測試。 數據初始化為，第一頁的第一列將全部為零，下一列的全部為1，下一列的全部為2，依此類推。在第二頁上，我們將所有內容加1，因此第一列將全部為1，第二列全為2，依此類推。因此，應該很容易就列的總和達成一致。 對於第一頁，列的總和應為0、10000、20000等。對於第二頁，它們的應為10000、20000、30000等。在第二頁的第一列上，我的代碼生成10000，您的代碼生成1.在注釋中更改索引后，第一頁的第一列將產生0，而您的代碼將產生9999。根據我描述的數據初始化，1和9999可能不是有效的列總和： 

$ cat t1263.cu
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

const int my_N = 10000;
const int my_D = 3;
const int my_blockSize = 768;
const int my_loopSize = my_N*my_N*my_D;
const int my_numBlocks = (my_loopSize + my_blockSize -1)/my_blockSize;
const int bsize = 512;
const float TOL = 0.1f;

#define HANDLE_ERROR(x) x

#define cudaCheckErrors(msg) \
    do { \
        cudaError_t __err = cudaGetLastError(); \
        if (__err != cudaSuccess) { \
            fprintf(stderr, "Fatal error: %s (%s at %s:%d)\n", \
                msg, cudaGetErrorString(__err), \
                __FILE__, __LINE__); \
            fprintf(stderr, "*** FAILED - ABORTING\n"); \
            exit(1); \
        } \
    } while (0)

#include <time.h>
#include <sys/time.h>
#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;
}

namespace kernel {
    __global__ void sumNND(float* devPtrIn, float* devPtrOut, const int N, const int D) {
        int index = blockIdx.x * blockDim.x + threadIdx.x;
        int stride = blockDim.x * gridDim.x;

        for (int id = index; id < N * N * D; id += stride) {
            const unsigned int d = id % D;       // 0 1 2 0 1 2 0 1 2
            const unsigned int i = (id - d) / D; // 0 0 0 1 1 1 2 2 2
            const unsigned int n = i / N;        // 0 0 0 0 0 0 0 0 0
            const unsigned int m = i % N;        // 0 0 0 1 1 1 2 2 2

            atomicAdd(&devPtrOut[d + D * n],    //  0 1 2 0 1 2 0 1 2
              devPtrIn[d + D * n + N * m]);     //  0 1 2 0+N 1+N 2+N 0+2N 1+2N 2+2N
        }
    }
}

void sumNND(const int numBlocks, const int blockSize, float* devPtrIn, float* devPtrOut, const int N, const int D) {
    HANDLE_ERROR(cudaMemset(devPtrOut, 0, N * D * sizeof(float)));
    kernel::sumNND<<<numBlocks, blockSize>>>(devPtrIn, devPtrOut, N, D);
    HANDLE_ERROR(cudaDeviceSynchronize());
}

// kernel assumes 1 block assigned per row, use block-striding methodology
// assumes block size is a power of 2
__global__ void sum_rows_NND(const float * __restrict__  devPtrIn, float * __restrict__  devPtrOut, const int N, const int D) {
  __shared__ float sdata[bsize];
  sdata[threadIdx.x] = 0;
  for (int i = threadIdx.x; i < N; i += blockDim.x) // block-stride
    sdata[threadIdx.x] += devPtrIn[(blockIdx.x * N) + i];
  __syncthreads();
  for (int i = blockDim.x>>1; i > 0; i>>=1){
    if (threadIdx.x < i) sdata[threadIdx.x] += sdata[threadIdx.x+i];
    __syncthreads();}
  if (!threadIdx.x) devPtrOut[blockIdx.x] = sdata[0];
}



// kernel assumes one thread assigned per column sum
// launch N threads
 __global__ void sum_cols_NND(const float * __restrict__  devPtrIn, float * __restrict__  devPtrOut, const int N, const int D) {
  int idx = threadIdx.x+blockDim.x*blockIdx.x;
  int ido = idx;
  if (idx < N){
    for (int j = 0; j < D; j++){
      float temp = 0;
      for (int i = 0; i < N; i++) temp += devPtrIn[idx + (i*N)];
      devPtrOut[ido] = temp;
      ido += N;
      idx += N*N;}}
}

int main(){

  float *h_data, *d_data, *h_res1, *h_res2, *d_res;

  h_data = new float[my_loopSize];
  cudaMalloc(&d_data, my_loopSize*sizeof(d_data[0]));
  h_res1 = new float[my_N*my_D];
  h_res2 = new float[my_N*my_D];
  cudaMalloc(&d_res, my_N*my_D*sizeof(d_res[0]));
  for (int i = 0; i < my_loopSize; i++) h_data[i] = i%my_N + i/(my_N*my_N); //rand()/(float)RAND_MAX;
  cudaCheckErrors("CUDA failure");
  cudaMemcpy(d_data, h_data, my_loopSize*sizeof(d_data[0]), cudaMemcpyHostToDevice);
  // test original approach
  cudaMemset(d_res, 0, my_N*my_D*sizeof(d_res[0]));
  unsigned long long dt1 = dtime_usec(0);
  kernel::sumNND<<<my_numBlocks, my_blockSize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt1 = dtime_usec(dt1);
  cudaMemcpy(h_res1, d_res, my_N*my_D*sizeof(d_res[0]), cudaMemcpyDeviceToHost);

  //test columnwise reduction
  unsigned long long dt2 = dtime_usec(0);
  //sum_rows_NND<<<my_N*my_D, bsize>>>(d_data, d_res, my_N, my_D);
  sum_cols_NND<<<(my_N + bsize -1)/bsize, bsize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt2 = dtime_usec(dt2);
  cudaMemcpy(h_res2, d_res, my_N*my_D*sizeof(d_res[0]), cudaMemcpyDeviceToHost);

  // validate results
  for (int i = 0; i < my_N*my_D; i++)
    if (fabsf(h_res1[i] - h_res2[i]) > TOL) {printf("mismatch at %d, was %f, should be %f\n", i, h_res2[i], h_res1[i]); return -1;}
  cudaCheckErrors("program error");

  printf("results match,  kernel 1 time: %fs, kernel 2 time: %fs\n", dt1/(float)USECPSEC, dt2/(float)USECPSEC);
  // time row reduction kernel
  unsigned long long dt3 = dtime_usec(0);
  sum_rows_NND<<<my_N*my_D, bsize>>>(d_data, d_res, my_N, my_D);
  cudaDeviceSynchronize();
  dt3 = dtime_usec(dt3);
  printf("row reduction kernel time: %fs\n", dt3/(float)USECPSEC);
  cudaCheckErrors("program error");
}
$ nvcc -arch=sm_52 -o t1263 t1263.cu
$ ./t1263
mismatch at 10000, was 10000.000000, should be 1.000000
$

解決方案2
 1  2017-12-27 15:45:07

這取決於矩陣的存儲順序以及要減小的維數。

目前，我將忽略D維，因為可以將操作視為減少包含NxN個條目的矩陣，其中每個條目都包含多個浮點數。

如果矩陣以行優先的順序存儲，並且您希望將每一行減少到其總和（或列主行和列的約簡），那么答案很簡單： 

const int row = blockIdx.x * blockDim.x + threadIdx.x;
if (row < N) { // necessary if N is not divisible by the thread block size
    float sum = 0; // stores the partial sum in a register
    for (int col = 0; col < N; ++col) {
        sum += devPtrIn[col + N * row];
    }
    devPtrOut[row] = sum; // no atomic operation necessary
}

這樣，每個線程都以合並方式讀取內存（有關全局內存訪問模式的討論，請參見NVIDIA的並行forall博客 ），除了最終結果外，不需要共享或全局內存寫入。

如果要沿着較小的維數進行縮減-假設在行較大的矩陣上進行列縮減-答案將變得更加困難：由於步幅較大，如果僅使用一個，則內存訪問將或多或少地表現為隨機訪問一次輸入該列。

因此，對於每個線程來說，沿着矩陣並行減少少量列並將部分結果存儲在共享內存中是有意義的： 

constexpr int numCols = ...;
__shared__ float partial[numCols * blockDim.x];
const int threadId = blockIdx.x * blockDim.x + threadIdx.x;
const int begin_col = threadId * numCols;
const int end_col = min(N, (threadId + 1) * numCols);
// initialize partial to 0
...
for (int row = 0; row < N; ++row) {
    for (int col = begin_col; col < end_col; ++col) {
        partial[threadIdx.x * numCols + col] += devPtrIn[col + N * row];
    }
}
// store partial to global memory
...

根據GPU每個線程擁有的寄存器數量，還可能通過展開內部循環並使用局部變量而不是數組來將部分和存儲在寄存器中 ，因為數組通常不存儲在寄存器中

這樣，我們總是從內存中讀取numCols浮點數的連續塊，這提供了比大步幅訪問更大的帶寬。

您可能必須嘗試使用numCols的最佳值，但是它應該足夠大，至少要使用GPU內存的內存寬度來加載這樣的塊，同時又要足夠小，以便所有共享內存用於一個線程塊適合GPU（有關詳細信息，請再次參見parallel forall ）

暫無
暫無

聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

相關問題 CUDA，使用2D和3D陣列 如何在推力中減少二維數據的一維 使用CUDA從2D圖像編程3D模型 Cuda-3D塊和網格尺寸混淆-另一個 將模板用於2D / 3D點 使用共享內存的CUDA與3D卷積 CUDA：使用線性化2D共享內存的數組中所有元素的總和 使用並行約簡的CUDA矩陣乘法 CUDA Zeropadding 3D 矩陣 對2D或3D向量使用擦除刪除習慣用法
相關標簽
 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM