2x3090 NVLink 王者配置再度进化——SGLang dev507 + DFLASH2 全面复测，并发 249 t/s 新高峰

[starryskyknight]

双 3090 NVLink 王者配置再度进化：SGLang dev507 + DFLASH2 全面复测

接上一篇 133 t/s 的实测帖，这周做了两件大事：引擎升级 506 个 commits + 跑完整优化矩阵。结论先行：王者配置没变，但藏着一个被内存挤掉的关键优化，挖出来后并发冲到 249 t/s 新高峰。

一、升级了什么

项目	旧	新
SGLang	8/26 快照	dev507（9/4 最新，506 commits）
关键修复	-	f60bc73c DFLASH TP 状态分歧修复
Kernel	7.0.0-30	7.0.0-31.31（swap_cgroup 崩溃修复版）
FlashInfer	0.6.17	0.6.18

其中 DFLASH TP 修复很重要：多轮长对话时 draft 模型状态会在 TP rank 间漂移，输出有潜在漂移风险，这版根除了。

二、挖出的隐藏瓶颈

升级后翻启动日志，发现一行：

Disable DFLASH draft cuda graph because only 0.93 GB GPU memory is available

draft 模型的 CUDA graph 一直被内存挤掉！mem-fraction 0.94 留给 draft graph 的空间只剩 0.93GB，不够。降到 0.90 后：

• draft cuda graph 启用
• selector decode（greedy + sampling）也折进 graph

三、优化矩阵实测（6 项，单变量）

测试	结果	判定
mem-fraction 0.94→0.90	draft graph 启用	采纳
dflash-block-size 16	并发 -28%	否决
dflash-block-size 4	JSON 场景 -18%	否决
tokenizer-worker-num 4	无增益	否决
fastokens（Rust tokenizer）	需 Rust toolchain	不适用
speculative-adaptive	仅支持 EAGLE	不适用

踩坑：DFLASH 强制 draft-tokens == block-size，不匹配直接 ValueError。

四、最终数据（2x3090 NVLink TP2 + AWQ INT4 + DFLASH2）

指标	数据
并发 aggregate（2 路）	219.1 avg / 249.1 峰
JSON 工具调用并发	280.5 avg（峰 303.7）
短 prompt 单路	297.3
代码生成	254.0
中文散文	85.4

vs 旧帖 133 t/s：+65% ~ +87%。

口径声明：并发 = 2 路 aggregate（双路同时生成的总吞吐）；单路端到端（含 prefill）一直 82-88 t/s。数字都是实测，无估算。

五、配置

--mem-fraction-static 0.90
--speculative-num-draft-tokens 8
--speculative-dflash-block-size 8
--tp-size 2 --kv-cache-dtype fp8_e5m2
--chunked-prefill-size 2048 --max-running-requests 2

完整报告和踩坑记录见回复区，欢迎交流。

[johnnybegood]

@starryskyknight 模型和草稿的下载地址能给一下么？ 另外我 3090+3080 没有 nvlink 能抄作业么？如果抄作业的话应该注意什么？谢谢

[stormaround]

dflash好像要牺牲视觉，两张3090 nvlink 接近两万了，而且现在二手都是矿渣，感觉不是很值

[applejuice]

我的nvlink 确定翻车 所以没有nvlink 但是不影响抄作业 谢谢
但是我也不了解
200多decode 是怎么一回事 跟没nvlink 差不多

export NCCL_P2P_DISABLE=1 # 无 NVLink / 无 P2P，走 host bounce
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True

python -m sglang.launch_server
--model-path /path/to/Qwen3.8-27B-AWQ
--speculative-algorithm DFLASH
--speculative-draft-model-path /path/to/Qwen3.8-27B-DFlash2
--speculative-num-draft-tokens 8
--speculative-dflash-block-size 8
--tp-size 2
--trust-remote-code
--context-length 262144
--mem-fraction-static 0.93
--kv-cache-dtype fp8_e5m2
--chunked-prefill-size 2048
--max-prefill-tokens 8192
--max-running-requests 2
--max-mamba-cache-size 10
--enable-cache-report
--reasoning-parser qwen3
--tool-call-parser qwen3_coder
--sampling-backend pytorch
--disable-custom-all-reduce
--disable-prefill-cuda-graph

