一篇文章理解CUDA架构、编程与进阶使用

一篇文章理解CUDA架构、编程与进阶使用

  • 一、CUDA架构
  • 二、CUDA编程基础
    • 1.矩阵加法
    • 2.矩阵乘法
  • 三、CUDA进阶 I——利用共享内存加速访存
    • 1.CUDA内存读写速度比较
    • 2.申请共享内存
  • 四、CUDA进阶 II——利用stream加速大批量文件IO读写耗时
    • 1. 认识CUDA stream
    • 2. CUDA stream API介绍
  • 五、CUDA进阶 III——调用cuBLAS库API进行矩阵计算

本文章详细介绍了CUDA的架构和基础编程方法,并对他的进阶优化方法进行了简单介绍,以便大家对CUDA编程有一个整体的认知。


一、CUDA架构

下图为GPU硬件模型:
一块GPU包括3级:GPU、多核处理器、线程处理器

  • 一个GPU包含多个多核处理器(SM,图中的Mlultiprocessor),GPU的内存是全局内存global memory(可以被所有线程访问)
  • 一个多核处理器包含多个线程处理器,多核处理器的内存是共享内存shared memory(编程时划分好block后,一个block内的所有线程可以访问共享内存)
  • 线程处理器,最基本的计算单元,有自己的局部内存和寄存器,只能自己访问

在CUDA编程时,我们经常用到thread, block, grid,其中thread对应硬件上的线程处理器,grid对应一块GPU。而block可以由我们自定义维度,对应到硬件上,其实是由一个多核处理器中的多个线程处理器组合而成,可以将一个多核处理器划分为多个block。
一篇文章理解CUDA架构、编程与进阶使用_第1张图片
线程束(warp)是最基本的执行单元,一个warp包含32个基本的计算单元-线程thread,也就是说比如我发一个指令,那么线程束中的32个thread将会并行执行该指令。(所以在我们划分blocksize的时候,一般都会设置成32的倍数)
一篇文章理解CUDA架构、编程与进阶使用_第2张图片

二、CUDA编程基础

CUDA编程并行计算整体流程

  1. 在GPU上分配显存,将CPU上的数据拷贝到显存上
  2. 利用核函数完成GPU显存中数据的计算
  3. 将显存中的计算结果拷贝回CPU内存中

从矩阵加法和矩阵乘法来学习CUDA编程的基本框架(耐心看完下面代码,基本都有注解,可以模仿范式编写自己的代码)

1.矩阵加法

计算矩阵加法:C = A + B,设A B为一维矩阵,长度为n

//核函数(即在GPU中执行的函数/用__global__申明)
__global__
void vecAddKernel(float* A_d, float* B_d, float* C_d, int n)
{
    int i = threadIdx.x + blockDim.x * blockIdx.x;  //计算线程ID
    if (i < n) C_d[i] = A_d[i] + B_d[i];  //筛选ID小于n的线程,即例如线程1计算C_d[1] = A_d[1] + B_d[1]
}

//主函数
int main(int argc, char *argv[]) {

    int n = 10000;

    size_t size = n * sizeof(float);

    // 在CPU上分配内存
    float *a = (float *)malloc(size);
    float *b = (float *)malloc(size);
    float *c = (float *)malloc(size);

	//初始化a b的值(将需要计算的向量放到分配好的内存中)
    for (int i = 0; i < n; i++) {
        float af = rand() / double(RAND_MAX);
        float bf = rand() / double(RAND_MAX);
        a[i] = af;
        b[i] = bf;
    }

	//在GPU上分配显存(格式按照 参考下面代码,size为需要分配的显存大小)
    float *da = NULL;
    float *db = NULL;
    float *dc = NULL;
    cudaMalloc((void **)&da, size);
    cudaMalloc((void **)&db, size);
    cudaMalloc((void **)&dc, size);

	//将CPU上初始化的a b值拷贝到GPU上
    cudaMemcpy(da,a,size,cudaMemcpyHostToDevice);
    cudaMemcpy(db,b,size,cudaMemcpyHostToDevice);
	
	//划分GPU的block和Grid
    int threadPerBlock = 256;  //一个warp大小为32,一般设置为32的倍数
    int blockPerGrid = (n + threadPerBlock - 1)/threadPerBlock;  //根据划分的blocksize计算gridsize
	
	//调用核函数
    vecAddKernel <<< blockPerGrid, threadPerBlock >>> (da, db, dc, n);
   	//将GPU上的计算结果拷贝回CPU
    cudaMemcpy(c,dc,size,cudaMemcpyDeviceToHost);
	
	//释放GPU显存资源
    cudaFree(da);
    cudaFree(db);
    cudaFree(dc);
    
	//释放CPU内存资源
    free(a);
    free(b);
    free(c);
    return 0;
}

