Introduction

本文旨在记录作者完成课程任务 Computer Architecture Lab 6 的过程,可供参考。

本实验需要完成的内容主要是优化大模型的矩阵乘法部分,检查加速效果

实验包链接如下

Llama2

指导书链接如下(需校内网)

计算机体系结构实验(2026秋季) | 哈工大(深圳)

环境配置

实验要求使用 x86_64 Linux 并且安装 NVIDIA 显卡的实体机/物理机 完成

实验过程

先下载实验包

curl -OL http://10.249.14.10:3011/lab6/llama2.c.tar.gz
tar -xvzf llama2.c.tar.gz llama2.c
cd llama2.c
curl -OL http://10.249.14.10:3011/lab6/stories110M.bin
curl -OL http://10.249.14.10:3011/lab6/stories15M.bin
curl -OL http://10.249.14.10:3011/lab6/stories42M.bin

基线性能

尝试编译

# llama2.c/
make run

尝试运行

lab6_baseline

以下是 9 次运行的统计结果,按照模型规模分组:

序号模型生成速度(tok/s)
1stories15M126.175
2stories42M43.397
3stories110M16.146
4stories15M127.148
5stories42M42.884
6stories110M16.086
7stories15M128.139
8stories42M42.804
9stories110M16.108

各模型运行统计

模型运行次数平均速度(tok/s)最高速度最低速度
stories15M3127.154128.139126.175
stories42M343.02843.39742.804
stories110M316.11316.14616.086

对比

模型相对速度
stories15M1.00×
stories42M0.338×
stories110M0.127×

数据表明,三种模型的运行速度非常稳定,三次测试的波动都很小。随着模型规模增大,生成速度明显下降。

尝试优化

矩阵乘法函数如下,指导书写到这是性能瓶颈

void matmul(float* xout, float* x, float* w, int n, int d) {
    // W (d,n) @ x (n,) -> xout (d,)
    // by far the most amount of time is spent inside this little function
    int i;
    #pragma omp parallel for private(i)
    for (i = 0; i < d; i++) {
        float val = 0.0f;
        for (int j = 0; j < n; j++) {
            val += w[i * n + j] * x[j];
        }
        xout[i] = val;
    }
}

直接尝试使用 cuBLAS 库,替换原来的代码

void matmul(float* xout, float* x, float* w, int n, int d) {
    cublasHandle_t handle;
    cublasCreate(&handle);

    float *d_x, *d_w, *d_y;

    cudaMalloc((void**)&d_x, n * sizeof(float));
    cudaMalloc((void**)&d_w, d * n * sizeof(float));
    cudaMalloc((void**)&d_y, d * sizeof(float));

    cudaMemcpy(d_x, x, n * sizeof(float),
               cudaMemcpyHostToDevice);

    cudaMemcpy(d_w, w, d * n * sizeof(float),
               cudaMemcpyHostToDevice);

    float alpha = 1.0f;
    float beta = 0.0f;

    cublasSgemv(
        handle,
        CUBLAS_OP_T,
        n, d,
        &alpha,
        d_w, n,
        d_x, 1,
        &beta,
        d_y, 1
    );

    cudaMemcpy(xout, d_y, d * sizeof(float),
               cudaMemcpyDeviceToHost);

    cudaFree(d_x);
    cudaFree(d_w);
    cudaFree(d_y);

    cublasDestroy(handle);
}

lab6-1

编译输出如图,因为反复地复制内存并且没有并行,效果还不如不优化

检查 matmul 的引用发现只有 forward 调用了它,所以尝试对其进行优化,尝试将权重参数尽量放在显存,下面是原代码