Decode（当前生产实例实测）

场景	decode t/s	实测区间	tok/chunk
代码生成	256.2	256.2–256.3	6.69
英文技术论述	113.3	113.2–113.3	2.97
中文常规对话	70.4	70.4–70.5	1.94
中文散文	65.1	65.0–65.2	2.06

并发（代码生成场景）

并发	单路 t/s	aggregate t/s	aggregate 区间	overlap
1	260.3	251.6	251.5–251.8	0.97×
2	227.2	429.7	428.9–430.3	1.89×

Prefill（冷 prefill：每次唯一 prompt，不命中 radix cache，按 TTFT 计算）

prompt tokens	TTFT	prefill t/s
3,228	1.97 s	1,635
13,894	8.72 s	1,593
57,560	41.96 s	1,372
116,234	101.66 s	1,143
234,226	269.74 s	868

[starryskyknight]

@johnnybegood

主模型（AWQ INT4，MTP 保留）：https://huggingface.co/twolven/Qwen3.8-27B-abliterated-AWQ-MTP

DFLASH2 草稿模型：https://huggingface.co/incoai/Qwen3.8-27B-DFlash2 （z-lab 有镜像）

3090 + 3080 无 NVLink 能不能抄：能，方向对（NCCL_P2P_DISABLE=1 走 host bounce），三个注意点：

1. 3080 必须是 12GB 版：主模型 18.7GB TP2 均分后每卡约 9.4GB，再加草稿 + KV cache + 激活值，10GB 版会爆显存。12GB 版可以，mem-fraction 建议 0.85 起步，给 draft CUDA graph 留空间（我们 0.94 时 draft graph 被挤掉过，降到 0.90 才启用）。
2. 预期掉速：无 NVLink 走 PCIe host bounce，底层前向速率会低于 31 次/秒，粗估掉 20-35%，代码场景 207 t/s 大概落到 130-160 区间。这条我没实测过无 NVLink 环境，是按带宽比例估的，仅供参考。
3. 视觉任务显存更紧：视觉塔 bf16 常驻，多图场景 3080 会先顶不住。

[starryskyknight]

@stormaround
关于「DFLASH 牺牲视觉」：不会，正好今天实测验证了。DFLASH 只参与 decode 阶段（草稿出 token），图像编码在 prefill 阶段完成，两段正交。twolven 这个 AWQ 版视觉塔保留 bf16 未量化，模型卡原文就有 "vision still works"。今天 curl 直传图片实测：读图 100% 正确（形状/颜色/文字全对），同时段 DFLASH accept rate 0.28-0.40 照常跑，零冲突。真实照片测试连法文成分表都能正确 OCR。

[starryskyknight]

@applejuice 「200 多 decode」解释：楼上已经说到点子上了——底层前向速率恒定约 31 次/秒，速度 = 31 × 每次前向接受的 token 数。DFLASH 一次草稿 8 个 token，主模型一次前向验证。代码场景一次能接受 6.69 个 → 207 t/s；中文散文只接受 2.06 个 → 52.7 t/s。「249 新高峰」是并发 2 路的 aggregate 口径，单路端到端（含 prefill）一直是 82-88 t/s，两个口径不矛盾。

[applejuice]

@stormaround 我感觉那些改涡轮卡 nvlink 都会出问题

[applejuice]

我不懂哪里出错
我测出来的都比楼主用nvlink更好

楼主可不可以给个统一测试方法

[starryskyknight]

@applejuice 你这数据有意思，我今早刚按统一口径复测了一轮，先对齐再下结论。

1. 口径真相：429.7 vs 249 不能直接比

