BREAK LAYER / 研究阅读室

NEW SNAPSHOT / 新榜前15名

前15名方案对比:
硬件配置、软件优化与得分

先沿曲线看15套成品,再点一个方案:它把数据留在哪里、怎样分工、两类任务各快多少。你的50,416分方案是默认参照,编号为09。

抓取时间(UTC):2026-09-29T05:10:09.736515+00:00 · v0.7 · 13份服务器验证 / 2份仅本地报告

两道题先分清。 P1一次处理整段输入,许多位置复用同一份权重;D1连续生成8个新位置,输入逐步释放,但权重可以跨步骤保留。它们共用一套硬件,必须算对,并通过面积和1000周期窗口功率门槛。这里的耗时与功率来自教学模拟器。

怎样读“提升”。 分数与两项耗时乘积的平方根成反比。下面可以准确算出分差分别对应哪项耗时变化;某个硬件或软件技巧独立贡献多少,需要同条件实验。第三张图提供一条有报告的真实更新路径。

01 / 先看整体,再选两套

15个点,15种成品组合

横轴按榜单分数从低到高排列,编号保持抓取时名次;连线帮助阅读,不表示同一方案随时间升级。实心点=服务器验证,空心菱形=仅本地报告。

值得一看的对照:
分数公式,以及“分差拆分”怎样计算

分数 S = 1000 × √(30,996,995 × 1,302,032 ÷ [P1周期 × D1周期])。相对于参照方案,P1的分数倍率为a = √(参照P1 ÷ 当前P1),D1的倍率为b = √(参照D1 ÷ 当前D1),两者相乘即总分倍率。

为把分差加起来看,取两种替换顺序的平均:P1对应分差 = 参照分数 × (a−1) × (1+b) / 2;D1同理。这两项之和精确等于总分差。它是评分公式的对称分摊,不能解释成某项代码改动的因果收益。

02 / 相同分数,可以有不同的快法

整段输入快,还是逐步生成快?

只画13份服务器验证成品。横轴是P1周期,纵轴是D1周期;越靠左下越快。灰色曲线连接理论上分数相同的耗时组合。点旁编号可点击,颜色与上图选择同步。

同一条等分曲线上:一题变慢,另一题必须相应变快,才能维持总分。曲线是评分公式,不是实测搜索轨迹。

03 / 差别落在哪些地方

把硬件选择、分块和搬运放在一张表里

SM是计算单元;矩阵阵列的“×K”表示沿求和方向的硬件并行度;RF是工作组的小存储,SH是共享暂存。软件分块的三个数依次为输出行、输出列、每轮求和项数。MB按百万字节计算。点击列头联动曲线。

除方案14外,其余14份程序都只在D1首步加载两层权重和原始历史。这是共同起点,无法单独解释它们之间的分差。指令与工作组数量也不直接等于速度。

04 / 有证据的提升路径

同一套硬件,方案02怎样继续涨分

这条线才表示同一个方案的先后更新。保存的四个完整评分摘要及对应计划显示硬件配置相同,最终点与本次服务器成绩一致。历史大报告未随ZIP附带,这条线依据摘要重建。点选阶段,查看它当时改了什么、哪类任务缩短了。

阶段之间可能合并多项优化;未保存全因素对照,不能将每一段涨分全部归给标签中的单个技巧。初始点是所选过程片段的起点。

05 / 从任何一份开始读

每套程序具体做了什么

每份都从任务背景开始,分别说明硬件、数据流、收益与代价;有记录的补充“发现 → 尝试 → 结果 → 下一步”。没有过程记录的只分析成品,不替作者补写思考过程。方案编号只对应本次快照,不能与旧版编号直接互换。

冻结榜单与最终报告;无JavaScript时仍可阅读
方案分数来源P1周期D1周期主要区别
方案0186,665.62服务器验证210,39925,539把中间结果留在计算组内,减少接力搬运
方案0280,098.00服务器验证237,09826,532谁先产出数据,后面的任务就先消费那一块
方案0380,076.53服务器验证252,27724,94916列分块、64项累加,整段与逐步生成分开组织
方案0475,413.74服务器验证273,19225,976按不同矩阵形状选择分块,并填满小存储的空隙
方案0575,084.45服务器验证260,34927,497较少的整段输入任务,配合更细的生成分块
方案0658,212.03服务器验证301,64439,48416个计算任务加控制组,优先保持较长求和块
方案0755,979.05服务器验证335,94838,337同一套机器,换了一种两类任务之间的取舍
方案0852,508.66服务器验证352,30541,54924个较轻计算单元,把历史拆成更多份
方案0950,416.65服务器验证337,47647,049你的五万分方案:二维复用、融合与精细装载
方案1047,957.06服务器验证403,19743,523让任务持有输出块,同时用计算覆盖加载
方案1145,492.34服务器验证585,22233,323小矩阵阵列与较大共享暂存,偏向生成任务
方案1241,351.14服务器验证438,47253,830保留4 MiB缓存,用缓存与分工共同控制流量
方案1340,076.35仅本地报告467,62753,7361 MiB缓存与历史分片,当前只有本地成绩
方案1436,020.89仅本地报告15,583,7481,996报告中的短生成耗时,不可当作通用优化
方案1533,894.64服务器验证569,94261,63820个计算单元加共享暂存,整段输入读流量较大

方案01 · 服务器验证

把中间结果留在计算组内,减少接力搬运

一段计算中,哪些中间结果可以留在原地,哪些小运算可以交给矩阵硬件批量完成?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 210,399 周期生成 D1 25,539 周期得分 86,665.62

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

把统计也当成可以批量处理的计算

模型在矩阵投影前要对输入做归一化:先求均值和方差,再调整各元素的尺度。方案01把一批输入排成矩阵,与全1向量相乘来求和;平方后的输入也可用同样方式求平方和。这里的矩阵阵列既做通常的乘法,也承担统计。好处是把许多零碎操作合在一起,代价是统计与主计算会共享矩阵和寄存器资源。

整段输入程序常见的分块是16行×32列、每轮累加32项,以及16行×16列、每轮累加64项。“分块”描述一次软件指令处理的数据,不是芯片上阵列的物理尺寸。整段程序包含80次工作组创建,不能把它读成80组同时驻留。

前馈中间结果为什么不用完整写到外存

前馈网络可以理解成三步:W1矩阵把向量变宽,GELU激活函数逐元素变换,W2矩阵再把它压回原宽度。生成程序把中间的512个通道分给16个任务,每个任务持有32个通道对应的W1列和W2行。它算完这32个值、做完激活,立即在寄存器小存储里接着乘W2。

每个任务得到的是128维输出的一份部分和,16份相加才是完整结果。这省掉了把完整中间向量写出再读回的路径,但仍有部分和传输与汇总。因而“融合”在这里有具体含义,不能理解成所有通信都消失。

注意力还需要另一种分工

注意力用当前输入的查询向量Q,与历史位置的键K比较,再按比较结果汇总值V。该方案把每一路历史注意力分成四片,各片计算局部统计和加权结果,最后重新缩放并合并。两层权重与原始历史仅首步加载,后续步骤继续复用;每一步的新输入仍需读取。

程序还存在按事件控制加载时刻的安排,说明“何时搬数据”也是成品结构的一部分。没有附带搜索记录,不能补写作者怎样选择事件间隔或怎样逐次获得这些改进。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

可迁移的观察角度是重新划定数据交接边界:中间结果的生产者能否直接完成下一步?同时检查新增的部分和汇总成本。静态结构说明这种机会存在,独立收益仍需对照实验。

证据能说到哪里:结构沿用旧快照的同一份程序,可核对汇编;本次提交没有搜索过程,不能补写作者怎样想到它。

核对硬件、指令与来源指纹

旧版最终构造分析:final-solutions.html 中方案一;与本快照对应同一份程序。

最终汇编中归一化统计、四片注意力与32通道前馈部分和路径。

面积 23.282 mm²;P1 / D1 峰值 19.218 / 19.289 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 0, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 64, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

b3a9c6a5b865c90240ad70add4cf443f413ae67d30d3d04f324bfc172106d69a

矩阵指令 22,848 条;加载指令 13,858 条;工作组生命周期 80 个。

{
  "line": 91,
  "args": {
    "a": {
      "space": "RF",
      "offset": 640,
      "count": 32,
      "wg": "w0",
      "lane": 15
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "w0",
      "lane": 10,
      "shape": [
        32,
        32
      ],
      "strides": [
        1,
        32
      ]
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 32,
      "wg": "w0",
      "lane": 15
    },
    "m": 1,
    "n": 32,
    "k": 32,
    "event": "w0m75_0"
  }
}