float* forward(Transformer* transformer, int token, int pos) {
    // a few convenience variables
    Config* p = &transformer->config;
    TransformerWeights* w = &transformer->weights;
    RunState* s = &transformer->state;
    float *x = s->x;
    int dim = p->dim;
    int kv_dim = (p->dim * p->n_kv_heads) / p->n_heads;
    int kv_mul = p->n_heads / p->n_kv_heads; // integer multiplier of the kv sharing in multiquery
    int hidden_dim =  p->hidden_dim;
    int head_size = dim / p->n_heads;

    // copy the token embedding into x
    float* content_row = w->token_embedding_table + token * dim;
    memcpy(x, content_row, dim*sizeof(*x));

    // forward all the layers
    for(unsigned long long l = 0; l < p->n_layers; l++) {
        // attention rmsnorm
        rmsnorm(s->xb, x, w->rms_att_weight + l*dim, dim);
        // key and value point to the kv cache
        int loff = l * p->seq_len * kv_dim; // kv cache layer offset for convenience
        s->k = s->key_cache + loff + pos * kv_dim;
        s->v = s->value_cache + loff + pos * kv_dim;
        // qkv matmuls for this position
        matmul(s->q, s->xb, w->wq + l*dim*dim, dim, dim);
        matmul(s->k, s->xb, w->wk + l*dim*kv_dim, dim, kv_dim);
        matmul(s->v, s->xb, w->wv + l*dim*kv_dim, dim, kv_dim);
        // RoPE relative positional encoding: complex-valued rotate q and k in each head
        for (int i = 0; i < dim; i+=2) {
            int head_dim = i % head_size;
            float freq = 1.0f / powf(10000.0f, head_dim / (float)head_size);
            float val = pos * freq;
            float fcr = cosf(val);
            float fci = sinf(val);
            int rotn = i < kv_dim ? 2 : 1; // how many vectors? 2 = q & k, 1 = q only
            for (int v = 0; v < rotn; v++) {
                float* vec = v == 0 ? s->q : s->k; // the vector to rotate (query or key)
                float v0 = vec[i];
                float v1 = vec[i+1];
                vec[i]   = v0 * fcr - v1 * fci;
                vec[i+1] = v0 * fci + v1 * fcr;
            }
        }
        // multihead attention. iterate over all heads
        int h;
        #pragma omp parallel for private(h)
        for (h = 0; h < p->n_heads; h++) {
            // get the query vector for this head
            float* q = s->q + h * head_size;
            // attention scores for this head
            float* att = s->att + h * p->seq_len;
            // iterate over all timesteps, including the current one
            for (int t = 0; t <= pos; t++) {
                // get the key vector for this head and at this timestep
                float* k = s->key_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
                // calculate the attention score as the dot product of q and k
                float score = 0.0f;
                for (int i = 0; i < head_size; i++) {
                    score += q[i] * k[i];
                }
                score /= sqrtf(head_size);
                // save the score to the attention buffer
                att[t] = score;
            }

            // softmax the scores to get attention weights, from 0..pos inclusively
            softmax(att, pos + 1);

            // weighted sum of the values, store back into xb
            float* xb = s->xb + h * head_size;
            memset(xb, 0, head_size * sizeof(float));
            for (int t = 0; t <= pos; t++) {
                // get the value vector for this head and at this timestep
                float* v = s->value_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
                // get the attention weight for this timestep
                float a = att[t];
                // accumulate the weighted value into xb
                for (int i = 0; i < head_size; i++) {
                    xb[i] += a * v[i];
                }
            }
        }
        // final matmul to get the output of the attention
        matmul(s->xb2, s->xb, w->wo + l*dim*dim, dim, dim);
        // residual connection back into x
        for (int i = 0; i < dim; i++) {
            x[i] += s->xb2[i];
        }
        // ffn rmsnorm
        rmsnorm(s->xb, x, w->rms_ffn_weight + l*dim, dim);
        // Now for FFN in PyTorch we have: self.w2(F.silu(self.w1(x)) * self.w3(x))
        // first calculate self.w1(x) and self.w3(x)
        matmul(s->hb, s->xb, w->w1 + l*dim*hidden_dim, dim, hidden_dim);
        matmul(s->hb2, s->xb, w->w3 + l*dim*hidden_dim, dim, hidden_dim);
        // SwiGLU non-linearity
        for (int i = 0; i < hidden_dim; i++) {
            float val = s->hb[i];
            // silu(x)=x*σ(x), where σ(x) is the logistic sigmoid
            val *= (1.0f / (1.0f + expf(-val)));
            // elementwise multiply with w3(x)
            val *= s->hb2[i];
            s->hb[i] = val;
        }
        // final matmul to get the output of the ffn
        matmul(s->xb, s->hb, w->w2 + l*dim*hidden_dim, hidden_dim, dim);
        // residual connection
        for (int i = 0; i < dim; i++) {
            x[i] += s->xb[i];
        }
    }
    // final rmsnorm
    rmsnorm(x, x, w->rms_final_weight, dim);
    // classifier into logits
    matmul(s->logits, x, w->wcls, p->dim, p->vocab_size);
    return s->logits;
}

由于代码比较复杂,后面的修改都交给了 Deepseek V41Flash

重新分析瓶颈

第一版直接用 cuBLAS 替换 matmul,结果反而更慢。原因在于这里的 matmul 是 batch=1 的 GEMV。以 stories110M 为例(dim = 768、hidden_dim = 2048、n_layers = 12、vocab_size = 32000,且 n_kv_heads = n_heads,所以 kv_dim = dim),每生成一个 token 要执行的矩阵向量乘法如下:

位置权重形状 (d × n)每层次数每 token 次数
q 投影768 × 768112
k / v 投影768 × 768224
attention 输出768 × 768112
FFN w1 / w32048 × 768224
FFN w2768 × 2048112
classifier32000 × 768-1

也就是每生成一个 token 要调用 85 次 matmul、做约 9500 万次乘加(约 1.9 亿 FLOP),但要读的权重却有 438MB。这个算子的性能瓶颈从来不是算力,而是显存(在 CPU 上是内存)带宽。

第一版每调用一次 matmul 就 cudaMalloc 三个显存块、把整个权重矩阵拷到显存、算完再 cudaFree,权重流量被放大成两倍以上的 H2D/D2H,再叠加每次调用的 cublasCreate/cublasDestroy,自然比 CPU 还慢。

正确的做法只有两条:

  1. 权重只在启动时上传一次,之后常驻显存;
  2. 一个 token 的整条数据流都留在 GPU 上,每 token 只回传一次 logits。

优化实现

原版和 GPU 版的根本差别在于数据放在哪、循环由谁执行。原版 run.c 里权重就是 mmap 进来的主机内存,激活缓冲是 calloc 出来的主机数组,matmul 直接在这些主机指针上做双重循环,整个 forward 由 CPU 执行;GPU 版把这套数据整体搬到显存,matmul 改调 cuBLAS,其余循环改写成 kernel,每 token 的主机↔设备通信只剩开头的 embedding 行和结尾的 logits。