我旧帖「并发 219.1 avg / 249.1 峰」是端到端含 prefill（两路同 prompt、威士忌长文、t=0.7、max 1024），你的 429.7 是纯 decode 重叠口径。我早上用你的口径重测，服务没退化。

2. 统一口径复测（t=0、max 512、代码场景、streaming + include_usage）

· 单路 decode（代码）：235.9 t/s（4.7 tok/chunk）
· 并发 2 路·同 prompt（radix 命中）：449.0 t/s
· 并发 2 路·不同 prompt：333.8 / 380.3 t/s（overlap 1.5×）
· 中文散文单路：89.3 t/s · 散文并发 2 路：181.8 t/s（overlap 2.0×）

同 prompt 并发我 449 略超你 429.7；不同 prompt 并发我 overlap 只有 1.5×，你 1.89× —— 这块想找你对齐几个细节。

3. 想找你要的数据（抄作业用）

① 你并发测试两路 prompt 是相同还是不同？相同（radix 命中）的话你的 429.7 对应我 449；不同还能 1.89× 的话，你的调度比我强，我认抄。
② 完整硬件：GPU 型号/数量、CPU、内存、PCIe 代数通道。你从没贴过配置，nvlink 翻车前你是什么卡？
③ expandable_segments:True + mem 0.93 还能开 draft graph 吗？我 0.94 时 draft graph 内存不足（差 0.93GB），降到 0.90 才开。你 0.93 能开我就立刻抄。
④ --sampling-backend pytorch vs 默认 flashinfer 有实测差异吗？

4. 统一测试法提案

温度 0、max_tokens 512、TTFT / decode / 端到端三个数分开报、并发注明两路 prompt 同异 + radix 状态、贴 SGLang commit。你我各跑一轮贴数据。

你我代码场景 tok/chunk 都在 4.5-6.7 区间、底层前向速率都 38 次/s 附近，模型层已经对齐，剩下就是调度层的戏，值得挖。

[applejuice]

很明显我也是ai 自动测试
叫他跟着你说的跑

拼发那个应该就是你说的那样
ai应该用到一样的prompt

你给个测试脚本 统一跑就好

[starryskyknight]

@applejuice 明白，我这边也是 AI 全自动跑。对上了：你并发同 prompt 的 429.7 就是 radix 命中场景，对应我这边 433.8 / 445.3（3 轮均值，两轮共 6 次），同口径我略高 3% 左右，算噪音范围内打平。

统一脚本来了，prompt 全部写死，双方跑同一套才算数。零依赖，直接跑：

#!/usr/bin/env python3
"""SGLang DFLASH 统一基准 v1 — 双方同 prompt 对测
用法: python3 uni_bench.py --model <模型名> [--base-url http://127.0.0.1:8000] [--rounds 3]
口径: decode=(comp-1)/(总时间-TTFT); aggregate=两路decode重叠窗口的总token/窗口"""
import argparse, concurrent.futures, json, time, urllib.request

P = {
    "code": "You are an expert Python engineer. Write a complete implementation of a thread-safe LRU cache class with TTL expiration support, including unit tests. Provide only code, no explanation.",
    "code_b": "You are an expert systems engineer. Write a complete implementation of a lock-free SPSC ring buffer in C++17 with acquire/release memory ordering annotations. Provide only code, no explanation.",
    "en_tech": "Write a detailed technical explanation of how speculative decoding with a draft model works, covering the draft-verify loop, acceptance criteria, and why acceptance rate varies by domain. Aim for depth and precision.",
    "cn_chat": "请用中文详细分析一下，为什么家用路由器长期不重启会越来越慢？从内存碎片、连接跟踪表、NAT 状态老化三个角度展开，给出可操作的解决建议。",
    "cn_essay": "请写一篇关于秋天的散文，描写北平的秋色，要求文笔优美，有细节描写，不少于五百字。",
}

