CUDA C++实战--中级

矩阵装置与访存优化

复制代码
#include <cuda_runtime.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <random>

#define TILE 32
#define BLOCK_ROWS 8

// naive转置内核
__global__ void Naive_kernel(float* naive_mem, float* naive_result, int row, int col, size_t input_size, size_t output_size) {
	int x = threadIdx.x + blockDim.x * blockIdx.x;
	int y = threadIdx.y + blockDim.y * blockIdx.y;

	size_t input_stride = input_size / sizeof(float);
	size_t output_stride = output_size / sizeof(float);

	if (x < col && y < row) {
		naive_result[x * output_stride + y] = naive_mem[y * input_stride + x];
	}
}

// tile转置内核
__global__ void Tile_kernel(float* tile_mem, float* tile_result, int row, int col, size_t input_size, size_t output_size) {
	__shared__ float tiles[TILE][TILE];
	int x = threadIdx.x + blockDim.x * blockIdx.x;
	int y = threadIdx.y + blockDim.y * blockIdx.y;

	size_t input_stride = input_size / sizeof(float);
	size_t output_stride = output_size / sizeof(float);

	float value = 0.0f;

	if (x < col && y < row) {
		value = tile_mem[y * input_stride + x];
	}
	tiles[threadIdx.x][threadIdx.y] = value;
	__syncthreads();
	int new_x = threadIdx.x + blockIdx.y * blockDim.x;
	int new_y = threadIdx.y + blockIdx.x * blockDim.y;
	if (new_x < row && new_y < col) {
		tile_result[new_y * output_stride + new_x] = tiles[threadIdx.y][threadIdx.x];
	}
}

// tile+padding转置内核
__global__ void TP_kernel(float* tp_mem, float* tp_result, int row, int col, size_t input_size, size_t output_size) {
	__shared__ float tiles[TILE][TILE + 1];
	int x = threadIdx.x + blockDim.x * blockIdx.x;
	int y = threadIdx.y + blockDim.y * blockIdx.y;

	size_t input_stride = input_size / sizeof(float);
	size_t output_stride = output_size / sizeof(float);

	float value = 0.0f;

	if (x < col && y < row) {
		value = tp_mem[y * input_stride + x];
	}
	tiles[threadIdx.y][threadIdx.x] = value;
	__syncthreads();
	int new_x = threadIdx.x + blockIdx.y * blockDim.x;
	int new_y = threadIdx.y + blockIdx.x * blockDim.y;
	if (new_x < row && new_y < col) {
		tp_result[new_y * output_stride + new_x] = tiles[threadIdx.x][threadIdx.y];
	}
}

// rectangle+tile+padding转置内核
__global__ void RETile_kernel(float* retp_mem, float* retp_result, int row, int col, size_t input_size, size_t output_size) {
	__shared__ float tiles[TILE][TILE + 1];
	int x = threadIdx.x + TILE * blockIdx.x;
	int y = threadIdx.y + TILE * blockIdx.y;

	size_t input_stride = input_size / sizeof(float);
	size_t output_stride = output_size / sizeof(float);

	for (int j = 0; j < TILE; j += BLOCK_ROWS) {
		if (x < col && y + j < row) {
			tiles[threadIdx.y + j][threadIdx.x] = retp_mem[(y + j) * input_stride + x];
		}
		else {
			tiles[threadIdx.y + j][threadIdx.x] = 0.0f;
		}
	}
	__syncthreads();
	int new_x = threadIdx.x + blockIdx.y * TILE;
	int new_y = threadIdx.y + blockIdx.x * TILE;
	for (int j = 0; j < TILE; j += BLOCK_ROWS) {
		if (new_x < row && new_y + j < col) {
			retp_result[(new_y + j) * output_stride + new_x] = tiles[threadIdx.x][threadIdx.y + j];
		}
	}
}

// rectangle+tile+padding转置内核
__global__ void RETile_kernel1(float* retp_mem, float* retp_result, int row, int col, size_t input_size, size_t output_size) {
	__shared__ float tiles[TILE][TILE + 1];
	int x = threadIdx.x + TILE * blockIdx.x;
	int y = threadIdx.y + TILE * blockIdx.y;

	size_t input_stride = input_size / sizeof(float);
	size_t output_stride = output_size / sizeof(float);

	for (int j = 0; j < TILE; j += BLOCK_ROWS) {
		if (x < col && y + j < row) {
			tiles[threadIdx.y + j][threadIdx.x] = retp_mem[(y + j) * input_stride + x];
		}
		else {
			tiles[threadIdx.y + j][threadIdx.x] = 0.0f;
		}
	}
	__syncthreads();
	int new_x = threadIdx.x + blockIdx.y * TILE;
	int new_y = threadIdx.y + blockIdx.x * TILE;
	for (int j = 0; j < TILE; j += BLOCK_ROWS) {
		if (new_x < row && new_y + j < col) {
			retp_result[(new_y + j) * output_stride + new_x] = tiles[threadIdx.x][threadIdx.y + j];
		}
	}
}

