Kestrel_VLLM - 38 · 一次「判别」省掉一整轮实现:小投影融合的门禁与落地

43 阅读10分钟

38 · 一次「判别」省掉一整轮实现:小投影融合的门禁与落地

一句话:阶段五最大的单笔收益(把同输入的多投影合并成一次发射,实测 1.1062×)差点被做错的方向吃掉 —— 它一开始被当成「把 cold→bulk 的损失拿回来」,而那条路的性质没人验过;一个只用一条命令的判别(--gran)把「该不该做」先验成「值得做」,再落地成 401 → 257 次发射。 前置:第 36 篇(「发射次数多≠主机侧开销大」的踩坑)、第 37 篇(--fuse3 的 9 形状内核级直测与「唯一一份源」)。 环境:x86-64 + NVIDIA RTX 5090 · Qwen3.5-27B q4(hybrid:48 GDN + 16 全注意力层)· CUDA 后端(阶段五)。

一、问题与结论

阶段五到中后段,最大的单笔收益(同输入多投影融合,1.1062×)差点被做错的方向吃掉:它一开始被当成「把 cold→bulk 的损失拿回来」,而那条路的性质没人验过 —— 如果那个缺口是主机侧发射成本,那么 CUDA Graph 早就该把它吃掉了,再写融合内核就是白干。

本篇讲的是一个只用一条命令的判别,以及它如何把一个「看起来该做」的方向先验成「值得做」,再落地成 401 → 257 次发射、实测 1.1062×。这也是本系列里「先量后做」性价比最高的一次:一步判别,省掉一整轮实现。

结论数值判定
要做的对象(投影)401 次发射 / 11.851 ms / 13.73 GB ⇒ 有效 1158 GB/s实测
bulk(同字节合成一次发射)1581.9 GB/s实测
缺口≈2.9 ms(占全 token 的 21%)实测
graph 相对 stream只高 +4.4%(1198.8 → 1251.1)实测
两次合成一次(都是 stream)+15.0%(1198.8 → 1378.6)实测
落地:发射数401 → 257(省 144 次)实测
落地:stream15.928 → 14.400 ms/token = 1.1062×实测
落地:graph14.033 → 12.884 = 1.0892×实测
落地:位级两档 h64/hfinal/logits 逐字节相同实测

要点:

  1. 机制未定,且两种可能指向完全相反的行动:若是主机侧发射固定成本 ⇒ CUDA Graph 应该已经吃掉它,没什么可做;若是设备侧每发一次的爬坡/收尾 ⇒ graph 吃不掉,只有合并才能拿回。
  2. 判别只用一条探针(--gran):固定总字节,只改「拆成几次发射」,每个配置同时测 stream 档与 graph 档。
  3. ★ 判别结论(最重要的单条事实):把 128 次发射捕成一张图,速率只从 1198.8 → 1251.1(+4.4%);而两次合成一次能到 1378.6(+15.0%) ⇒ graph 与合并是两个正交的机制,不是同一笔账的两种算法。
  4. 一条可推广的纪律:以后任何「省发射」的候选,先问「graph 档下还剩多少?」 剩得多 ⇒ 设备侧粒度,值得合并;剩得少 ⇒ 主机侧成本,graph 已经吃掉了。这一步只花一条命令。
  5. 落地结果:发射 401 → 257(省 144 次),stream 15.928 → 14.400 ms/token = 1.1062×、graph 14.033 → 12.884 = 1.0892×,且两档 h64/hfinal/logits 逐字节相同。
  6. 门禁的预测落点:≈1.100× / ≈1.093×,实测落在 ±5% 以内 —— 这是本系列里「模型预测 ↔ 实测」对得最好的一次。

二、背景

投影:401 次发射 / 11.851 ms / 13.73 GB  ⇒  有效 1158 GB/s
bulk(同字节合成一次发射)              ⇒        1581.9 GB/s
缺口 ≈ 2.9 ms(占全 token 21%)

关键不在缺口多大,而在它的性质。 这两种性质对应两种互斥的行动:

若缺口是…那么…行动
主机侧发射固定成本CUDA Graph 已经把它吃掉大半融合没什么可做
设备侧每发一次的爬坡/收尾graph 吃不掉只有合并发射能拿回

这一步必须先做判别,否则会重复投入 —— 项目里已经吃过一次「口径没定就动手」的亏(见第 36 篇那次 M 行 Graph 的失败)。

三、核心机制与做法

3.1 判别:固定总字节,只改「拆成几次」

探针 --gran 的做法很干净:总字节固定,把「一次发射多少行」按 2 的幂往上抬(rows × mult、copies ÷ mult),每个配置同时测 stream 档与 graph 档。

  • mult = 1 ⇒ 引擎默认(stream)档今天的形态;
  • mult = 2 ⇒ 「两份同输入投影合并」后的形态 —— 这正是融合能到达的点。

形状取自引擎的真实发射点(不是编的)。以 MLP gate+up 为例(5.98 GiB):