两者共存于同一份 run.c:gcc 编译时走原版 CPU 路径(一行未改),nvcc 编译时通过 __CUDACC__ 自动启用 GPU 后端,-DUSE_FP16 再切成半精度权重。改动量上,run.c 从 973 行变成 1480 行,新增 526 行、删改 19 行(全是 nvcc 按 C++ 编译所需的强制类型转换),原 CPU 逻辑一行没删。下面每一处都先放原版 CPU 代码,再放对应的 CUDA 实现,方便直接对照。

环节原版 CPU 路径CUDA 版
权重mmap 的主机内存,matmul 每次直接读启动时拷到显存,之后常驻
激活RunState 用 calloc 分配在主机CudaModel 的显存副本
matmul双重循环 + OpenMP,读主机权重gemv:cuBLAS 读常驻显存指针
q/k/v3 次 matmul,k/v 直接写进 KV cache1 次融合 GEMV,rope_kernel 写 cache
RoPEforward 里的循环,逐次算三角函数rope_kernel 查预计算的 cos/sin 表
attentionfor h / for t / softmax / 加权和attention_kernel:1 head 1 block
SwiGLUforward 里的 hidden_dim 循环silu_mul_kernel
残差for (i) x[i] += xb2[i]gemv 的 beta = 1 直接累加
主机↔设备无(全部在主机内存)每 token 1KB D2D + 128KB logits D2H

切换点就是 forward 的出口,原版实现保留在 #else 分支里:

float* forward(Transformer* transformer, int token, int pos) {
#ifdef USE_CUDA
    return forward_cuda(transformer, token, pos);   // GPU 路径
#else
    ... 原来的 CPU 实现,一行未改 ...
#endif
}

1. matmul:从双重循环到 cuBLAS GEMV

原版 CPU 版(run.c,直接读主机内存里的权重):

void matmul(float* xout, float* x, float* w, int n, int d) {
    // W (d,n) @ x (n,) -> xout (d,)
    // by far the most amount of time is spent inside this little function
    int i;
    #pragma omp parallel for private(i)
    for (i = 0; i < d; i++) {
        float val = 0.0f;
        for (int j = 0; j < n; j++) {
            val += w[i * n + j] * x[j];
        }
        xout[i] = val;
    }
}

第一版直接把循环换成 cuBLAS,但每次调用都 malloc/copy/free(见上一节),反而更慢。真正有效的改法是把权重变成显存里常驻的指针,再调 cublasSgemv。注意 cuBLAS 是列主序,行主序的 (d,n) 权重会被看成 W 的转置,所以带 CUBLAS_OP_T 调用时参数是:m = 输入维度、n = 输出维度、lda = m。最后一个 beta 用来合并残差(0 覆盖写,1 累加),正好对应原版里 x[i] += xb2[i] 的循环。fp16 版本没有对应的 hgemv 接口,改用 cublasGemmEx 表示 GEMV(n=1),A/B 为 half、C 为 float、CUBLAS_COMPUTE_32F 保证 fp32 累加。

CUDA 版(gemv,所有 matmul 调用的统一入口,指针换成显存指针):

static void gemv(float* y, const float* x, const wt_t* W, int m, int n, float beta) {
    const float alpha = 1.0f;
#ifdef USE_FP16
    f2h_kernel<<<grid_for(m, 256), 256>>>(x, cm.hx, m);       // 输入转 half
    CUBLAS_CHECK(cublasGemmEx(cm.handle, CUBLAS_OP_T, CUBLAS_OP_N, n, 1, m, &alpha,
                              W, CUDA_R_16F, m, cm.hx, CUDA_R_16F, m, &beta,
                              y, CUDA_R_32F, n, CUBLAS_COMPUTE_32F, CUBLAS_GEMM_DEFAULT));
#else
    CUBLAS_CHECK(cublasSgemv(cm.handle, CUBLAS_OP_T, m, n, &alpha, W, m, x, 1, &beta, y, 1));
#endif
}

于是程序里所有 matmul 调用点都换成了这个 gemv。

2. 数据布局:从 mmap/calloc 到 CudaModel

原版 CPU 版:权重的指针直接指向 mmap 进来的 checkpoint,激活缓冲在 malloc_run_state 里用 calloc 分配在主机:

// 权重:memory_map_weights() 把指针指到 mmap 的内存上
float* token_embedding_table;   // (vocab_size, dim)
float* wq;                      // (layer, dim, n_heads*head_size)
float* wk;                      // (layer, dim, n_kv_heads*head_size)
float* w1;                      // (layer, hidden_dim, dim)
// ...

// 激活:malloc_run_state() 里 calloc 在主机内存
s->x    = calloc(p->dim, sizeof(float));
s->xb   = calloc(p->dim, sizeof(float));
s->hb   = calloc(p->hidden_dim, sizeof(float));
s->q    = calloc(p->dim, sizeof(float));
s->key_cache   = calloc(p->n_layers * p->seq_len * kv_dim, sizeof(float));
s->value_cache = calloc(p->n_layers * p->seq_len * kv_dim, sizeof(float));
s->logits = calloc(p->vocab_size, sizeof(float));