M2_D1 · SHA256

64290db4628b0f2024cef4db9d25f55810306d4f8b45562a92bfbee8297a33d2

矩阵指令 6,656 条;加载指令 2,840 条;工作组生命周期 62 个。

{
  "line": 752,
  "args": {
    "a": {
      "space": "RF",
      "offset": 944,
      "count": 16,
      "wg": "f0_0",
      "lane": 15
    },
    "b": {
      "space": "RF",
      "offset": 928,
      "count": 32,
      "wg": "f0_0",
      "lane": 15,
      "shape": [
        16,
        2
      ],
      "strides": [
        1,
        16
      ]
    },
    "acc": {
      "space": "RF",
      "offset": 176,
      "count": 2,
      "wg": "f0_0",
      "lane": 14
    },
    "m": 1,
    "n": 2,
    "k": 16,
    "event": "f0_0m690"
  }
}

报告SHA256 071af5ed4dfe2c176fd202b45006f16ae8e90e619b1c15ea7175d825c8a1196a
提交ID TRF-6A0A6DAACD214831

方案02 · 服务器验证

谁先产出数据,后面的任务就先消费那一块

一个后续任务真的要等整个前阶段结束,还是需要的那一小块数据已经就绪?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 237,098 周期生成 D1 26,532 周期得分 80,098.00

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

从整阶段等待改成逐块交接

方案02把“生产者算完哪些列”和“消费者需要哪些列”对应起来。投影产生一部分输出后,下一道投影只等待自己要读的那部分;不必让所有任务先到达一个共同屏障。屏障就是要求一批任务全部到齐后才继续的同步点。

这要求同时维护真实依赖:数据必须算完并可见,缓冲不能被提前覆盖,未来步骤的输入也不能提前读取。最终程序的生成部分有49个工作组生命周期;它的关键差别在这些组怎样交接,单看组数无法解释速度。

硬件变化必须落实到数据排布

该方案有32条向量通道。随包记录说明,增加通道后寄存器的物理分区变小,原来的大操作数需要重新排布或拆成更细指令。最终整段输入最常见的是16行×16列、每轮32项的指令,不能直接把生成器里的名义大块当成实际执行块。

生成阶段还把只由固定归一化参数和权重决定的计算保留下来供后续步骤复用。第一步把真实输入与两份常量投影合批处理,因此会出现3行矩阵指令;新输入相关的均值、方差和投影仍须逐步计算。

删掉最后一段多余搬运

最终输出若先进入临时区,再由控制任务逐行复制到规定地址,会额外经过一次写、读、写。记录中的更新让最后一层直接写最终输出,并同步处理批次步长和提交时刻。另一些更新把归一化参数接入已有加载流,减少单独准备与等待。

这些改动共同把数据到达时间提前。它们也可能使活动更加集中,因此整段输入的写回又按任务组分批发出。快与合法需要一起检查,不能只看某个阶段缩短。

记录中的判断怎样改变

  1. 记录先暴露了物理分区与名义布局的不匹配。agent调整寄存器排布、拆分指令,并用生成结果与完整评估确认变换有效。
  2. 随后围绕数据就绪时刻改调度:查询先生成,历史注意力先工作;已完成的输出列向下一阶段流动。每次缩小等待都要保留对应生产者依赖。
  3. 已保存的同硬件摘要从74,092.80分推进到78,142.69分,期间含历史保留、缓冲调整、逐块消费和直接输出等多项改动,不能把整段涨分归给一个技巧。
  4. 参数加载调整后达到80,005.43分,再合并已验证的整段写回安排达到80,098.00分。历史完整大报告未随包保存,这段过程由阶段摘要与计划支撑。

这份方案值得带走什么

这条过程的经验是把“大操作之间的顺序”细化成“具体哪块数据何时可用”,再检验更细的依赖是否真正提前了下游执行。

证据能说到哪里:有阶段总结、最终报告和代码,下面单独绘制同硬件更新曲线;一段更新可能含多项改动。

核对硬件、指令与来源指纹

project/copt80_runs/README.md 的阶段记录;四份历史摘要与配置见本页真实更新图。

面积 23.999 mm²;P1 / D1 峰值 19.819 / 19.356 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 32, "sfu_lanes": 18, "reduction_units": 0, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

48642c61fc3ac02b8dffa6941314f987a487dbca697940649dbd5471c86f7fbf

矩阵指令 44,688 条;加载指令 29,172 条;工作组生命周期 64 个。

{
  "line": 111,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "w0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "w0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 256,
      "wg": "w0",
      "lane": 8
    },
    "m": 16,
    "n": 16,
    "k": 32,
    "event": "e31_0_0"
  }
}

M2_D1 · SHA256

555363b01869abe1d7a1e917087417079cbd11f2274b21243a5ce117e0e12c13

矩阵指令 7,352 条;加载指令 6,688 条;工作组生命周期 49 个。

{
  "line": 1238,
  "args": {
    "a": {
      "space": "RF",
      "offset": 128,
      "count": 96,
      "wg": "p0",
      "lane": 1,
      "shape": [
        3,
        32
      ],
      "strides": [
        128,
        1
      ]
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "p0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 48,
      "wg": "p0",
      "lane": 2
    },
    "m": 3,
    "n": 16,
    "k": 32,
    "event": "e596"
  }
}

报告SHA256 4b6ca18933dd1d63baaff0fd30705ccbc7f34522e423df0dec68f3d49d234d8b
提交ID TRF-EC2CC3E9434E4C13

方案03 · 服务器验证

16列分块、64项累加,整段与逐步生成分开组织

相同硬件下,较长的求和块与不同任务划分,怎样改变数据复用和等待?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 252,277 周期生成 D1 24,949 周期得分 80,076.53

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

先把“每轮累加64项”讲清楚

一个输出元素需要把输入与权重逐项相乘再累加。每轮处理64项,表示一条指令完成这64项的部分和;剩余项由后续轮次继续累加。方案03整段输入最常见的是16行×16列×64项。较长的求和块有机会减少发射与换块次数,同时占用更多输入、权重和临时空间。

最终整段程序有79个工作组生命周期,生成程序有64个。生命周期统计包含不同阶段的创建与结束,不能据此确定同时有多少任务运行。需要时间线才能进一步回答哪些任务真正重叠。

生成阶段先避免重复搬权重

静态读取记录显示,两层权重共1.5 MiB、原始历史共256 KiB,集中在生成首步读取;后面七步不再读这些原始对象。新步骤仍读取新输入并更新状态。这先解决了重复加载,剩余差别来自计算分块、数据交接与等待。

生成中常见1行×16列×32项和1行×16列×64项,也有较窄的输出块。它说明作者没有给所有计算强行用同一种粒度,但仅凭形状统计还不能确定每一种块对应哪条优化假设。

与05对照能确认什么

方案03和05的硬件配置完全相同。03的整段输入为252,277周期,05为260,349;生成分别为24,949和27,497周期。因此差异来自程序实现整体,不能归因于多配了计算资源。

03的整段外存读取约27.91 MB,05约32.70 MB;生成读取约2.02 MB对2.39 MB。更少流量与更短周期同时出现,是进一步检查复用与搬运路径的线索。缺少控制其他变量的实验,不能说流量差已经解释了全部耗时差。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

先选同硬件对照,把解释范围缩到软件,再顺着实际读取、分块和依赖找差异。没有搜索记录时,保留这种机制分析,不替作者虚构迭代顺序。

证据能说到哪里:与方案5的硬件规范相同,成品差异来自程序;无法仅凭指令形状确定某项优化贡献。没有搜索记录。

核对硬件、指令与来源指纹

面积 23.967 mm²;P1 / D1 峰值 19.957 / 19.105 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 1, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

8905e29663108f3acf36fdea6176edab59fdda566a65da2ab2f11c8b4df08435

矩阵指令 22,992 条;加载指令 16,476 条;工作组生命周期 79 个。

{
  "line": 1288,
  "args": {
    "a": {
      "space": "RF",
      "wg": "rfgemm_0",
      "lane": 0,
      "offset": 0,
      "count": 1024
    },
    "b": {
      "space": "RF",
      "wg": "rfgemm_0",
      "lane": 8,
      "offset": 0,
      "count": 1024
    },
    "acc": {
      "space": "RF",
      "wg": "rfgemm_0",
      "lane": 12,
      "offset": 0,
      "count": 256,
      "shape": [
        16,
        16
      ],
      "strides": [
        32,
        1
      ]
    },
    "m": 16,
    "n": 16,
    "k": 64,
    "event": "rf16comp_229_0_0"
  }
}