int main() {
	int N_nums[] = { 128, 130, 256, 512, 1024, 2048 };

	cudaStream_t stream;
	cudaStreamCreate(&stream);

	cudaEvent_t start;
	cudaEventCreate(&start);
	cudaEvent_t end;
	cudaEventCreate(&end);

	for (auto&& row : N_nums) {
		int col;
		if (row == 2048) {
			col = row;
		}
		else {
			col = row * 2;
		}
		std::cout << "数组行长:" << row << std::endl;
		std::cout << "数组列长:" << col << std::endl;

		// 固定随机数以确保参数相同
		std::mt19937 gen(42);
		std::uniform_real_distribution<float> dist(-10.0, 10.0);

		// 创建二维容器
		std::vector<float> v(row * col);
		for (int i = 0; i < row * col; ++i) {
			v[i] = dist(gen);
		}

		// cpu转置
		std::vector<std::vector<float>> v1(col, std::vector<float>(row, 0));
		for (int i = 0; i < row; ++i) {
			for (int j = 0; j < col; ++j) {
				v1[j][i] = v[i * col + j];
			}
		}

		// 得到cpu的结果
		std::vector<float> cpu_result(row * col);
		for (int i = 0; i < col; ++i) {
			for (int j = 0; j < row; ++j) {
				cpu_result[j + row * i] = v1[i][j];
			}
		}

		int N = row * col;
		dim3 BlockPerThreads(TILE, TILE);
		dim3 GridPerBlocks((col + BlockPerThreads.x - 1) / BlockPerThreads.x, (row + BlockPerThreads.y - 1) / BlockPerThreads.y);
		size_t size = N * sizeof(float);

		// naive转置的参数设定
		float* naive_mem = nullptr;
		float* naive_result = nullptr;
		size_t naive_input_size = 0;
		size_t naive_output_size = 0;
		std::vector<float> gpu_result1(row * col);
		auto naive_err1 = cudaMallocPitch(&naive_mem, &naive_input_size, (size_t)col * sizeof(float), (size_t)row);
		auto naive_err2 = cudaMallocPitch(&naive_result, &naive_output_size, (size_t)row * sizeof(float), (size_t)col);
		auto naive_err3 = cudaMemcpy2D(naive_mem, naive_input_size, v.data(), col * sizeof(float), col * sizeof(float), row, cudaMemcpyHostToDevice);
		if (naive_err1 != cudaSuccess || naive_err2 != cudaSuccess || naive_err3 != cudaSuccess) {
			std::cout << "naive转置输入内存分配出现问题" << std::endl;
			return 0;
		}

		// naive转置预热
		for (int i = 0; i < 10; ++i) {
			Naive_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (naive_mem, naive_result, row, col, naive_input_size, naive_output_size);
		}

		// naive转置
		float Naive_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			Naive_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (naive_mem, naive_result, row, col, naive_input_size, naive_output_size);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&Naive_time, start, end);
		auto naive_err4 = cudaMemcpy2D(gpu_result1.data(), row * sizeof(float), naive_result, naive_output_size, row * sizeof(float), col, cudaMemcpyDeviceToHost);
		if (naive_err4 != cudaSuccess) {
			std::cout << "naive转置输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < row * col; ++j) {
			if (cpu_result[j] != gpu_result1[j]) {
				std::cout << "naive转置结果错误" << std::endl;
				return 0;
			}
		}
		std::cout << "naive转置结果正确,平均耗时:" << Naive_time / 100 << std::endl;

		// tile转置的参数设定
		float* tile_mem = nullptr;
		float* tile_result = nullptr;
		size_t tile_input_size = 0;
		size_t tile_output_size = 0;
		std::vector<float> gpu_result2(row * col);
		auto tile_err1 = cudaMallocPitch(&tile_mem, &tile_input_size, (size_t)col * sizeof(float), (size_t)row);
		auto tile_err2 = cudaMallocPitch(&tile_result, &tile_output_size, (size_t)row * sizeof(float), (size_t)col);
		auto tile_err3 = cudaMemcpy2D(tile_mem, tile_input_size, v.data(), col * sizeof(float), col * sizeof(float), row, cudaMemcpyHostToDevice);
		if (tile_err1 != cudaSuccess || tile_err2 != cudaSuccess || tile_err3 != cudaSuccess) {
			std::cout << "tile转置输入内存分配出现问题" << std::endl;
			return 0;
		}

		// tile转置预热
		for (int i = 0; i < 10; ++i) {
			Tile_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tile_mem, tile_result, row, col, tile_input_size, tile_output_size);
		}

		// tile转置
		float tile_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			Tile_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tile_mem, tile_result, row, col, tile_input_size, tile_output_size);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&tile_time, start, end);
		auto tile_err4 = cudaMemcpy2D(gpu_result2.data(), row * sizeof(float), tile_result, tile_output_size, row * sizeof(float), col, cudaMemcpyDeviceToHost);
		if (tile_err4 != cudaSuccess) {
			std::cout << "tile转置输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < row * col; ++j) {
			if (cpu_result[j] != gpu_result2[j]) {
				std::cout << "tile转置结果错误" << std::endl;
				return 0;
			}
		}
		std::cout << " tile转置结果正确,平均耗时:" << tile_time / 100 << std::endl;

		// tile+padding转置的参数设定
		float* tp_mem = nullptr;
		float* tp_result = nullptr;
		size_t tp_input_size = 0;
		size_t tp_output_size = 0;
		std::vector<float> gpu_result3(row * col);
		auto tp_err1 = cudaMallocPitch(&tp_mem, &tp_input_size, (size_t)col * sizeof(float), (size_t)row);
		auto tp_err2 = cudaMallocPitch(&tp_result, &tp_output_size, (size_t)row * sizeof(float), (size_t)col);
		auto tp_err3 = cudaMemcpy2D(tp_mem, tp_input_size, v.data(), col * sizeof(float), col * sizeof(float), row, cudaMemcpyHostToDevice);
		if (tp_err1 != cudaSuccess || tp_err2 != cudaSuccess || tp_err3 != cudaSuccess) {
			std::cout << "tile+padding转置输入内存分配出现问题" << std::endl;
			return 0;
		}

		// tile+padding转置预热
		for (int i = 0; i < 10; ++i) {
			TP_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tp_mem, tp_result, row, col, tp_input_size, tp_output_size);
		}

		// tile+padding转置
		float tp_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			TP_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tp_mem, tp_result, row, col, tp_input_size, tp_output_size);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&tp_time, start, end);
		auto tp_err4 = cudaMemcpy2D(gpu_result3.data(), row * sizeof(float), tp_result, tp_output_size, row * sizeof(float), col, cudaMemcpyDeviceToHost);
		if (tp_err4 != cudaSuccess) {
			std::cout << "tile+padding转置输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < row * col; ++j) {
			if (cpu_result[j] != gpu_result3[j]) {
				std::cout << "tile+padding转置结果错误" << std::endl;
				return 0;
			}
		}
		std::cout << "   tp转置结果正确,平均耗时:" << tp_time / 100 << std::endl;

		// rectangle+tile+padding转置的参数设定
		float* retp_mem = nullptr;
		float* retp_result = nullptr;
		size_t retp_input_size = 0;
		size_t retp_output_size = 0;
		std::vector<float> gpu_result4(row * col);
		auto retp_err1 = cudaMallocPitch(&retp_mem, &retp_input_size, (size_t)col * sizeof(float), (size_t)row);
		auto retp_err2 = cudaMallocPitch(&retp_result, &retp_output_size, (size_t)row * sizeof(float), (size_t)col);
		auto retp_err3 = cudaMemcpy2D(retp_mem, retp_input_size, v.data(), col * sizeof(float), col * sizeof(float), row, cudaMemcpyHostToDevice);
		if (retp_err1 != cudaSuccess || retp_err2 != cudaSuccess || retp_err3 != cudaSuccess) {
			std::cout << "rectangle+tile+padding转置输入内存分配出现问题" << std::endl;
			return 0;
		}

		dim3 TileBlockPerThreads(TILE, BLOCK_ROWS);
		dim3 TileGridPerBlocks((col + TileBlockPerThreads.x - 1) / TileBlockPerThreads.x, (row + TileBlockPerThreads.y - 1) / TileBlockPerThreads.y);

		// rectangle+tile+padding转置预热
		for (int i = 0; i < 10; ++i) {
			RETile_kernel << <TileGridPerBlocks, TileBlockPerThreads, 0, stream >> > (retp_mem, retp_result, row, col, retp_input_size, retp_output_size);
		}

		// rectangle+tile+padding转置
		float retp_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			RETile_kernel << <TileGridPerBlocks, TileBlockPerThreads, 0, stream >> > (retp_mem, retp_result, row, col, retp_input_size, retp_output_size);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&retp_time, start, end);
		auto retp_err4 = cudaMemcpy2D(gpu_result4.data(), row * sizeof(float), retp_result, retp_output_size, row * sizeof(float), col, cudaMemcpyDeviceToHost);
		if (retp_err4 != cudaSuccess) {
			std::cout << "rectangle+tile+padding转置输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < row * col; ++j) {
			if (cpu_result[j] != gpu_result4[j]) {
				std::cout << "rectangle+tile+padding转置结果错误" << std::endl;
				return 0;
			}
		}
		std::cout << " retp转置结果正确,平均耗时:" << retp_time / 100 << std::endl;

		// 111rectangle+tile+padding转置的参数设定
		float* retp_mem1 = nullptr;
		float* retp_result1 = nullptr;
		size_t retp_input_size1 = 0;
		size_t retp_output_size1 = 0;
		std::vector<float> gpu_result5(row * col);
		auto retp_err11 = cudaMallocPitch(&retp_mem1, &retp_input_size1, (size_t)col * sizeof(float), (size_t)row);
		auto retp_err21 = cudaMallocPitch(&retp_result1, &retp_output_size1, (size_t)row * sizeof(float), (size_t)col);
		auto retp_err31 = cudaMemcpy2D(retp_mem1, retp_input_size1, v.data(), col * sizeof(float), col * sizeof(float), row, cudaMemcpyHostToDevice);
		if (retp_err11 != cudaSuccess || retp_err21 != cudaSuccess || retp_err31 != cudaSuccess) {
			std::cout << "rectangle+tile+padding转置输入内存分配出现问题" << std::endl;
			return 0;
		}

		dim3 TileBlockPerThreads1(TILE, BLOCK_ROWS);
		dim3 TileGridPerBlocks1((col + TILE - 1) / TILE, (row + TILE - 1) / TILE);

		// rectangle+tile+padding转置预热
		for (int i = 0; i < 10; ++i) {
			RETile_kernel1 << <TileGridPerBlocks1, TileBlockPerThreads1, 0, stream >> > (retp_mem1, retp_result1, row, col, retp_input_size1, retp_output_size1);
		}

		// rectangle+tile+padding转置
		float retp_time1 = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			RETile_kernel1 << <TileGridPerBlocks1, TileBlockPerThreads1, 0, stream >> > (retp_mem1, retp_result1, row, col, retp_input_size1, retp_output_size1);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&retp_time1, start, end);
		auto retp_err41 = cudaMemcpy2D(gpu_result5.data(), row * sizeof(float), retp_result1, retp_output_size1, row * sizeof(float), col, cudaMemcpyDeviceToHost);
		if (retp_err41 != cudaSuccess) {
			std::cout << "rectangle+tile+padding转置输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < row * col; ++j) {
			if (cpu_result[j] != gpu_result5[j]) {
				std::cout << "rectangle+tile+padding转置结果错误" << std::endl;
				return 0;
			}
		}
		std::cout << "retp1转置结果正确,平均耗时:" << retp_time1 / 100 << std::endl;

		cudaFree(naive_mem);
		cudaFree(naive_result);
		cudaFree(tile_mem);
		cudaFree(tile_result);
		cudaFree(tp_mem);
		cudaFree(tp_result);
		cudaFree(retp_mem);
		cudaFree(retp_result);
		cudaFree(retp_mem1);
		cudaFree(retp_result1);
	}

	cudaEventDestroy(start);
	cudaEventDestroy(end);
	cudaStreamDestroy(stream);

	return 0;
}