CUDA 版:新增一个全局的 CudaModel cm,把这些数据在显存里再存一份;权重类型 wt_t 在 fp16 版本是 __half,而 token_embedding_table 保持 fp32(每 token 只读一行):

typedef struct {
    cublasHandle_t handle;
    float* token_embedding_table;   // (vocab_size, dim),每 token 只读一行
    wt_t*  wcls;                    // (vocab_size, dim)
    float *rms_att_weight, *rms_ffn_weight, *rms_final_weight;
    wt_t*  wqkv;                    // (layer, dim+2*kv_dim, dim)  wq|wk|wv
    wt_t*  w13;                     // (layer, 2*hidden_dim, dim)  w1|w3
    wt_t*  w2;                      // (layer, dim, hidden_dim)
    wt_t*  wo;                      // (layer, dim, dim)
    float *x, *xb, *hb13, *qkv, *logits;   // 激活
    float *key_cache, *value_cache;        // KV cache
    float2* freq_cis;               // 预计算的 RoPE cos/sin 表
#ifdef USE_FP16
    __half* hx;                     // GEMV 输入转半精度的中转缓冲
#endif
} CudaModel;

cuda_upload_weights 只在 build_transformer 里执行一次(对应原版的 read_checkpoint / memory_map_weights):把每层 wq、wk、wv 拼成 (dim+2·kv_dim, dim),把 w1、w3 拼成 (2·hidden_dim, dim);tied embedding 时分类器直接复用 embedding 表(fp16 版本复制一份半精度副本);RoPE 的 cos/sin 表也在这时算好上传。cuda_alloc_state 对应原版的 malloc_run_state,在显存里分配激活和 KV cache。cuda_init 创建全局唯一的 cuBLAS 句柄并调用这两个函数(第一版每次 matmul 都 cublasCreate/cublasDestroy,这也是它慢的原因之一),cuda_free 按逆序释放并对 tied 指针判重:

void cuda_init(Transformer* t) {
    CUBLAS_CHECK(cublasCreate(&cm.handle));  // 句柄只创建一次
    cuda_upload_weights(t);                  // 权重一次性上传 + 融合
    cuda_alloc_state(t);                     // 激活缓冲 + KV cache
}

3. 逐层计算:原版的循环 → 4 个 kernel

原版这几部分都是 forward 里的普通 C 循环,GPU 版则各自是一个独立 kernel。下面逐个对照:CPU 一侧注明这段代码位于 forward() 的哪个部分,GPU 一侧给出完整的 kernel 定义(函数原型 + 函数体)以及它在 forward_cuda() 里的调用方式和启动参数。

rmsnorm

原版 CPU 版(两趟串行循环):

void rmsnorm(float* o, float* x, float* weight, int size) {
    // calculate sum of squares
    float ss = 0.0f;
    for (int j = 0; j < size; j++) {
        ss += x[j] * x[j];
    }
    ss /= size;
    ss += 1e-5f;
    ss = 1.0f / sqrtf(ss);
    // normalize and scale
    for (int j = 0; j < size; j++) {
        o[j] = weight[j] * (ss * x[j]);
    }
}

CUDA 版(一个 block、256 线程,平方和用块内规约代替串行累加):

__global__ void rmsnorm_kernel(float* o, const float* x, const float* w, int size) {
    __shared__ float sh[32];
    float ss = 0.0f;
    for (int i = threadIdx.x; i < size; i += blockDim.x) ss += x[i] * x[i];
    ss = block_reduce_sum(ss, sh);
    const float scale = 1.0f / sqrtf(ss / (float)size + 1e-5f);
    for (int i = threadIdx.x; i < size; i += blockDim.x) o[i] = w[i] * (scale * x[i]);
}

// 调用处(forward_cuda 内每层):一个 block、256 线程
rmsnorm_kernel<<<1, 256>>>(cm.xb, cm.x, cm.rms_att_weight + l*dim, dim);

缩放因子同样用 1.0f / sqrtf(...),写出表达式也和原版一致,这样结果才能和原版对得上;o 和 x 允许是同一块显存(最后的 rmsnorm 就是原地做的)。块内规约本身由 warp_reduce_sum(shuffle 树形归约)和 block_reduce_sum(各 warp 结果写共享内存、第一个 warp 再归约一次)组成,末尾多一次 __syncthreads(),保证所有线程读完结果后共享内存才能被下一次调用复用。

RoPE

原版 CPU 版(i 步长 2 的循环,每个位置都重新算 powf/cosf/sinf,q、k 原地旋转):

// 原版代码:这段位于 float* forward(Transformer*, int, int) 的逐层循环内
// RoPE relative positional encoding: complex-valued rotate q and k in each head
for (int i = 0; i < dim; i+=2) {
    int head_dim = i % head_size;
    float freq = 1.0f / powf(10000.0f, head_dim / (float)head_size);
    float val = pos * freq;
    float fcr = cosf(val);
    float fci = sinf(val);
    int rotn = i < kv_dim ? 2 : 1; // how many vectors? 2 = q & k, 1 = q only
    for (int v = 0; v < rotn; v++) {
        float* vec = v == 0 ? s->q : s->k; // the vector to rotate (query or key)
        float v0 = vec[i];
        float v1 = vec[i+1];
        vec[i]   = v0 * fcr - v1 * fci;
        vec[i+1] = v0 * fci + v1 * fcr;
    }
}