M2_D1 · SHA256

3566d25eaf24c2c5d551789cd87ecf358457126006ee000a6d7517eb89382a27

矩阵指令 6,144 条;加载指令 4,944 条;工作组生命周期 64 个。

{
  "line": 233,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 128,
      "wg": "g",
      "lane": 13,
      "shape": [
        2,
        64
      ],
      "strides": [
        128,
        1
      ]
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g",
      "lane": 0
    },
    "acc": {
      "space": "RF",
      "offset": 800,
      "count": 32,
      "wg": "g",
      "lane": 12,
      "shape": [
        2,
        16
      ],
      "strides": [
        24,
        1
      ]
    },
    "m": 2,
    "n": 16,
    "k": 64,
    "event": "e1153_columns0"
  }
}

报告SHA256 3fde588395bcbf28db4e2af820ec6bfdfa91c25d916b2d3f573f0fb915b3b308
提交ID TRF-6FD7DC2C6F614327

方案04 · 服务器验证

按不同矩阵形状选择分块,并填满小存储的空隙

分块一定要整齐统一吗?数据形状和剩余存储空间会怎样改变选择?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 273,192 周期生成 D1 25,976 周期得分 75,413.74

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

不同阶段使用不同形状

整段输入最常见的两类指令分别处理32行×16列×32项、64行×16列×16项。前者每轮沿求和方向走得更长,后者一次覆盖更多输入行。同一份权重可服务更多行,但输出累加器也要保留更多结果;两种形状承担的是不同的空间与复用取舍。

生成程序还出现1行×24列×32项、1行×32列×32项和1行×8列×56项。56这个长度说明,最终程序没有把求和分块限制为常见的二次幂。它可以来自容量安排或特定矩阵切法;当前证据没有证明作者选56时的具体推导。

“没有共享暂存”不等于没有数据复用

该硬件不配额外共享暂存和缓存,计算仍有寄存器小存储。64个生成工作组生命周期配合首步权重和历史加载,后续步骤不重复读取这批原始数据。应从数据真正保存在哪里理解复用,不能只看缓存容量。

该方案整段输入外存写出约3.80 MB,少于03的约5.21 MB;但整段耗时273,192周期,高于03的252,277周期。写得少是事实,等待、读取和计算组织仍可能抵消收益。

能从成品学到的边界

值得带走的是“按实际形状与空间选分块”这个分析视角。若要验证某个不整齐块是否有用,需要固定其它布局,检查总覆盖、局部容量、边界处理和最终周期。

这份提交没有搜索记录,因而正文中的容量解释是对结构的分析。它没有证实作者先做了容量推导再选择这些块,也没有给出56项比64项独立快多少。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

将不规则分块当作值得追查的证据,不因它看起来特殊就认定是秘诀。真正要核对的是覆盖了什么、节省了什么、又引入什么代价。

证据能说到哪里:这些是最终指令事实;填补容量空隙是机制解释,未从记录确认作者的选择顺序。

核对硬件、指令与来源指纹

面积 23.487 mm²;P1 / D1 峰值 19.835 / 19.865 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "tc_array": "8x16", "tc_k_parallel": 2, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 0, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

46bcedb8f76f8bef15a2183d2f071d25d0cf49d8ae9af0c5e3955c8a8adf0021

矩阵指令 24,048 条;加载指令 16,640 条;工作组生命周期 64 个。

{
  "line": 67,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "p00",
      "lane": 0,
      "shape": [
        64,
        16
      ],
      "strides": [
        16,
        1
      ]
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 16,
      "wg": "p00",
      "lane": 2
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 64,
      "wg": "p00",
      "lane": 9
    },
    "m": 64,
    "n": 1,
    "k": 16,
    "event": "m57_0_0"
  }
}

M2_D1 · SHA256

f1ceb1df7540d44787a86d0e3d0c10f71f8fba6e67929413b3efb6f838ead4ba

矩阵指令 6,592 条;加载指令 5,536 条;工作组生命周期 64 个。

{
  "line": 543,
  "args": {
    "a": {
      "space": "RF",
      "offset": 768,
      "count": 64,
      "wg": "g00",
      "lane": 1,
      "shape": [
        2,
        32
      ],
      "strides": [
        128,
        1
      ]
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 768,
      "wg": "g00",
      "lane": 0
    },
    "acc": {
      "space": "RF",
      "offset": 960,
      "count": 48,
      "wg": "g00",
      "lane": 4
    },
    "m": 2,
    "n": 24,
    "k": 32,
    "event": "m210_0"
  }
}

报告SHA256 13c51f977bc863f1709a30b6ff93b265fb6e6c52f9c1708d31a630e02674e989
提交ID TRF-28228B37A51F4EBA

方案05 · 服务器验证

较少的整段输入任务,配合更细的生成分块

让较少任务多做一些工作,能否换来复用;生成时更细的块又会付出什么?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 260,349 周期生成 D1 27,497 周期得分 75,084.45

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

整段与生成采用不同任务粒度

整段程序只有16个工作组生命周期,生成则有64个;03在同一硬件上分别为79和64个。较少的长期任务有机会重复使用已有数据、减少重新建立任务,但同时可能限制独立工作的数量。生命周期数量本身不能给出收益方向。

整段程序混用16行×16列×64项和32行×32列×32项等形状。生成最常见1行×16列×16项,求和块比03的一些常用块更短:单次存储需求较小,却需要更多累加轮次。

三行指令究竟说明什么

生成中能看到3行×16列×8项的指令,说明程序确实把三行数据合到一次矩阵操作。这里未沿每个操作数地址重建三行的含义,因此不能照搬其它方案的解释,说它们必然是当前输入和两份常量。

可以确定的是,权重和原始历史只在首步读取。跨步骤复用这一点与03相同,所以不能拿“权重驻留”单独解释两者的速度差。

同硬件比较揭示的剩余问题

05生成需要27,497周期,03为24,949;05生成外存写出286,976字节,03为148,480字节。更大的输出与中间搬运量、更多短块,都是检查数据交接的线索。不能把这些统计直接累加成一个因果解释。

下一步若要判定原因,应追踪哪些写出是接口必需、哪些是临时交接,再查看消费者是否因此等待。当前只有最终程序,未保存做这种对照的过程。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

对看似相同的方案,不重复列共同技巧;寻找共同技巧之后还剩下的差别,例如中间结果是否落地、累加被切成多少轮、任务何时获得输入。

证据能说到哪里:硬件与方案3一致。3行指令证明有合批计算,不能仅据此断言三行分别是什么。没有过程记录。

核对硬件、指令与来源指纹

面积 23.967 mm²;P1 / D1 峰值 19.930 / 19.955 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 1, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

2e7da035b47689b6df6bdd57a0acba078c143084b5f08e2c17c871aae61a71f5

矩阵指令 23,376 条;加载指令 21,444 条;工作组生命周期 16 个。

{
  "line": 783,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 256,
      "wg": "g0",
      "lane": 8
    },
    "m": 16,
    "n": 16,
    "k": 64,
    "event": "e765_0"
  }
}

M2_D1 · SHA256

649ce8626c182c0cdccdd54cac2d95bafe5f59a11a25737f09a652f969ef10f9

矩阵指令 13,056 条;加载指令 9,856 条;工作组生命周期 64 个。

{
  "line": 86,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 24,
      "wg": "g0",
      "lane": 2,
      "shape": [
        3,
        8
      ],
      "strides": [
        64,
        1
      ]
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 128,
      "wg": "g0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 48,
      "wg": "g0",
      "lane": 5
    },
    "m": 3,
    "n": 16,
    "k": 8,
    "event": "e21_0"
  }
}

报告SHA256 3fc24927ea9fb6123278c0224d96cc58135c594eac4852497a689c0793d5ddcf
提交ID TRF-AFEA6BF57F5443D6

方案06 · 服务器验证

16个计算任务加控制组,优先保持较长求和块

搬运资源较少时,如何用较长计算块与任务安排维持执行?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 301,644 周期生成 D1 39,484 周期得分 58,212.03

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 1 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

一套资源配比下的两类任务

方案06每个计算单元配置一个搬运引擎,另有两个专用归约单元。搬运引擎负责把数据送到计算附近;归约单元负责求和、取最大值一类汇总操作。资源配比提供可能性,实际是否繁忙还要看程序时间线。