理论上,预期retp1较快,naive较慢,tp通常快于tile。naive的跨行写入难以合并,tile则可以借助共享内存改善了全局内存访问,tp再通过填充消除共享内存的 Bank 冲突。retp1让每个线程处理多个元素,进一步分摊索引计算开销。retp采用相同的分块算法,但启动了多余的线程块,因此预期慢于 retp1。

实际测试中,五种方法的转置结果均正确。retp1在各组中最快,naive最慢。 retp多数时候快于tp和tile,但也有一组同时慢于两者。tp多数时候快于tile,个别组的顺序则相反。

retp的排名变化与网格配置有关。由于数据较少,多余的线程块没有处理有效数据,却增加了调度、边界判断和同步开销。而tp消除Bank冲突只降低了共享内存访问这一部分的成本,当内核启动、调度或缓存状态的影响较大时,这项优化的收益可能被掩盖。

前提要求

多维尺寸数据类型--dim3

通过dim3(x, y, z)可以定义至多三维尺寸的数据类型,没有指定的维度默认为1

复制代码
dim3 block(256);         // (256, 1, 1)
dim3 block(17, 16);      // (17, 16, 1)
dim3 block(8, 8, 4);     // (8, 8, 4)

以上述的二维数据为例,其表示17的列(x),16的行(y),因此在构建网格包含的线程块时,需要使用如下代码

复制代码
// 假设输入变量为(row, col)
dim3 GridPerBlocks(
    (col + BlockPerThreads.x - 1) / BlockPerThreads.x, // 列
    (row + BlockPerThreads.y - 1) / BlockPerThreads.y  // 行
);
二维数组内存分配--cudaMallocPitch
函数原型
复制代码
cudaError_t cudaMallocPitch(
    void** devPtr,
    size_t* pitch,
    size_t width,
    size_t height
);

devPtr:接收GPU内存地址

pitch:返回值,表示每一行实际占用的字节数

width:每行有效数据大小,简单来说就是矩阵的列×元素大小,单位为字节

height:矩阵行数

注意

这里需要注意的是在通过cudaMallocPitch后,返回的pitch才是数组实际上每一行占用的字节数,因此在使用该内存时,通常不使用传入的width,而是直接使用pitch。

这里主要的使用场景便是在内核实际进行转置,以及在使用cudaMemcpy2D进行数据之间的传输

因此如果你发现gpu计算的结果和cpu计算的结果不同,或者越界错误,可能便是这里出现了问题。

cudaMemcpy2D
函数原型
复制代码
cudaError_t cudaMemcpy2D(
    void* dst,
    size_t dpitch,
    const void* src,
    size_t spitch,
    size_t width,
    size_t height,
    cudaMemcpyKind kind
);

dst:目标地址

dpitch:目标每一行实际跨度

src:源地址

spitch:源每一行实际跨度

width:每行复制多少字节

height:复制多少行

kind:复制方向

预热和重复执行取平均值

内核预热:提前执行几次 Kernel,减少 CUDA 上下文初始化、内核加载等首次运行开销对计时结果的影响。

重复执行取平均值:通过多次测量,降低 GPU 频率波动、系统调度等随机因素的影响,使性能测试结果更加稳定、可靠。

代码解析

Naive转置

这就是传统的转置方法,较为简单,它的做法不做过多赘述。

在Naive转置中有一个非常明显的缺点(naive_resultx \* output_stride + y = naive_memy \* input_stride + x;),在之前的文章中(CUDA C++--编写SIMT内核和异步执行--全局内存的合并访问)我们提到过,全局内存是连续排列的,因此在连续地址读取时,其性能是最佳的,也就是我们所说的全局内存的合并访问。

对于连续访问(合并访问)的地址,硬件通常只需要一个内存事务即可满足整个线程束的需求,但是对于跨步访问(非合并访问)的地址,硬件必须使用多次的内存事务才能满足这些请求,导致实际传输的数据量远大于有效数据量,带宽利用率大幅下降。

因此这是就需要使用到另一种编程模式--Tile Programming

tile转置

这是本次实战中需要使用的最重要的一个方法,也是在我们之前文章(CUDA介绍--Tile Programming)提到过的另一种编程模式。

其本质便是通过共享内存构建一个tile,以tile为基本单位去执行转置,从而提高性能。

数学基础

在具体讲解之前,我们需要提一下本次实现代码使用的数学基础。

这里面最主要的便是矩阵分块,矩阵的转置=子矩阵内部转置+子矩阵整体位置转置

这个数学规律对于方阵与非方阵都成立。

而我们所使用的tile本质就是将整个全局内存矩阵切成一个个的分块子矩阵。

这样整个转置过程就可以分为2个部分:tile内部元素的转置、整个全局全局内存矩阵按照tile进行转置。
通过tilesthreadIdx.xthreadIdx.y = value;完成tile内部分块矩阵转置,再通过交换blockIdx.x和blockIdx.y完成tile整体位置转置,但因为tile内部已经转置,从而导致了tile内部行列已经调换,因此需要再使用tilesthreadIdx.ythreadIdx.x来完成局部转置的映射。

而如果使用tilesthreadIdx.ythreadIdx.x = value;时,情况就相反了,这一步并没有发生转置,通过交换blockIdx.x和blockIdx.y完成tile整体位置转置后,通过tilesthreadIdx.xthreadIdx.y就可以完成tile内部分块矩阵转置。

tile+padding转置

再之前的章节(CUDA C++--编写SIMT内核和异步执行--共享内存的访问模式)中,我们知道使用tile3232这样等长的tile可能照成缓存冲突,而为了解决这个问题,我们可以通过将tile多填充一列即可解决,这也是这部分编程的主体思想。

rectangle+tile+padding转置

而相较于采用 32×32 线程块的Tiled转置,32×8线程块仍然处理完整的32×32 Tile,但通过让每个线程处理4个元素,将每个线程块的线程数由 1024 减少至 256。类似于前文中介绍的Grid-Stride Loop。

这种设计能够分摊部分线程索引计算开销,降低大线程块对 SM 资源分配的限制,并提高线程块调度的灵活性。同时,两种方案均采用 [32][33] 的 Shared Memory Padding,能够减少转置访问产生的 Bank Conflict。因此,32×8 配置通常具有更好的性能优化潜力,但实际加速效果仍取决于 GPU 架构、资源占用和矩阵规模,需要通过性能测试验证。

rectangle+tile+padding变式转置

这个与上面方法最主要的区别便是启动的grid和block不同