2.矩阵乘法

计算矩阵乘法:C = A * B,矩阵A的维度为M*K,矩阵B的维度为K*N

#define M 512
#define K 512
#define N 512

void initial(float *array, int size)
{
	for (int i = 0; i < size; i++)
	{
		array[i] = (float)(rand() % 10 + 1);
	}
}

//核函数(传入显存ABC以及维度信息MNK)
__global__ void multiplicateMatrix(float *array_A, float *array_B, float *array_C, int M_p, int K_p, int N_p)
{
	//这里我们划分的lblock和grid是二维的,分别计算线程的二维索引(x方向和y方向的索引)
	int ix = threadIdx.x + blockDim.x*blockIdx.x;//row number,
	int iy = threadIdx.y + blockDim.y*blockIdx.y;//col number

	if (ix < N_p && iy < M_p)  //筛选线程,每个线程计算C中的一个元素,线程的xy索引与C的元素位置索引对应
	{
		float sum = 0;
		for (int k = 0; k < K_p; k++) //C中的某个元素为A中对应行和B中对应列向量的乘积和。
		{
			sum += array_A[iy*K_p + k] * array_B[k*N_p + ix];
		}
		array_C[iy*N_p + ix] = sum;
	}
}

//主函数
int main(int argc, char **argv)
{
	int Axy = M * K;
	int Bxy = K * N;
	int Cxy = M * N;

	float *h_A, *h_B, *hostRef, *deviceRef;
	
	//在CPU上分配内存
	h_A = (float*)malloc(Axy * sizeof(float)); 
	h_B = (float*)malloc(Bxy * sizeof(float));
	h_C = (float*)malloc(Cxy * sizeof(float));

	initial(h_A, Axy);
	initial(h_B, Bxy);
	
	//在GPU上分配显存
	float *d_A, *d_B, *d_C;
	cudaMalloc((void**)&d_A, Axy * sizeof(float));
	cudaMalloc((void**)&d_B, Bxy * sizeof(float));
	cudaMalloc((void**)&d_C, Cxy * sizeof(float));
	
	//将CPU上初始化的a b值拷贝到GPU上
	cudaMemcpy(d_A, h_A, Axy * sizeof(float), cudaMemcpyHostToDevice);
	cudaMemcpy(d_B, h_B, Bxy * sizeof(float), cudaMemcpyHostToDevice);

	//划分GPU的block和Grid
    int dimx = 2;
    int dimy = 2;
    dim3 block(dimx, dimy);
    dim3 grid((M + block.x - 1) / block.x, (N + block.y - 1) / block.y);
    
    //调用核函数
    multiplicateMatrix<<>> (d_A, d_B, d_C, M, K, N);
    
	//将GPU上计算结果拷贝回CPU
    cudaMemcpy(h_C, d_C, Cxy * sizeof(float), cudaMemcpyDeviceToHost);

	//释放GPU显存资源
    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);
    
	//释放CPU内存资源
    free(h_A);
    free(h_B);
    free(h_C);

return (0);
}

三、CUDA进阶 I——利用共享内存加速访存

一般我们将数据发送到GPU后,默认保存到全局内存,而全局内存的读写速度特别慢,这个时候我们将数据从全局内存放到线程块的共享内存中,计算过程中,读取访问速度更快的共享内存,将会大大减少数据访问耗时,提高程序速度。

1.CUDA内存读写速度比较

下列几种内存的架构参见下图:

  • 线程寄存器(~1周期)
  • Block共享内存(~5周期)
  • Grid全局内存(~500周期)
  • Grid常量内存(~5周期)
    一篇文章理解CUDA架构、编程与进阶使用_第3张图片

2.申请共享内存

前面对比了共享内存和全局内存的访问速度,为了进一步提高访存速度,可以把全局内存一部分数据拷贝到共享内存中(由于共享内存的大小有限,大概只有几十K,所以只能分多次拷贝数据)

申请共享内存的方式分为静态申请动态申请
申请共享内存关键字:__ shared __
块内共享内存同步:__syncthreads()函数(块内不同线程之间同步)

  • 静态申请
__global__ void staticFun(int* d, int n)
{
	__shared__ int s[64];  //静态申请,需要指定申请内存的大小
	int t = treadIdx.x;
	s[t] = d[t];  //将全局内存数据拷贝到申请的共享内存中,之后利用共享内存中的数据参与运算将会比调
	//用全局内存数据参与运算快(由于共享内存有限,不能全部拷贝到共享内存,这其中就涉及到分批拷贝问题了)
	__syncthreads();//需要等所有线程块都拷贝完成后再进行计算
}

