使用共享內存減少CUDA內核計算的計算時間
[英]Use of shared memory to reduce computational time of calculations inside CUDA kernel
問題描述
我有一個大小為1920 x 1080的圖像。我正在從H2D轉移，使用三個CUDA流從D2H處理和傳輸，其中每個流負責處理總數據的1/3。 通過理解SM，SP，warp的概念，我能夠優化每個塊的塊大小和線程數。 如果必須在內核中進行簡單的計算，代碼運行令人滿意（需要2毫秒）。 下面的簡單計算代碼從源圖像中找到R，G和B值，然后將這些值放在同一源圖像中。
ptr_source[numChannels* (iw*y + x) + 0] = ptr_source[numChannels* (iw*y + x) + 0];
ptr_source[numChannels* (iw*y + x) + 1] = ptr_source[numChannels* (iw*y + x) + 1];
ptr_source[numChannels* (iw*y + x) + 2] = ptr_source[numChannels* (iw*y + x) + 2];
但是我必須執行幾個獨立於所有其他線程的計算，然后計算時間增加6 ms，這對我的應用來說太多了。 我已經嘗試在constant memory聲明最常用的常量值。 這些計算的代碼如下所示。 在該代碼中，我再次找到R，G和B值。 然后，我通過將舊值與一些常數相乘來計算R，G和B的新值，最后我將這些新的R，G和B值再次放在相應位置的相同源圖像中。
__constant__ int iw = 1080;
__constant__ int ih = 1920;
__constant__ int numChannels = 3;
__global__ void cudaKernel(unsigned char *ptr_source, int numCudaStreams)
{
// Calculate our pixel's location
int x = (blockIdx.x * blockDim.x) + threadIdx.x;
int y = (blockIdx.y * blockDim.y) + threadIdx.y;
// Operate only if we are in the correct boundaries
if (x >= 0 && x < iw && y >= 0 && y < ih / numCudaStreams)
{
const int index_b = numChannels* (iw*y + x) + 0;
const int index_g = numChannels* (iw*y + x) + 1;
const int index_r = numChannels* (iw*y + x) + 2;
//GET VALUES: get the R,G and B values from Source image
unsigned char b_val = ptr_source[index_b];
unsigned char g_val = ptr_source[index_g];
unsigned char r_val = ptr_source[index_r];
float float_r_val = ((1.574090) * (float)r_val + (0.088825) * (float)g_val + (-0.1909) * (float)b_val);
float float_g_val = ((-0.344198) * (float)r_val + (1.579802) * (float)g_val + (-1.677604) * (float)b_val);
float float_b_val = ((-1.012951) * (float)r_val + (-1.781485) * (float)g_val + (2.404436) * (float)b_val);
unsigned char dst_r_val = (float_r_val > 255.0f) ? 255 : static_cast<unsigned char>(float_r_val);
unsigned char dst_g_val = (float_g_val > 255.0f) ? 255 : static_cast<unsigned char>(float_g_val);
unsigned char dst_b_val = (float_b_val > 255.0f) ? 255 : static_cast<unsigned char>(float_b_val);
//PUT VALUES---put the new calculated values of R,G and B
ptr_source[index_b] = dst_b_val;
ptr_source[index_g] = dst_g_val;
ptr_source[index_r] = dst_r_val;
}
}
問題：我認為將圖像片段（即ptr_src ）轉移到共享內存將有所幫助，但我對如何做到這一點感到很困惑。 我的意思是，共享內存的范圍僅適用於一個塊，因此如何管理圖像段到共享內存的傳輸。
PS：我的GPU是Quadro K2000，每SM計算3.0,2 SM，192 SP。
2 個解決方案
解決方案1
2
我暫時不會添加太多評論來添加此代碼：
const int iw = 1080;
const int ih = 1920;
const int numChannels = 3;
__global__ void cudaKernel3(unsigned char *ptr_source, int n)
{
int idx = threadIdx.x + blockIdx.x * blockDim.x;
int stride = blockDim.x * gridDim.x;
uchar3 * p = reinterpret_cast<uchar3 *>(ptr_source);
for(; idx < n; idx+=stride) {
uchar3 vin = p[idx];
unsigned char b_val = vin.x;
unsigned char g_val = vin.y;
unsigned char r_val = vin.z;
float float_r_val = ((1.574090f) * (float)r_val + (0.088825f) * (float)g_val + (-0.1909f) * (float)b_val);
float float_g_val = ((-0.344198f) * (float)r_val + (1.579802f) * (float)g_val + (-1.677604f) * (float)b_val);
float float_b_val = ((-1.012951f) * (float)r_val + (-1.781485f) * (float)g_val + (2.404436f) * (float)b_val);
uchar3 vout;
vout.x = (unsigned char)fminf(255.f, float_r_val);
vout.y = (unsigned char)fminf(255.f, float_g_val);
vout.z = (unsigned char)fminf(255.f, float_b_val);
p[idx] = vout;
}
}
// Original kernel with a bit of template magic to conditionally correct
// accidental double precision arithmetic removed for brevity
int main()
{
const size_t sz = iw * ih * numChannels;
typedef unsigned char uchar;
uchar * image = new uchar[sz];
uchar v = 0;
for(int i=0; i<sz; i++) {
image[i] = v;
v = (++v > 128) ? 0 : v;
}
uchar * image_;
cudaMalloc((void **)&image_, sz);
cudaMemcpy(image_, image, sz, cudaMemcpyHostToDevice);
dim3 blocksz(32,32);
dim3 gridsz(1+iw/blocksz.x, 1+ih/blocksz.y);
cudaKernel<1><<<gridsz, blocksz>>>(image_, 1);
cudaDeviceSynchronize();
cudaMemcpy(image_, image, sz, cudaMemcpyHostToDevice);
cudaKernel<0><<<gridsz, blocksz>>>(image_, 1);
cudaDeviceSynchronize();
cudaMemcpy(image_, image, sz, cudaMemcpyHostToDevice);
cudaKernel3<<<16, 512>>>(image_, iw * ih);
cudaDeviceSynchronize();
cudaDeviceReset();
return 0;
}
這里的想法是只擁有可以駐留在設備上的線程，並讓它們處理整個圖像，每個線程發出多個輸出。 塊調度在CUDA中非常便宜，但它不是免費的，也不是索引計算和一個線程執行有用工作所需的所有其他“設置”代碼。 因此，這個想法只是將這些成本攤銷到許多產品上。 因為您的圖像只是線性記憶，並且您對每個條目執行的操作完全獨立，所以使用2D網格和2D索引沒有任何意義。 它只是額外的設置代碼，會降低代碼速度。 您還將看到使用向量類型（char3），它可以通過減少每個像素的內存轉換次數來提高內存吞吐量。
另請注意，在具有雙精度功能的GPU上，將編譯雙精度常量並生成64位浮點運算。 與單精度相比，執行雙精度時會有2到12倍的性能損失，具體取決於您的GPU。 當我編譯您發布的內核並查看PTX時，CUDA 7發布編譯器為sm_30架構發出（與您的GPU相同），我在像素計算代碼中看到了這一點：
cvt.f64.f32 %fd1, %f4;
mul.f64 %fd2, %fd1, 0d3FF92F78FEEF5EC8;
ld.global.u8 %rs9, [%rd1+1];
cvt.rn.f32.u16 %f5, %rs9;
cvt.f64.f32 %fd3, %f5;
fma.rn.f64 %fd4, %fd3, 0d3FB6BD3C36113405, %fd2;
ld.global.u8 %rs10, [%rd1];
cvt.rn.f32.u16 %f6, %rs10;
cvt.f64.f32 %fd5, %f6;
fma.rn.f64 %fd6, %fd5, 0dBFC86F694467381D, %fd4;
cvt.rn.f32.f64 %f1, %fd6;
mul.f64 %fd7, %fd1, 0dBFD607570C564F98;
fma.rn.f64 %fd8, %fd3, 0d3FF946DE76427C7C, %fd7;
fma.rn.f64 %fd9, %fd5, 0dBFFAD7774ABA3876, %fd8;
cvt.rn.f32.f64 %f2, %fd9;
mul.f64 %fd10, %fd1, 0dBFF0350C1B97353B;
fma.rn.f64 %fd11, %fd3, 0dBFFC80F66A550870, %fd10;
fma.rn.f64 %fd12, %fd5, 0d40033C48F10A99B7, %fd11;
cvt.rn.f32.f64 %f3, %fd12;
注意，將所有內容提升到64位浮點，並且乘法都以64位完成，浮點常數采用IEEE754雙格式，然后將結果降級為32位。 這是一個真正的性能成本，您應該小心避免它通過適當定義的浮點常量作為單精度。
當在GT620M（2個SM Fermi移動部件，使用電池運行）上運行時，我們從nvprof獲得以下配置文件數據
Time(%) Time Calls Avg Min Max Name
39.44% 17.213ms 1 17.213ms 17.213ms 17.213ms void cudaKernel<int=1>(unsigned char*, int)
35.02% 15.284ms 3 5.0947ms 5.0290ms 5.2022ms [CUDA memcpy HtoD]
18.51% 8.0770ms 1 8.0770ms 8.0770ms 8.0770ms void cudaKernel<int=0>(unsigned char*, int)
7.03% 3.0662ms 1 3.0662ms 3.0662ms 3.0662ms cudaKernel3(unsigned char*, int)
==5504== API calls:
Time(%) Time Calls Avg Min Max Name
95.37% 1.01433s 1 1.01433s 1.01433s 1.01433s cudaMalloc
3.17% 33.672ms 3 11.224ms 4.8036ms 19.039ms cudaDeviceSynchronize
1.29% 13.706ms 3 4.5687ms 4.5423ms 4.5924ms cudaMemcpy
0.12% 1.2560ms 83 15.132us 427ns 541.81us cuDeviceGetAttribute
0.03% 329.28us 3 109.76us 91.086us 139.41us cudaLaunch
0.02% 209.54us 1 209.54us 209.54us 209.54us cuDeviceGetName
0.00% 23.520us 1 23.520us 23.520us 23.520us cuDeviceTotalMem
0.00% 13.685us 3 4.5610us 2.9930us 7.6980us cudaConfigureCall
0.00% 9.4090us 6 1.5680us 428ns 3.4210us cudaSetupArgument
0.00% 5.1320us 2 2.5660us 2.5660us 2.5660us cuDeviceGetCount
0.00% 2.5660us 2 1.2830us 1.2830us 1.2830us cuDeviceGet
當在更大的東西上運行時（帶有7個SMX的GTX 670 Kepler設備）：
==9442== NVPROF is profiling process 9442, command: ./a.out
==9442== Profiling application: ./a.out
==9442== Profiling result:
Time(%) Time Calls Avg Min Max Name
65.68% 2.6976ms 3 899.19us 784.56us 1.0829ms [CUDA memcpy HtoD]
20.84% 856.05us 1 856.05us 856.05us 856.05us void cudaKernel<int=1>(unsigned char*, int)
7.90% 324.64us 1 324.64us 324.64us 324.64us void cudaKernel<int=0>(unsigned char*, int)
5.58% 229.12us 1 229.12us 229.12us 229.12us cudaKernel3(unsigned char*, int)
==9442== API calls:
Time(%) Time Calls Avg Min Max Name
55.88% 45.443ms 1 45.443ms 45.443ms 45.443ms cudaMalloc
38.16% 31.038ms 1 31.038ms 31.038ms 31.038ms cudaDeviceReset
3.55% 2.8842ms 3 961.40us 812.99us 1.1982ms cudaMemcpy
1.92% 1.5652ms 3 521.72us 294.16us 882.27us cudaDeviceSynchronize
0.32% 262.49us 83 3.1620us 150ns 110.94us cuDeviceGetAttribute
0.09% 74.253us 3 24.751us 15.575us 41.784us cudaLaunch
0.03% 22.568us 1 22.568us 22.568us 22.568us cuDeviceTotalMem
0.03% 20.815us 1 20.815us 20.815us 20.815us cuDeviceGetName
0.01% 7.3900us 6 1.2310us 200ns 5.3890us cudaSetupArgument
0.00% 3.6510us 2 1.8250us 674ns 2.9770us cuDeviceGetCount
0.00% 3.1440us 3 1.0480us 516ns 1.9410us cudaConfigureCall
0.00% 2.1600us 2 1.0800us 985ns 1.1750us cuDeviceGet
因此，通過修復基本錯誤並在較小和較大的設備上使用合理的設計模式，可以大大加快速度。 信不信由你。
解決方案2
1 已采納 2015-07-21 13:55:41
共享內存對你的情況沒有幫助，你的內存訪問不是coaslescent。
您可以嘗試以下操作：將char * ptr_source替換為uchar3 *應該可以幫助您的線程訪問陣列中的連續數據。 uchar3只是意味着：3個連續的unsigned char。
因為同一warp中的線程同時執行相同的指令，所以你將擁有這種訪問模式：
假設您嘗試訪問地址處的內存：0x3F0000。
thread 1 copies data at : 0x3F0000 then 0x3F0001 then 0x3F0002
thread 2 copies data at : 0x3F0003 then 0x3F0004 then 0x3F0005
0x3F0000和0x3F0003不是連續的，因此您訪問數據的性能會很差。
與uchar3使用：
thread 1 : 0x3F0000 to 0x3F0002
thread 2 : 0x3F0003 to 0x3F0005
就像每個線程復制連續數據一樣，內存控制器可以快速復制它。
你也可以替換：
(float_r_val > 255.0f) ? 255 : static_cast<unsigned char>(float_r_val);
同
float_r_val = fmin(255.0f, float_r_val);
這應該給你一個像這樣的內核：
__global__ void cudaKernel(uchar3 *ptr_source, int numCudaStreams)
{
// Calculate our pixel's location
int x = (blockIdx.x * blockDim.x) + threadIdx.x;
int y = (blockIdx.y * blockDim.y) + threadIdx.y;
// Operate only if we are in the correct boundaries
if (x >= 0 && x < iw && y >= 0 && y < ih / numCudaStreams)
{
const int index = (iw*y + x);
uchar3 val = ptr_source)[index];
float float_r_val = ((1.574090f) * (float)val.x + (0.088825f) * (float)val.y + (-0.1909f) * (float)b_val.z);
float float_g_val = ((-0.344198f) * (float)val.x + (1.579802f) * (float)val.y + (-1.677604f) * (float)b_val.z);
float float_b_val = ((-1.012951f) * (float)val.x + (-1.781485f) * (float)val.y + (2.404436f) * (float)b_val.z);
ptr_source[index] = make_uchar3( fmin(255.0f, float_r_val), fmin(255.0f, float_g_val), fmin(255.0f, float_b_val) );
}
}
我希望這些更新能夠提高性能。
cuda shared memory, no synchronisation in kernel, premature output from kernel
[英]cuda shared memory, no synchronisation in kernel, premature output from kernel
GPGPU：用於1D線程索引的CUDA內核配置-線程，塊，共享內存和寄存器
[英]GPGPU: CUDA kernel configuration for 1D thread indexing - threads, blocks, shared memory, and registers
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.