复制代码
// rectangle+tile+padding转置
dim3 BlockPerThreads(32, 32);
dim3 GridPerBlocks((col + BlockPerThreads.x - 1) / BlockPerThreads.x, (row + BlockPerThreads.y - 1) / BlockPerThreads.y);

// rectangle+tile+padding变式转置
dim3 TileBlockPerThreads1(32, 8);
dim3 TileGridPerBlocks1((col + 32 - 1) / 32, (row + 32 - 1) / 32);

这样做的好处就是可以显著减少不必要线程块的启动,从而提高性能。

分块矩阵乘法

复制代码
#include <cuda_runtime.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <random>
#include <cmath>
#include <algorithm>

#include <cublas_v2.h>
#ifdef _MSC_VER
#pragma comment(lib, "cublas.lib")
#endif

#define TILE 32

__global__ void Naive_kernel(float* naive_A, float* naive_B, float* naive_result, size_t naive_Asize, size_t naive_Bsize, size_t naive_size, int length0, int length1, int length2) {
	int x = threadIdx.x + blockDim.x * blockIdx.x;
	int y = threadIdx.y + blockDim.y * blockIdx.y;

	size_t A_stride = naive_Asize / sizeof(float);
	size_t B_stride = naive_Bsize / sizeof(float);
	size_t result_stride = naive_size / sizeof(float);

	if (x < length2 && y < length0) {
		float sum = 0.0f;
		for (int i = 0; i < length1; ++i) {
			sum += (naive_A[i + y * A_stride] * naive_B[x + i * B_stride]);
		}
		naive_result[x + y * result_stride] = sum;
	}
}

__global__ void tile88_kernel(float* tile88_A, float* tile88_B, float* tile88_result, size_t tile88_Asize, size_t tile88_Bsize, size_t tile88_size, int length0, int length1, int length2) {
	int tx = threadIdx.x;
	int ty = threadIdx.y;

	size_t A_stride = tile88_Asize / sizeof(float);
	size_t B_stride = tile88_Bsize / sizeof(float);
	size_t result_stride = tile88_size / sizeof(float);

	__shared__ float A_tile[TILE][TILE + 1];
	__shared__ float B_tile[TILE][TILE + 1];

	float sum[4][4] = { 0.0f };

	for (int t = 0; t < length1; t += TILE) {
		// 传递数据
		for (int i = threadIdx.y; i < TILE; i += 8) {
			for (int j = threadIdx.x; j < TILE; j += 8) {
				int A_row = blockIdx.y * TILE + i;  // A矩阵行
				int A_col = t + j;					// A矩阵列
				int B_row = t + i;					// B矩阵行
				int B_col = blockIdx.x * TILE + j;  // A矩阵列

				A_tile[i][j] = (A_row < length0 && A_col < length1) ? tile88_A[A_row * A_stride + A_col] : 0.0f;
				B_tile[i][j] = (B_row < length1 && B_col < length2) ? tile88_B[B_row * B_stride + B_col] : 0.0f;
			}
		}
		__syncthreads();

		// 开始计算
		for (int k = 0; k < TILE; ++k) {
			for (int i = 0; i < 4; ++i) {
				for (int j = 0; j < 4; ++j) {
					sum[i][j] += A_tile[threadIdx.y + i * 8][k] * B_tile[k][threadIdx.x + j * 8];
				}
			}
		}
		__syncthreads();
	}

	// 写入结果
	for (int i = 0; i < 4; ++i) {
		for (int j = 0; j < 4; ++j) {
			int row = blockIdx.y * TILE + threadIdx.y + i * 8;
			int col = blockIdx.x * TILE + threadIdx.x + j * 8;

			if (row < length0 && col < length2) {
				tile88_result[row * result_stride + col] = sum[i][j];
			}
		}
	}
}

__global__ void tile1616_kernel(float* tile1616_A, float* tile1616_B, float* tile1616_result, size_t tile1616_Asize, size_t tile1616_Bsize, size_t tile1616_size, int length0, int length1, int length2) {
	int tx = threadIdx.x;
	int ty = threadIdx.y;

	size_t A_stride = tile1616_Asize / sizeof(float);
	size_t B_stride = tile1616_Bsize / sizeof(float);
	size_t result_stride = tile1616_size / sizeof(float);

	__shared__ float A_tile[TILE][TILE + 1];
	__shared__ float B_tile[TILE][TILE + 1];

	float sum[2][2] = { 0.0f };

	for (int t = 0; t < length1; t += TILE) {
		// 传递数据
		for (int i = threadIdx.y; i < TILE; i += 16) {
			for (int j = threadIdx.x; j < TILE; j += 16) {
				int A_row = blockIdx.y * TILE + i;  // A矩阵行
				int A_col = t + j;					// A矩阵列
				int B_row = t + i;					// B矩阵行
				int B_col = blockIdx.x * TILE + j;  // A矩阵列

				A_tile[i][j] = (A_row < length0 && A_col < length1) ? tile1616_A[A_row * A_stride + A_col] : 0.0f;
				B_tile[i][j] = (B_row < length1 && B_col < length2) ? tile1616_B[B_row * B_stride + B_col] : 0.0f;
			}
		}
		__syncthreads();

		// 开始计算
		for (int k = 0; k < TILE; ++k) {
			for (int i = 0; i < 2; ++i) {
				for (int j = 0; j < 2; ++j) {
					sum[i][j] += A_tile[threadIdx.y + i * 16][k] * B_tile[k][threadIdx.x + j * 16];
				}
			}
		}
		__syncthreads();
	}

	// 写入结果
	for (int i = 0; i < 2; ++i) {
		for (int j = 0; j < 2; ++j) {
			int row = blockIdx.y * TILE + threadIdx.y + i * 16;
			int col = blockIdx.x * TILE + threadIdx.x + j * 16;

			if (row < length0 && col < length2) {
				tile1616_result[row * result_stride + col] = sum[i][j];
			}
		}
	}
}

__global__ void tile3232_kernel(float* tile3232_A, float* tile3232_B, float* tile3232_result, size_t tile3232_Asize, size_t tile3232_Bsize, size_t tile3232_size, int length0, int length1, int length2) {
	int x = threadIdx.x + blockDim.x * blockIdx.x;
	int y = threadIdx.y + blockDim.y * blockIdx.y;

	size_t A_stride = tile3232_Asize / sizeof(float);
	size_t B_stride = tile3232_Bsize / sizeof(float);
	size_t result_stride = tile3232_size / sizeof(float);

	__shared__ float A_tile[TILE][TILE + 1];
	__shared__ float B_tile[TILE][TILE + 1];

	float sum = 0.0f;

	for (int t = 0; t < length1; t += TILE) {
		// 传递数据
		A_tile[threadIdx.y][threadIdx.x] = (y < length0 && t + threadIdx.x < length1) ? tile3232_A[y * A_stride + t + threadIdx.x] : 0.0f;
		B_tile[threadIdx.y][threadIdx.x] = (x < length2 && t + threadIdx.y < length1) ? tile3232_B[x + (t + threadIdx.y) * B_stride] : 0.0f;
		__syncthreads();
		// 开始计算
		for (int k = 0; k < TILE; ++k) {
			sum += A_tile[threadIdx.y][k] * B_tile[k][threadIdx.x];
		}
		__syncthreads();
	}
	// 写入结果
	if (y < length0 && x < length2) {
		tile3232_result[y * result_stride + x] = sum;
	}
}