def gen(base, model, prompt, mt=512, t=0.0):
    payload = {"model": model, "messages": [{"role": "user", "content": prompt}],
               "max_tokens": mt, "temperature": t, "stream": True,
               "stream_options": {"include_usage": True}}
    req = urllib.request.Request(base.rstrip("/") + "/v1/chat/completions",
                                 data=json.dumps(payload).encode(),
                                 headers={"Content-Type": "application/json"})
    t0 = time.time(); ttft = None; nch = 0; usage = None
    with urllib.request.urlopen(req, timeout=900) as r:
        for raw in r:
            line = raw.decode().strip()
            if not line.startswith("data:"): continue
            d = line[5:].strip()
            if d == "[DONE]": break
            try: j = json.loads(d)
            except Exception: continue
            if j.get("usage"): usage = j["usage"]
            ch = (j.get("choices") or [{}])[0].get("delta", {})
            if (ch.get("content") or "") or (ch.get("reasoning_content") or ""):
                if ttft is None: ttft = time.time() - t0
                nch += 1
    total = time.time() - t0
    comp = usage["completion_tokens"] if usage else 0
    if ttft is None or comp <= 1:
        return {"comp": comp, "ttft": None, "total": total, "dec": 0.0, "tpc": 0.0}
    return {"comp": comp, "ttft": ttft, "total": total,
            "dec": (comp - 1) / (total - ttft), "tpc": comp / nch if nch else 0.0}

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--base-url", default="http://127.0.0.1:8000")
    ap.add_argument("--model", required=True)
    ap.add_argument("--rounds", type=int, default=3)
    ap.add_argument("--max-tokens", type=int, default=512)
    a = ap.parse_args()
    print(f"# 统一基准: {a.model} @ {a.base_url}  rounds={a.rounds} max_tokens={a.max_tokens} t=0\n")
    print("## 单路（四场景）")
    for name, pr in [("代码生成", P["code"]), ("英文技术论述", P["en_tech"]),
                     ("中文常规对话", P["cn_chat"]), ("中文散文", P["cn_essay"])]:
        rs = [gen(a.base_url, a.model, pr, mt=a.max_tokens) for _ in range(a.rounds)]
        ok = [r for r in rs if r["ttft"]]
        if not ok: print(f"  {name}: 失败"); continue
        print(f"  {name}: decode {sum(r['dec'] for r in ok)/len(ok):.1f} t/s | "
              f"TTFT {sum(r['ttft'] for r in ok)/len(ok):.3f}s | tok/chunk {sum(r['tpc'] for r in ok)/len(ok):.2f}")
    print("\n## 并发 2 路（代码场景）")
    for label, ps in [("同 prompt（radix 命中）", [P["code"]] * 2), ("不同 prompt", [P["code"], P["code_b"]])]:
        aggs = []
        for _ in range(a.rounds):
            with concurrent.futures.ThreadPoolExecutor(2) as ex:

rs = list(ex.map(lambda p: gen(a.base_url, a.model, p, mt=a.max_tokens), ps))
            rs = [r for r in rs if r["ttft"]]
            if len(rs) < 2: continue
            aggs.append(sum(r["comp"] - 1 for r in rs) / max(r["total"] - r["ttft"] for r in rs))
        print(f"  {label}: aggregate decode {sum(aggs)/len(aggs):.1f} t/s (n={len(aggs)})" if aggs else f"  {label}: 失败")

if __name__ == "__main__":
    main()

我这边结果（NVLink、mem 0.90、flashinfer sampling、dev507+27 commits）：

单路 decode t/s：代码 237 | 英文技术 166 | 中文对话 123 | 中文散文 92
并发 2 路：同 prompt 440 | 不同 prompt 390

等你跑完贴数。另外两个问题还等你答：
① expandable_segments + mem 0.93 你 draft graph 开得起来吗？我 0.94 就崩（draft graph 差 0.93GB 内存）
② 你机器具体什么卡？几张？同硬件这对比才有意义
③ 你 tok/chunk 6.69 是 verify 步口径，我脚本里 tok/chunk 是 stream chunk 口径，两边数字别直接比，只比 decode t/s 和 aggregate

[stormaround]