整段输入有17个工作组生命周期,常见16行×16列×64项;生成有49个,常见1行×16列×64项。较长求和块可以让一次指令完成更多累加,但若下一块尚未送到,计算仍然会等。

首步加载与后续复用

两层生成权重和原始历史仅在首步读取,后续七步继续复用。这把反复搬运变成一次性准备,却保留了启动加载、每步新输入、局部计算与结果交接的成本。

生成外存读取约2.26 MB、写出约0.31 MB。对这种已大量复用的程序,下一轮调查不能只问能否再缓存权重,还应问剩余传输是谁在等、是否可以更早到达。

与07的差异是两类任务的取舍

06与07硬件完全一致。06整段输入301,644周期,比07的335,948更快;生成39,484周期,却比07的38,337略慢。06整段读取也较少,约25.63 MB对28.24 MB。

共同评分取决于两类任务耗时的乘积,因此这次整段收益足以抵消生成退步。这个对照证明软件组合存在取舍;没有单因素实验,不能说增加或减少某一组任务就导致了它。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

分开保存两类任务的变化,再用真实目标函数决定是否采用。只挑一个更好看的分项,会遗漏另一项付出的代价。

证据能说到哪里:硬件与方案7相同;方案6整段输入更快、生成略慢,说明软件分工存在取舍。没有过程记录。

核对硬件、指令与来源指纹

面积 23.647 mm²;P1 / D1 峰值 19.546 / 18.719 W。

{"cache_mib": 0, "dma_depth": 2, "dma_engines": 1, "hbm_channels": 8, "multicast": true, "noc_bytes_per_cycle": 512, "reduction_units": 2, "rf_ports": "8R4W", "sfu_lanes": 16, "shared_kib": 0, "sm_count": 16, "sm_noc_bytes_per_cycle": 128, "tc_array": "8x16", "tc_count": 1, "tc_k_parallel": 2, "vector_lanes": 16, "version": "challenge-hardware-v0.4"}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

024cec37fb8891e7b2459a8f85faa94f93c2fb28ca5b14a1ae45e4c0693a322a

矩阵指令 21,024 条;加载指令 20,446 条;工作组生命周期 17 个。

{
  "line": 445,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "0",
      "lane": 12
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "0",
      "lane": 4
    },
    "m": 32,
    "n": 32,
    "k": 32,
    "event": "e401"
  }
}

M2_D1 · SHA256

3d5c015d43044a8fadf273cb83405eaa2e98afbc86a5f7b8517c4153a9e48c95

矩阵指令 4,160 条;加载指令 3,688 条;工作组生命周期 49 个。

{
  "line": 524,
  "args": {
    "a": {
      "space": "RF",
      "offset": 64,
      "count": 64,
      "wg": "weight_0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "weight_0",
      "lane": 4,
      "shape": [
        64,
        16
      ],
      "strides": [
        1,
        64
      ]
    },
    "acc": {
      "space": "RF",
      "offset": 48,
      "count": 16,
      "wg": "weight_0",
      "lane": 1
    },
    "m": 1,
    "n": 16,
    "k": 64,
    "event": "e453"
  }
}

报告SHA256 3118c81596bb35be9a7ccfdc3fd4485a124d734910ffedd3f13781b9eb54a210
提交ID TRF-DC4E8AD991D841C9

方案07 · 服务器验证

同一套机器,换了一种两类任务之间的取舍

同一套硬件,怎样理解“生成略快,但整段输入更慢”的成品?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 335,948 周期生成 D1 38,337 周期得分 55,979.05

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 1 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

任务数量和分块与06不同

07整段输入有32个工作组生命周期,06为17个;生成分别为64和49个。整段常见32行×16列×32项和32行×32列×32项,生成最常见1行×16列×32项。它与06的64项长块形成软件粒度上的区别。

更多任务可能填补等待,也可能增加同步、重复数据与队列竞争。静态统计能指出哪里不同,却不能判断究竟是哪一种效应占主导。

少量生成收益伴随更多流量

07生成38,337周期,比06的39,484少1,147周期;但生成外存读取约2.36 MB,高于06的2.26 MB,写出也更多。这说明即使搬运量上升,安排得更合适仍可能更快。具体原因还需查看数据何时到达和计算重叠。

两者都仅在首步加载权重和原始历史,也都只有一个搬运引擎。解释差异时应关注程序分工和时间安排,避免拿相同的硬件或相同的驻留策略重复归因。

为什么这份对照值得保留

整段任务反过来慢了34,304周期,超过生成阶段节省的相对比例。最终总分较低,但这并不抹掉生成子程序的比较价值:它可能包含可移植的调度安排。

若尝试组合06的整段程序与07的生成程序,需要重新核对兼容配置和完整评估。这只是由同硬件对照引出的后续实验,本页没有替作者运行或声称组合一定更好。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

保留分项优势,不只保留总分最高的一个文件。后续组合可以有新机会,但要通过实际整合验证。

证据能说到哪里:没有单变量对照和搜索记录,无法把差异归给一个具体调度参数。下方展示实际分块、搬运与任务组数。

核对硬件、指令与来源指纹

面积 23.647 mm²;P1 / D1 峰值 19.542 / 19.025 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 2, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 1, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

037a247e174f9632bc8a07cda360d6e4a077bc3632519f451352238f0a7f1260

矩阵指令 17,760 条;加载指令 24,070 条;工作组生命周期 32 个。

{
  "line": 514,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 8
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 10
    },
    "m": 32,
    "n": 32,
    "k": 32,
    "event": "e442_0_0"
  }
}

M2_D1 · SHA256

7875e722201d68275587784a3fe88bbc184e32a0a6824b730de5c8ddef3d5692

矩阵指令 6,784 条;加载指令 9,000 条;工作组生命周期 64 个。

{
  "line": 334,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 32,
      "wg": "w0",
      "lane": 12
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "w0",
      "lane": 0
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 16,
      "wg": "w0",
      "lane": 13
    },
    "m": 1,
    "n": 16,
    "k": 32,
    "event": "e342_0_0"
  }
}

报告SHA256 76f92680835c1c46d415ebebafff767d75d67c2bb8b4e8c66f654af0f53c7df0
提交ID TRF-228287797A584402

方案08 · 服务器验证

24个较轻计算单元,把历史拆成更多份

把机器做成更多、较轻的计算单元,能否让短小的生成任务也充分并行?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 352,305 周期生成 D1 41,549 周期得分 52,508.66

先看这套硬件提供了什么

配置 24 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 1 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 1 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

硬件增加的是任务位置,也有能力交换

这里有24个计算单元,而许多方案为16个;每个矩阵阵列沿求和方向只并行处理1项,常见方案为2项。更多单元提供更多任务位置和分布式小存储,代价是单个单元的计算配置较轻,每单元只有一个搬运引擎。

整段程序有24个工作组,一组对应一个计算单元,主块为32行×32列×16项。程序以相近节奏发出共同读取,利用相同请求合并传输;能否合并依赖地址和到达时机,不能仅凭开启组播配置保证。

一份历史为什么分成六片

生成模型有四路独立注意力,每路要查看128个历史位置。该方案把每路分成22、22、21、21、21、21个位置,交给六个任务;每层24个持久任务各自保留需要的权重和历史。

各片产生局部最大分数、指数和、加权值向量。合并时依据各片最大值重新缩放,再合成总分母与结果。不能直接平均六份局部输出,因为每片归一化用的分母不同。拆分减少单任务工作,却增加六份摘要的交换和汇总。

前馈也沿求和方向分给不同任务

第二次前馈矩阵变换的输入宽度为512,方案把它沿求和方向切开。已核对的一个任务负责176项,按64、64、48项分轮计算,再与另外任务的部分和相加。较短的最终输出因此也能让更多计算单元参与。

最终生成41,549周期、整段352,305周期。这个结果说明较轻单元配细分工可以形成有效方案;它没有证明更多单元或更多历史分片单独产生了多少收益。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

当输出太短、沿输出切不出足够任务时,可以检查历史维度或求和维度是否可拆。先写清合并公式,再计算通信与同步代价。

证据能说到哪里:这是旧快照同一份程序的最终构造。更多计算单元与更多分片同时变化,无法单独估计各自收益。

核对硬件、指令与来源指纹

旧版 final-solutions.html 中方案五;与本快照方案08为同一份程序。