int main() {
	int N_nums[] = { 64, 128, 130, 256, 512 };

	cudaStream_t stream;
	cudaStreamCreate(&stream);

	cudaEvent_t start;
	cudaEventCreate(&start);
	cudaEvent_t end;
	cudaEventCreate(&end);

	// cuBLAS初始化
	cublasHandle_t handle = nullptr;
	auto cublas_initerr1 = cublasCreate(&handle);
	if (cublas_initerr1 != CUBLAS_STATUS_SUCCESS) {
		std::cout << "cuBLAS句柄创建出现问题" << std::endl;
		return 1;
	}
	auto cublas_initerr2 = cublasSetStream(handle, stream);			// 设置流
	auto cublas_initerr3 = cublasSetMathMode(handle, CUBLAS_PEDANTIC_MATH);				// 设置计算模式,严格保证精度
	auto cublas_initerr4 = cublasSetPointerMode(handle, CUBLAS_POINTER_MODE_HOST);		// 设置指针模式
	if (cublas_initerr2 != CUBLAS_STATUS_SUCCESS || cublas_initerr3 != CUBLAS_STATUS_SUCCESS || cublas_initerr4 != CUBLAS_STATUS_SUCCESS) {
		std::cout << "cuBLAS流或计算模式设置出现问题" << std::endl;
		cublasDestroy(handle);
		return 1;
	}

	for (auto&& N : N_nums) {
		std::vector<int> length(3);
		length[0] = N;
		length[1] = 2 * N;
		length[2] = 4 * N;
		std::cout << "矩阵A维度:(" << length[0] << ", " << length[1] << ")\n";
		std::cout << "矩阵B维度:(" << length[1] << ", " << length[2] << ")\n";

		// 固定随机数以确保参数相同
		std::mt19937 gen(42);
		std::uniform_real_distribution<float> dist(-10.0, 10.0);

		// 创建A、B矩阵
		std::vector<float> A(length[0] * length[1]);
		std::vector<float> B(length[1] * length[2]);
		for (int i = 0; i < length[1] * length[2]; ++i) {
			if (i < length[0] * length[1]) {
				A[i] = dist(gen);
			}
			B[i] = dist(gen);
		}

		// CPU实现矩阵乘法
		std::vector<float> cpu_result(length[0] * length[2], 0.0f);
		for (int i = 0; i < length[0]; ++i) {
			for (int k = 0; k < length[2]; ++k) {
				for (int j = 0; j < length[1]; ++j) {
					cpu_result[k + i * length[2]] += (A[j + i * length[1]] * B[k + j * length[2]]);
				}
			}
		}

		dim3 BlockPerThreads(TILE, TILE);
		dim3 GridPerBlocks((length[2] + BlockPerThreads.x - 1) / BlockPerThreads.x, (length[0] + BlockPerThreads.y - 1) / BlockPerThreads.y);

		// naive矩阵乘法的参数设定
		float* naive_A = nullptr;
		float* naive_B = nullptr;
		float* naive_result = nullptr;
		size_t naive_Asize = 0;
		size_t naive_Bsize = 0;
		size_t naive_size = 0;
		std::vector<float> gpu_result1(length[0] * length[2], 0.0f);
		auto naive_err1 = cudaMallocPitch(&naive_A, &naive_Asize, length[1] * sizeof(float), length[0]);
		auto naive_err2 = cudaMallocPitch(&naive_B, &naive_Bsize, length[2] * sizeof(float), length[1]);
		auto naive_err3 = cudaMallocPitch(&naive_result, &naive_size, length[2] * sizeof(float), length[0]);
		auto naive_err4 = cudaMemcpy2D(naive_A, naive_Asize, A.data(), length[1] * sizeof(float), length[1] * sizeof(float), length[0], cudaMemcpyHostToDevice);
		auto naive_err5 = cudaMemcpy2D(naive_B, naive_Bsize, B.data(), length[2] * sizeof(float), length[2] * sizeof(float), length[1], cudaMemcpyHostToDevice);
		if (naive_err1 != cudaSuccess || naive_err2 != cudaSuccess || naive_err3 != cudaSuccess || naive_err4 != cudaSuccess || naive_err5 != cudaSuccess) {
			std::cout << "naive矩阵乘法输入内存分配出现问题" << std::endl;
			return 0;
		}

		// naive矩阵乘法预热
		for (int i = 0; i < 10; ++i) {
			Naive_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (naive_A, naive_B, naive_result, naive_Asize, naive_Bsize, naive_size, length[0], length[1], length[2]);
		}

		// naive矩阵乘法
		float Naive_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			Naive_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (naive_A, naive_B, naive_result, naive_Asize, naive_Bsize, naive_size, length[0], length[1], length[2]);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&Naive_time, start, end);
		auto naive_err6 = cudaMemcpy2D(gpu_result1.data(), length[2] * sizeof(float), naive_result, naive_size, length[2] * sizeof(float), length[0], cudaMemcpyDeviceToHost);
		if (naive_err6 != cudaSuccess) {
			std::cout << "naive矩阵乘法输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < length[0] * length[2]; ++j) {
			float abs_err = std::abs(cpu_result[j] - gpu_result1[j]);
			float tolerance = 1e-3f + 1e-4f * std::max(std::abs(cpu_result[j]), std::abs(gpu_result1[j]));
			if (!std::isfinite(cpu_result[j]) || !std::isfinite(gpu_result1[j]) || abs_err > tolerance) {
				std::cout << "naive矩阵乘法结果错误" << std::endl;
				std::cout << "索引: " << j << std::endl;
				std::cout << "CPU: " << cpu_result[j] << std::endl;
				std::cout << "GPU: " << gpu_result1[j] << std::endl;
				return 0;
			}
		}
		std::cout << "naive矩阵乘法结果正确,平均耗时:" << Naive_time / 100 << std::endl;

		// tile8×8矩阵乘法的参数设定
		float* tile88_A = nullptr;
		float* tile88_B = nullptr;
		float* tile88_result = nullptr;
		size_t tile88_Asize = 0;
		size_t tile88_Bsize = 0;
		size_t tile88_size = 0;
		std::vector<float> gpu_result2(length[0] * length[2], 0.0f);
		auto tile88_err1 = cudaMallocPitch(&tile88_A, &tile88_Asize, length[1] * sizeof(float), length[0]);
		auto tile88_err2 = cudaMallocPitch(&tile88_B, &tile88_Bsize, length[2] * sizeof(float), length[1]);
		auto tile88_err3 = cudaMallocPitch(&tile88_result, &tile88_size, length[2] * sizeof(float), length[0]);
		auto tile88_err4 = cudaMemcpy2D(tile88_A, tile88_Asize, A.data(), length[1] * sizeof(float), length[1] * sizeof(float), length[0], cudaMemcpyHostToDevice);
		auto tile88_err5 = cudaMemcpy2D(tile88_B, tile88_Bsize, B.data(), length[2] * sizeof(float), length[2] * sizeof(float), length[1], cudaMemcpyHostToDevice);
		if (tile88_err1 != cudaSuccess || tile88_err2 != cudaSuccess || tile88_err3 != cudaSuccess || tile88_err4 != cudaSuccess || tile88_err5 != cudaSuccess) {
			std::cout << "tile8×8矩阵乘法输入内存分配出现问题" << std::endl;
			return 0;
		}

		dim3 tile88BlockPerThreads(8, 8);
		dim3 tile88GridPerBlocks((length[2] + TILE - 1) / TILE, (length[0] + TILE - 1) / TILE);

		// tile8×8矩阵乘法预热
		for (int i = 0; i < 10; ++i) {
			tile88_kernel << <tile88GridPerBlocks, tile88BlockPerThreads, 0, stream >> > (tile88_A, tile88_B, tile88_result, tile88_Asize, tile88_Bsize, tile88_size, length[0], length[1], length[2]);
		}

		// tile8×8矩阵乘法乘法
		float tile88_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			tile88_kernel << <tile88GridPerBlocks, tile88BlockPerThreads, 0, stream >> > (tile88_A, tile88_B, tile88_result, tile88_Asize, tile88_Bsize, tile88_size, length[0], length[1], length[2]);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&tile88_time, start, end);
		auto tile88_err6 = cudaMemcpy2D(gpu_result2.data(), length[2] * sizeof(float), tile88_result, tile88_size, length[2] * sizeof(float), length[0], cudaMemcpyDeviceToHost);
		if (tile88_err6 != cudaSuccess) {
			std::cout << "tile8×8矩阵乘法输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < length[0] * length[2]; ++j) {
			float abs_err = std::abs(cpu_result[j] - gpu_result2[j]);
			float tolerance = 1e-3f + 1e-4f * std::max(std::abs(cpu_result[j]), std::abs(gpu_result2[j]));
			if (!std::isfinite(cpu_result[j]) || !std::isfinite(gpu_result2[j]) || abs_err > tolerance) {
				std::cout << "tile8×8矩阵乘法结果错误" << std::endl;
				std::cout << "索引: " << j << std::endl;
				std::cout << "CPU: " << cpu_result[j] << std::endl;
				std::cout << "GPU: " << gpu_result2[j] << std::endl;
				return 0;
			}
		}
		std::cout << "tile8×8矩阵乘法结果正确,平均耗时:" << tile88_time / 100 << std::endl;

		// tile16×16矩阵乘法的参数设定
		float* tile1616_A = nullptr;
		float* tile1616_B = nullptr;
		float* tile1616_result = nullptr;
		size_t tile1616_Asize = 0;
		size_t tile1616_Bsize = 0;
		size_t tile1616_size = 0;
		std::vector<float> gpu_result3(length[0] * length[2], 0.0f);
		auto tile1616_err1 = cudaMallocPitch(&tile1616_A, &tile1616_Asize, length[1] * sizeof(float), length[0]);
		auto tile1616_err2 = cudaMallocPitch(&tile1616_B, &tile1616_Bsize, length[2] * sizeof(float), length[1]);
		auto tile1616_err3 = cudaMallocPitch(&tile1616_result, &tile1616_size, length[2] * sizeof(float), length[0]);
		auto tile1616_err4 = cudaMemcpy2D(tile1616_A, tile1616_Asize, A.data(), length[1] * sizeof(float), length[1] * sizeof(float), length[0], cudaMemcpyHostToDevice);
		auto tile1616_err5 = cudaMemcpy2D(tile1616_B, tile1616_Bsize, B.data(), length[2] * sizeof(float), length[2] * sizeof(float), length[1], cudaMemcpyHostToDevice);
		if (tile1616_err1 != cudaSuccess || tile1616_err2 != cudaSuccess || tile1616_err3 != cudaSuccess || tile1616_err4 != cudaSuccess || tile1616_err5 != cudaSuccess) {
			std::cout << "tile16×16矩阵乘法输入内存分配出现问题" << std::endl;
			return 0;
		}

		dim3 tile1616BlockPerThreads(16, 16);
		dim3 tile1616GridPerBlocks((length[2] + TILE - 1) / TILE, (length[0] + TILE - 1) / TILE);

		// tile16×16矩阵乘法预热
		for (int i = 0; i < 10; ++i) {
			tile1616_kernel << <tile1616GridPerBlocks, tile1616BlockPerThreads, 0, stream >> > (tile1616_A, tile1616_B, tile1616_result, tile1616_Asize, tile1616_Bsize, tile1616_size, length[0], length[1], length[2]);
		}

		// tile16×16矩阵乘法乘法
		float tile1616_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			tile1616_kernel << <tile1616GridPerBlocks, tile1616BlockPerThreads, 0, stream >> > (tile1616_A, tile1616_B, tile1616_result, tile1616_Asize, tile1616_Bsize, tile1616_size, length[0], length[1], length[2]);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&tile1616_time, start, end);
		auto tile1616_err6 = cudaMemcpy2D(gpu_result3.data(), length[2] * sizeof(float), tile1616_result, tile1616_size, length[2] * sizeof(float), length[0], cudaMemcpyDeviceToHost);
		if (tile1616_err6 != cudaSuccess) {
			std::cout << "tile16×16矩阵乘法输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < length[0] * length[2]; ++j) {
			float abs_err = std::abs(cpu_result[j] - gpu_result3[j]);
			float tolerance = 1e-3f + 1e-4f * std::max(std::abs(cpu_result[j]), std::abs(gpu_result3[j]));
			if (!std::isfinite(cpu_result[j]) || !std::isfinite(gpu_result3[j]) || abs_err > tolerance) {
				std::cout << "tile16×16矩阵乘法结果错误" << std::endl;
				std::cout << "索引: " << j << std::endl;
				std::cout << "CPU: " << cpu_result[j] << std::endl;
				std::cout << "GPU: " << gpu_result3[j] << std::endl;
				return 0;
			}
		}
		std::cout << "tile16×16矩阵乘法结果正确,平均耗时:" << tile1616_time / 100 << std::endl;

		// tile32×32矩阵乘法的参数设定
		float* tile3232_A = nullptr;
		float* tile3232_B = nullptr;
		float* tile3232_result = nullptr;
		size_t tile3232_Asize = 0;
		size_t tile3232_Bsize = 0;
		size_t tile3232_size = 0;
		std::vector<float> gpu_result4(length[0] * length[2], 0.0f);
		auto tile3232_err1 = cudaMallocPitch(&tile3232_A, &tile3232_Asize, length[1] * sizeof(float), length[0]);
		auto tile3232_err2 = cudaMallocPitch(&tile3232_B, &tile3232_Bsize, length[2] * sizeof(float), length[1]);
		auto tile3232_err3 = cudaMallocPitch(&tile3232_result, &tile3232_size, length[2] * sizeof(float), length[0]);
		auto tile3232_err4 = cudaMemcpy2D(tile3232_A, tile3232_Asize, A.data(), length[1] * sizeof(float), length[1] * sizeof(float), length[0], cudaMemcpyHostToDevice);
		auto tile3232_err5 = cudaMemcpy2D(tile3232_B, tile3232_Bsize, B.data(), length[2] * sizeof(float), length[2] * sizeof(float), length[1], cudaMemcpyHostToDevice);
		if (tile3232_err1 != cudaSuccess || tile3232_err2 != cudaSuccess || tile3232_err3 != cudaSuccess || tile3232_err4 != cudaSuccess || tile3232_err5 != cudaSuccess) {
			std::cout << "tile32×32矩阵乘法输入内存分配出现问题" << std::endl;
			return 0;
		}

		// tile32×32矩阵乘法预热
		for (int i = 0; i < 10; ++i) {
			tile3232_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tile3232_A, tile3232_B, tile3232_result, tile3232_Asize, tile3232_Bsize, tile3232_size, length[0], length[1], length[2]);
		}

		// tile32×32矩阵乘法乘法
		float tile3232_time = 0.0f;
		cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			tile3232_kernel << <GridPerBlocks, BlockPerThreads, 0, stream >> > (tile3232_A, tile3232_B, tile3232_result, tile3232_Asize, tile3232_Bsize, tile3232_size, length[0], length[1], length[2]);
		}
		cudaEventRecord(end, stream);
		cudaEventSynchronize(end);
		cudaEventElapsedTime(&tile3232_time, start, end);
		auto tile3232_err6 = cudaMemcpy2D(gpu_result4.data(), length[2] * sizeof(float), tile3232_result, tile3232_size, length[2] * sizeof(float), length[0], cudaMemcpyDeviceToHost);
		if (tile3232_err6 != cudaSuccess) {
			std::cout << "tile32×32矩阵乘法输出内存分配出现问题" << std::endl;
			return 0;
		}
		for (int j = 0; j < length[0] * length[2]; ++j) {
			float abs_err = std::abs(cpu_result[j] - gpu_result4[j]);
			float tolerance = 1e-3f + 1e-4f * std::max(std::abs(cpu_result[j]), std::abs(gpu_result4[j]));
			if (!std::isfinite(cpu_result[j]) || !std::isfinite(gpu_result4[j]) || abs_err > tolerance) {
				std::cout << "tile32×32矩阵乘法结果错误" << std::endl;
				std::cout << "索引: " << j << std::endl;
				std::cout << "CPU: " << cpu_result[j] << std::endl;
				std::cout << "GPU: " << gpu_result4[j] << std::endl;
				return 0;
			}
		}
		std::cout << "tile32×32矩阵乘法结果正确,平均耗时:" << tile3232_time / 100 << std::endl;

		// cuBLAS矩阵乘法的参数设定
		float* cublas_A = nullptr;
		float* cublas_B = nullptr;
		float* cublas_result = nullptr;
		size_t cublas_Asize = 0;
		size_t cublas_Bsize = 0;
		size_t cublas_size = 0;
		std::vector<float> gpu_result5(length[0] * length[2], 0.0f);
		auto cublas_err1 = cudaMallocPitch(&cublas_A, &cublas_Asize, length[1] * sizeof(float), length[0]);
		auto cublas_err2 = cudaMallocPitch(&cublas_B, &cublas_Bsize, length[2] * sizeof(float), length[1]);
		auto cublas_err3 = cudaMallocPitch(&cublas_result, &cublas_size, length[2] * sizeof(float), length[0]);
		if (cublas_err1 != cudaSuccess || cublas_err2 != cudaSuccess || cublas_err3 != cudaSuccess) {
			std::cout << "cuBLAS矩阵乘法内存分配出现问题" << std::endl;
			return 1;
		}
		auto cublas_err4 = cudaMemcpy2D(cublas_A, cublas_Asize, A.data(), length[1] * sizeof(float), length[1] * sizeof(float), length[0], cudaMemcpyHostToDevice);
		auto cublas_err5 = cudaMemcpy2D(cublas_B, cublas_Bsize, B.data(), length[2] * sizeof(float), length[2] * sizeof(float), length[1], cudaMemcpyHostToDevice);
		if (cublas_err4 != cudaSuccess || cublas_err5 != cudaSuccess) {
			std::cout << "cuBLAS矩阵乘法输入数据传输出现问题" << std::endl;
			return 1;
		}

		// 求取矩阵主维度ld以及各个缩放参数
		int cublas_Astride = static_cast<int>(cublas_Asize / sizeof(float));
		int cublas_Bstride = static_cast<int>(cublas_Bsize / sizeof(float));
		int cublas_stride = static_cast<int>(cublas_size / sizeof(float));
		float alpha = 1.0f;
		float beta = 0.0f;

		// cuBLAS矩阵乘法预热
		for (int i = 0; i < 10; ++i) {
			auto cublas_status = cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N,
				length[2], length[0], length[1],
				&alpha, cublas_B, cublas_Bstride,
				cublas_A, cublas_Astride,
				&beta, cublas_result, cublas_stride);
			if (cublas_status != CUBLAS_STATUS_SUCCESS) {
				std::cout << "cuBLAS矩阵乘法预热出现问题,错误码:" << static_cast<int>(cublas_status) << std::endl;
				return 1;
			}
		}

		// cuBLAS矩阵乘法
		float cublas_time = 0.0f;
		auto cublas_err7 = cudaEventRecord(start, stream);
		for (int i = 0; i < 100; ++i) {
			auto cublas_status = cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N,
				length[2], length[0], length[1],
				&alpha, cublas_B, cublas_Bstride,
				cublas_A, cublas_Astride,
				&beta, cublas_result, cublas_stride);
		}
		auto cublas_err8 = cudaEventRecord(end, stream);
		auto cublas_err9 = cudaEventSynchronize(end);
		auto cublas_err10 = cudaEventElapsedTime(&cublas_time, start, end);
		if (cublas_err8 != cudaSuccess || cublas_err9 != cudaSuccess || cublas_err10 != cudaSuccess) {
			std::cout << "cuBLAS矩阵乘法执行或计时出现问题,CUDA错误码:"
				<< static_cast<int>(cublas_err8) << ", "
				<< static_cast<int>(cublas_err9) << ", "
				<< static_cast<int>(cublas_err10) << std::endl;
			return 1;
		}
		auto cublas_err6 = cudaMemcpy2D(gpu_result5.data(), length[2] * sizeof(float), cublas_result, cublas_size, length[2] * sizeof(float), length[0], cudaMemcpyDeviceToHost);
		if (cublas_err6 != cudaSuccess) {
			std::cout << "cuBLAS矩阵乘法输出数据传输出现问题" << std::endl;
			return 1;
		}
		double cublas_max_abs_err = 0.0;
		double cpu_max_abs_err = 0.0;
		for (int j = 0; j < length[0] * length[2]; ++j) {
			int row = j / length[2];
			int col = j % length[2];
			double cublas_cpu_result = 0.0;
			double cublas_sum_abs = 0.0;
			for (int k = 0; k < length[1]; ++k) {
				double product = static_cast<double>(A[row * length[1] + k]) * static_cast<double>(B[k * length[2] + col]);
				cublas_cpu_result += product;
				cublas_sum_abs += std::abs(product);
			}
			double abs_err = std::abs(cublas_cpu_result - static_cast<double>(gpu_result5[j]));
			double tolerance = 1e-3 + 1e-4 * std::max(std::abs(cublas_cpu_result), std::abs(static_cast<double>(gpu_result5[j]))) + 1e-6 * cublas_sum_abs;
			cublas_max_abs_err = std::max(cublas_max_abs_err, abs_err);
			cpu_max_abs_err = std::max(cpu_max_abs_err, std::abs(cublas_cpu_result - static_cast<double>(cpu_result[j])));
			if (!std::isfinite(cublas_cpu_result) || !std::isfinite(gpu_result5[j]) || abs_err > tolerance) {
				std::cout << "cuBLAS矩阵乘法结果超出误差容限" << std::endl;
				std::cout << "索引: " << j << std::endl;
				std::cout << "CPU double参考: " << cublas_cpu_result << std::endl;
				std::cout << "cuBLAS: " << gpu_result5[j] << std::endl;
				std::cout << "绝对误差: " << abs_err << ", 容限: " << tolerance << std::endl;
				return 1;
			}
		}
		std::cout << "cuBLAS FP32矩阵乘法结果正确,平均耗时:" << cublas_time / 100 << " ms" << std::endl;

		cudaFree(naive_A);
		cudaFree(naive_B);
		cudaFree(naive_result);
		cudaFree(tile88_A);
		cudaFree(tile88_B);
		cudaFree(tile88_result);
		cudaFree(tile1616_A);
		cudaFree(tile1616_B);
		cudaFree(tile1616_result);
		cudaFree(tile3232_A);
		cudaFree(tile3232_B);
		cudaFree(tile3232_result);
		cudaFree(cublas_A);
		cudaFree(cublas_B);
		cudaFree(cublas_result);
	}

	cudaEventDestroy(start);
	cudaEventDestroy(end);
	cudaStreamDestroy(stream);
	cublasDestroy(handle);

	return 0;
}