staticFun<<1,n>>(d, n);
  • 动态申请
__global__ void dynamicFun(int *d, int n)
{
	extern __shared__ int s[]; //动态申请,不需要指定大小,需要加上extern关键字
	int t = threadIdx.x;
	s[t] = d[t];
	__syncthreads();
}

dynamicFun<<1, n, n*sizeof(int)>>(d, n); //动态申请需要在外部指定共享内存大小

上面内容只是让大家对共享内存如何加速运算有一个初步的认识,详细使用方法可以参考我的另外一篇文章:CUDA加速计算矩阵乘法&进阶玩法(共享内存)

后面的内容有待补充。。。有用的话记得点赞搜藏o

四、CUDA进阶 II——利用stream加速大批量文件IO读写耗时

1. 认识CUDA stream

CUDA的stream流,类似我们经常使用CPU时开多线程。

  • 当我们使用GPU进行计算时,如果我们没有主动开启stream流,GPU会自动创建默认流来执行核函数,默认流和CPU端的计算是同步的。(也即在CPU执行任务过程中,必须等GPU执行完核函数后,才能继续往下执行)
  • 当我们使用GPU进行计算时,我们可以主动开启多个stream流,类似CPU开启多线程。我们可以将大批量文件读写分给多个流去执行,或者用不同的流分别计算不同的核函数。开启的多个流之间是异步的,流与CPU端的计算也是异步的。所以我们需要注意加上同步操作。
    值得注意的是,受PCIe总线带宽的限制,当一个流在进行读写操作时,另外一个流不能同时进行读写操作,但是其他流可以进行数值计算任务。这个有点类似与CPU中的流水线机制。
    一篇文章理解CUDA架构、编程与进阶使用_第4张图片

2. CUDA stream API介绍

• 创建一个stream
cudaStream_t stream;
cudaStreamCreate(&stream);
• 将host数据拷贝到device
cudaMemcpyAsync(dst, src, size, type, stream)
• kernel在流中执行
kernel_name<<>>(praments);
• 同步和查询
cudaError_t cudaStreamSynchronize(cudaStream_t stream)
cudaError_t cudaStreamQuery(cudaStream_t stream);
• 销毁流
cudaError_t cudaStreamDestroy(cudaStream_t stream)

上面仅对CUDA stream有一个简单的介绍和认知,CUDA stream使用示例在这篇文章进行了介绍:CUDA优化方案—stream的使用

官方参考文档:https://developer.nvidia.com/blog/gpu-pro-tip-cuda-7-streams-simplify-concurrency/

五、CUDA进阶 III——调用cuBLAS库API进行矩阵计算

cuBLAS是一个BLAS的实现,允许用户使用NVIDIA的GPU的计算资源。使用cuBLAS 的时候,应用程序应该分配矩阵或向量所需的GPU内存空间,并加载数据,调用所需的cuBLAS函数,然后从GPU的内存空间上传计算结果至主机,cuBLAS API也提供一些帮助函数来写或者读取数据从GPU中。
• 列优先的数组,索引以1为基准
• 头文件 include "cublas_v2.h“
• 三类函数(向量标量、向量矩阵、矩阵矩阵)

cuBlas使用范例

int main(int argc, char **argv)
{
		......
        cublasStatus_t status;
        cublasHandle_t handle;
        cublasCreate(&handle);

        float a = 1, b = 0;
        cublasSgemm(
          handle,
          CUBLAS_OP_T,   //矩阵A的属性参数,转置,按行优先
          CUBLAS_OP_T,   //矩阵B的属性参数,转置,按行优先
          M,          //矩阵A、C的行数
          N,          //矩阵B、C的列数
          K,          //A的列数,B的行数,此处也可为B_ROW,一样的
          &a,             //alpha的值
          d_A,            //左矩阵,为A
          K,          //A的leading dimension,此时选择转置,按行优先,则leading dimension为A的列数
          d_B,            //右矩阵,为B
          N,          //B的leading dimension,此时选择转置,按行优先,则leading dimension为B的列数
          &b,             //beta的值
          d_C,            //结果矩阵C
          M           //C的leading dimension,C矩阵一定按列优先,则leading dimension为C的行数
        );
        cudaMemcpy(deviceRef, d_C, Cxy * sizeof(float), cudaMemcpyDeviceToHost);
        cudaDeviceSynchronize();
        ......
}

详细的各种API介绍,推荐参考官方文档:https://docs.nvidia.com/cuda/cublas/index.html

你可能感兴趣的:(CUDA并行计算,架构,cuda,gpu,并行计算,c++)