面积 23.645 mm²;P1 / D1 峰值 16.958 / 19.357 W。

{"cache_mib": 0, "dma_depth": 2, "dma_engines": 1, "hbm_channels": 8, "multicast": true, "noc_bytes_per_cycle": 512, "reduction_units": 0, "rf_ports": "8R4W", "sfu_lanes": 8, "shared_kib": 0, "sm_count": 24, "sm_noc_bytes_per_cycle": 64, "tc_array": "8x16", "tc_count": 1, "tc_k_parallel": 1, "vector_lanes": 16, "version": "challenge-hardware-v0.4"}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

7c96cfd20a9cd880cb5e6659098a19aab5f49a9fb6b172fa16cd31904a540aa7

矩阵指令 23,760 条;加载指令 14,594 条;工作组生命周期 24 个。

{
  "line": 1718,
  "args": {
    "a": {
      "space": "RF",
      "offset": 512,
      "count": 512,
      "wg": "p0",
      "lane": 8
    },
    "b": {
      "space": "RF",
      "offset": 32,
      "count": 512,
      "wg": "p0",
      "lane": 6,
      "shape": [
        16,
        32
      ],
      "strides": [
        64,
        1
      ]
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "p0",
      "lane": 5
    },
    "m": 32,
    "n": 32,
    "k": 16,
    "event": "L0qkv0|m191"
  }
}

M2_D1 · SHA256

3269111204509cfa19f0046cdf79753927c8797bb2070d4ce6ca66b5ccd1dba3

矩阵指令 5,184 条;加载指令 2,944 条;工作组生命周期 48 个。

{
  "line": 72,
  "args": {
    "a": {
      "space": "RF",
      "offset": 512,
      "count": 64,
      "wg": "L0w0",
      "lane": 2
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "L0w0",
      "lane": 3
    },
    "acc": {
      "space": "RF",
      "offset": 520,
      "count": 16,
      "wg": "L0w0",
      "lane": 0
    },
    "m": 1,
    "n": 16,
    "k": 64,
    "event": "setup0|mn"
  }
}

报告SHA256 3515ed0ed701c85c5c3f1ba3e3cf668188d25f1481a6006052d66f07c3d64d5f
提交ID TRF-46FFD60D9C754BBE

方案09 · 服务器验证

你的五万分方案:二维复用、融合与精细装载

从重复搬运出发,怎样逐次发现新限制,最终把一个很快但超功率的方案变成可用结果?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 337,476 周期生成 D1 47,049 周期得分 50,416.65

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

整段输入:让一次读取服务多个输出块

矩阵相乘时,同一个输入行块可配多个权重列块,同一个权重列块也可配多个输入行块。你的方案让一个任务同时保留二维排列的输出累加器,利用这两个方向的复用。

以已保存的2行块×4列块安排为例,一轮读取2块输入和4块权重,可形成8块输出;如果8块各自独立取数据,则需要16次逻辑块读取。节省的只是这一局部轮次,不能据此推算整题加速倍数。8块未完成输出和下一轮缓冲同时占小存储,所以更大网格不一定装得下。

生成:权重留住之后,继续管首次装载

生成程序跨步骤保留权重与历史,把前馈相邻操作接续执行,历史注意力分成8份并合并。已经不再重复读取的权重仍要在首次装进来,多个计算单元同时发请求会争抢外存、网络和寄存器写口。

agent进一步按实际搬运字节量分桶,用事件控制发射间隔。按计算单元数量分批可能一批很重、一批很轻,字节量能更直接描述本轮放出的请求规模。K/V也改为直接写最终位置,省掉临时区往返。

最后的关键是定位,而非全面降速

功率限制检查任意连续1000周期的平均值。一个阶段变快或一个峰被压下去后,决定资格的窗口可能转移到别处。最终整段程序只多付出117周期,就让最高窗口进入预算;它不是凭空找到一个万能等待常数。

最终整段337,476周期、生成47,049周期。额外输入检查也保留在旧复盘中。下面的过程是依据保存记录重建的判断变化,按问题整理,不表示所有实验严格串行发生。

记录中的判断怎样改变

  1. 先检查数据能否跨步骤保留:总权重加临时区、历史状态,既算总量,也算每个任务的局部容量。模型只保证放置合法,完整程序仍需评估。
  2. 观察到少数任务承担历史注意力,尝试拆分历史并正确合并;整段输入则从供数与重复读取转向二维复用。
  3. 局部变快后多次超功率。一次放慢前部计算让程序变慢,却没有改变最高峰,调查于是转向后续K/V导出,发现并删掉临时区往返。
  4. 进一步复用后再次接近功率上限,agent重建窗口时间线,先调整前馈写回;最高峰随后转移到Q/K/V写回,又只调整新峰附近的节奏。
  5. 最后以小幅等待换取完整合格版本,再固定最终产物核对评分和额外输入。旧复盘保留成功与失败对照。

这份方案值得带走什么

遇到改动无效,先检查是否干预了真正限制;遇到改动成功,再检查限制是否转移。把一条失败当作下一次测量的线索。

证据能说到哪里:最终两份程序与旧复盘对应的评分一致。完整过程、失败对照和解释保留在Astra页。

核对硬件、指令与来源指纹

astra-path.html:容量、代理失配、二维复用、首次装载、最高功率窗口转移。

面积 22.495 mm²;P1 / D1 峰值 19.971 / 19.866 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 8, "reduction_units": 0, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 1, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

15c27abb16a094fbe485e25fa7d763d0f7ec330f7c9e2e8a82ebd1eaac3e89a2

矩阵指令 13,536 条;加载指令 17,932 条;工作组生命周期 16 个。

{
  "line": 302,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 10
    },
    "m": 32,
    "n": 32,
    "k": 32,
    "event": "g0_e27_0"
  }
}

M2_D1 · SHA256

215fa41ae58e369d4e59b31195ed56cfe7a227631ff250e99ad7375e3571f7b6

矩阵指令 4,544 条;加载指令 3,640 条;工作组生命周期 64 个。

{
  "line": 1456,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 128,
      "wg": "g0",
      "lane": 12
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 1
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 8,
      "wg": "g0",
      "lane": 14
    },
    "m": 1,
    "n": 8,
    "k": 128,
    "event": "g0_e28"
  }
}

报告SHA256 5f90f210265eaad5092afb58c4cbfa7ca8d4aae8b2b3ebf05f07d27710ff0b24
提交ID TRF-AC27B1E446A749B3

方案10 · 服务器验证

让任务持有输出块,同时用计算覆盖加载

局部内核几乎减半,为什么完整程序还需要回退和重新安排加载?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 403,197 周期生成 D1 43,523 周期得分 47,957.06

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。不另配共享暂存和缓存,计算仍可使用寄存器小存储。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

让任务持有自己负责的权重和结果

随包知识记录把第二次前馈变换W2沿求和方向拆开:每个任务保留自己负责的权重,计算对应部分和,再合成完整输出。“owner常驻”在这里指数据由明确任务持有,避免每次计算再从外部搬来。

整段程序最常见的指令为16行×16列×128项,生成则按不同输出宽度和求和长度混用分块。两层生成权重仅首步读取,读取总量约1.97 MB。流量较低,仍不足以单独说明关键路径短。

局部对照与整案发生了什么

知识记录中的一组W2冷启动局部实验,从60,223周期降到30,689周期,外存读取从6.85 MB降到2.10 MB。这是该局部核的对照,不能乘上层数当作完整模型收益。

合入完整程序后,一版整段输入达到394,748周期,但峰值21.2578 W,超过20 W门槛。随后保留有用的数据所有权安排,改变其它投影的保留方式、分段加载与生成中的计算搬运重叠,最终整段为403,197周期,功率19.1436 W。

资源忙碌比例给线索,不直接给原因

最终整段报告的片内网络忙碌比例约48.01%,最忙计算单元的寄存器读比例约36.97%,矩阵阵列约20.70%。这些数字促使agent继续查供数与等待,但没有证明全部时间都卡在外存。

不同任务可同时工作,累计等待也可能超过总时长;不能把这些比例相加拼成总耗时。该记录明确保留了这种证据边界,是值得继承的分析习惯。

记录中的判断怎样改变

  1. 先在W2局部核验证沿求和方向拆分和任务保留权重是否减少流量。局部收益支持继续整合。
  2. 完整评估暴露功率超限,推翻了“局部加速可直接采用”的判断。
  3. 保留有效结构,重新组织加载与重叠,接受整段输入略慢以恢复合法性;最后同时验证生成程序与共同硬件。