理论上,cuBLAS通常较快,共享内存分块方法也应比朴素方法更有优势 。朴素方法需要反复读取矩阵元素,分块方法则让同一线程块重复利用共享内存中的数据,减少全局内存访问。三个 tile 版本处理相同大小的数据分块,但线程分工不同。tile8×8和tile16×16让每个线程计算多个输出,能够复用参与乘法的数据,并交错执行多条独立的累加运算,因此比每个线程只计算一个输出的 tile32×32 更有性能优势。cuBLAS 则进一步优化了分块策略和指令调度。

实际测试中,各种方法均通过误差校验。 本次实现中,每个线程承担多个输出的分块方式取得了较好的效果。最小一组的计算任务较少,库调用和调度的固定开销更容易掩盖 cuBLAS 的计算效率优势,使其在该组中落后。

最明显的偏差是tile32×32 始终慢于 naive。它虽然减少了全局内存重复读取,却增加了共享内存读写和反复的整块同步,同时每个线程仍只有一条串行累加链。naive 的相邻线程读取矩阵 B 时地址连续,读取矩阵 A 时又访问相同元素,能够受益于缓存,因此实际访存成本低于"所有读取都直接访问显存"的简单估计。结合代码结构,本次 tile32×32 增加的共享访存与同步成本抵消了分块复用的收益,而其他两个 tile 版本通过每线程计算多个输出,更充分地利用了已加载的数据。