@starryskyknight 说:

@stormaround
关于「DFLASH 牺牲视觉」：不会，正好今天实测验证了。DFLASH 只参与 decode 阶段（草稿出 token），图像编码在 prefill 阶段完成，两段正交。twolven 这个 AWQ 版视觉塔保留 bf16 未量化，模型卡原文就有 "vision still works"。今天 curl 直传图片实测：读图 100% 正确（形状/颜色/文字全对），同时段 DFLASH accept rate 0.28-0.40 照常跑，零冲突。真实照片测试连法文成分表都能正确 OCR。

那还可以，之前用双r9700跑tp2，mtp和dflash速度差不多，就没有再去调dflash

[applejuice]

这就对了
nvlink 帮助还是很大的
不懂之前ai 怎样测的

单路（四场景） — Single stream, 512 tokens, t=0, 3 rounds

Scenario	Decode (t/s)	TTFT (s)	Tokens / chunk
代码生成 (Code generation)	141.1	0.149	3.64
英文技术论述 (English technical)	104.0	0.136	2.69
中文常规对话 (Chinese chat)	76.8	0.135	1.99
中文散文 (Chinese essay)	63.8	0.137	1.67

并发 2 路（代码场景） — Two concurrent streams, code prompts

Case	Aggregate decode (t/s)	n
同 prompt（radix 命中） Same prompt, radix hit	207.1	3
不同 prompt Different prompts	203.9	3

Setup: SGLang, Qwen3.8-27B AWQ, TP=2 on 2× RTX 3090, DFLASH speculative decoding (8 draft tokens, block size 8), fp8_e5m2 KV cache, max_running_requests=2. AMD EPYC 7452, 62 GB RAM.

[applejuice]

另一个发现 我刚才是思考模式 你的是什么模式跑

单路（四场景） — Single stream, 512 tokens, t=0, 3 rounds, thinking OFF

Scenario	Decode (t/s)	TTFT (s)	Tokens / chunk
代码生成 (Code generation)	246.7	0.147	6.32
英文技术论述 (English technical)	140.8	0.134	3.63
中文常规对话 (Chinese chat)	99.0	0.134	2.56
中文散文 (Chinese essay)	61.4	0.135	1.60

并发 2 路（代码场景） — Two concurrent streams, code prompts, thinking OFF

Case	Aggregate decode (t/s)	n
同 prompt（radix 命中） Same prompt, radix hit	429.7	3
不同 prompt Different prompts	402.4	3

Setup: SGLang 0.5.19.dev990, Qwen3.8-27B AWQ, TP=2 on 2× RTX 3090 (no NVLink, NCCL P2P disabled), DFLASH speculative decoding (DFlash2 draft, 8 draft tokens, block size 8), fp8_e5m2 KV cache, ctx 262144, max_running_requests=2. AMD EPYC 7452, 62 GB RAM. Request payload adds "chat_template_kwargs": {"enable_thinking": false}; no ignore_eos.

[johnnybegood]

@starryskyknight

我是 3090 24G + 3080 20G， 抄你的作業， 這是圖片。 不過感覺哪裏怪怪的。

[williamlouis]

还真就是王者了。NV显卡价格继续飙升。3090算是守门员了。

[johnnybegood]

@starryskyknight 我有個問題， 如果是兩張 3090 跑張量並行， 那是不是比單張 48G的 4090 跑的快很多呢？ 就好像兩根小容量內存組雙通道， 比一根大容量內存還要快。

[applejuice]

@johnnybegood 应该4090更快 而且架构更新

[applejuice]

@johnnybegood 你这个就是我说的 3090 会跌成3080速度
基本上3080 就差3090 10+% 算力
sglang vllm 都不能分配算力 都是平均分配

现在还不知道我们跟有nvlink 的测试有什么不同
如果楼主是用thinking 模式 就跟甩我们没有nvlink一大截了

之前我用nvlink 没有mtp 没有dflash 速度差个10-15%
现在用dflash 如果是直接叠加 差真的很多