这份方案值得带走什么

把局部实验当成方向筛选,尽早合入完整执行;更快但超限的版本可以提供线索,却不能替换已合格版本。

证据能说到哪里:局部W2的60,223→30,689周期不能乘层数推成总收益。最终报告为403,197 / 43,523周期。

核对硬件、指令与来源指纹

project/docs/knowledge.md:W2局部对照、joint27/joint28及资源占用解释。

面积 23.263 mm²;P1 / D1 峰值 19.144 / 15.786 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "vector_lanes": 8, "sfu_lanes": 8, "reduction_units": 1, "rf_ports": "8R4W", "shared_kib": 0, "dma_depth": 2, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 2}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

8c254168220322899671f3c0aecd37f2c95c6e7e97178654af8a8b9bd3dd5c5f

矩阵指令 10,464 条;加载指令 16,246 条;工作组生命周期 32 个。

{
  "line": 574,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 2048,
      "wg": "g0",
      "lane": 2
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "g0",
      "lane": 1
    },
    "m": 16,
    "n": 32,
    "k": 64,
    "event": "e500_0"
  }
}

M2_D1 · SHA256

3c5ed26bf12ad009469bafb89697288f8ed48bc9daa416218eed6f358167229f

矩阵指令 2,496 条;加载指令 2,064 条;工作组生命周期 64 个。

{
  "line": 290,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 64,
      "wg": "l0_a_0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1536,
      "wg": "l0_a_0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 24,
      "wg": "l0_a_0",
      "lane": 2
    },
    "m": 1,
    "n": 24,
    "k": 64,
    "event": "e226"
  }
}

报告SHA256 58061c2e0ef11a12d00f44ff038fb3fce24c9a4c4fc49be24c0688b83d793a2f
提交ID TRF-BC8FECE989DF4894

方案11 · 服务器验证

小矩阵阵列与较大共享暂存,偏向生成任务

为什么先改生成程序,再调硬件,最后还要回到整段输入的功率窗口?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 585,222 周期生成 D1 33,323 周期得分 45,492.34

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 4×8 矩阵阵列,沿求和方向并行 4 项。每单元共享暂存 256 KiB,缓存 0 MiB。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 256 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

两类任务实际上用了不同的存储路径

硬件每个计算单元有256 KiB共享暂存,矩阵阵列为4×8、求和并行4项。最终整段源码中有3,072行直接涉及共享暂存的读取或写出,生成源码中为0行。这里是源码行数,不等于循环展开后的传输次数。

因此不能把较快的生成直接归功于大共享暂存。生成权重与原始历史仅首步读取,后续更接近由持久任务在寄存器里保存并继续使用。芯片配置与具体程序使用路径必须分开看。

过程记录里的大变化来自生成重写

当时的阶段总结先报告:同一旧硬件下,重写生成程序将约138k周期降到约58k;之后再调整硬件与加载,进入33,323周期的阶段。这个摘要支持“先有软件变化,再评估资源配置”的顺序,不能把整段收益全部归给换阵列。

重写包括权重与历史保留、把历史分片交给多个任务,以及把归一化与投影安排在可重叠的路径上。偏置、激活和残差等收尾操作接入相邻计算,减少独立阶段的同步。

这条过程没有止于“多给资源”

阶段记录中,把全局网络由256加宽到512字节/周期,两类任务都变快,但整段功率达到20.069 W,超限。随后改变加载分批,也出现生成更快、整段更慢且仍超限的组合。这些是历史候选,不能当作最终程序的指标。

本快照最终生成仍为33,323周期,整段已经降到585,222周期;早期摘要的整段814,670周期不应混作最终结果。目前仅对所列过程片段做了核对,没有把之后每一步整段优化全部还原。

记录中的判断怎样改变

  1. 早期记录把逐步生成列为主要调查对象,先重写跨步骤数据保留与任务安排。
  2. 在软件变化后评估关闭缓存、增加搬运引擎、调整矩阵阵列形状等组合;阶段摘要显示生成进一步缩短。
  3. 扩大网络试验虽更快却超功率,agent转查具体加载阶段并尝试分批。这些失败没有被写成合格成绩。
  4. 最终提交的两份程序以本页服务器报告为准。过程片段来自当时说明,未做整条历史的重新评分。

这份方案值得带走什么

有剩余面积或功率,不意味着简单加硬件就能受益。先弄清软件是否产生了可服务的工作,再检查新增资源是否触发另一类任务的最坏窗口。

证据能说到哪里:已核对最终程序和所列阶段说明。历史片段解释了生成重写与功率取舍;后续整段优化未逐步还原,历史指标与最终报告分开。

核对硬件、指令与来源指纹

agent-trace/power-budget-search.jsonl:第24行阶段总结。

agent-trace/main-session.jsonl:第218、232、243、257行阶段说明;只作历史记录,不替代最终报告。

面积 18.773 mm²;P1 / D1 峰值 20.000 / 19.893 W。

{"version": "challenge-hardware-v0.4", "sm_count": 16, "tc_count": 1, "tc_array": "4x8", "tc_k_parallel": 4, "vector_lanes": 8, "sfu_lanes": 8, "reduction_units": 0, "rf_ports": "8R4W", "shared_kib": 256, "shared_banks": 8, "shared_ports": "2R1W", "dma_depth": 1, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 256, "hbm_channels": 8, "cache_mib": 0}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 3072,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

9e0cf19037a08351cc822cd802d2e0df6bc6bdc2e104f19acb04bee5c887d817

矩阵指令 12,480 条;加载指令 27,652 条;工作组生命周期 16 个。

{
  "line": 397,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 2048,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 2048,
      "wg": "g0",
      "lane": 1
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 256,
      "wg": "g0",
      "lane": 4
    },
    "m": 16,
    "n": 16,
    "k": 128,
    "event": "e278_g0_0"
  }
}

M2_D1 · SHA256

c4e7a6927bfd1d036fb3e2fdcde208562f7d326c37b0803442d099195272328d

矩阵指令 2,224 条;加载指令 2,192 条;工作组生命周期 48 个。

{
  "line": 93,
  "args": {
    "a": {
      "space": "RF",
      "offset": 128,
      "count": 256,
      "wg": "L0s0",
      "lane": 1
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 2048,
      "wg": "L0s0",
      "lane": 2
    },
    "acc": {
      "space": "RF",
      "offset": 1632,
      "count": 32,
      "wg": "L0s0",
      "lane": 1
    },
    "m": 2,
    "n": 16,
    "k": 128,
    "event": "e44_L0s0"
  }
}

报告SHA256 c23efded3602030cd7f4e4dbabb8d0528e235ffa550c52e3be49b643d12f91bd
提交ID TRF-8A39F0D07AF64109

方案12 · 服务器验证

保留4 MiB缓存,用缓存与分工共同控制流量

去掉缓存,两道题都更快,为什么最后仍然保留缓存?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 438,472 周期生成 D1 53,830 周期得分 41,351.14

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 4×8 矩阵阵列,沿求和方向并行 4 项。每单元共享暂存 32 KiB,缓存 4 MiB。每单元 4 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

缓存既影响重复读取,也改变流量节奏

方案12配4 MiB缓存、每单元32 KiB共享暂存、4个搬运引擎。缓存可以减少部分重复外存访问,也会改变未命中请求的服务节奏;哪一种效应占主导要结合实际程序测量。

整段源码没有直接共享暂存读写,生成源码有1,152行。配置里有这种存储,并不意味着两个程序都用同一条路径。生成权重和原始历史仍只在首步读取,之后复用。

记录保存了一次明确的否定结果

历史去缓存候选的整段为401,704周期,生成44,810周期,比保留版本更快且数值正确;但最高窗口分别20.9665 W和20.2890 W,超过门槛。它回答的是“这个程序和配置下,直接去缓存是否可采用”:答案是否定的。

agent因此试着减少外存通道或缩窄片内网络来控制供数。记录里一部分只有生成单题结果或仍待完整评估,不能把它们补算成已取得的总分。

最终程序还有更细的软件更新

阶段记录将整段最后位置的投影专门处理,以及注意力中的标量广播,列为后期改动。标量广播是把同一个数供给一批元素使用,减少重复准备;它仍应符合指令和输出语义。

某次编译器变换连带改变了生成程序的寄存器分配,agent因此重新测量生成,即使数学含义相同也没有直接继承旧的性能结果。最终以438,472和53,830周期的服务器报告为准。