mult每次 MiB发射次数stream GB/sgraph GB/s
147.811281198.81251.1
295.62641378.61417.7
4191.25321497.21512.6
16765.0081566.71575.4
1286120.0011598.11590.7

这段探针的实现就是「同一份权重跑 copies 次,先在 stream 上量、再把同一串发射捕成一张图量」——干净到只改一个维度:

/* 文件名:tools/q35_q4_gpu.cu —— --gran:固定总字节,只改「拆成几次发射」 */
static void gran_one(long long rows, long long cols, int copies, int iters,
                     double *gb_stream, double *gb_graph) {
    const size_t bpc = q4_bytes(rows, cols);
    const size_t tot = bpc * (size_t)copies;
    /* --- stream:逐次发射(引擎默认档的形态)--- */
    cudaEventRecord(t0);
    for (int it = 0; it < iters; it++)
        for (int c = 0; c < copies; c++)
            k_rq_q4_gemv_f32act<<<blocks, threads>>>(dW + (size_t)c * bpc, dx,
                                              dy + (size_t)c * rows, (int)rows, (int)cols);
    cudaEventRecord(t1); cudaEventSynchronize(t1);
    float ms = 0; cudaEventElapsedTime(&ms, t0, t1);
    *gb_stream = (double)tot * iters / (ms * 1e6);

    /* --- graph:把同一串发射捕成图、重放 iters 次 --- */
    cudaStreamBeginCapture(cs, cudaStreamCaptureModeThreadLocal);
    for (int c = 0; c < copies; c++)
        k_rq_q4_gemv_f32act<<<blocks, threads, 0, cs>>>(dW + (size_t)c * bpc, dx,
                                                 dy + (size_t)c * rows, (int)rows, (int)cols);
    cudaStreamEndCapture(cs, &gr);
    cudaGraphInstantiate(&ge, gr, 0);
    cudaEventRecord(t0, cs);
    for (int it = 0; it < iters; it++) cudaGraphLaunch(ge, cs);
    cudaEventRecord(t1, cs); cudaEventSynchronize(t1);
    ms = 0; cudaEventElapsedTime(&ms, t0, t1);
    *gb_graph = (double)tot * iters / (ms * 1e6);
}

判别就摆在表里:

档mult=1mult=2
stream1198.81378.6
graph1251.11417.7
  • graph 相对 stream:只高 +4.4%;
  • 合并相对拆开(都是 stream):+15.0%。

⇒ CUDA Graph 与合并发射不是同一笔账的两种算法,而是两个正交的机制:

  • graph 消的是主机侧的发射成本;
  • 合并消的是设备侧每发一次都要付的爬坡/收尾(graph 之后它还在)。

★ 顺手解释了一个此前偏小的估算:那个用「节点成本 × 节点数」估的算法之所以偏小,正是因为节点成本不是这条路的全部。

3.2 折算与判定(归因必须分级)

按实测带宽折算(三组,覆盖投影的 68%):

组字节发射 401→257stream 省graph 省
① mlp gate+up6.42 GB128 → 640.70 ms0.60 ms
② gdn in_qkv+in_z2.27 GB96 → 480.53 ms0.45 ms
③ attn q+k+v0.67 GB48 → 160.22 ms0.14 ms
合计9.36 GB−144 次≈1.45 ms/token≈1.19 ms/token

归因分级(必须照写,否则会被读成实测收益):

说法等级
表里所有 GB/s、以及「graph 只比 stream 高 4.4%」实测
「三组合计省 1.45 / 1.19 ms/token」实测 × 模型:每组的带宽是实测,合并后的形态是模型
「端到端 ≈1.100× / 1.093×」外推(当时未落地、未过零回归/位级门禁)
② 的基线用统一 MiB 数(两个不同形状的均值)模型简化(只影响基线加权,不改结论方向)

形状级门禁:三组的 基线/地板 = 1.34× / 1.72× / ~1.76× ⇒ 全部通过(门槛 1.20×)。⇒ 判定:通过,列为落地候选(比同期的另一个候选大 10 倍)。

3.3 落地:合并的是输出行,所以位级应当不变

内核设计:仿已有的双输出内核,新增一个「2–3 个输出、行数可不同」的融合 GEMV(grid 按总行数分块,块号落在哪一段就取哪个权重指针):

/* 文件名:src/npu/cuda/q4_gemv_twin.inc —— M 行 + 多输出:同一份 x 服务 2–3 段投影、一次发射 */
template <int R, int M>
__global__ void k_rq_q4_gemv_mr3(const uint8_t *__restrict W0,
                                 const uint8_t *__restrict W1,
                                 const uint8_t *__restrict W2,
                                 const float   *__restrict x,   /* [M][cols] 行主序 */
                                 float *__restrict y0, float *__restrict y1, float *__restrict y2,
                                 int r0, int r1, int r2, int cols) {
    const int warp = (int)((blockIdx.x * blockDim.x + threadIdx.x) >> 5);
    const int lane = (int)(threadIdx.x & 31u);
    const int n0 = (r0 + R - 1) / R, n1 = (r1 + R - 1) / R, n2 = (r2 + R - 1) / R;
    if (warp >= n0 + n1 + n2) return;
    /* 合并的只有「输出行」这一维:warp 号落在哪一段,就取哪一对 (W, y) */
    const uint8_t *W; float *y; int rows, base;
    if (warp < n0)           { W = W0; y = y0; rows = r0; base = warp * R; }
    else if (warp < n0 + n1) { W = W1; y = y1; rows = r1; base = (warp - n0) * R; }
    else                     { W = W2; y = y2; rows = r2; base = (warp - n0 - n1) * R; }
    if (base >= rows) return;
    /* 下面从 lane 起与单输出版逐字相同 ⇒ 逐行结果应当逐位不变(用 memcmp 验,不靠推理) */
}

