【Cuda并行编程之二】Cuda Memory Hierarchy_Cuda内存层次结构

- 日理万妓 2022-08-01 12:16 250阅读 0赞

要想编写高效的程序，那么一定要对内存结构有比较深刻的认识，就像C/C++里面的堆内存，栈内存，全局存储区，静态存储区，常量区等。Cuda是并行计算框架，而GPU的内存有限，那么如果想编写高效的Cuda程序，首先要对其内存结构有一个简单的认识。

首先我们先上一张图，然后通过解释一些名词和代码来进行解释。

![SouthEast][]

**各种存储器比较：**

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14.074073791503906px; line-height:25.995370864868164px">       
 <tbody> 
  <tr> 
   <td>存储器&nbsp;</td> 
   <td>位置</td> 
   <td>拥有缓存</td> 
   <td>访问权限</td> 
   <td>变量生存周期</td> 
  </tr> 
  <tr> 
   <td>register</td> 
   <td>GPU片内</td> 
   <td>N/A</td> 
   <td>device可读/写</td> 
   <td>与thread相同</td> 
  </tr> 
  <tr> 
   <td>local memory</td> 
   <td>板载显存</td> 
   <td>无</td> 
   <td>device可读/写</td> 
   <td>与thread相同</td> 
  </tr> 
  <tr> 
   <td>shared memory&nbsp;</td> 
   <td>GPU片内</td> 
   <td>N/A</td> 
   <td>device可读/写</td> 
   <td>与block相同</td> 
  </tr> 
  <tr> 
   <td>constant memory</td> 
   <td>板载显存</td> 
   <td>有</td> 
   <td>device可读，host可读写</td> 
   <td>可在程序中保持</td> 
  </tr> 
  <tr> 
   <td>texture memory&nbsp;</td> 
   <td>板载显存</td> 
   <td>有</td> 
   <td>device可读，host可读写</td> 
   <td>可在程序中保持</td> 
  </tr> 
  <tr> 
   <td>global memory&nbsp;</td> 
   <td>板载显存</td> 
   <td>无</td> 
   <td>device可读写，host可读写</td> 
   <td>可在程序中保持</td> 
  </tr> 
  <tr> 
   <td>host memory&nbsp;</td> 
   <td>主机内存</td> 
   <td>无</td> 
   <td>host可读写&nbsp;</td> 
   <td>可在程序中保持</td> 
  </tr> 
  <tr> 
   <td>pinned memory</td> 
   <td>主机内存</td> 
   <td>无</td> 
   <td>host可读写</td> 
   <td>可在程序中保持</td> 
  </tr> 
 </tbody> 
</table>

**registers：**寄存器。它是GPU片上告诉缓存器，执行单元可以以极低的延迟访问寄存器。寄存器的基本单元是寄存器文件（register file），每个寄存器文件大小为32bit。寄存器文件数量虽然客观，但是平均分给并行执行的线程，每个线程拥有的数量就非常有限了。编程时，不要为每个线程分配过多的私有变量。下面程序中，aBegin,aEnd,aStep,a等变量都是寄存器变量，每个线程都会维护这些变量。

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \_\_global\_\_ **void** registerDemo(**float** \*B,**float** \*A ,**int** wA)  
2.  \{  
3.      **int** aBegin = wA\*BLOCK\_SIZE \* blockIdx.y;  
4.      **int** aEnd = aBegin + wA - 1;  
5.      **int** aStep = BLOCK\_SIZE;  
6.        
7.      **for**(**int** a=aBegin;a<=aEnd;a+=aStep)  
8.      \{  
9.          //...  
10.     \}  
11. \}

local memory： 局部 存储器。对于每个线程，局部存储器也是私有的。如果寄存器被消耗完，数据将被存储在局部存储器中。如果每个线程用了过多的寄存器，或声明了大型结构体或数组，或者编译期无法确定数组的大小，线程的私有数据就有可能被分配到local memory中。一个线程的输入和中间变量将被保存在寄存器或者局部存储器中。局部存储器中的数据将被保存在显存中，而不是片上的寄存器或者缓存中，因此对local memory的访问速度比较慢。

**shared memory：**共享存储器。共享存储器也是GPU片内的告诉存储器。它是一个块可以被同一block中的所有线程访问的可读写存储器。访问共享存储器的速度几乎和访问寄存器一样快。是实现线程间通信的延迟最小的方法。共享存储器可用于实现多种功能，如用于保存共用的计数器（例如计算循环迭代次数）或者block的公共结果（例如规约的结果）。