CUDA 版(cos/sin 表启动时算好;一个线程一对元素,旋转后的 k 直接写进 KV cache、v 原样拷入):

__global__ void rope_kernel(float* q, float* k, const float* v, float* kcache,
                            float* vcache, const float2* cis, int dim, int kv_dim,
                            int half_head, int pos) {
    const int hi = blockIdx.x * blockDim.x + threadIdx.x; // 第 hi 对 (i, i+1)
    const int i = hi * 2;
    if (i >= dim) return;
    const float2 c = cis[(size_t)pos * half_head + (hi % half_head)];
    {   // q 总是旋转
        const float q0 = q[i], q1 = q[i + 1];
        q[i] = q0 * c.x - q1 * c.y;
        q[i + 1] = q0 * c.y + q1 * c.x;
    }
    if (i < kv_dim) { // k 旋转后写 cache,v 原样存入
        const float k0 = k[i], k1 = k[i + 1];
        kcache[i] = k0 * c.x - k1 * c.y;
        kcache[i + 1] = k0 * c.y + k1 * c.x;
        vcache[i] = v[i];
        vcache[i + 1] = v[i + 1];
    }
}

// 调用处(forward_cuda 内每层):共 dim/2 个线程,每个线程处理一对相邻元素
rope_kernel<<<grid_for(dim / 2, 128), 128>>>(
    cm.qkv, cm.qkv + dim, cm.qkv + dim + kv_dim,
    cm.key_cache + loff + (size_t)pos * kv_dim,
    cm.value_cache + loff + (size_t)pos * kv_dim,
    cm.freq_cis, dim, kv_dim, half_head, pos);

原版里 s->k 本身就指向 KV cache,所以旋转结果直接落在 cache 里;GPU 版的 qkv 是一次 GEMV 的连续输出,因此改成在 rope_kernel 里显式写回 cache,效果与原版一致。

attention

原版 CPU 版(for h 三重循环,整个跑在 CPU 上):

// 原版代码:这段位于 float* forward(Transformer*, int, int) 的逐层循环内
int h;
#pragma omp parallel for private(h)
for (h = 0; h < p->n_heads; h++) {
    float* q = s->q + h * head_size;
    float* att = s->att + h * p->seq_len;
    for (int t = 0; t <= pos; t++) {
        float* k = s->key_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
        float score = 0.0f;
        for (int i = 0; i < head_size; i++) {
            score += q[i] * k[i];
        }
        score /= sqrtf(head_size);
        att[t] = score;
    }
    softmax(att, pos + 1);
    float* xb = s->xb + h * head_size;
    memset(xb, 0, head_size * sizeof(float));
    for (int t = 0; t <= pos; t++) {
        float* v = s->value_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
        float a = att[t];
        for (int i = 0; i < head_size; i++) {
            xb[i] += a * v[i];
        }
    }
}

CUDA 版(每个 head 一个 block,score/softmax/加权和融合进一个 kernel):

__global__ void attention_kernel(const float* qkv, const float* key_cache,
                                 const float* value_cache, float* xb, int pos,
                                 int head_size, int kv_dim, int kv_mul,
                                 size_t loff, float scale) {
    extern __shared__ float satt[]; // 当前 head 的注意力权重(pos+1 个)
    __shared__ float sh[32];
    const int h = blockIdx.x;       // 每个 head 一个 block
    const float* q = qkv + h * head_size;
    const int kvh = h / kv_mul;     // GQA/MQA:多个 q head 共享 kv
    const float* kbase = key_cache + loff + (size_t)kvh * head_size;
    const float* vbase = value_cache + loff + (size_t)kvh * head_size;

    // 1) score:一个线程一个 timestep,串行点积(与 CPU 累加顺序相同)
    for (int t = threadIdx.x; t <= pos; t += blockDim.x) {
        const float* k = kbase + (size_t)t * kv_dim;
        float s = 0.0f;
        for (int i = 0; i < head_size; i++) s += q[i] * k[i];
        satt[t] = s * scale;
    }
    __syncthreads();

    // 2) softmax:块内 max → expf → 块内 sum → 归一化
    float mx = -3.402823466e+38f;
    for (int t = threadIdx.x; t <= pos; t += blockDim.x) mx = fmaxf(mx, satt[t]);
    mx = block_reduce_max(mx, sh);
    float sum = 0.0f;
    for (int t = threadIdx.x; t <= pos; t += blockDim.x) {
        satt[t] = expf(satt[t] - mx);
        sum += satt[t];
    }
    sum = block_reduce_sum(sum, sh);
    const float inv = 1.0f / sum;
    for (int t = threadIdx.x; t <= pos; t += blockDim.x) satt[t] *= inv;
    __syncthreads();

    // 3) 加权和:线程并行于 head_size,t 串行累加(同样与 CPU 顺序一致)
    for (int i = threadIdx.x; i < head_size; i += blockDim.x) {
        float acc = 0.0f;
        for (int t = 0; t <= pos; t++) acc += satt[t] * vbase[(size_t)t * kv_dim + i];
        xb[h * head_size + i] = acc;
    }
}

