跳转至内容
  • 版块
  • 最新
  • 标签
  • 热门
  • 用户
  • 群组
皮肤
  • 浅色
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • 深色
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • 默认(LCZ-Blue)
  • 不使用皮肤
  • LCZ-Green
  • LCZ-Blue
  • LCZ-Black
折叠
品牌标识

抡锤者

首页 版块 标签
硬件
装备秀
AI 广场 App
  1. 主页
  2. 版块
  3. AI音视频画图
  4. 【34.5 min → 3.3 min】用对注意力机制的2×7900XTX在H3流程中可以提速多少?—— 答案1050%↑

【34.5 min → 3.3 min】用对注意力机制的2×7900XTX在H3流程中可以提速多少?—— 答案1050%↑

已定时 已固定 已锁定 已移动 精华 热议 AI音视频画图
7900xtx视频生成多卡部署
59 帖子 15 发布者 2.9k 浏览 3 关注中
  • 从旧到新
  • 从新到旧
  • 最多赞同
回复
  • 在新帖中回复
登录后回复
此主题已被删除。只有拥有主题管理权限的用户可以查看。
  • E
    E
    Enigma
    硕果累累 贵族大夫
    编写于 最后由 编辑
    #49

    @xiongjie-gao 几天没来,又出了如此精品作业啊,苏妈的offer正飞奔过来...我再考虑要不要再屯一张7900

    1 条回复 最后回复
    1
    • xiongjie gaoX xiongjie gao

      @terry 学文爷,把挨嘴把子当学费。
      疼,但不致命。平平安安活到八十。

      E
      E
      Enigma
      硕果累累 贵族大夫
      编写于 最后由 编辑
      #50

      @xiongjie-gao 说:

      @terry 学文爷,把挨嘴把子当学费。
      疼,但不致命。平平安安活到八十。

      抄作业交卷:2×7900XTX 上把你的 3035 复现了一遍。单卡 6% 内对上,双卡要改你两行代码,另外顺手发现 sol 比 int8 还能再快一倍多。

      先认个错,我这台的数和你的不是一组:DiT 是 Minimax-h3_Singularity_ref2va_v2_Pruned_w4a8(12.55 GB,你的是 fl2va w4a8 11.7 GB)、TE 是 qwen3vl_32b_minimax_h3_nvfp4_awq(15.69 GB,你的 w4a8 是 26 GB)、LoRA 是 minimax_h3_dmd_ref2va_8step_turbo_pruned(你那个 turbo_v4_step600 在我们机器上是坏链接)、CPU 是 5950X 不是 E5-2696v4、两卡到 CPU 还是 x8。所以下面只比同档位的比值和你给的验收线。

      一、单卡:你的三档,我们都在 6% 内

      档 你的 我们
      832×480·124f·8 步 单卡 11.235 s/it 10.564(端到端 109.2 s)
      832×480·362f·8 步 单卡 53.7,显存 19.96 GB 50.78,20.01 GB
      1344×768·362f·2 步 单卡 257.9,显存 23.82 GB 251.90,23.84 GB

      (用的是你 kuzuryusen 仓库里那个 bench.py + run_tp.sh,只换了权重名和端口。)

      二、你 1050% 里最大的那层(F1),我们这台没有

      我们 venv 里是 torch 2.15.0+rocm7.14,/opt 里躺着 7.2.3 / 7.13.0 / 10.1 —— 按 F1 的说法这叫"看着就该坏"。但 S1 探针是健康的:

      路径 4096 8192 16384
      pytorch(SDPA) 13.2 85.3 1164.4
      kitchen int8 6.4 24.7 93.3
      kitchen sol 2.3 7.4 25.3
      basic(默认) 19.8 77.3 OOM(要 28.00 GiB)

      所以 F1 的正确用法是"用 S1 去证",不是看版本号猜 —— 这点你帖里已经写了,我只是补一个反例:版本不同源不等于内核坏。

      顺带一个建议:你那条 200 ms 的线,建议挪到 16384。 我们这台 SDPA 在 8192 只有 85 ms(过线),到 16384 是 1164 ms(×13.7,长度翻倍平方该 ×4)—— 8192 上是"假健康"。真实序列(1344×768·294f ≈ 30 万 token)比 16384 还远。

      三、双卡:p2p 只值 1%,真原因是 split_state_dict 取裸 key

      原样跑,三档全是负的:

      档 原样双卡 相对单卡 你的
      832×480·124f·8 11.95 s/it 0.88× 7.618(1.47×)
      832×480·362f·8 54.20 0.94× 31.9(1.68×)
      1344×768·362f·2 257.78 0.98× 112.3(2.30×)

      先按你的路子走了一遍 p2p:装 p2p_force、按你这台的真实 sysfs 拓扑生成 NCCL_TOPO_FILE(2e:00.0 → 2f:00.0/32:00.0)、重启后 isAllDirectP2p 1、通道 via P2P/IPC、你自己的 bootcheck 也 [OK] KFD 链路 2。只快 1%(11.99→11.95、54.20→53.59)。传输不是瓶颈。

      真原因在 comfyui-tp2/__init__.py 的 split_state_dict() 开头:

      qkv = sd.get("blocks.0.attn.qkv_proj.weight")     # 取不到 → return sd,静默、不切
      hd  = sd.get("blocks.0.attn.q_norm.weight")
      if qkv is None or hd is None:
          return sd
      

      我们这个 w4a8 检查点 1333 个 key 里 1332 个带 model.diffusion_model. 前缀,裸 key 0 个 → 每次都静默 return。于是两卡各算整个模型,每步 450 次 all_reduce / 15.1 GB;10.564 + 1.4 ≈ 11.95,一分不差。

      把取 key 改成允许 "" / model.diffusion_model. / diffusion_model. 三种前缀(就那两行),立刻听到:

      [tp2] rank0 state_dict split: heads 56->28, keys 1332
      
      档 切了之后 相对单卡 每卡显存
      832×480·124f·8 6.539 s/it,端到端 79.2 s 1.61× 23.74 GB
      1344×768·362f·2 131.66 s/it,端到端 370.4 s 1.91× 17.60 GB(−6.2)

      LoRA 那 208 个 shape 错也一起没了(模型切了,切过的 LoRA 就对上了)。

      但有个必须说清的:切了不等于单卡那一张。整帧 mean|Δ| 16.5/255(结构 14.7);参照是换 seed 重采 34.1、没切 54.8、同配置两次 0.00。全局统计一致(mean RGB 107/103/95 vs 110/103/94,std 66.8 vs 67.2)——不是坏图,但不是你验收表里的 max_abs_diff = 0。

      原因大概在格式:我们是打包 I8(qkv [21504,2688]、fc1 [28672,2688],头部没有 _quantization_metadata),你依赖的是 comfy_quant + codebook。打包 I8 按 K 对半切合不合法,得你判 —— 我只能给"快是真的"。

      四、彩蛋:sol_attn 比 int8 快,而且 1MP 单卡就够

      你 S1 表里 kitchen 只有 int8。但 attention.py 里还有 comfy_kitchen_sol(config 写 "attention": "comfy_kitchen_sol";节点下拉里没有,得自己 set_model_optimized_attention)。16k 上它是 int8 的 3.7×。

      搬进流水线(tau=1.0、seed 145、每档冷启动、其余开关不动、权重与上表相同):

      档 kitchen int8 sol s/it
      832×480·124f·8 单卡 10.53 / 108.2 s 8.09 / 87.2 s 1.30×
      832×480·124f·8 TP2 6.55 / 77.6 s 5.32 / 68.4 s 1.23×
      832×480·362f·8 单卡 50.78 / 455.6 s 28.96 / 280.5 s 1.75×
      1344×768·362f·2 单卡 250.58 / 596.8 s 105.00 / 312.5 s 2.39×
      1344×768·362f·2 TP2 132.40 / 367.6 s 60.47 / 226.3 s 2.19×

      三句话:

      1. 序列越长赢越多(1.2× → 2.4×),和你 S1 里 16k 那格的形态一致。
      2. 1MP 不用 TP2 了:单卡 sol 105.0 s/it,比 int8 双卡 132.4 还快,也接近你双卡的 112.3。代价是显存:0.4MP·362f 从 20.01 涨到 23.83(+3.8 GB),1MP 单卡仍装得下(23.83,没 OOM)。
      3. 输出约等于换一次 seed(30.5/255),是另一张同题图,不是坏图。

      五、想请你判两件事

      1. 打包 I8 按 K 对半切(qkv [21504,2688] → 每卡 [10752,2688])合不合法?如果不合法,我们那 1.91× 就只能当"能跑但别用"。
      2. sol 在你那套权重/环境上能不能也复现 2.4×?能的话,你 S4 的 112.3 大概还能再对半一次。

      代码我可以直接开 PR:split_state_dict 的后缀匹配 + 一个 18 行的 MiniMaxSOLAttention 节点(set_model_optimized_attention(partial(attention_comfy_kitchen_sol, tau=1.0))),要不要?

      xiongjie gaoX 6 3 条回复 最后回复
      2
      • E Enigma

        @xiongjie-gao 说:

        @terry 学文爷,把挨嘴把子当学费。
        疼,但不致命。平平安安活到八十。

        抄作业交卷:2×7900XTX 上把你的 3035 复现了一遍。单卡 6% 内对上,双卡要改你两行代码,另外顺手发现 sol 比 int8 还能再快一倍多。

        先认个错,我这台的数和你的不是一组:DiT 是 Minimax-h3_Singularity_ref2va_v2_Pruned_w4a8(12.55 GB,你的是 fl2va w4a8 11.7 GB)、TE 是 qwen3vl_32b_minimax_h3_nvfp4_awq(15.69 GB,你的 w4a8 是 26 GB)、LoRA 是 minimax_h3_dmd_ref2va_8step_turbo_pruned(你那个 turbo_v4_step600 在我们机器上是坏链接)、CPU 是 5950X 不是 E5-2696v4、两卡到 CPU 还是 x8。所以下面只比同档位的比值和你给的验收线。

        一、单卡:你的三档,我们都在 6% 内

        档 你的 我们
        832×480·124f·8 步 单卡 11.235 s/it 10.564(端到端 109.2 s)
        832×480·362f·8 步 单卡 53.7,显存 19.96 GB 50.78,20.01 GB
        1344×768·362f·2 步 单卡 257.9,显存 23.82 GB 251.90,23.84 GB

        (用的是你 kuzuryusen 仓库里那个 bench.py + run_tp.sh,只换了权重名和端口。)

        二、你 1050% 里最大的那层(F1),我们这台没有

        我们 venv 里是 torch 2.15.0+rocm7.14,/opt 里躺着 7.2.3 / 7.13.0 / 10.1 —— 按 F1 的说法这叫"看着就该坏"。但 S1 探针是健康的:

        路径 4096 8192 16384
        pytorch(SDPA) 13.2 85.3 1164.4
        kitchen int8 6.4 24.7 93.3
        kitchen sol 2.3 7.4 25.3
        basic(默认) 19.8 77.3 OOM(要 28.00 GiB)

        所以 F1 的正确用法是"用 S1 去证",不是看版本号猜 —— 这点你帖里已经写了,我只是补一个反例:版本不同源不等于内核坏。

        顺带一个建议:你那条 200 ms 的线,建议挪到 16384。 我们这台 SDPA 在 8192 只有 85 ms(过线),到 16384 是 1164 ms(×13.7,长度翻倍平方该 ×4)—— 8192 上是"假健康"。真实序列(1344×768·294f ≈ 30 万 token)比 16384 还远。

        三、双卡:p2p 只值 1%,真原因是 split_state_dict 取裸 key

        原样跑,三档全是负的:

        档 原样双卡 相对单卡 你的
        832×480·124f·8 11.95 s/it 0.88× 7.618(1.47×)
        832×480·362f·8 54.20 0.94× 31.9(1.68×)
        1344×768·362f·2 257.78 0.98× 112.3(2.30×)

        先按你的路子走了一遍 p2p:装 p2p_force、按你这台的真实 sysfs 拓扑生成 NCCL_TOPO_FILE(2e:00.0 → 2f:00.0/32:00.0)、重启后 isAllDirectP2p 1、通道 via P2P/IPC、你自己的 bootcheck 也 [OK] KFD 链路 2。只快 1%(11.99→11.95、54.20→53.59)。传输不是瓶颈。

        真原因在 comfyui-tp2/__init__.py 的 split_state_dict() 开头:

        qkv = sd.get("blocks.0.attn.qkv_proj.weight")     # 取不到 → return sd,静默、不切
        hd  = sd.get("blocks.0.attn.q_norm.weight")
        if qkv is None or hd is None:
            return sd
        

        我们这个 w4a8 检查点 1333 个 key 里 1332 个带 model.diffusion_model. 前缀,裸 key 0 个 → 每次都静默 return。于是两卡各算整个模型,每步 450 次 all_reduce / 15.1 GB;10.564 + 1.4 ≈ 11.95,一分不差。

        把取 key 改成允许 "" / model.diffusion_model. / diffusion_model. 三种前缀(就那两行),立刻听到:

        [tp2] rank0 state_dict split: heads 56->28, keys 1332
        
        档 切了之后 相对单卡 每卡显存
        832×480·124f·8 6.539 s/it,端到端 79.2 s 1.61× 23.74 GB
        1344×768·362f·2 131.66 s/it,端到端 370.4 s 1.91× 17.60 GB(−6.2)

        LoRA 那 208 个 shape 错也一起没了(模型切了,切过的 LoRA 就对上了)。

        但有个必须说清的:切了不等于单卡那一张。整帧 mean|Δ| 16.5/255(结构 14.7);参照是换 seed 重采 34.1、没切 54.8、同配置两次 0.00。全局统计一致(mean RGB 107/103/95 vs 110/103/94,std 66.8 vs 67.2)——不是坏图,但不是你验收表里的 max_abs_diff = 0。

        原因大概在格式:我们是打包 I8(qkv [21504,2688]、fc1 [28672,2688],头部没有 _quantization_metadata),你依赖的是 comfy_quant + codebook。打包 I8 按 K 对半切合不合法,得你判 —— 我只能给"快是真的"。

        四、彩蛋:sol_attn 比 int8 快,而且 1MP 单卡就够

        你 S1 表里 kitchen 只有 int8。但 attention.py 里还有 comfy_kitchen_sol(config 写 "attention": "comfy_kitchen_sol";节点下拉里没有,得自己 set_model_optimized_attention)。16k 上它是 int8 的 3.7×。

        搬进流水线(tau=1.0、seed 145、每档冷启动、其余开关不动、权重与上表相同):

        档 kitchen int8 sol s/it
        832×480·124f·8 单卡 10.53 / 108.2 s 8.09 / 87.2 s 1.30×
        832×480·124f·8 TP2 6.55 / 77.6 s 5.32 / 68.4 s 1.23×
        832×480·362f·8 单卡 50.78 / 455.6 s 28.96 / 280.5 s 1.75×
        1344×768·362f·2 单卡 250.58 / 596.8 s 105.00 / 312.5 s 2.39×
        1344×768·362f·2 TP2 132.40 / 367.6 s 60.47 / 226.3 s 2.19×

        三句话:

        1. 序列越长赢越多(1.2× → 2.4×),和你 S1 里 16k 那格的形态一致。
        2. 1MP 不用 TP2 了:单卡 sol 105.0 s/it,比 int8 双卡 132.4 还快,也接近你双卡的 112.3。代价是显存:0.4MP·362f 从 20.01 涨到 23.83(+3.8 GB),1MP 单卡仍装得下(23.83,没 OOM)。
        3. 输出约等于换一次 seed(30.5/255),是另一张同题图,不是坏图。

        五、想请你判两件事

        1. 打包 I8 按 K 对半切(qkv [21504,2688] → 每卡 [10752,2688])合不合法?如果不合法,我们那 1.91× 就只能当"能跑但别用"。
        2. sol 在你那套权重/环境上能不能也复现 2.4×?能的话,你 S4 的 112.3 大概还能再对半一次。

        代码我可以直接开 PR:split_state_dict 的后缀匹配 + 一个 18 行的 MiniMaxSOLAttention 节点(set_model_optimized_attention(partial(attention_comfy_kitchen_sol, tau=1.0))),要不要?

        xiongjie gaoX
        xiongjie gaoX
        xiongjie gao
        王侯将相
        编写于 最后由 编辑
        #51

        @Enigma 也就是你自己还把int8r换成了sol
        生成速度提升 1.99× / 4.17× (per-step)
        端到端 1.60–2.64×

        https://github.com/shawn86574-prog/x99-7900xtx-p2p
        https://github.com/shawn86574-prog/kuzuryusen

        1 条回复 最后回复
        1
        • E Enigma

          @xiongjie-gao 说:

          @terry 学文爷,把挨嘴把子当学费。
          疼,但不致命。平平安安活到八十。

          抄作业交卷:2×7900XTX 上把你的 3035 复现了一遍。单卡 6% 内对上,双卡要改你两行代码,另外顺手发现 sol 比 int8 还能再快一倍多。

          先认个错,我这台的数和你的不是一组:DiT 是 Minimax-h3_Singularity_ref2va_v2_Pruned_w4a8(12.55 GB,你的是 fl2va w4a8 11.7 GB)、TE 是 qwen3vl_32b_minimax_h3_nvfp4_awq(15.69 GB,你的 w4a8 是 26 GB)、LoRA 是 minimax_h3_dmd_ref2va_8step_turbo_pruned(你那个 turbo_v4_step600 在我们机器上是坏链接)、CPU 是 5950X 不是 E5-2696v4、两卡到 CPU 还是 x8。所以下面只比同档位的比值和你给的验收线。

          一、单卡:你的三档,我们都在 6% 内

          档 你的 我们
          832×480·124f·8 步 单卡 11.235 s/it 10.564(端到端 109.2 s)
          832×480·362f·8 步 单卡 53.7,显存 19.96 GB 50.78,20.01 GB
          1344×768·362f·2 步 单卡 257.9,显存 23.82 GB 251.90,23.84 GB

          (用的是你 kuzuryusen 仓库里那个 bench.py + run_tp.sh,只换了权重名和端口。)

          二、你 1050% 里最大的那层(F1),我们这台没有

          我们 venv 里是 torch 2.15.0+rocm7.14,/opt 里躺着 7.2.3 / 7.13.0 / 10.1 —— 按 F1 的说法这叫"看着就该坏"。但 S1 探针是健康的:

          路径 4096 8192 16384
          pytorch(SDPA) 13.2 85.3 1164.4
          kitchen int8 6.4 24.7 93.3
          kitchen sol 2.3 7.4 25.3
          basic(默认) 19.8 77.3 OOM(要 28.00 GiB)

          所以 F1 的正确用法是"用 S1 去证",不是看版本号猜 —— 这点你帖里已经写了,我只是补一个反例:版本不同源不等于内核坏。

          顺带一个建议:你那条 200 ms 的线,建议挪到 16384。 我们这台 SDPA 在 8192 只有 85 ms(过线),到 16384 是 1164 ms(×13.7,长度翻倍平方该 ×4)—— 8192 上是"假健康"。真实序列(1344×768·294f ≈ 30 万 token)比 16384 还远。

          三、双卡:p2p 只值 1%,真原因是 split_state_dict 取裸 key

          原样跑,三档全是负的:

          档 原样双卡 相对单卡 你的
          832×480·124f·8 11.95 s/it 0.88× 7.618(1.47×)
          832×480·362f·8 54.20 0.94× 31.9(1.68×)
          1344×768·362f·2 257.78 0.98× 112.3(2.30×)

          先按你的路子走了一遍 p2p:装 p2p_force、按你这台的真实 sysfs 拓扑生成 NCCL_TOPO_FILE(2e:00.0 → 2f:00.0/32:00.0)、重启后 isAllDirectP2p 1、通道 via P2P/IPC、你自己的 bootcheck 也 [OK] KFD 链路 2。只快 1%(11.99→11.95、54.20→53.59)。传输不是瓶颈。

          真原因在 comfyui-tp2/__init__.py 的 split_state_dict() 开头:

          qkv = sd.get("blocks.0.attn.qkv_proj.weight")     # 取不到 → return sd,静默、不切
          hd  = sd.get("blocks.0.attn.q_norm.weight")
          if qkv is None or hd is None:
              return sd
          

          我们这个 w4a8 检查点 1333 个 key 里 1332 个带 model.diffusion_model. 前缀,裸 key 0 个 → 每次都静默 return。于是两卡各算整个模型,每步 450 次 all_reduce / 15.1 GB;10.564 + 1.4 ≈ 11.95,一分不差。

          把取 key 改成允许 "" / model.diffusion_model. / diffusion_model. 三种前缀(就那两行),立刻听到:

          [tp2] rank0 state_dict split: heads 56->28, keys 1332
          
          档 切了之后 相对单卡 每卡显存
          832×480·124f·8 6.539 s/it,端到端 79.2 s 1.61× 23.74 GB
          1344×768·362f·2 131.66 s/it,端到端 370.4 s 1.91× 17.60 GB(−6.2)

          LoRA 那 208 个 shape 错也一起没了(模型切了,切过的 LoRA 就对上了)。

          但有个必须说清的:切了不等于单卡那一张。整帧 mean|Δ| 16.5/255(结构 14.7);参照是换 seed 重采 34.1、没切 54.8、同配置两次 0.00。全局统计一致(mean RGB 107/103/95 vs 110/103/94,std 66.8 vs 67.2)——不是坏图,但不是你验收表里的 max_abs_diff = 0。

          原因大概在格式:我们是打包 I8(qkv [21504,2688]、fc1 [28672,2688],头部没有 _quantization_metadata),你依赖的是 comfy_quant + codebook。打包 I8 按 K 对半切合不合法,得你判 —— 我只能给"快是真的"。

          四、彩蛋:sol_attn 比 int8 快,而且 1MP 单卡就够

          你 S1 表里 kitchen 只有 int8。但 attention.py 里还有 comfy_kitchen_sol(config 写 "attention": "comfy_kitchen_sol";节点下拉里没有,得自己 set_model_optimized_attention)。16k 上它是 int8 的 3.7×。

          搬进流水线(tau=1.0、seed 145、每档冷启动、其余开关不动、权重与上表相同):

          档 kitchen int8 sol s/it
          832×480·124f·8 单卡 10.53 / 108.2 s 8.09 / 87.2 s 1.30×
          832×480·124f·8 TP2 6.55 / 77.6 s 5.32 / 68.4 s 1.23×
          832×480·362f·8 单卡 50.78 / 455.6 s 28.96 / 280.5 s 1.75×
          1344×768·362f·2 单卡 250.58 / 596.8 s 105.00 / 312.5 s 2.39×
          1344×768·362f·2 TP2 132.40 / 367.6 s 60.47 / 226.3 s 2.19×

          三句话:

          1. 序列越长赢越多(1.2× → 2.4×),和你 S1 里 16k 那格的形态一致。
          2. 1MP 不用 TP2 了:单卡 sol 105.0 s/it,比 int8 双卡 132.4 还快,也接近你双卡的 112.3。代价是显存:0.4MP·362f 从 20.01 涨到 23.83(+3.8 GB),1MP 单卡仍装得下(23.83,没 OOM)。
          3. 输出约等于换一次 seed(30.5/255),是另一张同题图,不是坏图。

          五、想请你判两件事

          1. 打包 I8 按 K 对半切(qkv [21504,2688] → 每卡 [10752,2688])合不合法?如果不合法,我们那 1.91× 就只能当"能跑但别用"。
          2. sol 在你那套权重/环境上能不能也复现 2.4×?能的话,你 S4 的 112.3 大概还能再对半一次。

          代码我可以直接开 PR:split_state_dict 的后缀匹配 + 一个 18 行的 MiniMaxSOLAttention 节点(set_model_optimized_attention(partial(attention_comfy_kitchen_sol, tau=1.0))),要不要?

          xiongjie gaoX
          xiongjie gaoX
          xiongjie gao
          王侯将相
          编写于 最后由 编辑
          #52

          @Enigma 你的报告把这项目又推到了更夸张的提升。

          结论先给

          指标 数值 含义
          SOL 单次注意力 vs kitchen int8 3.5–4.1× 本机 microbench,S=15k/23k/38.5k
          SOL 端到端折算 1.5–2.0× 0.4 MP 1.54×,1 MP ~2.0×(按注意力占比)
          卡间实测带宽 5.00 GB/s 本机 Gen3 x8 是瓶颈(理论上限 7.88,效率 63%)
          换 x16 板后 10.30 GB/s X99-T8 类,同 CPU 同 root port,只差 lane 数
          TP2 每步通信暴露 4.0 s/it 32.7 − 57.4/2,占 TP2 单步 12.2%
          并表后总加速 10.5 → 11.9 → 12.5× +SOL → 再加 P2P;单条 3.3 → 2.90 → 2.76 min

          一句话:真正的大头是 SOL 注意力,不是卡间带宽。SOL 把单次注意力压到 1/3.5–1/4.1,端到端(外部同构实测 1.23×)就能把总账从 10.5× 推到 11.9×;P2P 只值 6–12%,且要换主板。

          https://github.com/shawn86574-prog/x99-7900xtx-p2p
          https://github.com/shawn86574-prog/kuzuryusen

          E 1 条回复 最后回复
          1
          • xiongjie gaoX xiongjie gao

            @Enigma 你的报告把这项目又推到了更夸张的提升。

            结论先给

            指标 数值 含义
            SOL 单次注意力 vs kitchen int8 3.5–4.1× 本机 microbench,S=15k/23k/38.5k
            SOL 端到端折算 1.5–2.0× 0.4 MP 1.54×,1 MP ~2.0×(按注意力占比)
            卡间实测带宽 5.00 GB/s 本机 Gen3 x8 是瓶颈(理论上限 7.88,效率 63%)
            换 x16 板后 10.30 GB/s X99-T8 类,同 CPU 同 root port,只差 lane 数
            TP2 每步通信暴露 4.0 s/it 32.7 − 57.4/2,占 TP2 单步 12.2%
            并表后总加速 10.5 → 11.9 → 12.5× +SOL → 再加 P2P;单条 3.3 → 2.90 → 2.76 min

            一句话:真正的大头是 SOL 注意力,不是卡间带宽。SOL 把单次注意力压到 1/3.5–1/4.1,端到端(外部同构实测 1.23×)就能把总账从 10.5× 推到 11.9×;P2P 只值 6–12%,且要换主板。

            E
            E
            Enigma
            硕果累累 贵族大夫
            编写于 最后由 编辑
            #53

            @xiongjie-gao 说:

            @Enigma 你的报告把这项目又推到了更夸张的提升。

            结论先给

            指标 数值 含义
            SOL 单次注意力 vs kitchen int8 3.5–4.1× 本机 microbench,S=15k/23k/38.5k
            SOL 端到端折算 1.5–2.0× 0.4 MP 1.54×,1 MP ~2.0×(按注意力占比)
            卡间实测带宽 5.00 GB/s 本机 Gen3 x8 是瓶颈(理论上限 7.88,效率 63%)
            换 x16 板后 10.30 GB/s X99-T8 类,同 CPU 同 root port,只差 lane 数
            TP2 每步通信暴露 4.0 s/it 32.7 − 57.4/2,占 TP2 单步 12.2%
            并表后总加速 10.5 → 11.9 → 12.5× +SOL → 再加 P2P;单条 3.3 → 2.90 → 2.76 min

            一句话:真正的大头是 SOL 注意力,不是卡间带宽。SOL 把单次注意力压到 1/3.5–1/4.1,端到端(外部同构实测 1.23×)就能把总账从 10.5× 推到 11.9×;P2P 只值 6–12%,且要换主板。

            👍 👍 👍

            1 条回复 最后回复
            0
            • E Enigma

              @xiongjie-gao 说:

              @terry 学文爷,把挨嘴把子当学费。
              疼,但不致命。平平安安活到八十。

              抄作业交卷:2×7900XTX 上把你的 3035 复现了一遍。单卡 6% 内对上,双卡要改你两行代码,另外顺手发现 sol 比 int8 还能再快一倍多。

              先认个错,我这台的数和你的不是一组:DiT 是 Minimax-h3_Singularity_ref2va_v2_Pruned_w4a8(12.55 GB,你的是 fl2va w4a8 11.7 GB)、TE 是 qwen3vl_32b_minimax_h3_nvfp4_awq(15.69 GB,你的 w4a8 是 26 GB)、LoRA 是 minimax_h3_dmd_ref2va_8step_turbo_pruned(你那个 turbo_v4_step600 在我们机器上是坏链接)、CPU 是 5950X 不是 E5-2696v4、两卡到 CPU 还是 x8。所以下面只比同档位的比值和你给的验收线。

              一、单卡:你的三档,我们都在 6% 内

              档 你的 我们
              832×480·124f·8 步 单卡 11.235 s/it 10.564(端到端 109.2 s)
              832×480·362f·8 步 单卡 53.7,显存 19.96 GB 50.78,20.01 GB
              1344×768·362f·2 步 单卡 257.9,显存 23.82 GB 251.90,23.84 GB

              (用的是你 kuzuryusen 仓库里那个 bench.py + run_tp.sh,只换了权重名和端口。)

              二、你 1050% 里最大的那层(F1),我们这台没有

              我们 venv 里是 torch 2.15.0+rocm7.14,/opt 里躺着 7.2.3 / 7.13.0 / 10.1 —— 按 F1 的说法这叫"看着就该坏"。但 S1 探针是健康的:

              路径 4096 8192 16384
              pytorch(SDPA) 13.2 85.3 1164.4
              kitchen int8 6.4 24.7 93.3
              kitchen sol 2.3 7.4 25.3
              basic(默认) 19.8 77.3 OOM(要 28.00 GiB)

              所以 F1 的正确用法是"用 S1 去证",不是看版本号猜 —— 这点你帖里已经写了,我只是补一个反例:版本不同源不等于内核坏。

              顺带一个建议:你那条 200 ms 的线,建议挪到 16384。 我们这台 SDPA 在 8192 只有 85 ms(过线),到 16384 是 1164 ms(×13.7,长度翻倍平方该 ×4)—— 8192 上是"假健康"。真实序列(1344×768·294f ≈ 30 万 token)比 16384 还远。

              三、双卡:p2p 只值 1%,真原因是 split_state_dict 取裸 key

              原样跑,三档全是负的:

              档 原样双卡 相对单卡 你的
              832×480·124f·8 11.95 s/it 0.88× 7.618(1.47×)
              832×480·362f·8 54.20 0.94× 31.9(1.68×)
              1344×768·362f·2 257.78 0.98× 112.3(2.30×)

              先按你的路子走了一遍 p2p:装 p2p_force、按你这台的真实 sysfs 拓扑生成 NCCL_TOPO_FILE(2e:00.0 → 2f:00.0/32:00.0)、重启后 isAllDirectP2p 1、通道 via P2P/IPC、你自己的 bootcheck 也 [OK] KFD 链路 2。只快 1%(11.99→11.95、54.20→53.59)。传输不是瓶颈。

              真原因在 comfyui-tp2/__init__.py 的 split_state_dict() 开头:

              qkv = sd.get("blocks.0.attn.qkv_proj.weight")     # 取不到 → return sd,静默、不切
              hd  = sd.get("blocks.0.attn.q_norm.weight")
              if qkv is None or hd is None:
                  return sd
              

              我们这个 w4a8 检查点 1333 个 key 里 1332 个带 model.diffusion_model. 前缀,裸 key 0 个 → 每次都静默 return。于是两卡各算整个模型,每步 450 次 all_reduce / 15.1 GB;10.564 + 1.4 ≈ 11.95,一分不差。

              把取 key 改成允许 "" / model.diffusion_model. / diffusion_model. 三种前缀(就那两行),立刻听到:

              [tp2] rank0 state_dict split: heads 56->28, keys 1332
              
              档 切了之后 相对单卡 每卡显存
              832×480·124f·8 6.539 s/it,端到端 79.2 s 1.61× 23.74 GB
              1344×768·362f·2 131.66 s/it,端到端 370.4 s 1.91× 17.60 GB(−6.2)

              LoRA 那 208 个 shape 错也一起没了(模型切了,切过的 LoRA 就对上了)。

              但有个必须说清的:切了不等于单卡那一张。整帧 mean|Δ| 16.5/255(结构 14.7);参照是换 seed 重采 34.1、没切 54.8、同配置两次 0.00。全局统计一致(mean RGB 107/103/95 vs 110/103/94,std 66.8 vs 67.2)——不是坏图,但不是你验收表里的 max_abs_diff = 0。

              原因大概在格式:我们是打包 I8(qkv [21504,2688]、fc1 [28672,2688],头部没有 _quantization_metadata),你依赖的是 comfy_quant + codebook。打包 I8 按 K 对半切合不合法,得你判 —— 我只能给"快是真的"。

              四、彩蛋:sol_attn 比 int8 快,而且 1MP 单卡就够

              你 S1 表里 kitchen 只有 int8。但 attention.py 里还有 comfy_kitchen_sol(config 写 "attention": "comfy_kitchen_sol";节点下拉里没有,得自己 set_model_optimized_attention)。16k 上它是 int8 的 3.7×。

              搬进流水线(tau=1.0、seed 145、每档冷启动、其余开关不动、权重与上表相同):

              档 kitchen int8 sol s/it
              832×480·124f·8 单卡 10.53 / 108.2 s 8.09 / 87.2 s 1.30×
              832×480·124f·8 TP2 6.55 / 77.6 s 5.32 / 68.4 s 1.23×
              832×480·362f·8 单卡 50.78 / 455.6 s 28.96 / 280.5 s 1.75×
              1344×768·362f·2 单卡 250.58 / 596.8 s 105.00 / 312.5 s 2.39×
              1344×768·362f·2 TP2 132.40 / 367.6 s 60.47 / 226.3 s 2.19×

              三句话:

              1. 序列越长赢越多(1.2× → 2.4×),和你 S1 里 16k 那格的形态一致。
              2. 1MP 不用 TP2 了:单卡 sol 105.0 s/it,比 int8 双卡 132.4 还快,也接近你双卡的 112.3。代价是显存:0.4MP·362f 从 20.01 涨到 23.83(+3.8 GB),1MP 单卡仍装得下(23.83,没 OOM)。
              3. 输出约等于换一次 seed(30.5/255),是另一张同题图,不是坏图。

              五、想请你判两件事

              1. 打包 I8 按 K 对半切(qkv [21504,2688] → 每卡 [10752,2688])合不合法?如果不合法,我们那 1.91× 就只能当"能跑但别用"。
              2. sol 在你那套权重/环境上能不能也复现 2.4×?能的话,你 S4 的 112.3 大概还能再对半一次。

              代码我可以直接开 PR:split_state_dict 的后缀匹配 + 一个 18 行的 MiniMaxSOLAttention 节点(set_model_optimized_attention(partial(attention_comfy_kitchen_sol, tau=1.0))),要不要?

              6
              6
              6cccccc
              编写于 最后由 编辑
              #54

              @Enigma 我让hy4 flash查看了一下,说sol_attn虽然更快,但是精度上要比int8差,不知道实际出片的时候是什么样的

              xiongjie gaoX E 2 条回复 最后回复
              0
              • 6 6cccccc

                @Enigma 我让hy4 flash查看了一下,说sol_attn虽然更快,但是精度上要比int8差,不知道实际出片的时候是什么样的

                xiongjie gaoX
                xiongjie gaoX
                xiongjie gao
                王侯将相
                编写于 最后由 编辑
                #55

                @6cccccc 昨天跑了样片,因为太晚了没时间整理
                今晚整理出来
                从我观感看来,这个损失可以接受,几乎看不出画面质量的区别。

                https://github.com/shawn86574-prog/x99-7900xtx-p2p
                https://github.com/shawn86574-prog/kuzuryusen

                6 1 条回复 最后回复
                0
                • xiongjie gaoX xiongjie gao

                  @6cccccc 昨天跑了样片,因为太晚了没时间整理
                  今晚整理出来
                  从我观感看来,这个损失可以接受,几乎看不出画面质量的区别。

                  6
                  6
                  6cccccc
                  编写于 最后由 编辑
                  #56

                  @xiongjie-gao 行,我一会也试试

                  1 条回复 最后回复
                  0
                  • 6 6cccccc

                    @Enigma 我让hy4 flash查看了一下,说sol_attn虽然更快,但是精度上要比int8差,不知道实际出片的时候是什么样的

                    E
                    E
                    Enigma
                    硕果累累 贵族大夫
                    编写于 最后由 编辑
                    #57

                    @6cccccc 说:

                    @Enigma 我让hy4 flash查看了一下,说sol_attn虽然更快,但是精度上要比int8差,不知道实际出片的时候是什么样的

                    两张样片 + 一张左右对照(左 = kitchen int8,右 = sol)
                    side_int8_sol.png

                    感觉SOL更好,有没有?

                    6 1 条回复 最后回复
                    0
                    • E Enigma

                      @6cccccc 说:

                      @Enigma 我让hy4 flash查看了一下,说sol_attn虽然更快,但是精度上要比int8差,不知道实际出片的时候是什么样的

                      两张样片 + 一张左右对照(左 = kitchen int8,右 = sol)
                      side_int8_sol.png

                      感觉SOL更好,有没有?

                      6
                      6
                      6cccccc
                      编写于 最后由 编辑
                      #58

                      @Enigma 我还传不了图,我用h3感觉没啥问题,目测的话。moss我刚刚试用了一下,sol这个用同样种子出的图跟int8的比较来说根本看不了。不知道哪里出问题了

                      E 1 条回复 最后回复
                      0
                      • 6 6cccccc

                        @Enigma 我还传不了图,我用h3感觉没啥问题,目测的话。moss我刚刚试用了一下,sol这个用同样种子出的图跟int8的比较来说根本看不了。不知道哪里出问题了

                        E
                        E
                        Enigma
                        硕果累累 贵族大夫
                        编写于 最后由 编辑
                        #59

                        @6cccccc 说:

                        @Enigma 我还传不了图,我用h3感觉没啥问题,目测的话。moss我刚刚试用了一下,sol这个用同样种子出的图跟int8的比较来说根本看不了。不知道哪里出问题了

                        我传了视频,你可以去看看 https://lcz.me/topic/3189

                        1 条回复 最后回复
                        0

                        你好!看起来您对这段对话很感兴趣,但您还没有一个账号。

                        厌倦了每次访问都刷到同样的帖子?您注册账号后,您下次访问时都将自动回到上次浏览的位置,并可选择接收新回复的通知(通过电子邮件或推送通知)。您还可以收藏帖子、为帖子点赞,以此向其他社区成员表达您的感谢。

                        有了你的建议,这篇帖子会更精彩哦 💗

                        注册 登录
                        回复
                        • 在新帖中回复
                        登录后回复
                        • 从旧到新
                        • 从新到旧
                        • 最多赞同


                        • 登录

                        • 登录或注册以进行搜索。
                        • 第一个帖子
                          最后一个帖子
                        0
                        • 版块
                        • 最新
                        • 标签
                        • 热门
                        • 用户
                        • 群组