static variable使用shared memory：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>  
2.  \#include<stdio.h>  
3.    
4.  \#if 1  
5.  \_\_global\_\_ **void** example(**float** \*u)  
6.  \{  
7.      **int** i = threadIdx.x;  
8.      <strong>\_\_shared\_\_ **int** tmp\[4\];</strong>  
9.      tmp\[i\] = u\[i\];   
10.     u\[i\] = tmp\[i\] \* tmp\[i\] + tmp\[3-i\] ;  
11. \}  
12. \#endif  
13.   
14. \#if 1  
15.   
16. **int** main()  
17. \{  
18.     **float** host\_u\[4\] = \{1,2,3,4\};  
19.     **float** \* dev\_u ;   
20.     **size\_t** size = 4\***sizeof**(**float**);  
21.   
22.     cudaMalloc(&dev\_u , size);  
23.     cudaMemcpy(dev\_u,host\_u,size,cudaMemcpyHostToDevice);  
24.   
25.     example<<<1,4>>> (dev\_u);  
26.   
27.     cudaMemcpy(host\_u , dev\_u , size , cudaMemcpyDeviceToHost);  
28.   
29.     cudaFree(dev\_u);  
30.   
31.     **for**(**int** i=0;i<4;i++)  
32.         printf("%f\\n",host\_u\[i\]);  
33.     **return** 0;  
34. \}  
35.   
36. \#endif

dynamic variable使用shared memory：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>  
2.  \#include<stdio.h>  
3.    
4.  <strong>**extern** \_\_shared\_\_ **int** tmp\[\];</strong>  
5.    
6.  \_\_global\_\_ **void** example(**float** \*u)  
7.  \{  
8.      **int** i = threadIdx.x;  
9.      tmp\[i\] = u\[i\];  
10.     u\[i\] = tmp\[i\] \* tmp\[i\] + tmp\[3-i\];  
11. \}  
12.   
13. **int** main()  
14. \{  
15.     **float** host\_u\[4\] = \{1,2,3,4\};  
16.     **float** \* dev\_u;  
17.     <strong>**size\_t** size = 4\***sizeof**(**float**);</strong>  
18.   
19.     cudaMalloc(&dev\_u,size);  
20.     cudaMemcpy(dev\_u , host\_u ,size , cudaMemcpyHostToDevice);  
21.     example<<<1,4,<strong>size</strong>>>>(dev\_u);  
22.   
23.     cudaMemcpy(host\_u, dev\_u,size,cudaMemcpyDeviceToHost);  
24.     cudaFree(dev\_u);  
25.     **for**(**int** i=0;i<4;i++)  
26.         printf("%f ",host\_u\[i\]);  
27.     **return** 0;  
28. \}

**global memory：**全局存储器位于显存（占据了显存的绝大部分），CPU、GPU都可以进行读写访问。整个网格中的任意线程都能读写全局存储器的任意位置由于全局存储器是可写的。全局存储器能够提供很高的带宽，但同时也具有较高的访存延迟。显存中的全局存储器也称为线性内存。线性内存通常使用cudaMalloc()函数分配，cudaFree()函数释放，并由cudaMemcpy()进行主机端与设备端的数据传输。

此外，也可以使用\_\_device\_\_关键字定义的变量分配全局存储器，这个变量应该在所有函数外定义，必须对使用这个变量的host端和device端函数都可见才能成功编译。在定义\_\_device\_\_变量的同时可以对其赋值。

**static variable使用global memory：**

global\_mem\_static.cu:

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<stdio.h>  
2.  \#include<iostream>  
3.    
4.  \_\_device\_\_ **float** devU\[4\];  
5.  \_\_device\_\_ **float** devV\[4\];  
6.    
7.  //\_\_global\_\_ function   
8.  \_\_global\_\_ **void** addUV()  
9.  \{  
10.     **int** i = threadIdx.x;  
11.     devU\[i\] += devV\[i\];  
12. \}  
13.   
14. **int** main()  
15. \{  
16.     **float** hostU\[4\] = \{1,2,3,4\};  
17.     **float** hostV\[4\] = \{5,6,7,8\};  
18.       
19.     **int** size = 4\* **sizeof**(**float**);  
20.   
21.     //cudaMemcpyToSymbol:将数据复制到\_\_constant\_\_或者\_\_device\_\_变量中  
22.     //cudaMemcpyFromSymbol:同上相反  
23.     //cudaMalloc:在设备端分配内存  
24.     //cudaMemcpy:数据拷贝  
25.     //cudaFree():内存释放  
26.     //cudaMemset():内存初始化  
27.     cudaMemcpyToSymbol(devU,hostU,size,0,cudaMemcpyHostToDevice);  
28.     cudaMemcpyToSymbol(devV,hostV,size,0,cudaMemcpyHostToDevice);  
29.   
30.     addUV<<<1,4>>>();  
31.   
32.     cudaMemcpyFromSymbol( hostU,devU,size,0,cudaMemcpyDeviceToHost );  
33.   
34.     **for**(**int** i=0;i<4;i++)  
35.         printf("hostU\[%d\] = %f\\n",i,hostU\[i\]);  
36.     **return** 0;  
37. \}

**结果：**

**![SouthEast 1][]**

dynamic variable使用global memory：