// 调用处(forward_cuda 内每层):每 head 一个 block,动态共享内存放 seq_len 个权重
attention_kernel<<<p->n_heads, 128, (size_t)p->seq_len * sizeof(float)>>>(
    cm.qkv, cm.key_cache, cm.value_cache, cm.xb, pos, head_size, kv_dim,
    kv_mul, loff, 1.0f / sqrtf((float)head_size));

score 阶段一个线程负责一个 timestep 并串行点积(累加顺序与原版相同,这是 GPU 输出能和 CPU 逐字节一致的关键);softmax 用块规约求 max/sum,指数用 expf 而不是近似版 __expf;加权求和阶段线程并行于 head_size,对 t 的累加仍然串行。

SwiGLU

原版 CPU 版(hidden_dim 的循环):

// 原版代码:这段位于 float* forward(Transformer*, int, int) 的逐层循环内
// SwiGLU non-linearity
for (int i = 0; i < hidden_dim; i++) {
    float val = s->hb[i];
    // silu(x)=x*σ(x), where σ(x) is the logistic sigmoid
    val *= (1.0f / (1.0f + expf(-val)));
    // elementwise multiply with w3(x)
    val *= s->hb2[i];
    s->hb[i] = val;
}

CUDA 版(w1/w3 的输出拼在 hb13 里,a 的前半是 w1(x)、后半是 w3(x)):

__global__ void silu_mul_kernel(float* a, const float* b, int n) {
    const int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) a[i] = (a[i] / (1.0f + expf(-a[i]))) * b[i];
}

// 调用处(forward_cuda 内每层):每个元素一个线程
silu_mul_kernel<<<grid_for(hidden_dim, 128), 128>>>(cm.hb13, cm.hb13 + hidden_dim,
                                                   hidden_dim);

4. 合并权重,减少 GEMV 次数

原版 CPU 版(每层 7 次 matmul,7 次都要读一遍 xb):

// 原版代码:这段位于 float* forward(Transformer*, int, int) 的逐层循环内
matmul(s->q, s->xb, w->wq + l*dim*dim, dim, dim);
matmul(s->k, s->xb, w->wk + l*dim*kv_dim, dim, kv_dim);
matmul(s->v, s->xb, w->wv + l*dim*kv_dim, dim, kv_dim);
// ...
matmul(s->hb,  s->xb, w->w1 + l*dim*hidden_dim, dim, hidden_dim);
matmul(s->hb2, s->xb, w->w3 + l*dim*hidden_dim, dim, hidden_dim);

CUDA 版(把共享输入的权重在启动时拼好,每层只剩 4 次 GEMV,xb 少读一遍):

// 以下调用位于 float* forward_cuda(Transformer*, int, int) 的逐层循环内
// qkv = (wq|wk|wv) @ xb,一次 GEMV 出三个投影
gemv(cm.qkv, cm.xb, cm.wqkv + (size_t)l * rows_qkv * dim, dim, rows_qkv, 0.0f);
// hb13 = (w1|w3) @ xb,一次 GEMV 出两个 FFN 投影
gemv(cm.hb13, cm.xb, cm.w13 + (size_t)l * 2 * hidden_dim * dim, dim, 2 * hidden_dim, 0.0f);

拼接后的布局在输出端正好对应:qkv 缓冲前 dim 个是 q、接着 kv_dim 个是 k、最后 kv_dim 个是 v,一次 GEMV 之后可以直接把 q/k/v 作为指针传给 RoPE 和 attention;w1|w3 的输出也正好是"前一半 w1、后一半 w3",SwiGLU 只需读 a[i] 与 a[i+hidden_dim]。

5. 顺手省掉两个 kernel

原版 CPU 版(残差是 for 循环;RoPE 之后不需要额外拷贝,因为 s->k 直接指向 cache):

// 原版其中:这两段位于 float* forward(Transformer*, int, int) 的逐层循环内
// attention 之后
for (int i = 0; i < dim; i++) x[i] += s->xb2[i];
// ffn 之后
for (int i = 0; i < dim; i++) x[i] += s->xb[i];

CUDA 版(残差交给 cublasSgemv 的 beta = 1 直接累加;k/v 写入 cache 合进 rope_kernel):

// 以下调用位于 float* forward_cuda(Transformer*, int, int) 的逐层循环内
// beta = 1:y = alpha*W*x + 1*y,等价于原版的 x[i] += xb2[i]
gemv(cm.x, cm.xb,  cm.wo + (size_t)l * dim * dim, dim, dim, 1.0f);
gemv(cm.x, cm.hb13, cm.w2 + (size_t)l * hidden_dim * dim, hidden_dim, dim, 1.0f);
// k/v 写入 KV cache 放在 rope_kernel 里,省掉两次 cudaMemcpy

最终每 token 的 GPU 操作只有:12 层 × 9 个 kernel(2 次 rmsnorm、4 次 GEMV、RoPE、attention、SwiGLU)+ 收尾的 rmsnorm、GEMV,共约 110 次 kernel launch;fp16 版每个 GEMV 多一次输入转换,约 159 次。

6. forward_cuda 与原版 forward 的逐句对照

原版 CPU 版(forward 的骨架,RoPE 和 attention 的细节见上):

