矩阵装置与访存优化
#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库,但是遇到库无法满足的需求或明确的性能瓶颈,再自己优化。