记录中的判断怎样改变

  1. 先在已有合格版本上优化整段末位置计算和注意力数据供给;编译输出变化后重新检查受影响程序。
  2. 测得去缓存版本更快,但两项功率都超限,拒绝把它作为当前最佳合格版本。
  3. 由超限结果转向供数节奏与带宽组合,保留单题筛选与完整验收的区别;当前快照选择的是已完成验证的保留缓存版本。

这份方案值得带走什么

保留“更快但不可用”的完整证据,让它推动下一次约束修复。一次去缓存失败只限定当时组合,不应变成所有无缓存方案都不可行的先验。

证据能说到哪里:那份移除缓存实验是历史局部比较,不能推导所有无缓存方案都超功率。最终成品以服务器报告为准。

核对硬件、指令与来源指纹

project/STATUS.md 的 Completed experiment conclusions:R182、R183、R191、R192与后续候选状态。

面积 23.269 mm²;P1 / D1 峰值 18.147 / 18.967 W。

{"cache_mib": 4, "dma_depth": 2, "dma_engines": 4, "hbm_channels": 8, "multicast": true, "noc_bytes_per_cycle": 512, "reduction_units": 2, "rf_ports": "8R4W", "sfu_lanes": 16, "shared_banks": 8, "shared_kib": 32, "shared_ports": "2R1W", "sm_count": 16, "sm_noc_bytes_per_cycle": 128, "tc_array": "4x8", "tc_count": 1, "tc_k_parallel": 4, "vector_lanes": 16, "version": "challenge-hardware-v0.4"}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 1152;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

082ea61bbd8a783bce5a026b6055a1edeff8ae21c1d8b6c34fef26e3e1f453f0

矩阵指令 19,224 条;加载指令 24,958 条;工作组生命周期 40 个。

{
  "line": 78,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "p0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "p0",
      "lane": 4
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 512,
      "wg": "p0",
      "lane": 6
    },
    "m": 32,
    "n": 16,
    "k": 32,
    "event": "e28_0_0_0_p0"
  }
}

M2_D1 · SHA256

5962f01bfe64130fd6079aa6781fc893e12b4e028f06838ac78209872dc376fe

矩阵指令 5,056 条;加载指令 6,648 条;工作组生命周期 64 个。

{
  "line": 602,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 128,
      "wg": "l0qkvp0",
      "lane": 8
    },
    "b": {
      "space": "RF",
      "wg": "l0qkvp0",
      "lane": 9,
      "offset": 0,
      "count": 1024
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 8,
      "wg": "l0qkvp0",
      "lane": 2
    },
    "m": 1,
    "n": 8,
    "k": 128,
    "event": "e19_0_0_p0"
  }
}

报告SHA256 e7bcffe0daabdccc53200b0bfd9457a58cd2437d3d6ac64a421deb7c1293dbb7
提交ID TRF-0B387F52B41E44E0

方案13 · 仅本地报告

1 MiB缓存与历史分片,当前只有本地成绩

一个早期失败的硬件方向,为什么在软件结构改变后值得重试?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 467,627 周期生成 D1 53,736 周期得分 40,076.35

先看这套硬件提供了什么

配置 16 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 2 项。每单元共享暂存 0 KiB,缓存 1 MiB。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 256 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

先消掉反复搬运,再改相邻操作的交接

生成阶段每步处理新输入,但权重与已存在的历史会反复使用。笔记记录的路线先让历史键K和值V保留在寄存器,再让负责权重的任务连续完成相邻操作,减少中间数据离开原任务后的搬运。

历史注意力随后分成四片:每片计算自己的局部最大值、指数和及加权向量,最后用一致的缩放合并。这里的“4片”是具体候选选择,分得更多还会增加合并成本。

一个较干净的局部归因

笔记记载,在硬件和整段程序保持不变的条件下,采用四片历史版本使生成从62,515降到53,736周期。这个对照比跨参赛方案的分差更接近回答一次改动的作用,但本页没有重新运行该历史实验。

最终程序逐步读取新输入,加载与矩阵指令都存在,权重和原始历史只在第一步加载。它与方案14的固定常量输出有明确区别;两者在本快照都标为本地报告,不代表具有同一种问题。

为什么重新开放之前失败的配置

记录中,较早的8通道组合没有成为可采用的结果。完成数据保留和融合后,agent重新测试相关硬件组合,得到通过完整本地评估的候选。这说明此前失败依赖当时的软件与资源组合。

最终缓存为1 MiB、全局网络256字节/周期。笔记的40,076.35分首先来自实验评估路径;本快照仅认定为本地成绩,不用它冒充服务器隐藏输入验证。

记录中的判断怎样改变

  1. 先保留合格起点,再尝试按输出列分工;这一步单独没有改善,未被当作成功。
  2. 历史保留、任务内相邻操作接续分别带来改善,再把整段复用与调度改动整合。
  3. 软件结构变化后重试此前不成功的硬件方向,完成共同硬件下的评估。
  4. 最后用同硬件、同整段程序的四片历史对照验证生成收益,再核对额外输入、生成产物与报告对应关系。

这份方案值得带走什么

给失败附上条件:哪个程序、什么配置、因为什么失败。数据流已经改变,就允许重开旧方向;同时保留本地实验与服务器验证的层次。

证据能说到哪里:本次榜单标为local;笔记中的Rust实验不替代服务器验证。图中空心点,不并入已验证耗时地图。

核对硬件、指令与来源指纹

notes/20260929T110343+0800-score-40k-achieved.md 的逐时实验记录。

面积 23.866 mm²;P1 / D1 峰值 18.654 / 18.366 W。

{"cache_mib": 1, "dma_depth": 2, "dma_engines": 2, "hbm_channels": 8, "multicast": true, "noc_bytes_per_cycle": 256, "reduction_units": 1, "rf_ports": "8R4W", "sfu_lanes": 8, "shared_kib": 0, "sm_count": 16, "sm_noc_bytes_per_cycle": 128, "tc_array": "8x16", "tc_count": 1, "tc_k_parallel": 2, "vector_lanes": 16, "version": "challenge-hardware-v0.4"}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

764b474e23b87695bcd7d90a3563c6568ec279de1d347992cf87d5a0f73a6481

矩阵指令 12,960 条;加载指令 23,956 条;工作组生命周期 32 个。

{
  "line": 67,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "wg0",
      "lane": 4
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "wg0",
      "lane": 6
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "wg0",
      "lane": 0
    },
    "m": 32,
    "n": 32,
    "k": 32,
    "event": "wg0_e28_0"
  }
}

M2_D1 · SHA256

c9ab8e397a022c8a3432133e41bf17b2094b3778dfcc404cfb13a784ac4ecfae

矩阵指令 3,712 条;加载指令 5,160 条;工作组生命周期 64 个。

{
  "line": 537,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 64,
      "wg": "wg16",
      "lane": 12
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "wg16",
      "lane": 0
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 16,
      "wg": "wg16",
      "lane": 13
    },
    "m": 1,
    "n": 16,
    "k": 64,
    "event": "d0l0qkv_c0_mma_0"
  }
}

报告SHA256 b44d72454a8bae188a040ef2b981307469617dd9ca00c46ebe031e8b438ebb75
提交ID TRF-D078B9A779F54287

方案14 · 仅本地报告

报告中的短生成耗时,不可当作通用优化

极短的生成耗时,究竟代表计算被优化了,还是预定答案被直接写了出来?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 15,583,748 周期生成 D1 1,996 周期得分 36,020.89

先看这套硬件提供了什么

配置 8 个计算单元(SM);每单元 2 个 4×8 矩阵阵列,沿求和方向并行 1 项。每单元共享暂存 128 KiB,缓存 0 MiB。每单元 1 个搬运引擎(DMA);全局片内网络每周期可传 256 字节,外部内存有 4 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

正常生成程序需要完成什么

连续生成8步时,每一步要使用新输入、模型权重和历史状态进行计算,写出新的隐藏向量以及每层的键K和值V,再提交本步结果。输入变化时,相应输出也应能变化。

这份生成程序没有读取指令,也没有矩阵乘法。它有5,120条向量指令,主要用“固定浮点数加0”的方式把常量放到寄存器,再用136条存储指令写到输出位置。

为何1996周期不能和其它生成程序同读

程序将这些常量写出后连续执行8次步骤提交。报告外存读取为0,写出20,480字节,正好对应5,120个32位浮点数。它测到的主要是装入常量和写出结果的工作,没有覆盖一般输入下的模型计算。