float* forward(Transformer* transformer, int token, int pos) {
    // ... 取 p / w / s,copy token embedding 到 x ...
    memcpy(x, content_row, dim*sizeof(*x));
    for (unsigned long long l = 0; l < p->n_layers; l++) {
        rmsnorm(s->xb, x, w->rms_att_weight + l*dim, dim);
        int loff = l * p->seq_len * kv_dim;   // kv cache 层偏移
        s->k = s->key_cache + loff + pos * kv_dim;
        s->v = s->value_cache + loff + pos * kv_dim;
        matmul(s->q, s->xb, w->wq + l*dim*dim, dim, dim);
        matmul(s->k, s->xb, w->wk + l*dim*kv_dim, dim, kv_dim);
        matmul(s->v, s->xb, w->wv + l*dim*kv_dim, dim, kv_dim);
        /* RoPE 与 attention:见上一节 */
        matmul(s->xb2, s->xb, w->wo + l*dim*dim, dim, dim);
        for (int i = 0; i < dim; i++) x[i] += s->xb2[i];
        rmsnorm(s->xb, x, w->rms_ffn_weight + l*dim, dim);
        matmul(s->hb,  s->xb, w->w1 + l*dim*hidden_dim, dim, hidden_dim);
        matmul(s->hb2, s->xb, w->w3 + l*dim*hidden_dim, dim, hidden_dim);
        /* SwiGLU:见上一节 */
        matmul(s->xb, s->hb, w->w2 + l*dim*hidden_dim, hidden_dim, dim);
        for (int i = 0; i < dim; i++) x[i] += s->xb[i];
    }
    rmsnorm(x, x, w->rms_final_weight, dim);
    matmul(s->logits, x, w->wcls, p->dim, p->vocab_size);
    return s->logits;
}

CUDA 版(forward_cuda,结构逐句对应):

float* forward_cuda(Transformer* transformer, int token, int pos) {
    // ... 取 p / s,copy token embedding 行到显存 x(D2D)...
    cudaMemcpyAsync(cm.x, cm.token_embedding_table + (size_t)token * dim,
                    (size_t)dim * sizeof(float), cudaMemcpyDeviceToDevice);
    for (int l = 0; l < p->n_layers; l++) {
        rmsnorm_kernel<<<1, 256>>>(cm.xb, cm.x, cm.rms_att_weight + l*dim, dim);
        gemv(cm.qkv, cm.xb, cm.wqkv + (size_t)l*rows_qkv*dim,
             dim, rows_qkv, 0.0f);                    // 一次 GEMV 出 q|k|v
        rope_kernel<<<...>>>(cm.qkv, cm.qkv+dim, cm.qkv+dim+kv_dim, ...);
        attention_kernel<<<p->n_heads, 128, seq_len*4>>>(...);
        gemv(cm.x, cm.xb, cm.wo + (size_t)l*dim*dim,
             dim, dim, 1.0f);                         // beta=1:累加残差
        rmsnorm_kernel<<<1, 256>>>(cm.xb, cm.x, cm.rms_ffn_weight + l*dim, dim);
        gemv(cm.hb13, cm.xb, cm.w13 + (size_t)l*2*hidden_dim*dim,
             dim, 2*hidden_dim, 0.0f);                // 一次 GEMV 出 w1|w3
        silu_mul_kernel<<<grid_for(hidden_dim,128),128>>>(
            cm.hb13, cm.hb13 + hidden_dim, hidden_dim);
        gemv(cm.x, cm.hb13, cm.w2 + (size_t)l*hidden_dim*dim,
             hidden_dim, dim, 1.0f);                  // beta=1:累加残差
    }
    rmsnorm_kernel<<<1, 256>>>(cm.x, cm.x, cm.rms_final_weight, dim);
    gemv(cm.logits, cm.x, cm.wcls, dim, p->vocab_size, 0.0f);
    cudaMemcpy(s->logits, cm.logits, (size_t)p->vocab_size * 4,
               cudaMemcpyDeviceToHost);               // 唯一的回传
    return s->logits;
}

两边的对应关系汇总成一张表:

原版 forward(CPU 路径)CUDA 版 forward_cuda
memcpy(x, embedding 行, dim*4)cudaMemcpyAsync 到显存 x(D2D)
matmul(q/k/v, xb, wq/wk/wv) ×3gemv(qkv, xb, wqkv + lrows_qkvdim, dim, rows_qkv, 0)
RoPE 双重循环(原地改 q/k)rope_kernel(旋转 + 写 KV cache)
for h:点积 / softmax / 加权和attention_kernel(每 head 一个 block)
matmul(xb2, xb, wo) + x += xb2gemv(x, xb, wo + …, dim, dim, 1.0f)
matmul(hb, xb, w1) + matmul(hb2, xb, w3)gemv(hb13, xb, w13 + …, dim, 2*hidden_dim, 0)
SwiGLU 循环(hidden_dim)silu_mul_kernel
matmul(xb, hb, w2) + x += xbgemv(x, hb13, w2 + …, hidden_dim, dim, 1.0f)
rmsnorm(x, x, rms_final) + matmul(logits, x, wcls)rmsnorm_kernel + gemv + D2H 回传 logits