代码解析

Naive矩阵乘法

Naive矩阵乘法在这里不做过多的赘述。

在 Naive 转置中,naive_resultx \* output_stride + y = naive_memy \* input_stride + x存在明显的访存问题。同一个Warp中,相邻线程的x连续变化,因此读取输入时地址连续,能够合并访存。但写入输出时,相邻线程的地址相差一个行跨度,写入请求分散到不同的内存区域,需要更多内存事务才能完成,降低了有效带宽。

而Tile转置先将输入连续读入共享内存,再交换分块坐标和共享内存索引,使相邻线程能够连续写入输出。这样,读取和写入都能利用合并访存。它的代价是增加了共享内存读写和块级同步,计算任务较少时,这些额外开销会削弱优化收益。

tile矩阵乘法

普通Tile使用方形共享内存数组,按列访问时,不同线程容易访问同一个 Bank 中的不同地址,产生 Bank 冲突,使访问分批执行。Tile 加 Padding 通过增加一列填充,改变相邻行的地址间隔,将列向访问分散到不同 Bank,从而提高共享内存访问效率,代价是略微增加共享内存占用。

代码中的方形线程块让每个线程搬运一个元素,索引简单、单线程工作量少,但参与同步的线程较多。矩形线程块让每个线程通过循环搬运多个元素,用更少的线程完成同一个数据分块,能够分摊索引计算开销,并减少参与块级同步的线程数。它的代价是增加单线程工作量和临时变量需求,对循环优化和寄存器分配的依赖更强。