global\_mem\_dynamic.cu:

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>  
2.  \#include<stdio.h>  
3.    
4.  \_\_global\_\_ **void** add4f(**float** \*u , **float** \*v)  
5.  \{  
6.      **int** i = threadIdx.x;  
7.      u\[i\] += v\[i\];  
8.  \}  
9.    
10. **void** print(**float** \* U ,**int** size)  
11. \{  
12.     **for**(**int** i=0;i<4;i++)  
13.     \{  
14.         printf("U\[%d\] = %f\\n",i,U\[i\]);  
15.     \}  
16. \}  
17.   
18. **int** main()  
19. \{  
20.     **float** hostU\[4\] = \{1,2,3,4\};  
21.     **float** hostV\[4\] = \{5,6,7,8\};  
22.   
23.     **float** \* devU ;  
24.     **float** \* devV ;   
25.     **int** size = **sizeof**(**float**) \* 4;  
26.       
27.     //在设备内存上分配空间  
28.     cudaMalloc( &devU,size );  
29.     cudaMalloc( &devV,size );  
30.     //数据拷贝  
31.     cudaMemcpy( devU ,hostU ,size ,cudaMemcpyHostToDevice );  
32.     cudaMemcpy( devV ,hostV ,size ,cudaMemcpyHostToDevice );  
33.   
34.     add4f<<<1,4>>> (devU,devV);  
35.     //数据返回  
36.     cudaMemcpy(hostU,devU,size,cudaMemcpyDeviceToHost);  
37.   
38.     print(hostU,size);  
39.     //释放空间  
40.     cudaFree(devV);  
41.     cudaFree(devU);  
42.     **return** 0;  
43. \}

结果：

**![SouthEast 2][]**

**host memory : **主机端内存，即CPU对应的我们普通意义上的内存。主机端内存分为两种：可分页内存（pageable memory）和页锁定（page-locked 或pinned）内存。可分页内存即为通过操作系统API（malloc()，new()）分配的存储器空间：而页锁定内存始终不会被分配到低俗的虚拟内存中，能够保证存在于屋里内存中，并且能够通过DMA加速与设备端的通信。

**constant memory：**常数存储器。它是只读的地址空间。常熟存储器中的数据位于显存，但拥有缓存加速。常数存储器的空间较小，在Cuda程序中用于存储需要频繁访问的只读参数。当来自同一half-warp的线程访问常数存储器中的同一数据时，如果发生缓存命中，那么只需要一个周期就可以获得数据。常数存储器有缓存机制，用以节约带宽，加快访问速度。每个SM拥有8KB的常数存储器缓存。常数存储器是只读的，因此不存在缓存一致性问题。

constant memory的使用：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>  
2.    
3.  **using** **namespace** std;  
4.    
5.  \_\_constant\_\_ **int** devVar = 100;  
6.    
7.  \_\_global\_\_ **void** xminus(**int** \*a)  
8.  \{  
9.      **int** i = threadIdx.x;  
10.     a\[i\] = devVar+i;  
11. \}  
12.   
13. **int** main()  
14. \{  
15.     **int** \*h\_a = (**int**\*)malloc(4\*10) ;  
16.     **int** \*d\_a ;  
17.     cudaMalloc(&d\_a, 4\*10) ;  
18.     cudaMemset(d\_a, 0, 40) ;  
19.   
20.     xminus<<<1,4>>>(d\_a);  
21.       
22.     cudaMemcpy(h\_a, d\_a, 4\*10, cudaMemcpyDeviceToHost) ;  
23.   
24.     **for**(**int** i = 0; i < 4 ; i++)  
25.         cout << h\_a\[i\] << " " ;  
26.     cout << endl ;  
27. \}

**结果：**

![SouthEast 3][]

**texture memory：**纹理存储器。在此不做过多介绍。

![SouthEast 4][]

再结合一个图解释一下GPU里面的一些概念作为结尾：

**Thread：**线程。即一个GPU核心处理的单个单元。

**Block：**块。一个块里面有多个线程组成。block是软件级别的概念。

**Grid：**格。即二维的格，由多个block组成。

**SM：**Streaming multiprocessor。一个GPU里面有多个SM，一个SM里面有多个SP（streaming processor），是硬件级别的概念。

**Warp：**Warp是SM调度和执行的基本单位。warp是32个并列的线程，软件级别的概念。CPU上执行一条指令时候都是一个线程的，但是GPU则是以warp为单位。SM执行一条指令，那么这条指令使得32个线程同时执行，而每个线程都会操作自己的内存处理自己相应的数据，因此就达到了执行一条指令操作多个数据，也就是**SIMD（single instruction and multiple data）**。

注明出处：[http://blog.csdn.net/lavorange/article/details/20465869][http_blog.csdn.net_lavorange_article_details_20465869]

[SouthEast]: /images/20220731/a7127691a7784265a13607ee0965688a.png
[view plain]: http://blog.csdn.net/lavorange/article/details/20465869#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/549707
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/549707/fork
[SouthEast 1]: /images/20220731/26e060a19a094caeb56515b52beedc84.png
[SouthEast 2]: /images/20220731/884d86e3a1c94644a626a82477a63308.png
[SouthEast 3]: /images/20220731/ba2f7ec46c934ffdb68f868892e6d7d8.png
[SouthEast 4]: /images/20220731/bfeab249ba244f65b88eae02e6468b19.png
[http_blog.csdn.net_lavorange_article_details_20465869]: http://blog.csdn.net/lavorange/article/details/20465869