注意原版里 s->q、s->k、s->v 是指向 KV cache 的指针,matmul 的输出现场就落在 cache 上;GPU 版改成一块 qkv 连续缓冲加显式偏移,所以 RoPE 里要多写一次 cache。

编译

# llama2.c/
make run              # gcc:CPU 基线,和原始代码逐字节一致
make runcublas        # nvcc -x cu:cuBLAS 版(权重常驻显存)
make runcublasfp16    # 同一份 run.c,再加 -DUSE_FP16
./run_cublas stories15M.bin -n 256 -t 0 -s 42 -i "Once upon a time"

实际命令就是 nvcc -x cu -O3 -std=c++17 -arch=native -o run_cublas run.c -lm -lcublas:用 -x cu 让 nvcc 直接编译 run.c,用 -arch=native 针对本机 GPU 生成代码(指导书里的 compute_35 太老,发挥不出新架构)。指导书里 cp run.c run.cu && nvcc ... 的流程也能直接跑通,因为启用 CUDA 后端靠的是 __CUDACC__ 而不是文件后缀。生成/采样逻辑没有改动。

正确性验证

GPU 的浮点求和顺序与 CPU 不完全相同,为了确认不是"快但算错了",另外写了一个对比程序:把同一段 token 序列分别喂给原版 CPU 路径和 GPU 实现,逐位置比较 32000 维 logits。

  • 前 256 个位置,logits 的最大绝对误差分别为 4.1e-5(15M)、3.7e-5(42M)、3.4e-5(110M),argmax 全部一致;
  • 三个模型在贪心解码(-t 0 -s 42,256 步)下,生成的文本与 CPU 版本逐字节相同。

性能对比

为了公平,所有版本都在同一台机器上重新测试 5 次(第一版 cuBLAS 3 次),取平均值,单位为 tok/s,测试条件 -n 256 -t 0 -s 42、prompt 为 “Once upon a time”,每组波动都在 1% 以内:

模型CPU 基线第一版 cuBLAS优化后 (cuBLAS)加速比
stories15M128.5248.322024.3815.7×
stories42M43.2925.941071.4324.8×
stories110M15.8512.28439.0427.7×

测试机器:AMD Ryzen 7 8845H + NVIDIA GeForce RTX 4060 Laptop GPU(8GB、128-bit、标称带宽 256 GB/s)。

lab6-perf

上图中 (a) 是四种实现的生成速度(对数坐标,数值标在柱顶),(b) 是相对 CPU 基线的加速比。可以直观地看到:朴素 cuBLAS 版因为每 token 都要把权重拷进显存,反而比 CPU 还慢(0.40.8×);权重常驻显存之后才真正吃上 GPU 的带宽,速度直接跳两个数量级;半精度再在 fp32 的基础上翻 1.41.8×。

结果分析

把每 token 需要读取的权重和实测时间放在一起看:

模型每 token 权重每 token 时间等效带宽相对标称峰值
stories15M60.8 MB0.494 ms123 GB/s48%
stories42M167.2 MB0.933 ms179 GB/s70%
stories110M438.4 MB2.278 ms192 GB/s75%

(每 token 权重按模型文件大小算,其中包含共享的 embedding / classifier 权重。)

可以得到几个结论:

  • 优化后每 token 时间几乎与参数量成正比,说明 kernel 启动、logits 回传这些固定开销已经很小,程序进入了"以显存带宽为瓶颈"的状态;
  • stories110M 达到 192 GB/s,约为标称峰值的 75%。batch=1 的 GEMV 只读不写、每行又很短,实际可用带宽本来就低于拷贝测试的峰值,这个数字已经接近 cuBLAS 在这块卡上的上限,继续在 fp32 下压榨的空间不大;
  • 模型越小,固定开销占比越高:stories15M 只有 60.8MB 权重,0.494ms 里还有一部分是 56 个 kernel 的启动和 logits 回传开销,所以等效带宽只有 123 GB/s;
  • 模型越大提升越明显(15.7× → 27.7×):CPU 单线程(make run 没有开 OpenMP)算 GEMV 的劣势随矩阵规模放大,而 GPU 端始终贴着带宽跑。

进一步优化:半精度权重

既然瓶颈是显存带宽,最直接的办法就是减少权重的字节数:把权重存成 fp16、用 cublasGemmEx 以 fp32 累加,每 token 的权重流量直接减半。实测还能再快 1.4~1.7×:

模型fp32 优化版fp16 权重相对 fp32相对 CPU 基线
stories15M2024.383733.281.84×29.0×
stories42M1071.431539.161.44×35.6×
stories110M439.04729.361.66×46.0×

代价是输出不再与 CPU 版本逐字节一致(贪心解码下个别 token 会变化),但生成的文本仍然通顺。半精度只需要 -DUSE_FP16 开关,和 fp32 版共用同一份 run.c(多一个 wt_t 类型和一次 fp32→fp16 的权重转换),make runcublasfp16 即可编译,作为实验对比;主交付仍然是 fp32 版本。

复现

# 基线
make run && ./bench.sh ./run 5
# 优化版
make runcublas && ./bench.sh ./run_cublas 5
# 半精度实验
make runcublasfp16 && ./bench.sh ./run_cublas_fp16 5

bench.sh 就是上面表格用的测试脚本(三个模型各跑若干次,输出平均值/最小/最大)。