因此换新输入时,这段程序仍写同一批值,无法作为通用生成实现。硬件只有8个计算单元、整段耗时15,583,748周期,这些配置与指标也不能替代对生成语义的检查。

结论到哪里为止

静态程序足以确认生成输出不依赖输入;它不能说明常量最初从哪里得到、作者的动机是什么,也不能证明服务器隐藏验证被绕过。快照成绩来自本地报告。

本页保留它在冻结榜单中的位置,便于说明数据来源;排除它的已验证性能比较和分差拆分。其它方案的工程经验不能从这个固定输出耗时推导。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

面对异常大的加速,先核对完成的工作是否一致,再讨论优化机制。结果的输入依赖、必需输出与完整步骤,是比一个漂亮周期数更基础的证据。

证据能说到哪里:榜单目前仅本地成绩。保留原榜位置与数字,但从已验证耗时图、提升拆分和可学习性能结论中排除;本次未重跑隐藏输入。

核对硬件、指令与来源指纹

面积 5.598 mm²;P1 / D1 峰值 3.384 / 1.229 W。

{"cache_mib": 0, "dma_depth": 1, "dma_engines": 1, "hbm_channels": 4, "multicast": false, "noc_bytes_per_cycle": 256, "reduction_units": 0, "rf_ports": "4R2W", "sfu_lanes": 8, "shared_banks": 4, "shared_kib": 128, "shared_ports": "1R1W", "sm_count": 8, "sm_noc_bytes_per_cycle": 64, "tc_array": "4x8", "tc_count": 2, "tc_k_parallel": 1, "vector_lanes": 16, "version": "challenge-hardware-v0.4"}

D1逐步权重读取字节数:[0, 0, 0, 0, 0, 0, 0, 0]。历史读取:[0, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 0,D1 0;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

9ec81254749d4bdb5c2966ed97d8bbb0beaee1de78e69bb879b735b079bf7917

矩阵指令 76,320 条;加载指令 165,130 条;工作组生命周期 2 个。

{
  "line": 26,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 384,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 768,
      "wg": "g0",
      "lane": 1
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 128,
      "wg": "g0",
      "lane": 2
    },
    "m": 8,
    "n": 16,
    "k": 48,
    "event": "e19_0_0_0"
  }
}

M2_D1 · SHA256

6cec6318092874ca850c79ad4a5fb3052281d3928e85e9ebf7bdac499afd7916

矩阵指令 0 条;加载指令 0 条;工作组生命周期 8 个。

未发现矩阵乘法指令。

报告SHA256 a196f1fed2b9c1814dea87f7615250869a9df1ea664eba4b716a6b5e65ddfb41
提交ID TRF-8A4CA289C1744F74

方案15 · 服务器验证

20个计算单元加共享暂存,整段输入读流量较大

计算单元与共享暂存都不少,为什么仍需从实际流量和任务映射查起?

从这里开始读:这份方案为同一个模型计算选择硬件和执行程序。P1处理整段输入及紧接的首个新位置;D1使用已有历史,连续生成8步。权重是各步复用的模型参数;工作组是承担一部分计算的任务,寄存器(RF)是它直接使用的小存储。下列周期与功率均来自教学模拟器。

整段 P1 569,942 周期生成 D1 61,638 周期得分 33,894.64

先看这套硬件提供了什么

配置 20 个计算单元(SM);每单元 1 个 8×16 矩阵阵列,沿求和方向并行 1 项。每单元共享暂存 96 KiB,缓存 0 MiB。每单元 2 个搬运引擎(DMA);全局片内网络每周期可传 512 字节,外部内存有 8 个通道。这些是模拟器中的配置,作用要结合程序的数据放置与执行顺序判断。

资源数量不等于有效并行

方案15有20个计算单元,每个配96 KiB共享暂存;矩阵阵列沿求和方向并行1项。整段有40个工作组生命周期,生成有16个。工作组如何映射、哪些阶段同时运行,无法只由这些数量确定。

更多单元扩大了可用资源,但如果依赖限制可运行任务,或数据集中经过少数通路,规格优势就未必转成速度。需要把任务和数据的实际分配对应起来。

两份程序都实际使用共享暂存

整段源码直接涉及共享暂存的读写有1,440行,生成有6,480行。共享暂存可以保存可复用数据,也要付出进入和离开它的搬运成本;这些行数仅说明存在路径,不能当作精确传输量。

生成权重和原始历史仅在首步读取,之后仍会发生内部存储之间的搬运。常见生成指令为1行×8列×32项和1行×16列×32项;小输出块有较低单次容量需求,也可能带来更多指令与交接。

从可见的流量提出下一步问题

整段外存读取约63.34 MB,高于本页多数已验证方案;最终整段569,942周期、生成61,638周期。这使重复读取、布局放大和中间转存成为值得检查的方向。

但大流量不是因果证明:应按数据对象检查哪些读取不可避免、哪些由当前任务分工重复产生,再看减少它们能否提前完成时间。该提交没有搜索记录,不能说作者已经做过这套诊断或确定某一级存储就是瓶颈。

过程证据:本次没有可用于还原搜索顺序的记录。上文讲的是最终程序及其机制;没有把这种事后分析当成作者当时的思考过程。

这份方案值得带走什么

硬件表只是起点。沿数据经过的每一级存储追踪读取次数、拥有者和等待者,才能判断资源是在帮助复用还是增加交接。

证据能说到哪里:流量较大是报告事实,不足以单独证明它决定全部耗时。没有搜索记录,不能断言作者如何权衡这些配置。

核对硬件、指令与来源指纹

面积 23.629 mm²;P1 / D1 峰值 19.854 / 18.491 W。

{"version": "challenge-hardware-v0.4", "sm_count": 20, "tc_count": 1, "vector_lanes": 16, "sfu_lanes": 16, "reduction_units": 2, "rf_ports": "8R4W", "shared_kib": 96, "dma_depth": 1, "dma_engines": 2, "sm_noc_bytes_per_cycle": 128, "multicast": true, "noc_bytes_per_cycle": 512, "hbm_channels": 8, "cache_mib": 0, "tc_array": "8x16", "tc_k_parallel": 1, "shared_banks": 4, "shared_ports": "1R1W"}

D1逐步权重读取字节数:[1572864, 0, 0, 0, 0, 0, 0, 0]。历史读取:[262144, 0, 0, 0, 0, 0, 0, 0]。

源文件中涉及共享暂存SH的LD/ST行数:P1 1440,D1 6480;这是源码行统计,不等于循环展开后的传输次数。

M1_P1 · SHA256

fa47f2837615ff464132d33543b2aec5c36ba2f43b0705fcc224580d3d8ed825

矩阵指令 14,688 条;加载指令 20,128 条;工作组生命周期 40 个。

{
  "line": 351,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "b0c0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "b0c0",
      "lane": 12
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 1024,
      "wg": "b0c0",
      "lane": 4
    },
    "m": 32,
    "n": 32,
    "k": 32,
    "event": "b0c0_e30_0"
  }
}

M2_D1 · SHA256

01bfea51ed57a9285fa241a24a47d7eb81be7a043090b962377ea134ef595f10

矩阵指令 12,096 条;加载指令 11,176 条;工作组生命周期 16 个。

{
  "line": 118,
  "args": {
    "a": {
      "space": "RF",
      "offset": 0,
      "count": 32,
      "wg": "g0",
      "lane": 0
    },
    "b": {
      "space": "RF",
      "offset": 512,
      "count": 512,
      "wg": "g0",
      "lane": 0
    },
    "acc": {
      "space": "RF",
      "offset": 0,
      "count": 16,
      "wg": "g0",
      "lane": 1
    },
    "m": 1,
    "n": 16,
    "k": 32,
    "event": "g0_e20_0_0"
  }
}

报告SHA256 46fdf4f9a2078c0ec6728af4ba8cf9c8c6d633d4fa5dcad8e458d434be755d7f
提交ID TRF-80D63BC1CBF64889

数据与边界

从榜单获取当时前15名的代表提交,读取ZIP中的最终硬件和两份程序。13份优先核对服务器报告,2份核对随包本地报告;15份硬件和程序指纹、展开指令数量、评分公式均匹配。没有执行提交中的Python,没有重新求解、评分或上传。对话文件保留存在与指纹信息;方案11另核对若干阶段说明,其他过程依据已标明的实验笔记和摘要。本页不发布原始对话、身份和回执信息。

完整派生数据与来源指纹 · 范围与复现 · 服务器榜单