★ 位级安全性:合并的是输出行,而每一行的归约仍是「同一 cols、同一核内同序」⇒ 逐行结果应当逐位不变。但纪律是:落地后用 memcmp 验,不靠推理。

A/B 的做法很讲究:两个 DLL、同一份源码、只差一个 -D ⇒ 排除了「两次不同构建」这个混淆项,A/B 的差异只能来自那一个开关。

四、实测数据

判定(同会话交错):

档合并前合并后倍率
默认(stream)15.92814.400 ms/token1.1062×
graph14.03312.8841.0892×

位级:两档 h64/hfinal/logits 逐字节相同。 门禁预测对账:预测 ≈1.100× / ≈1.093× ⇒ 实测落在 ±5% 以内。

口径数值判定
--gran 各 mult 的 stream/graph GB/s见 3.1 表实测(总字节固定 6.12 GB)
graph 相对 stream 的增益+4.4%实测
合并相对拆开的增益+15.0%实测
三组合计折算省≈1.45 / 1.19 ms/token实测 × 模型
端到端 stream / graph1.1062× / 1.0892×实测
位级两档三文件逐字节相同实测

五、边界与已知限制

  • 归因分级必须写在表旁边:同一张表里,「GB/s」是实测、「省 1.45 ms」是实测×模型、「端到端 1.100×」是外推。不分开标注,三者会被读成同一等级的结论。
  • 判别只覆盖一组形状:--gran 只回答 gate/up 这一组;端到端要按各组合并后的字节加权,并落地后重测。
  • ② 的基线是模型简化:用统一 MiB 数(两个不同形状的均值),只影响基线加权,不改结论方向。
  • 合并要求各段用同一个 R:R 是模板参数,一次发射只能有一个 R;段间 R 不同就不能融合。

CPU 对照(迁移前基线)

  • CPU 参考:model/vllm_q35_fused.c:q35_fused_gemv / q35_fused_swiglu —— 同输入多投影的 CPU 参考实现。
  • 迁移要点:只合并「输出行」这一维、每行归约序不变 ⇒ 逐行位级不变;段间须同一 R;--gran 判别「graph 治主机侧、合并治设备侧」两个正交机制。
  • 真机验证:命中 E3(双 entry 位级相同 + vs CPU-f32 maxrel=2.4e-6)、E6(q35_fused_check:融合 12.7 vs f32 2.6 GMAC/s、字节账 7.11×)。--gran 判别与端到端 1.1062× 属历史测量,未在本机清单复现。

六、小结

  1. 判别比优化便宜得多,而且必须先做。这一步花的是一条 --gran 命令;若不做,就可能按「主机侧发射成本」的假设去写融合内核,做完发现收益被 graph 吃掉 ⇒ 「机制未定」不是「先动手再想」,是「先花最小成本把它定下来」。
  2. ★ 「graph 档下还剩多少?」是一条可复用的判别式。任何「省发射」的候选都适用:剩得多 ⇒ 设备侧粒度(合并有用);剩得少 ⇒ 主机侧成本(graph 已经吃掉)⇒ 这条判别式被写进规格,作为后续同类立项的前置问题。
  3. 两个机制正交这件事,本身是知识:graph 治主机侧,合并治设备侧。知道了这一点,就不会再把「省发射」当成一个笼统的筐,也不会用「合并能省 15%」去推断「graph 也能省 15%」(第 36 篇 M 行 Graph 的翻车正是踩在这上面:把「发射次数多」当成了「主机侧开销大」)。
  4. 归因分级要写在表旁边。同一张表里,「GB/s」是实测、「省 1.45 ms」是实测×模型、「端到端 1.100×」是外推。不分开标注,三者会被读成同一等级的结论。
  5. 位级安全论证 + memcmp 双管。合并输出行「应当」逐位不变是论证,但落地的判据仍是逐字节。这与第 34 篇块内的「块内因果」是同一套:论证给出方向,memcmp 给出结论。

相关篇目:第 36 篇(M 行 Graph 的翻车 —— 把「发射次数多」当「主机侧开销大」);第 29 篇(CUDA Graph 接到 hybrid,主机侧那一半);第 27 篇(两次「少发一次」);第 37 篇(--fuse3 的 9 形状内核级直测与「唯一一份源」)。 源码与配套资源:本仓库 gitee.com/pei-xiaogua…; CPU 推理源码 gitee.com/pei-xiaogua…