tile矩阵乘法具体解析

总的来说,tile矩阵乘法步骤如下:

将全局内存的数据传递给共享内存tile→计算对应结果→将结果写入对应结果全局内存

下面我将按照8×8启动内核来进行讲解。

线程索引和内存分配
复制代码
int tx = threadIdx.x;
int ty = threadIdx.y;

size_t A_stride = tile88_Asize / sizeof(float);
size_t B_stride = tile88_Bsize / sizeof(float);
size_t result_stride = tile88_size / sizeof(float);

__shared__ float A_tile[TILE][TILE + 1];
__shared__ float B_tile[TILE][TILE + 1];

float sum[4][4] = { 0.0f };

由于TILE为3233,因此一个线程块需要负责32×32个输出元素,而启动内核为8×8,即一个线程块有8×8个线程,由此一个线程需要处理4×4个输出元素。

这里的sum存储在局部内存或寄存器中,与__shared__定义的数据不同点在于,其是线程私有的局部数组,具体存储在局部内存或寄存器中,通常由编译器来决定,当寄存器资源足够时,优先放在寄存器中,否则放在局部内存中。

沿length1进行分块
复制代码
for (int t = 0; t < length1; t += TILE) {}

这里假设length1的值为256,TILE为32,那么相当于就会分成8块,这样就可以将矩阵乘法变为:

即便length1的值刚好不是TILE的倍数,最后一轮中未定义的直接补零即可

线程共同加载共享内存
复制代码
// 传递数据
for (int i = threadIdx.y; i < TILE; i += 8) {
    for (int j = threadIdx.x; j < TILE; j += 8) {
        int A_row = blockIdx.y * TILE + i;  // A矩阵行
        int A_col = t + j;					// A矩阵列
        int B_row = t + i;					// B矩阵行
        int B_col = blockIdx.x * TILE + j;  // A矩阵列

        A_tile[i][j] = (A_row < length0 && A_col < length1) ? tile88_A[A_row * A_stride +     A_col] : 0.0f;
        B_tile[i][j] = (B_row < length1 && B_col < length2) ? tile88_B[B_row * B_stride + B_col] : 0.0f;
	}
}
__syncthreads();

这个循环在上面那个循环之中,即沿着length1来依次进行处理。

通过上面的公式可以看出,我们需要按照TILE的长度将输入数据切块。

首先是两个for循环,这两个for循环分别是沿着length0和length2来依次进行处理,但是由于内核长度为8×8,因此每一个线程需要每隔8个元素进行相同的处理,保证每个线程处理了4×4个元素。

然后是索引的定义,如代码后面的解释所言,其分别是A、B矩阵的行和列。

最后通过边界判断后给tile赋值,这个边界判断即是为了解决上述,当length1的值刚好不是TILE的倍数的问题,在length1长度内的元素赋值为对应的元素,超出长度的元素赋值为0。

最后同步所有线程。

线程开始计算
复制代码
for (int k = 0; k < TILE; ++k) {
	for (int i = 0; i < 4; ++i) {
		for (int j = 0; j < 4; ++j) {
			sum[i][j] += A_tile[threadIdx.y + i * 8][k] * B_tile[k][threadIdx.x + j * 8];
		}
	}
}
__syncthreads();

这个循环同样在上面那个循环之中,即沿着length1来依次进行处理。

这里主要便是对一个求和公式进行相加:

比如这个可能便是先进行前32个元素的求和相加。

最后再进行线程同步。

将结果返回给全局内存
复制代码
for (int i = 0; i < 4; ++i) {
	for (int j = 0; j < 4; ++j) {
		int row = blockIdx.y * TILE + threadIdx.y + i * 8;
		int col = blockIdx.x * TILE + threadIdx.x + j * 8;

		if (row < length0 && col < length2) {
			tile88_result[row * result_stride + col] = sum[i][j];
		}
	}
}

这里需要加上8i或者8j,因为这可以让同一个线程跳过其他线程负责的位置,继续处理自己再32×33Tile中剩余的元素。

cuBLAS高性能库

cuBLAS全称为CUDA高性能线性代数计算库,其是NVIDIA提供的GPU加速线性代数计算库,主要用于矩阵乘法、矩阵与向量运算、向量计算等操作。这个库在后面会做一个详细的介绍,这里仅用作对比。

运算类型 常见函数 作用
向量加法 cublasSaxpy() 计算 y = αx + y
向量点积 cublasSdot() 两个向量的内积
向量范数 cublasSnrm2() 计算向量的 L2 范数
矩阵向量乘法 cublasSgemv() 矩阵 × 向量
矩阵乘法 cublasSgemm() 矩阵 × 矩阵
批量矩阵乘法 cublasSgemmStridedBatched() 批量计算多个矩阵乘法

cuBLAS也不代表在所有场景下都是最快的。 比如很小的矩阵、特殊形状的矩阵或能够与前后算子融合的运算,自定义 Kernel 可能更合适。
在真正使用CUDA C++时,其真正使用时,通常优先使用成熟库,比如cuBLAS库,但是遇到库无法满足的需求或明确的性能瓶颈,再自己优化。

相关推荐
张紫娃22 分钟前
Chrome插件-Stylus(屏蔽博客广告)
前端·chrome·stylus
Yannik1 小时前
在 Apple Silicon Mac 上用 Jenkins + Fastlane 搭建 iOS CI:从自动打包到 MR 检查流水线的完整实践
前端
Nayana1 小时前
《Web 到 HarmonyOS》-- 打包:Vite 产物 → HAP / HAR / HSP
前端
FungLeo1 小时前
FengCMS · PHP+MySQL 升级实录 · 内容写入一致性:锁等待超时与跨模型子树删除竞态
开发语言·mysql·php·工程实践·fengcms
inksci1 小时前
用飞帆做了个小网页
前端·javascript·css·html
去伪存真1 小时前
被 pnpm 打包坑惨后,我彻底盘明白了硬链接与软链接
前端·electron
zhensherlock2 小时前
Protocol Launcher 系列:CodeHub 移动端 GitHub 协作利器
前端·javascript·typescript·node.js·自动化·github·js
谙弆悕博士2 小时前
多智能体架构详解:市场拍卖式架构(Market-based / 竞价协商)
开发语言·架构·去中心化·多智能体·智能体·拍卖架构
ShineWinsu3 小时前
对于Qt:QMessageBox的解析
开发语言·c++·qt·面试·客户端·qmessagebox·消息对话框